README

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.

Installation

The suggested installation method is via composer:

composer require sroze/argument-resolver

Resolving arguments

The argument resolver can be created easily using the ArgumentResolverFactory class:

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:

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:

$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:

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.

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:

$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:

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

Rules

Priorities

These are the resolution priorities for the arguments:

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

Constraints

The following constraints applies:

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