Available only since version 2.3.0

In your phpreflect.json configuration file, add in plugins section the following entry:

    {
        "name": "Cache",
        "class": "Bartlett\\Reflect\\Plugin\\Cache\\CachePlugin",
        "options": {
            "adapter": "DoctrineCacheAdapter",
            "backend": {
                "class": "Doctrine\\Common\\Cache\\FilesystemCache",
                "args": [
                    "%{TEMP}/bartlett/cache"
                ]
            }
        }
    }

	You may use any environment variable that will be replaced, at run-time, by their value. E.g: TEMP, HOME

	Since release 2.3.0, the HOME syntax is compatible Linux/Windows.

In previous configuration we used the Doctrine Cache adapter and its File system backend. See the same configuration applied with other SAPI, in Section 17.3, “File cache”

<?php

use Bartlett\Reflect\Provider\SymfonyFinderProvider;
use Symfony\Component\Finder\Finder;

$dirs = dirname(__DIR__) . '/sources';

$finder = new Finder();
$finder->files()
    ->name('*.php')
    ->in($dirs);

$provider = new SymfonyFinderProvider($finder);

At this step, we have created a data source provider that is allowed to retrieve each element to parse.

Reflect need to know it. We attach then the previous provider instance to a Provider Manager, with a label ( e.g: Single ) to identify it easily.

Reflect Provider Manager with a unique data source. 

<?php

use Bartlett\Reflect\ProviderManager;

$pm = new ProviderManager;
$pm->set('Single', $provider);

	A Provider Manager may provide one or more data source identifications. Equivalent to the source-providers section of the phpreflect.json configuration file for the command-line interface.

Reflect Provider Manager with multiple data sources. 

<?php

use Bartlett\Reflect\ProviderManager;
use Bartlett\Reflect\Provider\SymfonyFinderProvider;
use Symfony\Component\Finder\Finder;

$pm = new ProviderManager;

// -- source 1
$source1 = dirname(__DIR__) . '/sources/';

$finder1 = new Finder();
$finder1->files()
    ->name('sample1.php')
    ->in($source1);

$pm->set('Sample', new SymfonyFinderProvider($finder1));

// -- source 2
$pharFile = dirname(__DIR__) . '/sources/pirus.phar';
$source2  = 'phar://' . $pharFile;

$finder2 = new Finder();
$finder2->files()
    ->path('/Pirus/')
    ->name('*.php')
    ->in($source2);

$pm->set('Pirus', new SymfonyFinderProvider($finder2));

On this example Reflect is able to parse contents of two data sources: Sample and Pirus, all at once (default behavior) or individually.

Your first collection returned could be the list of packages defined in your source code, if any.

Packages or Namespaces are used to organize software elements to avoid conflicts.

Indifferently, we will use the term package or namespace as an alias of the other. Main reason is that PHP5 provides only namespace and not package element as Java.

Reflect returns a list of namespaces/packages with the getPackages() method.

<?php

use Bartlett\Reflect;

$reflect = new Reflect;

$packages = $reflect->getPackages();

This list ($packages) is an iterator, that can be traversed by a simple foreach loop.

Easy exploit namespaces. 

<?php

use Bartlett\Reflect;

foreach ($reflect->getPackages() as $package) {
    echo $package->getName(), PHP_EOL;
}

Your second collection returned could be the list of classes defined in a package, if any.

Reflect returns a list of classes with the getClasses() method.

<?php

use Bartlett\Reflect;

$reflect = new Reflect;

foreach ($reflect->getPackages() as $package) {
    $classes = $package->getClasses();
}

This list ($classes) is an iterator, that can be traversed by a simple foreach loop.

Easy exploit classes. 

<?php

use Bartlett\Reflect;

$reflect = new Reflect;

foreach ($reflect->getPackages() as $package) {
    foreach ($package->getClasses() as $class) {
        echo $class->getName(), PHP_EOL;
    }
}

Your next collection returned could be the list of interfaces defined in a package, if any.

Reflect returns a list of interfaces with the getInterfaces() method.

<?php

use Bartlett\Reflect;

$reflect = new Reflect;

foreach ($reflect->getPackages() as $package) {
    $interfaces = $package->getInterfaces();
}

This list ($interfaces) is an iterator, that can be traversed by a simple foreach loop.

Easy exploit interfaces. 

<?php

use Bartlett\Reflect;

foreach ($reflect->getPackages() as $package) {
    foreach ($package->getInterfaces() as $interface) {
        echo $interface->getName(), PHP_EOL;
    }
}

Your next collection returned could be the list of traits defined in a package, if any.

