Initial Implementation

Signed-off-by: RJ Garcia <[email protected]>

Author: ragboyjr

.gitignore

@@ -0,0 +1,3 @@
+/vendor/
+/playground.php
+/composer.lock

CHANGELOG.md

@@ -0,0 +1,11 @@
+# Change Log
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](http://keepachangelog.com/)
+and this project adheres to [Semantic Versioning](http://semver.org/).
+
+## [Unreleased]
+### Added
+
+- Initial Implementation
+- Added Documentation

LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) Bighead Technology 2017
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Makefile

@@ -0,0 +1,4 @@
+.PHONY: test
+
+test:
+	./vendor/bin/peridot test

README.md

@@ -0,0 +1,72 @@
+# Auto Args
+
+Auto Args provides a system for automatically resolving arguments for any callable. This can also be referred to as Auto wiring.
+
+## Installation
+
+Install with composer at `krak/auto-args`.
+
+## Usage
+
+```php
+<?php
+
+use Krak\AutoArgs;
+
+$args = new AutoArgs();
+
+$context = [
+    'vars' => ['a' => 1],
+    'objects' => [new SplStack()],
+];
+
+$func = function($a, SplDoublyLinkedList $stack, $b = 1) {
+    assert($a == 1 && $b === 1);
+};
+
+$args->invoke($func, $context);
+```
+
+### Pimple Integration
+
+```php
+<?php
+
+use Krak\AutoArgs;
+
+$args = new AutoArgs();
+
+$context = [
+    'pimple' => new \Pimple\Container([
+        AutoArgs\AutoArgs::class => function() {
+            return $this->aa;
+        }
+    ])
+];
+
+$func = function(\Pimple\Container $container, AutoArgs\AutoArgs $aa) {
+
+};
+
+$args->invoke($func, $context);
+```
+
+## API
+
+### Class AutoArgs
+
+#### \_\_construct($resolve_arg = null)
+
+Accepts an argument resolver which will accept Argument metadata and context and return the proper argument for it. If none is supplied, the default stack is created and composed instead.
+
+#### mixed invoke(callable $callable, array $context)
+
+Invokes a callable and resolves the arguments from the argument resolver and given context.
+
+#### array resolveArguments(callable $callable, array $context)
+
+Returns the array of resolved arguments for the given callable. An exception will be thrown if no argument was able to be resolved.
+
+#### Krak\\Mw\\MwStack ::createStack()
+
+Returns a configured instance of an mw stack.

composer.json

@@ -0,0 +1,27 @@
+{
+    "name": "krak/auto-args",
+    "description": "Auto Argument Resolver",
+    "type": "library",
+    "license": "MIT",
+    "keywords": ["auto args", "auto wiring", "argument resolver"],
+    "authors": [
+        {
+            "name": "RJ Garcia",
+            "email": "[email protected]"
+        }
+    ],
+    "require-dev": {
+        "peridot-php/peridot": "^1.18",
+        "pimple/pimple": "^3.0",
+        "symfony/var-dumper": "^3.2"
+    },
+    "autoload": {
+        "psr-4": {
+            "Krak\\AutoArgs\\": "src"
+        },
+        "files": ["src/resolve-argument.php"]
+    },
+    "require": {
+        "krak/mw": "^0.4.0"
+    }
+}

src/AutoArgs.php

@@ -0,0 +1,63 @@
+<?php
+
+namespace Krak\AutoArgs;
+
+use Krak\Mw;
+
+class AutoArgs
+{
+    private $resolve_arg;
+
+    public function __construct(callable $resolve_arg = null) {
+        $this->resolve_arg = $resolve_arg ?: self::createStack()->compose(function() {
+            return [];
+        });
+    }
+
+    public function invoke(callable $callable, array $context) {
+        $args = $this->resolveArguments($callable, $context);
+        return call_user_func_array($callable, $args);
+    }
+
+    /** resolves the arguments for the callable and returns the array of args */
+    public function resolveArguments(callable $callable, array $context) {
+        $resolve_arg = $this->resolve_arg;
+
+        $rf = $this->callableToReflectionFunctionAbstract($callable);
+
+        $args = [];
+        foreach ($rf->getParameters() as $i => $arg_meta) {
+            $arg = $resolve_arg($arg_meta, $context);
+            if (!count($arg) && $arg_meta->isOptional()) {
+                continue;
+            } else if (!count($arg)) {
+                throw new \RuntimeException(sprintf('Action argument %d is unable to be resolved.', $i));
+            }
+
+            $args[] = $arg[0];
+        }
+
+        return $args;
+    }
+
+    public function callableToReflectionFunctionAbstract(callable $callable) {
+        if (is_array($callable)) {
+            return new \ReflectionMethod($callable[0], $callable[1]);
+        } else if (is_object($callable) && method_exists($callable, '__invoke')) {
+            return new \ReflectionMethod($callable, '__invoke');
+        } else if (is_string($callable) && strpos($callable, '::') !== false) {
+            list($class, $method) = explode('::', $callable);
+            return new \ReflectionMethod($class, $method);
+        } else {
+            return new \ReflectionFunction($callable);
+        }
+    }
+
+    public static function createStack() {
+        return mw\stack('Resolve Argument')
+            ->push(defaultValueResolveArgument(), -1, 'defaultValue')
+            ->push(varNameResolveArgument(), 0, 'varName')
+            ->push(subclassOfResolveArgument(), 0, 'subclassOf')
+            ->push(pimpleContainerResolveArgument(), 0, 'pimpleContainer');
+    }
+}

src/resolve-argument.php

@@ -0,0 +1,91 @@
+<?php
+
+namespace Krak\AutoArgs;
+
+use Krak\Mw,
+    ReflectionParameter;
+
+/** array resolveArgument(ReflectionParameter, array);
+    array resolveArgumentMiddleware(ReflectParameter, array, callable $next)
+*/
+
+function _isSubclassOf($parent, $child) {
+    return $parent == $child || is_subclass_of($child, $parent);
+}
+
+function hasKeyResolveArgument($key, $mw) {
+    return mw\filter($mw, function(ReflectionParameter $arg_meta, array $context) use ($key) {
+        return array_key_exists($key, $context);
+    });
+}
+
+/** Resolves an argument if the context contains a key that matches the var name */
+function varNameResolveArgument($key = 'vars') {
+    return hasKeyResolveArgument($key, function(ReflectionParameter $arg_meta, array $context, $next) use ($key) {
+        $vars = $context[$key];
+
+        if (array_key_exists($arg_meta->getName(), $vars)) {
+            return [$vars[$arg_meta->getName()]];
+        }
+
+        return $next($arg_meta, $context);
+    });
+}
+
+/** Resolves the argument if is a subclass of */
+function subclassOfResolveArgument($key = 'objects') {
+    return hasKeyResolveArgument($key, function(ReflectionParameter $arg_meta, array $context, $next) use ($key) {
+        if (!$arg_meta->getClass()) {
+            return $next($arg_meta, $context);
+        }
+
+        $class = $arg_meta->getClass();
+        $objects = $context[$key];
+
+        foreach ($objects as $obj) {
+            if (_isSubclassOf($arg_meta->getClass()->getName(), get_class($obj))) {
+                return [$obj];
+            }
+        }
+
+        return $next($arg_meta, $context);
+    });
+}
+
+/** Resolves the argument as the given default value if supplied */
+function defaultValueResolveArgument() {
+    return function(ReflectionParameter $arg_meta, array $context, $next) {
+        if (!$arg_meta->isOptional()) {
+            return $next($arg_meta, $context);
+        }
+        if (!$arg_meta->isDefaultValueAvailable()) {
+            return [];
+        }
+
+        return [$arg_meta->getDefaultValue()];
+    };
+}
+
+function pimpleContainerResolveArgument($key = 'pimple') {
+    return hasKeyResolveArgument($key, function(ReflectionParameter $arg_meta, array $context, $next) use ($key) {
+        if (!$arg_meta->getClass()) {
+            return $next($arg_meta, $context);
+        }
+
+        $class = $arg_meta->getClass();
+        $container = $context[$key];
+
+        if (!$container instanceof \Pimple\Container) {
+            throw new \LogicException('Expected Pimple\Container instance');
+        }
+
+        if (isset($container[$class->getName()])) {
+            return [$container[$class->getName()]];
+        }
+        if (_isSubclassOf(\Pimple\Container::class, $class->getName())) {
+            return [$container];
+        }
+
+        return $next($arg_meta, $context);
+    });
+}

test/auto-args.spec.php

@@ -0,0 +1,79 @@
+<?php
+
+use Krak\AutoArgs;
+
+class Invokeable {
+    public function __invoke() {}
+}
+
+class StaticMethodClass {
+    public static function staticMethod() {}
+}
+
+describe('Krak AutoArgs', function() {
+    describe('AutoArgs', function() {
+        beforeEach(function() {
+            $this->aa = new AutoArgs\AutoArgs();
+        });
+        describe('->callableToReflectionFunctionAbstract()', function() {
+            $params = [
+                ['converts a normal string callable', 'array_push'],
+                ['converts a Closure', function() {}],
+                ['converts an ($object,$method) tuple', [new SplStack, 'push']],
+                ['converts static method', 'StaticMethodClass::staticMethod'],
+                ['converts an invokeable object', new Invokeable()],
+            ];
+
+            foreach ($params as list($msg, $callable)) {
+                it($msg, function() use ($callable) {
+                    $rf = $this->aa->callableToReflectionFunctionAbstract($callable);
+                    assert($rf instanceof ReflectionFunctionAbstract);
+                });
+            }
+        });
+        describe('->resolveArguments()', function() {
+            it('returns an array of arguments from the argument resolver', function() {
+                $aa = new AutoArgs\AutoArgs(function() {
+                    return [1];
+                });
+
+                $func = function($a, $b) {
+                    assert($a === $b && $a === 1);
+                };
+
+                $aa->resolveArguments($func, []);
+            });
+            it('throws an exception if no args where resolved', function() {
+                $aa = new AutoArgs\AutoArgs(function() {
+                    return [];
+                });
+
+                $func = function($a, $b) {};
+
+                try {
+                    $aa->resolveArguments($func, []);
+                    assert(false);
+                } catch (RuntimeException $e) {
+                    assert(true);
+                }
+            });
+            it('resolves arguments with context', function() {
+                $context = [
+                    'vars' => ['a' => 1, 'stack' => 2],
+                    'objects' => [new SplStack()],
+                    'pimple' => new \Pimple\Container([
+                        AutoArgs\AutoArgs::class => function() {
+                            return $this->aa;
+                        }
+                    ])
+                ];
+
+                $func = function($a, SplDoublyLinkedList $stack, \Pimple\Container $container, AutoArgs\AutoArgs $aa, $b = 1) {
+                    assert($a == 1 && $b === 1);
+                };
+
+                $this->aa->invoke($func, $context);
+            });
+        });
+    });
+});