--- /dev/null
+<?php
+
+/*
+ * This file is part of the Behat.
+ * (c) Konstantin Kudryashov <ever.zet@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Behat\Testwork\Argument;
+
+use ReflectionFunctionAbstract;
+use ReflectionClass;
+use ReflectionParameter;
+
+/**
+ * Organises function arguments using its reflection.
+ *
+ * @author Konstantin Kudryashov <ever.zet@gmail.com>
+ */
+final class MixedArgumentOrganiser implements ArgumentOrganiser
+{
+ private $definedArguments = array();
+
+ /**
+ * Organises arguments using function reflection.
+ *
+ * @param ReflectionFunctionAbstract $function
+ * @param mixed[] $arguments
+ *
+ * @return mixed[]
+ */
+ public function organiseArguments(ReflectionFunctionAbstract $function, array $arguments)
+ {
+ return $this->prepareArguments($function->getParameters(), $arguments);
+ }
+
+ /**
+ * Prepares arguments based on provided parameters.
+ *
+ * @param ReflectionParameter[] $parameters
+ * @param mixed[] $arguments
+ *
+ * @return mixed[]
+ */
+ private function prepareArguments(array $parameters, array $arguments)
+ {
+ $this->markAllArgumentsUndefined();
+
+ list($named, $typehinted, $numbered) = $this->splitArguments($parameters, $arguments);
+
+ $arguments =
+ $this->prepareNamedArguments($parameters, $named) +
+ $this->prepareTypehintedArguments($parameters, $typehinted) +
+ $this->prepareNumberedArguments($parameters, $numbered) +
+ $this->prepareDefaultArguments($parameters);
+
+ return $this->reorderArguments($parameters, $arguments);
+ }
+
+ /**
+ * Splits arguments into three separate arrays - named, numbered and typehinted.
+ *
+ * @param ReflectionParameter[] $parameters
+ * @param mixed[] $arguments
+ *
+ * @return array
+ */
+ private function splitArguments(array $parameters, array $arguments)
+ {
+ $parameterNames = array_map(
+ function (ReflectionParameter $parameter) {
+ return $parameter->getName();
+ },
+ $parameters
+ );
+
+ $namedArguments = array();
+ $numberedArguments = array();
+ $typehintedArguments = array();
+ foreach ($arguments as $key => $val) {
+ if ($this->isStringKeyAndExistsInParameters($key, $parameterNames)) {
+ $namedArguments[$key] = $val;
+ } elseif ($this->isParameterTypehintedInArgumentList($parameters, $val)) {
+ $typehintedArguments[] = $val;
+ } else {
+ $numberedArguments[] = $val;
+ }
+ }
+
+ return array($namedArguments, $typehintedArguments, $numberedArguments);
+ }
+
+ /**
+ * Checks that provided argument key is a string and it matches some parameter name.
+ *
+ * @param mixed $argumentKey
+ * @param string[] $parameterNames
+ *
+ * @return Boolean
+ */
+ private function isStringKeyAndExistsInParameters($argumentKey, $parameterNames)
+ {
+ return is_string($argumentKey) && in_array($argumentKey, $parameterNames);
+ }
+
+ /**
+ * Check if a given value is typehinted in the argument list.
+ *
+ * @param ReflectionParameter[] $parameters
+ * @param mixed $value
+ *
+ * @return Boolean
+ */
+ private function isParameterTypehintedInArgumentList(array $parameters, $value)
+ {
+ if (!is_object($value)) {
+ return false;
+ }
+
+ foreach ($parameters as $parameter) {
+ if ($this->isValueMatchesTypehintedParameter($value, $parameter)) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ /**
+ * Checks if value matches typehint of provided parameter.
+ *
+ * @param object $value
+ * @param ReflectionParameter $parameter
+ *
+ * @return Boolean
+ */
+ private function isValueMatchesTypehintedParameter($value, ReflectionParameter $parameter)
+ {
+ $typehintRefl = $parameter->getClass();
+
+ return $typehintRefl && $typehintRefl->isInstance($value);
+ }
+
+ /**
+ * Captures argument values based on their respective names.
+ *
+ * @param ReflectionParameter[] $parameters
+ * @param mixed[] $namedArguments
+ *
+ * @return mixed[]
+ */
+ private function prepareNamedArguments(array $parameters, array $namedArguments)
+ {
+ $arguments = array();
+
+ foreach ($parameters as $num => $parameter) {
+ $name = $parameter->getName();
+
+ if (array_key_exists($name, $namedArguments)) {
+ $arguments[$name] = $namedArguments[$name];
+ $this->markArgumentDefined($num);
+ }
+ }
+
+ return $arguments;
+ }
+
+ /**
+ * Captures argument values for typehinted arguments based on the given candidates.
+ *
+ * This method attempts to match up the best fitting arguments to each constructor argument.
+ *
+ * This case specifically fixes the issue where a constructor asks for a parent and child class,
+ * as separate arguments, but both arguments could satisfy the first argument,
+ * so they would both be passed in (overwriting each other).
+ *
+ * This will ensure that the children (exact class matches) are mapped first, and then other dependencies
+ * are mapped sequentially (to arguments which they are an `instanceof`).
+ *
+ * As such, this requires two passes of the $parameters array to ensure it is mapped as accurately as possible.
+ *
+ * @param ReflectionParameter[] $parameters Reflection Parameters (constructor argument requirements)
+ * @param mixed[] $typehintedArguments Resolved arguments
+ *
+ * @return mixed[] Ordered list of arguments, index is the constructor argument position, value is what will be injected
+ */
+ private function prepareTypehintedArguments(array $parameters, array $typehintedArguments)
+ {
+ $arguments = array();
+
+ $candidates = $typehintedArguments;
+
+ $this->applyPredicateToTypehintedArguments(
+ $parameters,
+ $candidates,
+ $arguments,
+ array($this, 'classMatchingPredicateForTypehintedArguments')
+ );
+
+ // This iteration maps up everything else, providing the argument is an instanceof the parameter.
+ $this->applyPredicateToTypehintedArguments(
+ $parameters,
+ $candidates,
+ $arguments,
+ array($this, 'isInstancePredicateForTypehintedArguments')
+ );
+
+ return $arguments;
+ }
+
+ /**
+ * Filtered out superfluous parameters for matching up typehinted arguments.
+ *
+ * @param ReflectionParameter[] $parameters Constructor Arguments
+ * @return ReflectionParameter[] Filtered $parameters
+ */
+ private function filterApplicableTypehintedParameters(array $parameters)
+ {
+ $filtered = array();
+
+ foreach ($parameters as $num => $parameter) {
+ if ($this->isArgumentDefined($num)) {
+ continue;
+ }
+
+ $reflectionClass = $parameter->getClass();
+
+ if (!$reflectionClass) {
+ continue;
+ }
+
+ $filtered[$num] = $parameter;
+ }
+
+ return $filtered;
+ }
+
+ /**
+ * Applies a predicate for each candidate when matching up typehinted arguments.
+ * This passes through to another loop of the candidates in @matchParameterToCandidateUsingPredicate,
+ * because this method is "too complex" with two loops...
+ *
+ * @param ReflectionParameter[] $parameters Reflection Parameters (constructor argument requirements)
+ * @param mixed[] &$candidates Resolved arguments
+ * @param mixed[] &$arguments Argument mapping
+ * @param callable $predicate Callable predicate to apply to each candidate
+ * @return void
+ */
+ private function applyPredicateToTypehintedArguments(
+ array $parameters,
+ array &$candidates,
+ array &$arguments,
+ callable $predicate
+ ) {
+ $filtered = $this->filterApplicableTypehintedParameters($parameters);
+
+ foreach ($filtered as $num => $parameter) {
+ $this->matchParameterToCandidateUsingPredicate($parameter, $candidates, $arguments, $predicate);
+ }
+ }
+
+ /**
+ * Applies a predicate for each candidate when matching up typehinted arguments.
+ * This helps to avoid repetition when looping them, as multiple passes are needed over the parameters / candidates.
+ *
+ * @param ReflectionParameter $parameter Reflection Parameter (constructor argument requirements)
+ * @param mixed[] &$candidates Resolved arguments
+ * @param mixed[] &$arguments Argument mapping
+ * @param callable $predicate Callable predicate to apply to each candidate
+ * @return boolean Returns true if a candidate has been matched to the given parameter, otherwise false
+ */
+ public function matchParameterToCandidateUsingPredicate(
+ ReflectionParameter $parameter,
+ array &$candidates,
+ array &$arguments,
+ callable $predicate
+ ) {
+ foreach ($candidates as $candidateIndex => $candidate) {
+ if (call_user_func_array($predicate, array($parameter->getClass(), $candidate))) {
+ $num = $parameter->getPosition();
+
+ $arguments[$num] = $candidate;
+
+ $this->markArgumentDefined($num);
+
+ unset($candidates[$candidateIndex]);
+
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ /**
+ * Typehinted argument predicate to check if the argument and parameter classes match equally.
+ *
+ * @param ReflectionClass $reflectionClass Typehinted argument
+ * @param mixed $candidate Resolved argument
+ * @return boolean
+ */
+ private function classMatchingPredicateForTypehintedArguments(ReflectionClass $reflectionClass, $candidate)
+ {
+ return $reflectionClass->getName() === get_class($candidate);
+ }
+
+ /**
+ * Typehinted argument predicate to check if the argument is an instance of the parameter.
+ *
+ * @param ReflectionClass $reflectionClass Typehinted argument
+ * @param mixed $candidate Resolved argument
+ * @return boolean
+ */
+ private function isInstancePredicateForTypehintedArguments(ReflectionClass $reflectionClass, $candidate)
+ {
+ return $reflectionClass->isInstance($candidate);
+ }
+
+ /**
+ * Captures argument values for undefined arguments based on their respective numbers.
+ *
+ * @param ReflectionParameter[] $parameters
+ * @param mixed[] $numberedArguments
+ *
+ * @return mixed[]
+ */
+ private function prepareNumberedArguments(array $parameters, array $numberedArguments)
+ {
+ $arguments = array();
+
+ $increment = 0;
+ foreach ($parameters as $num => $parameter) {
+ if ($this->isArgumentDefined($num)) {
+ continue;
+ }
+
+ if (array_key_exists($increment, $numberedArguments)) {
+ $arguments[$num] = $numberedArguments[$increment++];
+ $this->markArgumentDefined($num);
+ }
+ }
+
+ return $arguments;
+ }
+
+ /**
+ * Captures argument values for undefined arguments based on parameters defaults.
+ *
+ * @param ReflectionParameter[] $parameters
+ *
+ * @return mixed[]
+ */
+ private function prepareDefaultArguments(array $parameters)
+ {
+ $arguments = array();
+
+ foreach ($parameters as $num => $parameter) {
+ if ($this->isArgumentDefined($num)) {
+ continue;
+ }
+
+ if ($parameter->isDefaultValueAvailable()) {
+ $arguments[$num] = $parameter->getDefaultValue();
+ $this->markArgumentDefined($num);
+ }
+ }
+
+ return $arguments;
+ }
+
+ /**
+ * Reorders arguments based on their respective parameters order.
+ *
+ * @param ReflectionParameter[] $parameters
+ * @param array $arguments
+ *
+ * @return mixed[]
+ */
+ private function reorderArguments(array $parameters, array $arguments)
+ {
+ $orderedArguments = array();
+
+ foreach ($parameters as $num => $parameter) {
+ $name = $parameter->getName();
+
+ if (array_key_exists($num, $arguments)) {
+ $orderedArguments[$num] = $arguments[$num];
+ } elseif (array_key_exists($name, $arguments)) {
+ $orderedArguments[$name] = $arguments[$name];
+ }
+ }
+
+ return $orderedArguments;
+ }
+
+ /**
+ * Marks arguments at all positions as undefined.
+ *
+ * This is used to share state between get*Arguments() methods.
+ */
+ private function markAllArgumentsUndefined()
+ {
+ $this->definedArguments = array();
+ }
+
+ /**
+ * Marks an argument at provided position as defined.
+ *
+ * @param integer $position
+ */
+ private function markArgumentDefined($position)
+ {
+ $this->definedArguments[$position] = true;
+ }
+
+ /**
+ * Checks if an argument at provided position is defined.
+ *
+ * @param integer $position
+ *
+ * @return Boolean
+ */
+ private function isArgumentDefined($position)
+ {
+ return isset($this->definedArguments[$position]);
+ }
+}
projects / yaffs-website / blobdiff