Reflect returns a list of traits with the getTraits() method.

<?php

use Bartlett\Reflect;

$reflect = new Reflect;

foreach ($reflect->getPackages() as $package) {
    $traits = $package->getTraits();
}

This list ($traits) is an iterator, that can be traversed by a simple foreach loop.

Easy exploit traits. 

<?php

use Bartlett\Reflect;

foreach ($reflect->getPackages() as $package) {
    foreach ($package->getTraits() as $trait) {
        echo $trait->getName(), PHP_EOL;
    }
}

Your next collection returned could be the list of class properties defined in a package, if any.

Reflect returns a list of class properties with the getProperties() method.

<?php

use Bartlett\Reflect;

$reflect = new Reflect;

foreach ($reflect->getPackages() as $package) {
    foreach ($package->getClasses() as $class) {
        printf( 'Processing class "%s" ...' . PHP_EOL, $class->getName() );
        $properties = array();

        foreach ($class->getProperties() as $property) {
            $properties[] = $property->getName();
        }
        printf( 'Properties are : %s' . PHP_EOL, print_r($properties, true) );
    }
}

Your next collection returned could be the list of function parameters defined, if any.

Reflect returns a list of function parameters with the getParameters() method.

<?php

use Bartlett\Reflect;

$reflect = new Reflect;

foreach ($reflect->getPackages() as $package) {
    foreach ($package->getClasses() as $class) {
        printf( 'Processing class "%s" ...' . PHP_EOL, $class->getName() );

        foreach ($class->getMethods() as $method) {
            $parameters = array();

            foreach ($method->getParameters() as $parameter) {
                $parameters[] = $parameter->getName();
            }
            printf( 'Parameters are : %s' . PHP_EOL, print_r($parameters, true) );
        }
    }
}

Your next collection returned could be the list of functions defined in a package, if any.

Reflect returns a list of user functions with the getFunctions() method.

<?php

use Bartlett\Reflect;

$reflect = new Reflect;

foreach ($reflect->getPackages() as $package) {
    $functions = $package->getFunctions();
}

This list ($functions) is an iterator, that can be traversed by a simple foreach loop.

Easy exploit functions. 

<?php

use Bartlett\Reflect;

foreach ($reflect->getPackages() as $package) {
    foreach ($package->getFunctions() as $function) {
        echo $function->getName(), PHP_EOL;
    }
}

Your next collection returned could be the list of constants defined in a package, if any.

Reflect returns a list of constants with the getConstants() method.

<?php

use Bartlett\Reflect;

$reflect = new Reflect;

foreach ($reflect->getPackages() as $package) {
    $constants = $package->getConstants();
}

This list ($constants) is an iterator, that can be traversed by a simple foreach loop.

Easy exploit constants. 

<?php

use Bartlett\Reflect;

foreach ($reflect->getPackages() as $package) {
    foreach ($package->getConstants() as $constant) {
        echo $constant->getName(), PHP_EOL;
    }
}

Your next collection returned could be the list of includes defined in a package, if any.

Reflect returns a list of includes with the getIncludes() method.

<?php

use Bartlett\Reflect;

$reflect = new Reflect;

foreach ($reflect->getPackages() as $package) {
    $includes = $package->getIncludes();
}

This list ($includes) is an iterator, that can be traversed by a simple foreach loop.

Easy exploit includes. 

<?php

use Bartlett\Reflect;

foreach ($reflect->getPackages() as $package) {
    foreach ($package->getIncludes() as $include) {
        echo $include->getFilePath(), PHP_EOL;
    }
}

Your last collection returned could be the list of dependencies defined in a package, if any.

Reflect returns a list of dependencies with the getDependencies() method.

<?php

use Bartlett\Reflect;

$reflect = new Reflect;

foreach ($reflect->getPackages() as $package) {
    $dependencies = $package->getDependencies();
}

This list ($dependencies) is an iterator, that can be traversed by a simple foreach loop.

Easy exploit dependencies. 

<?php

use Bartlett\Reflect;

foreach ($reflect->getPackages() as $package) {
    foreach ($package->getDependencies() as $dep) {
        echo $dep->getName(), PHP_EOL;
    }
}

The Bartlett\Reflect\Model\PackageModel class reports information about a package/namespace.

Reflect returns a list of packages with the getPackages() method, and each of these elements can be exploited with this PackageModel.

<?php

use Bartlett\Reflect;

$reflect = new Reflect;

$packages = $reflect->getPackages();

This list ($packages) is an iterator, that can be traversed by a simple foreach loop. Each $package element returned is an instance of PackageModel.

