sroze/argument-resolver

A lightweight utility to resolve method arguments based on types and names

Argument Resolver

, _(*1)

This lightweight library helps to automatically call a callable (function, method or closure) with a list of available arguments. The developer of the callable can then use type hinting and/or specific variable names to chose which arguments (s)he wants., _(*2)

Installation

The suggested installation method is via composer:, _(*3)

composer require sroze/argument-resolver

Resolving arguments

The argument resolver can be created easily using the ArgumentResolverFactory class:, _(*4)

use ArgumentResolver\ArgumentResolverFactory;

$argumentResolver = ArgumentResolverFactory::create();

The resolveArguments method returns an ordered array of resolved arguments for the given callable. The method's arguments are:, _(*5)

1. The callable
2. The available arguments, as an array

Here's an example of how it can be used to have arguments of some closures based on a set of available arguments:, _(*6)

$closures = [
    function(MyClass $object) {
        return $object instanceof MyClass;
    },
    function($bar, array $list) {
        return count($list);
    }
];

foreach ($closures as $callable) {
    $arguments = $argumentResolver->resolveArguments($callable, [
        'classObject' => new MyClass(),
        'bar' => 'foo',
        'list' => ['an', 'array']
    ]);

    // ...
}

More than argument identification with type hinting, you can also use names:, _(*7)

class Foo
{
    public function method($foo, $bar)
    {
    }
}

$argumentResolver->resolveArguments([new Foo(), 'method'], [
    'bar' => 1,
    'foo' => 2,
    'baz' => 3
]);

// Which returns: [2, 1]

To prevent possible conflicts, the library follow priorities and constraints described in the Rules chapter., _(*8)

The callable runner

Because when you've resolved the needed arguments of a given callable it's often to call it, the library comes with a CallableRunner class that will do everything for you:, _(*9)

$runner = new CallableRunner($argumentResolver);
$runner->run($callable, $availableArguments);

Instantiate an object

Sometimes, you would like to instantiate an object with a set of arguments. Here's the Instanciator usage:, _(*10)

$instantiator = new Instantiator($argumentResolver);
$instantiator->instantiate(YourClassName::class, $availableArguments);

Rules

Priorities

These are the resolution priorities for the arguments:, _(*11)

1. Strict matching: Same name and same type
2. Type matching
3. Name matching

Constraints

The following constraints applies:, _(*12)

• If there's multiple arguments of the same type, then strict matching apply for this type
• Required arguments have to be resolved