class PHPUnit_Util_Class

class PHPUnit_Util_Class {
  protected static $buffer = array();

  /**
   * Starts the collection of loaded classes.
   *
   */
  public static function collectStart() {
    self::$buffer = get_declared_classes();
  }

  /**
   * Stops the collection of loaded classes and
   * returns the names of the loaded classes.
   *
   * @return array
   */
  public static function collectEnd() {
    return array_values(array_diff(get_declared_classes(), self::$buffer));
  }

  /**
   * Returns the class hierarchy for a given class.
   *
   * @param  string  $className
   * @param  boolean $asReflectionObjects
   * @return array
   */
  public static function getHierarchy($className, $asReflectionObjects = FALSE) {
    if ($asReflectionObjects) {
      $classes = array(
        new ReflectionClass($className),
      );
    }
    else {
      $classes = array(
        $className,
      );
    }
    $done = FALSE;
    while (!$done) {
      if ($asReflectionObjects) {
        $class = new ReflectionClass($classes[count($classes) - 1]
          ->getName());
      }
      else {
        $class = new ReflectionClass($classes[count($classes) - 1]);
      }
      $parent = $class
        ->getParentClass();
      if ($parent !== FALSE) {
        if ($asReflectionObjects) {
          $classes[] = $parent;
        }
        else {
          $classes[] = $parent
            ->getName();
        }
      }
      else {
        $done = TRUE;
      }
    }
    return $classes;
  }

  /**
   * Returns the parameters of a function or method.
   *
   * @param  ReflectionFunction|ReflectionMethod $method
   * @param  boolean                             $forCall
   * @return string
   * @since  Method available since Release 3.2.0
   */
  public static function getMethodParameters($method, $forCall = FALSE) {
    $parameters = array();
    foreach ($method
      ->getParameters() as $i => $parameter) {
      $name = '$' . $parameter
        ->getName();

      /* Note: PHP extensions may use empty names for reference arguments
       * or "..." for methods taking a variable number of arguments.
       */
      if ($name === '$' || $name === '$...') {
        $name = '$arg' . $i;
      }
      $default = '';
      $reference = '';
      $typeHint = '';
      if (!$forCall) {
        if ($parameter
          ->isArray()) {
          $typeHint = 'array ';
        }
        else {
          if (version_compare(PHP_VERSION, '5.4', '>') && $parameter
            ->isCallable()) {
            $typeHint = 'callable ';
          }
          else {
            try {
              $class = $parameter
                ->getClass();
            } catch (ReflectionException $e) {
              $class = FALSE;
            }
            if ($class) {
              $typeHint = $class
                ->getName() . ' ';
            }
          }
        }
        if ($parameter
          ->isDefaultValueAvailable()) {
          $value = $parameter
            ->getDefaultValue();
          $default = ' = ' . var_export($value, TRUE);
        }
        else {
          if ($parameter
            ->isOptional()) {
            $default = ' = null';
          }
        }
      }
      if ($parameter
        ->isPassedByReference()) {
        $reference = '&';
      }
      $parameters[] = $typeHint . $reference . $name . $default;
    }
    return join(', ', $parameters);
  }

  /**
   * Returns the package information of a user-defined class.
   *
   * @param  string $className
   * @param  string $docComment
   * @return array
   */
  public static function getPackageInformation($className, $docComment) {
    $result = array(
      'namespace' => '',
      'fullPackage' => '',
      'category' => '',
      'package' => '',
      'subpackage' => '',
    );
    if (strpos($className, '\\') !== FALSE) {
      $result['namespace'] = self::arrayToName(explode('\\', $className));
    }
    if (preg_match('/@category[\\s]+([\\.\\w]+)/', $docComment, $matches)) {
      $result['category'] = $matches[1];
    }
    if (preg_match('/@package[\\s]+([\\.\\w]+)/', $docComment, $matches)) {
      $result['package'] = $matches[1];
      $result['fullPackage'] = $matches[1];
    }
    if (preg_match('/@subpackage[\\s]+([\\.\\w]+)/', $docComment, $matches)) {
      $result['subpackage'] = $matches[1];
      $result['fullPackage'] .= '.' . $matches[1];
    }
    if (empty($result['fullPackage'])) {
      $result['fullPackage'] = self::arrayToName(explode('_', str_replace('\\', '_', $className)), '.');
    }
    return $result;
  }

  /**
   * Returns the value of a static attribute.
   * This also works for attributes that are declared protected or private.
   *
   * @param  string  $className
   * @param  string  $attributeName
   * @return mixed
   * @throws PHPUnit_Framework_Exception
   * @since  Method available since Release 3.4.0
   */
  public static function getStaticAttribute($className, $attributeName) {
    if (!is_string($className)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'string');
    }
    if (!class_exists($className)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'class name');
    }
    if (!is_string($attributeName)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(2, 'string');
    }
    $class = new ReflectionClass($className);
    while ($class) {
      $attributes = $class
        ->getStaticProperties();
      if (array_key_exists($attributeName, $attributes)) {
        return $attributes[$attributeName];
      }
      $class = $class
        ->getParentClass();
    }
    throw new PHPUnit_Framework_Exception(sprintf('Attribute "%s" not found in class.', $attributeName));
  }

  /**
   * Returns the value of an object's attribute.
   * This also works for attributes that are declared protected or private.
   *
   * @param  object  $object
   * @param  string  $attributeName
   * @return mixed
   * @throws PHPUnit_Framework_Exception
   * @since  Method available since Release 3.4.0
   */
  public static function getObjectAttribute($object, $attributeName) {
    if (!is_object($object)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'object');
    }
    if (!is_string($attributeName)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(2, 'string');
    }
    try {
      $attribute = new ReflectionProperty($object, $attributeName);
    } catch (ReflectionException $e) {
      $reflector = new ReflectionObject($object);
      while ($reflector = $reflector
        ->getParentClass()) {
        try {
          $attribute = $reflector
            ->getProperty($attributeName);
          break;
        } catch (ReflectionException $e) {
        }
      }
    }
    if (isset($attribute)) {
      if (!$attribute || $attribute
        ->isPublic()) {
        return $object->{$attributeName};
      }
      $attribute
        ->setAccessible(TRUE);
      $value = $attribute
        ->getValue($object);
      $attribute
        ->setAccessible(FALSE);
      return $value;
    }
    throw new PHPUnit_Framework_Exception(sprintf('Attribute "%s" not found in object.', $attributeName));
  }

  /**
   * Returns the package information of a user-defined class.
   *
   * @param  array  $parts
   * @param  string $join
   * @return string
   * @since  Method available since Release 3.2.12
   */
  protected static function arrayToName(array $parts, $join = '\\') {
    $result = '';
    if (count($parts) > 1) {
      array_pop($parts);
      $result = join($join, $parts);
    }
    return $result;
  }

}