Gets an array of element counters. 

<?php

use Bartlett\Reflect;

foreach ($reflect->getPackages() as $package) {
    $pkgName = $package->getName();
    printf( 'Processing package "%s" ...' . PHP_EOL, $pkgName );

    $counters = array(
        'classes'    => count($package->getClasses()),
        'interfaces' => count($package->getInterfaces()),
        'traits'     => count($package->getTraits()),
        'functions'  => count($package->getFunctions()),
        'constants'  => count($package->getConstants()),
        'includes'   => count($package->getIncludes()),
    );

    printf( 'Metrics : %s' . PHP_EOL, print_r($counters, true) );
}

And lot more. See PackageModel Reference to learn all features and behaviors.

	PackageModel Reference is not yet available.

The Bartlett\Reflect\Model\ClassModel class reports information about a class, an interface or a trait.

Reflect returns a list of classes with the getClasses() method, and each of these elements can be exploited with this ClassModel.

<?php

use Bartlett\Reflect;

$reflect = new Reflect;

foreach ($reflect->getPackages() as $package) {
    $classes = $package->getClasses();
}

This list ($classes) is an iterator, that can be traversed by a simple foreach loop. Each $class element returned is an instance of ClassModel.

Gets an array of methods for the class. 

<?php

use Bartlett\Reflect;

foreach ($reflect->getPackages() as $package) {
    foreach ($package->getClasses() as $class) {
        printf( 'Processing class "%s" ...' . PHP_EOL, $class->getName() );
        $methods = array();

        foreach ($class->getMethods() as $method) {
            $methods[] = $method->getShortName();
        }
        printf( 'Methods are : %s' . PHP_EOL, print_r($methods, true) );
    }
}

Gets an array of constants for the class. 

<?php

use Bartlett\Reflect;

foreach ($reflect->getPackages() as $package) {
    foreach ($package->getClasses() as $class) {
        printf( 'Processing class "%s" ...' . PHP_EOL, $class->getName() );
        $constants = array();

        foreach ($class->getConstants() as $constant) {
            $constants[ $constant->getShortName() ] = $constant->getValue();
        }
        printf( 'Constants are : %s' . PHP_EOL, print_r($constants, true) );
    }
}

Gets an array of properties for the class. 

<?php

use Bartlett\Reflect;

foreach ($reflect->getPackages() as $package) {
    foreach ($package->getClasses() as $class) {
        printf( 'Processing class "%s" ...' . PHP_EOL, $class->getName() );
        $properties = array();

        foreach ($class->getProperties() as $property) {
            $properties[] = $property->getName();
        }
        printf( 'Properties are : %s' . PHP_EOL, print_r($properties, true) );
    }
}

And lot more. See ClassModel Reference to learn all features and behaviors.

	ClassModel Reference is not yet available.

The Bartlett\Reflect\Model\ClassModel class reports information about a class, an interface or a trait.

Reflect returns a list of interfaces with the getInterfaces() method, and each of these elements can be exploited with this ClassModel.

<?php

use Bartlett\Reflect;

$reflect = new Reflect;

foreach ($reflect->getPackages() as $package) {
    $interfaces = $package->getInterfaces();
}

This list ($interfaces) is an iterator, that can be traversed by a simple foreach loop. Each $interface element returned is an instance of ClassModel.

Gets an array of methods for the interface. 

<?php

use Bartlett\Reflect;

foreach ($reflect->getPackages() as $package) {
    foreach ($package->getInterfaces() as $interface) {
        printf( 'Processing interface "%s" ...' . PHP_EOL, $interface->getName() );
        $methods = array();

        foreach ($interface->getMethods() as $method) {
            $methods[] = $method->getShortName();
        }
        printf( 'Methods are : %s' . PHP_EOL, print_r($methods, true) );
    }
}

And lot more. See ClassModel Reference to learn all features and behaviors.

	ClassModel Reference is not yet available.

The Bartlett\Reflect\Model\ClassModel class reports information about a class, an interface or a trait.

Reflect returns a list of traits with the getTraits() method, and each of these elements can be exploited with this ClassModel.

<?php

use Bartlett\Reflect;

$reflect = new Reflect;

foreach ($reflect->getPackages() as $package) {
    $traits = $package->getTraits();
}

This list ($traits) is an iterator, that can be traversed by a simple foreach loop. Each $interface element returned is an instance of ClassModel.

Gets an array of methods for the trait. 

<?php

use Bartlett\Reflect;

