/**
  * Reflect the handle class
  *
  * @param string $class
  * @return Collection\Method
  * @throws Exception\InvalidArgument
  */
 public function reflect($class)
 {
     if (class_exists($class) === false) {
         throw new Exception\InvalidArgument(sprintf($this->exceptions[1], $class), 1);
     }
     // Check if we've already reflected this class
     if (static::$reflections->offsetExists($class)) {
         return static::$reflections->offsetGet($class);
     }
     // Create reflection
     $reflectionClass = new \ReflectionClass($class);
     $reflectionMethods = $reflectionClass->getMethods(\ReflectionMethod::IS_PUBLIC);
     // Method container
     $methods = new Collection\Method();
     // Loop through the class methods (Only public);
     foreach ($reflectionMethods as $reflectionMethod) {
         // Create method information entity
         $method = new Entity\Method();
         $method->setName($reflectionMethod->getName());
         // Get method parameters
         $reflectionParams = $reflectionMethod->getParameters();
         // Evaluate the method params
         foreach ($reflectionParams as $reflectionParam) {
             // Create parameter information entity
             $parameter = new Entity\Parameter();
             $parameter->setIndex($reflectionParam->getPosition());
             $parameter->setName($reflectionParam->getName());
             $parameter->setRequired($reflectionParam->isDefaultValueAvailable() === false);
             // Only set default value when param is optional
             if ($parameter->getRequired() === false) {
                 $parameter->setDefault($reflectionParam->getDefaultValue());
             }
             // Add the parameter to the container
             $method->addParameter($parameter);
         }
         // Add the method to the method container
         $methods->offsetSet(strtolower($method->getName()), $method);
     }
     // Cache reflection in the runtime
     self::$reflections->offsetSet($class, $methods);
     // Return the methods
     return $methods;
 }
Example #2
0
 /**
  * Get the setters of an object
  *
  * @param mixed $object
  * @return Collection\Method
  */
 protected function getSetters($object)
 {
     // Get the current class
     $class = get_class($object);
     // Check if we have already parsed this class
     if (array_key_exists($class, $this->classMethodsCache) === true) {
         return $this->classMethodsCache[$class];
     }
     // Regex for parsing ReflectionParameter::__toString()
     $regex = '/\\[\\s\\<(?P<required>[^\\>]+)\\>\\s' . '(?:(?P<typehint_a>[^\\s]+|(?P<typehint_b>[^\\s]+)\\sor\\s(?P<typehint_c>[^\\s]+))\\s)?' . '(?P<variable>\\$[^\\s]+)\\s(?:=\\s(?P<default>[^\\]]+)\\s)?\\]/';
     // Make reflection and fetch the methods
     $reflectionClass = new ReflectionClass($object);
     $methods = $reflectionClass->getMethods(ReflectionMethod::IS_PUBLIC);
     // Make result container
     $setters = new Collection\Method();
     // Loop through the methods
     foreach ($methods as $method) {
         // We only care about the setters
         if (substr($method->getName(), 0, 3) !== 'set') {
             continue;
         }
         // Get parameter collection
         $parameters = $method->getParameters();
         // We only take care of the first parameter of the setter
         $parameter = $parameters[0];
         $raw = (string) $parameter;
         // If we cannot match it we continue
         if (($result = preg_match($regex, $raw, $matches)) === false || $result === 0) {
             continue;
         }
         // Parse the result of the regex
         $required = $matches['required'] === 'required';
         $variable = $matches['variable'];
         $default = $required ? null : $matches['default'];
         $typehint = null;
         // Advanced typehint detection
         if (empty($matches['typehint_b']) === false) {
             $typehint = $matches['typehint_b'];
         } else {
             if (empty($matches['typehint_a']) === false) {
                 $typehint = $matches['typehint_a'];
             }
         }
         // Set the correct default value
         switch ($default) {
             case null:
             case 'NULL':
                 $default = null;
                 break;
             case 'Array':
                 $default = array();
                 break;
             default:
                 $default = trim($default, "'");
                 break;
         }
         // Has it child objects
         $childObject = $typehint !== null && $typehint !== 'array';
         // Set the results the the response object
         $setters->offsetSet($method->getName(), new Entity\Method($required, $default, $typehint, $childObject));
     }
     // Return the just generated response
     return $this->classMethodsCache[$class] = $setters;
 }