README

Simple DI Container with autowiring in a single file with NO dependencies allows you to easily use it in your PHP applications and especially convenient for WordPress plugins and themes.

Why choose Simple DI Container

Easy to integrate in your WordPress project - just copy one file or install via Composer.
No dependencies on other scripts or libraries.
Supports auto-wiring __constructor parameters for classes as well as for scalar types that have default values.
Supports PHP ^7.4|^8.
Allow you following the best practices for developing your code.
No PHPCS conflicts.
Supports Lazy Load class instantiating.
Lightweight and fast.

How to install in a project

There are several ways, you can choose what you more prefer:

Install via Composer

composer require renakdup/simple-php-dic

Copy and paste file

Just copy the file ./src/Container.php to your plugin directory or theme.
Rename namespace in the file
from Renakdup\SimpleDIC to <Your_Plugin_Name>\SimpleDIC
Include the file.

How to use it

Get started:

Create container instance.
Set a service
Get a service
Use object

use Renakdup\SimpleDIC\Container;

// create container
$container = new Container();

// set service
$container->set( Paypal::class, function () {
    return new Paypal();
} );

// get service
$paypal = $container->get( Paypal::class );

// use this object
$paypal->pay();

SimpleDIC allows to set values for the container for primitive types:

$container->set( 'requests_limit', 100 );
$container->set( 'post_type', 'products' );
$container->set( 'users_ids', [ 1, 2, 3, 4] );

$user_ids = $container->get( 'users_ids', [ 1, 2, 3, 4] );

Method get() can resolve not set object in the $container and then save resolved results in the $container. It means when you run $container->get( $service ) several times you get the same object.

$obj1 = $constructor->get( Paypal::class );
$obj2 = $constructor->get( Paypal::class );
var_dump( $obj1 === $obj2 ) // true

If you want to instantiate service several time use make() method.

Factory

Factory is an anonymous function that wrap creating an instance.
Allows to configure how an object will be created and allows to use Conainer instance inside the factory.

$container->set( Paypal::class, function () {
    return new Paypal();
} );

As well factories create objects in the Lazy Load mode. It means that object will be created just when you resolve it by using get() method:

$container->set( Paypal::class, function () {
    return new Paypal();
} );

$paypal = $constructor->get( Paypal::class ); // PayPal instance created

Container inside factory

SimpleDIC allows to get a Container instance inside a factory if you add parameter in a callback ( Container $c ). This allows to get or resolve another services inside for building an object:

$container->set( 'config', [
    'currency' => '$',
    'environment' => 'production',
] );

$container->set( Paypal::class, function ( Container $c ) {
    return new Paypal( $c->get('config') );
} );

Autowiring

SimpleDIС autowiring feature allows to Container automatically create and inject dependencies.

I'll show an example:

class PayPalSDK {}
class Logger {}

class Paypal {
    public function __constructor( PayPalSDK $pal_sdk, Logger $logger ) {
        //...
    }
}

And then when you create Paypal::class, you run $container->get(Paypal::class), and Container identifies all classes in the constructor and resolves them. As if it's:

new Paypal( new PayPalSDK(), new Logger() );

Container autowiring can resolve default values for primitive parameters in a constructor:

class Logger {
    public function __constructor( $type = 'filestorage', $error_lvl = 1 ) {
        //...
    }
}

You can use auto-wiring feature that allows to Container create an instances that requires in the __constructor of class as well as it resolves constructor dependencies for

Note

But if object creating is more complex and requires configuring and you don't have parameters with default values in the constructor then you need to use factory for preparing service.

Create an instance every time

Method make() resolves services by its name. It returns a new instance of service every time and supports auto-wiring.

$conatainer->make( Paypal::class );

Note

Constructor's dependencies will not instantiate every time.
If dependencies were resolved before then they will be passed as resolved dependencies.

Consider example:

class PayPalSDK {}

class Paypal {
    public PayPalSDK $pal_sdk;
    public function __constructor( PayPalSDK $pal_sdk ) {
        $this->pal_sdk = $pal_sdk;
    }
}

// if we create PayPal instances twice
$paypal1 = $container->make( Paypal::class );
$paypal2 = $container->make( Paypal::class );

var_dump( $paypal1 !== $paypal2 ); // true
var_dump( $paypal1->pal_sdk === $paypal2->pal_sdk ); // true

Dependencies of PayPal service will not be recreated and will be taken from already resolved objects.

PSR11 Compatibility

in progress

Roadmap

Add binding services with configuration
Add auto-wiring for registered classes in DIC
Add auto-wiring for defaults primitives for auto-fillings
Add supporting invocable classes
Add PSR11 interfaces in the Container.php.
Add auto-wiring support for not bounded classes.
Add resolved service storage (getting singleton).
Add ability to create new instances of service every time.
Improve performance.
Fix deprecated Use ReflectionParameter::getType() and the ReflectionType APIs should be used instead. for PHP8
Bind $container instance by default.
Add remove method.
Circular dependency protector.

Nice to have

Integrate CI with running autotests
Add badges with tests passed
Add PHPStan analyzer
Add code coverage badge
Add descriptions in the code for functions.
Choose codestyle
Add on packegist
Add if class exist checks in the Container file?
Rename Container.php to SimpleContainer.php
Show stack trace when I have a debug only?
PHP 8 named arguments and autowiring.
Allow to set definitions via __constructor.
Add supporting Code Driven IoC.
Add configurations of Container.
Add Performance Benchmarks

License

The MIT License (MIT). Please see the License File for more information.

renakdup / simple-dic

Maintainers

Details