foreach ($reflect->getPackages() as $package) {
    foreach ($package->getTraits() as $trait) {
        printf( 'Processing trait "%s" ...' . PHP_EOL, $trait->getName() );
        $methods = array();

        foreach ($trait->getMethods() as $method) {
            $methods[] = $method->getShortName();
        }
        printf( 'Methods are : %s' . PHP_EOL, print_r($methods, true) );
    }
}

And lot more. See ClassModel Reference to learn all features and behaviors.

	ClassModel Reference is not yet available.

The Bartlett\Reflect\Model\PropertyModel class reports information about a class property.

Reflect returns a list of class properties with the getProperties() method, and each of these elements can be exploited with this PropertyModel.

<?php

use Bartlett\Reflect;

$reflect = new Reflect;

foreach ($reflect->getPackages() as $package) {
    foreach ($package->getClasses() as $class) {
        $properties = $class->getProperties();
    }
}

This list ($properties) is an iterator, that can be traversed by a simple foreach loop. Each $properties element returned is an instance of PropertyModel.

<?php

use Bartlett\Reflect;

foreach ($reflect->getPackages() as $package) {
    foreach ($package->getClasses() as $class) {
        printf( 'Processing class "%s" ...' . PHP_EOL, $class->getName() );
        $properties = array();

        foreach ($class->getProperties() as $property) {
            $properties[] = $property->getName();
        }
        printf( 'Properties are : %s' . PHP_EOL, print_r($properties, true) );
    }
}

	PropertyModel Reference is not yet available.

The Bartlett\Reflect\Model\ParameterModel class reports information about a function parameter.

Reflect returns a list of function parameters with the getParameters() method, and each of these elements can be exploited with this ParameterModel.

<?php

use Bartlett\Reflect;

$reflect = new Reflect;

foreach ($reflect->getPackages() as $package) {
    foreach ($package->getClasses() as $class) {
        foreach ($class->getMethods() as $method) {
            $parameters = $method->getParameters();
        }
    }
}

This list ($parameters) is an iterator, that can be traversed by a simple foreach loop. Each $parameters element returned is an instance of ParameterModel.

<?php

use Bartlett\Reflect;

$reflect = new Reflect;

foreach ($reflect->getPackages() as $package) {
    foreach ($package->getClasses() as $class) {
        printf( 'Processing class "%s" ...' . PHP_EOL, $class->getName() );

        foreach ($class->getMethods() as $method) {
            $parameters = array();

            foreach ($method->getParameters() as $parameter) {
                $parameters[] = $parameter->getName();
            }
            printf( 'Parameters are : %s' . PHP_EOL, print_r($parameters, true) );
        }
    }
}

	ParameterModel Reference is not yet available.

The Bartlett\Reflect\Model\FunctionModel class reports information about a function.

Reflect returns a list of user functions with the getFunctions() method, and each of these elements can be exploited with this FunctionModel.

<?php

use Bartlett\Reflect;

$reflect = new Reflect;

foreach ($reflect->getPackages() as $package) {
    $functions = $package->getFunctions();
}

This list ($functions) is an iterator, that can be traversed by a simple foreach loop. Each $function element returned is an instance of FunctionModel.

Gets an array of functions for the data source. 

<?php

use Bartlett\Reflect;

foreach ($reflect->getPackages() as $package) {
    foreach ($package->getFunctions() as $function) {
        printf( 'Processing function "%s" ...' . PHP_EOL, $function->getName() );
        $parameters = array();

        foreach ($function->getParameters() as $parameter) {

            $parameters[] = array(
                'position' => $parameter->getPosition(),
                'optional' => $parameter->isOptional() ? 'YES' : 'NO',
                'name'     => $parameter->getName(),
            );
        }
        printf( 'Parameters are : %s' . PHP_EOL, print_r($parameters, true) );
    }
}

And lot more. See FunctionModel Reference to learn all features and behaviors.

	FunctionModel Reference is not yet available.

The Bartlett\Reflect\Model\ConstantModel class reports information about a constant.

Reflect returns a list of constants with the getConstants() method, and each of these elements can be exploited with this ConstantModel.

<?php

use Bartlett\Reflect;

$reflect = new Reflect;

foreach ($reflect->getPackages() as $package) {
    $constants = $package->getConstants();
}

This list ($constants) is an iterator, that can be traversed by a simple foreach loop. Each $constant element returned is an instance of ConstantModel.

Gets an array of constants for the data source. 

<?php

use Bartlett\Reflect;

