Skip to content
Higher order factories for PHP
PHP
Branch: master
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Permalink
Type Name Latest commit message Commit time
Failed to load latest commit information.
src
tests
.gitattributes
.gitignore
.styleci.yml
.travis.yml
LICENSE.md
README.md
composer.json
phpunit.xml

README.md

Higher order factories

Latest Version Software License Build Status StyleCI

This package provides a declarative higher order syntax for implementing the factory pattern.

use function Skollro\Factory\make;

class VehicleFactory
{
    public static function make($type)
    {
        return make($type)
            ->resolve('car', Car::class)
            ->resolve('bike', Bike::class)
            ->resolve([
                'truck' => Truck::class,
                'bus' => Bus::class,
            ])
            ->otherwiseThrow(InvalidArgumentException::class);
    }
}

$car = VehicleFactory::make('car'); // returns instance of Car
$truck = VehicleFactory::make('truck'); // returns instance of Truck
$motorcycle = VehicleFactory::make('motorcycle') // throws InvalidArgumentException

Install

You can install this package via composer:

composer require skollro/factory

Usage

Every make consists out of one or multiple resolve and one otherwise to provide values for each path.

make($type): Factory

This package provides a helper function make.

use Skollro\Factory\Factory;
use function Skollro\Factory\make;

$factory = make($type);
$factory = Factory::make($type);

resolve($type, $resolvable = null): Factory

$type is the identifier of an instance. $type also accepts an associative array which maps identifiers to class names. $resolvable can be some class name or a callable that returns an instance.

$object = make('bike')
    ->resolve('car', Car::class)
    ->resolve('bike', function () {
        return new Bike;
    })
    ->resolve('bike', MountainBike::class) // this is not the first match and thus not the result
    ->resolve([
        'truck' => Truck::class,
        'bus' => Bus::class,
    ])
    ->otherwiseThrow(InvalidArgumentException::class);

// $object is an instance of Bike

otherwise($resolvable)

$resolvable is some class name or a callable that returns an instance. Supplies the default instance if no resolve has matched before.

$object = make('motorcycle')
    ->resolve([
        'car' => Car::class,
        'bike' => Bike::class,
    ])
    ->otherwise(Vehicle::class);

// $object is an instance of Vehicle

$object = make('motorcycle')
    ->resolve([
        'car' => Car::class,
        'bike' => Bike::class,
    ])
    ->otherwise(function () {
        return new Vehicle;
    });

// $object is an instance of Vehicle

otherwiseThrow($resolvable)

$resolvable is some exception class name or a callable that returns an exception. Throws an exception if no resolve has matched before.

$object = make('motorcycle')
    ->resolve([
        'car' => Car::class,
        'bike' => Bike::class,
    ])
    ->otherwiseThrow(InvalidArgumentException::class);

// throws an InvalidArgumentException

Factory::resolveUsing($resolver)

resolveUsing is a static method of Factory. You can use a custom resolver to resolve an instance from a class name, e.g. a dependency injection container. If no resolver is set, an instance of the requested class is created with new.

Integration with Laravel
// in your AppServiceProvider
Factory::resolveUsing(function ($className) {
    return app($className);
});

// in your code
$object = make('car')
    ->resolve('car', Car::class)
    ->otherwiseThrow(InvalidArgumentException::class);

// $object is an instance of Car, resolved by Laravel container

License

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

You can’t perform that action at this time.