Refactored entire Reflector to be more flexible

README.md

@@ -4,18 +4,54 @@ Better Reflection
 Mimics PHP's [reflection API](http://php.net/manual/en/book.reflection.php) but without actually loading the class at
 any point. Like magic. Idea credit goes to @ocramius.
 
-Example usage:
+Example usage with the Composer autoloader:
 
 ```php
 <?php
 
 $classLoader = require "vendor/autoload.php";
 
-$reflector = new Reflector($classLoader);
+use BetterReflection\Reflector\ClassReflector;
 
+$reflector = new ClassReflector(new ComposerSourceLocator($classLoader));
 $reflectionClass = $reflector->reflect('Foo\Bar\MyClass');
 
 echo $reflectionClass->getShortName(); // MyClass
 echo $reflectionClass->getName(); // Foo\Bar\MyClass
 echo $reflectionClass->getNamespaceName(); // Foo\Bar
 ```
+
+Example usage for loading a class from a specific file:
+
+```php
+<?php
+
+$reflector = new ClassReflector(new SingleFileSourceLocator('path/to/MyApp/MyClass.php'));
+$reflectionClass = $reflector->reflect('MyApp\MyClass');
+
+echo $reflectionClass->getShortName(); // MyClass
+echo $reflectionClass->getName(); // MyApp\MyClass
+echo $reflectionClass->getNamespaceName(); // MyApp
+```
+
+Example usage for loading a class from a string:
+
+```php
+<?php
+
+$code = '<?php class Foo {};';
+
+$reflector = new ClassReflector(new StringSourceLocator($code));
+$reflectionClass = $reflector->reflect('Foo');
+
+echo $reflectionClass->getShortName(); // Foo
+```
+
+Example usage to fetch a list of classes from a file
+
+```php
+<?php
+
+$reflector = new ClassReflector(new SingleFileSourceLocator('path/to/file.php'));
+$classes = $reflector->getClassesFromFile();
+```

composer.json

@@ -17,6 +17,9 @@
             "BetterReflectionTest\\": "test"
         }
     },
+    "suggest": {
+        "composer/composer": "Required to use the ComposerSourceLocator thing"
+    },
     "minimum-stability": "dev",
     "prefer-stable": true
 }

src/Identifier/Identifier.php

@@ -0,0 +1,52 @@
+<?php
+
+namespace BetterReflection\Identifier;
+
+use PhpParser\Node;
+
+class Identifier
+{
+    /**
+     * @var string
+     */
+    private $name;
+
+    /**
+     * @var IdentifierType
+     */
+    private $type;
+
+    public function __construct($name, IdentifierType $type)
+    {
+        $this->type = $type;
+
+        $name = ltrim($name, '\\');
+        // @todo validate the name somehow (see issue #20)
+        $this->name = (string)$name;
+    }
+
+    /**
+     * @return string
+     */
+    public function getName()
+    {
+        return $this->name;
+    }
+
+    /**
+     * @return IdentifierType
+     */
+    public function getType()
+    {
+        return $this->type;
+    }
+
+    /**
+     * @todo implement this
+     * @return bool
+     */
+    public function isLoaded()
+    {
+        return false;
+    }
+}

src/Identifier/IdentifierType.php

@@ -0,0 +1,56 @@
+<?php
+
+namespace BetterReflection\Identifier;
+
+use PhpParser\Node;
+use BetterReflection\Reflection\ReflectionClass;
+use BetterReflection\Reflection\Reflection;
+
+class IdentifierType
+{
+    const IDENTIFIER_CLASS = ReflectionClass::class;
+
+    /**
+     * @var string[]
+     */
+    private $validTypes = [
+        self::IDENTIFIER_CLASS,
+    ];
+
+    /**
+     * @var string
+     */
+    private $name;
+
+    public function __construct($type = self::IDENTIFIER_CLASS)
+    {
+        if (!in_array($type, $this->validTypes, true)) {
+            throw new \InvalidArgumentException(sprintf(
+                '%s is not a valid identifier type',
+                $type
+            ));
+        }
+        $this->name = $type;
+    }
+
+    /**
+     * @return string
+     */
+    public function getName()
+    {
+        return $this->name;
+    }
+
+    /**
+     * @return string
+     */
+    public function getDisplayName()
+    {
+        return ucfirst(basename($this->name));
+    }
+
+    public function isMatchingReflector(Reflection $reflector)
+    {
+        return $this->name === get_class($reflector);
+    }
+}

src/NodeCompiler/CompileNodeToValue.php

@@ -0,0 +1,45 @@
+<?php
+
+namespace BetterReflection\NodeCompiler;
+
+use PhpParser\Node;
+
+class CompileNodeToValue
+{
+    /**
+     * Compile an expression from a node into a value
+     *
+     * @param Node $node
+     * @return mixed
+     */
+    public function __invoke(Node $node)
+    {
+        switch (get_class($node)) {
+            case Node\Scalar\String_::class:
+            case Node\Scalar\DNumber::class:
+            case Node\Scalar\LNumber::class:
+                return $node->value;
+            case Node\Expr\Array_::class:
+                return []; // @todo compile expression
+            case Node\Expr\ConstFetch::class:
+                if ($node->name->parts[0] == 'null') {
+                    return null;
+                } else if ($node->name->parts[0] == 'false') {
+                    return false;
+                } else if ($node->name->parts[0] == 'true') {
+                    return true;
+                } else {
+                    // @todo this should evaluate the VALUE, not the name
+                    return $node->name->parts[0];
+                }
+                break;
+            case Node\Expr\ClassConstFetch::class:
+                // @todo this should evaluate the VALUE, not the name
+                $className = implode('\\', $node->class->parts);
+                $constName = $node->name;
+                return $className . '::' . $constName;
+            default:
+                throw new \LogicException('Unable to compile expression: ' . $type);
+        }
+    }
+}

src/Reflection/Exception/InvalidDefaultValueType.php

@@ -0,0 +1,7 @@
+<?php
+
+namespace BetterReflection\Reflection\Exception;
+
+class InvalidDefaultValueType extends \RuntimeException
+{
+}

src/Reflection/Reflection.php

@@ -0,0 +1,20 @@
+<?php
+
+namespace BetterReflection\Reflection;
+
+/**
+ * This interface is used internally by the Generic reflector in order to
+ * ensure we are working with BetterReflection reflections
+ *
+ * @internal
+ */
+interface Reflection
+{
+    /**
+     * Get the name of the reflection (e.g. if this is a ReflectionClass this
+     * will be the class name).
+     *
+     * @return string
+     */
+    public function getName();
+}