jasny/reflection-factory

Abstract factory for PHP Reflection

v1.1.2 2022-06-10 23:23 UTC

Requires

• php: >=7.4.0

Requires (Dev)

• jasny/php-code-quality: ~2.7.0
• phpunit/phpunit: ^9.0

MIT

• Arnold Daniels

README

Factory to use in dependency injection when using PHP Reflection.

Why use a factory instead or just doing new ReflectionClass()?

Dependency injection might seem like making things needlessly complex. However it's a key component in building maintainable (and testable) code.

Using new within your classes creates a strong coupling between classes. This makes it more difficult when writing unit tests because there is no opertunity to mock the reflection. In practice this means that a class using ReflectionClass can only be tested with real, existing classes.

Using ReflectionFactory with dependency injection, allows you to inject a mock of the factory instead. This in term allows you to create mock Reflection objects, for non-existing classes, functions, properties, etc.

Installation

composer require jasny/reflection-factory

Usage

use Jasny\ReflectionFactory\ReflectionFactory;

$factory = new ReflectionFactory();
$reflection = $factory->reflectClass(\DateTime::class);

Example use case

Without dependency injection

use Jasny\ReflectionFactory\ReflectionFactory;

class SomeTool
{
    public function foo(string $class)
    {
        $reflection = new ReflectionClass($class);
        
        return $reflection->getConstant('FOO');
    }
}

But writing the test is hard, as it doesn't allow mocking. Instead we need to create a SomeToolTestFooSupport class just to test this feature.

class SomeToolTestFooSupport
{
    const FOO = 10;
}

In the unit test we do

use PHPUnit\Framework\TestCase;

class SomeToolTest extends TestCase
{
    public function testFoo()
    {
        $tool = new SomeTool();
        
        $this->assertEquals(10, $tool->foo("SomeToolTestFooSupport"));
    }
}

Adding one test class isn't so bad. But consider we need to add one per test, it quickly becomes a mess.

With dependency injection

Dependency injection adds a little overhead to the class as we need to pass the reflection factory to SomeTool.

use Jasny\ReflectionFactory\ReflectionFactoryInterface;

class SomeTool
{
    protected $reflectionFactory;
    
    public function __construct(ReflectionFactoryInterface $reflectionFactory)
    {
        $this->reflectionFactory = $reflectionFactory;    
    }
    
    public function foo(string $class)
    {
        return $this->reflectionFactory->reflectClass($class)->getConstant('FOO');
    }
}

In the unit test, we mock the ReflectionClass and ReflectionFactory. The tests class FakeClass doesn't need to exist.

use PHPUnit\Framework\TestCase;
use Jasny\ReflectionFactory\ReflectionFactoryInterface;

class SomeToolTest extends TestCase
{
    public function testFoo()
    {
        $mockReflection = $this->createMock(\ReflectionClass::class);
        $mockReflection->expects($this->once())->method('getConstant')
            ->with('FOO')->willReturn(10);
            
        $mockFactory = $this->createMock(ReflectionFactoryInterface::class);
        $mockFactory->expects($this->once())->method('reflectClass')
            ->with('FakeClass')->willReturn($mockReflection);
            
        $tool = new SomeTool($mockFactory);
        
        $this->assertEquals(10, $tool->foo("FakeClass"));
    }
}

Methods

Method	Reflection class
reflectClass	ReflectionClass
reflectClassConstant	ReflectionClassConstant
reflectZendExtension	ReflectionZendExtension
reflectExtension	ReflectionExtension
reflectFunction	ReflectionFunction
reflectMethod	ReflectionMethod
reflectObject	ReflectionObject
reflectParameter	ReflectionParameter
reflectProperty	ReflectionProperty
reflectGenerator	ReflectionGenerator

Some PHP functions have been wrapped, so they can be mocked

Method	Function
functionExists	function_exists
classExists	class_exists
methodExists	method_exists
propertyExists	property_exists
extensionLoaded	extension_loaded
isA	is_a
isCallable	is_callable