foreach ($reflect->getPackages() as $package) {
    foreach ($package->getConstants() as $constant) {
        printf( 'Processing constant "%s" ...' . PHP_EOL, $constant->getName() );

        if ($constant->isMagic() === true) {
            echo '- Magic constant';
        } else {
            echo '- User constant with value ' . $constant->getValue();
        }
        echo PHP_EOL;
    }
}

And lot more. See ConstantModel Reference to learn all features and behaviors.

	ConstantModel Reference is not yet available.

The Bartlett\Reflect\Model\IncludeModel class reports information about an include.

Reflect returns a list of includes with the getIncludes() method, and each of these elements can be exploited with this IncludeModel.

<?php

use Bartlett\Reflect;

$reflect = new Reflect;

foreach ($reflect->getPackages() as $package) {
    $includes = $package->getIncludes();
}

This list ($includes) is an iterator, that can be traversed by a simple foreach loop. Each $include element returned is an instance of IncludeModel.

Gets an array of includes for the data source. 

<?php

use Bartlett\Reflect;

foreach ($reflect->getPackages() as $package) {
    foreach ($package->getIncludes() as $include) {
        if ($include->isRequire() === true) {
            printf( '- require "%s"', $include->getFilePath() );
        } elseif ($include->isRequireOnce() === true) {
            printf( '- require_once "%s"', $include->getFilePath() );
        } elseif ($include->isInclude() === true) {
            printf( '- include "%s"', $include->getFilePath() );
        } elseif ($include->isIncludeOnce() === true) {
            printf( '- include_once "%s"', $include->getFilePath() );
        }
        echo PHP_EOL;
    }
}

And lot more. See IncludeModel Reference to learn all features and behaviors.

	IncludeModel Reference is not yet available.

The Bartlett\Reflect\Model\DependencyModel class reports information about a dependency like class, an interface, a php or extension function.

Reflect returns a list of dependencies with the getDependencies() method, and each of these elements can be exploited with this DependencyModel.

<?php

use Bartlett\Reflect;

$reflect = new Reflect;

foreach ($reflect->getPackages() as $package) {
    $dependencies = $package->getDependencies();
}

This list ($dependencies) is an iterator, that can be traversed by a simple foreach loop. Each $dependency element returned is an instance of DependencyModel.

Gets an array of internal php functions. 

<?php

use Bartlett\Reflect;

$internalFunctions = array();

foreach ($reflect->getPackages() as $package) {
    foreach ($package->getDependencies() as $dep) {
        $internalFunctions[] = $dep->getName();
    }
}
print_r($internalFunctions);

And lot more. See DependencyModel Reference to learn all features and behaviors.

	DependencyModel Reference is not yet available.

Reflect implement interface Bartlett\Reflect\Event\DispatcherInterface. You can add event listeners and event subscribers to this object.

You can get the EventDispatcher of Bartlett\Reflect\Event\DispatcherInterface by calling the getEventDispatcher() method.

Here is an example :

<?php

use Bartlett\Reflect;

$reflect = new Reflect;

$ed = $reflect->getEventDispatcher();

After you have the event dispatcher, you can register event listeners that listen to specific events.

<?php

use Bartlett\Reflect;
use Symfony\Component\EventDispatcher\GenericEvent;

$reflect = new Reflect;

$reflect->getEventDispatcher()->addListener(
    'reflect.progress',
    function (GenericEvent $e) {
        printf(
            'Parsing Data source "%s" in progress ... File "%s"' . PHP_EOL,
            $e['source'],
            $e['file']->getPathname()
        );
    }
);

<?php

use Bartlett\Reflect;
use Symfony\Component\EventDispatcher\GenericEvent;

$reflect = new Reflect;

$reflect->getEventDispatcher()->addListener(
    'reflect.success',
    function (GenericEvent $e) {
        $ast = unserialize($e['ast']);
        printf(
            'Parsing Data source "%s", file "%s". AST = %s' . PHP_EOL,
            $e['source'],
            $e['file'],
            print_r($ast, true)
        );

    }
);

Event subscribers are classes that implement interface Symfony\Component\EventDispatcher\EventSubscriberInterface. They are used to register one or more event listeners to methods of the class. Event subscribers tell event dispatcher exactly which events to listen to and what method to invoke on the class.

Reflect plugins follow the event subscribers behaviors. Have a look on AnalyserPlugin :

<?php
class AnalyserPlugin implements EventSubscriberInterface
{
    public static function getSubscribedEvents()
    {
        return array(
            'reflect.complete' => 'onReflectComplete',
        );
    }
}

This plugin registers event listeners to the reflect.complete event of a Reflect parse request.

When the reflect.complete event is emitted, the onReflectComplete instance method of the plugin is invoked.