eventespresso / event-espresso-core

vendor/phpspec/prophecy/src/Prophecy/Prediction/CallbackPrediction.php

Indentation +33 added lines, -33 removed lines

@@ -25,42 +25,42 @@
  */
 class CallbackPrediction implements PredictionInterface
 {
-    private $callback;
+	private $callback;
 
-    /**
-     * Initializes callback prediction.
-     *
-     * @param callable $callback Custom callback
-     *
-     * @throws \Prophecy\Exception\InvalidArgumentException
-     */
-    public function __construct($callback)
-    {
-        if (!is_callable($callback)) {
-            throw new InvalidArgumentException(sprintf(
-                'Callable expected as an argument to CallbackPrediction, but got %s.',
-                gettype($callback)
-            ));
-        }
+	/**
+	 * Initializes callback prediction.
+	 *
+	 * @param callable $callback Custom callback
+	 *
+	 * @throws \Prophecy\Exception\InvalidArgumentException
+	 */
+	public function __construct($callback)
+	{
+		if (!is_callable($callback)) {
+			throw new InvalidArgumentException(sprintf(
+				'Callable expected as an argument to CallbackPrediction, but got %s.',
+				gettype($callback)
+			));
+		}
 
-        $this->callback = $callback;
-    }
+		$this->callback = $callback;
+	}
 
-    /**
-     * Executes preset callback.
-     *
-     * @param Call[]         $calls
-     * @param ObjectProphecy $object
-     * @param MethodProphecy $method
-     */
-    public function check(array $calls, ObjectProphecy $object, MethodProphecy $method)
-    {
-        $callback = $this->callback;
+	/**
+	 * Executes preset callback.
+	 *
+	 * @param Call[]         $calls
+	 * @param ObjectProphecy $object
+	 * @param MethodProphecy $method
+	 */
+	public function check(array $calls, ObjectProphecy $object, MethodProphecy $method)
+	{
+		$callback = $this->callback;
 
-        if ($callback instanceof Closure && method_exists('Closure', 'bind') && (new ReflectionFunction($callback))->getClosureThis() !== null) {
-            $callback = Closure::bind($callback, $object);
-        }
+		if ($callback instanceof Closure && method_exists('Closure', 'bind') && (new ReflectionFunction($callback))->getClosureThis() !== null) {
+			$callback = Closure::bind($callback, $object);
+		}
 
-        call_user_func($callback, $calls, $object, $method);
-    }
+		call_user_func($callback, $calls, $object, $method);
+	}
 }

Spacing +1 added lines, -1 removed lines

@@ -36,7 +36,7 @@
      */
     public function __construct($callback)
     {
-        if (!is_callable($callback)) {
+        if ( ! is_callable($callback)) {
             throw new InvalidArgumentException(sprintf(
                 'Callable expected as an argument to CallbackPrediction, but got %s.',
                 gettype($callback)

vendor/phpspec/prophecy/src/Prophecy/Prediction/CallTimesPrediction.php

Indentation +69 added lines, -69 removed lines

@@ -27,81 +27,81 @@
  */
 class CallTimesPrediction implements PredictionInterface
 {
-    private $times;
-    private $util;
+	private $times;
+	private $util;
 
-    /**
-     * Initializes prediction.
-     *
-     * @param int        $times
-     * @param StringUtil $util
-     */
-    public function __construct($times, StringUtil $util = null)
-    {
-        $this->times = intval($times);
-        $this->util  = $util ?: new StringUtil;
-    }
+	/**
+	 * Initializes prediction.
+	 *
+	 * @param int        $times
+	 * @param StringUtil $util
+	 */
+	public function __construct($times, StringUtil $util = null)
+	{
+		$this->times = intval($times);
+		$this->util  = $util ?: new StringUtil;
+	}
 
-    /**
-     * Tests that there was exact amount of calls made.
-     *
-     * @param Call[]         $calls
-     * @param ObjectProphecy $object
-     * @param MethodProphecy $method
-     *
-     * @throws \Prophecy\Exception\Prediction\UnexpectedCallsCountException
-     */
-    public function check(array $calls, ObjectProphecy $object, MethodProphecy $method)
-    {
-        if ($this->times == count($calls)) {
-            return;
-        }
+	/**
+	 * Tests that there was exact amount of calls made.
+	 *
+	 * @param Call[]         $calls
+	 * @param ObjectProphecy $object
+	 * @param MethodProphecy $method
+	 *
+	 * @throws \Prophecy\Exception\Prediction\UnexpectedCallsCountException
+	 */
+	public function check(array $calls, ObjectProphecy $object, MethodProphecy $method)
+	{
+		if ($this->times == count($calls)) {
+			return;
+		}
 
-        $methodCalls = $object->findProphecyMethodCalls(
-            $method->getMethodName(),
-            new ArgumentsWildcard(array(new AnyValuesToken))
-        );
+		$methodCalls = $object->findProphecyMethodCalls(
+			$method->getMethodName(),
+			new ArgumentsWildcard(array(new AnyValuesToken))
+		);
 
-        if (count($calls)) {
-            $message = sprintf(
-                "Expected exactly %d calls that match:\n".
-                "  %s->%s(%s)\n".
-                "but %d were made:\n%s",
+		if (count($calls)) {
+			$message = sprintf(
+				"Expected exactly %d calls that match:\n".
+				"  %s->%s(%s)\n".
+				"but %d were made:\n%s",
 
-                $this->times,
-                get_class($object->reveal()),
-                $method->getMethodName(),
-                $method->getArgumentsWildcard(),
-                count($calls),
-                $this->util->stringifyCalls($calls)
-            );
-        } elseif (count($methodCalls)) {
-            $message = sprintf(
-                "Expected exactly %d calls that match:\n".
-                "  %s->%s(%s)\n".
-                "but none were made.\n".
-                "Recorded `%s(...)` calls:\n%s",
+				$this->times,
+				get_class($object->reveal()),
+				$method->getMethodName(),
+				$method->getArgumentsWildcard(),
+				count($calls),
+				$this->util->stringifyCalls($calls)
+			);
+		} elseif (count($methodCalls)) {
+			$message = sprintf(
+				"Expected exactly %d calls that match:\n".
+				"  %s->%s(%s)\n".
+				"but none were made.\n".
+				"Recorded `%s(...)` calls:\n%s",
 
-                $this->times,
-                get_class($object->reveal()),
-                $method->getMethodName(),
-                $method->getArgumentsWildcard(),
-                $method->getMethodName(),
-                $this->util->stringifyCalls($methodCalls)
-            );
-        } else {
-            $message = sprintf(
-                "Expected exactly %d calls that match:\n".
-                "  %s->%s(%s)\n".
-                "but none were made.",
+				$this->times,
+				get_class($object->reveal()),
+				$method->getMethodName(),
+				$method->getArgumentsWildcard(),
+				$method->getMethodName(),
+				$this->util->stringifyCalls($methodCalls)
+			);
+		} else {
+			$message = sprintf(
+				"Expected exactly %d calls that match:\n".
+				"  %s->%s(%s)\n".
+				"but none were made.",
 
-                $this->times,
-                get_class($object->reveal()),
-                $method->getMethodName(),
-                $method->getArgumentsWildcard()
-            );
-        }
+				$this->times,
+				get_class($object->reveal()),
+				$method->getMethodName(),
+				$method->getArgumentsWildcard()
+			);
+		}
 
-        throw new UnexpectedCallsCountException($message, $method, $this->times, $calls);
-    }
+		throw new UnexpectedCallsCountException($message, $method, $this->times, $calls);
+	}
 }

vendor/phpspec/prophecy/src/Prophecy/Prediction/CallPrediction.php

Indentation +50 added lines, -50 removed lines

@@ -26,61 +26,61 @@
  */
 class CallPrediction implements PredictionInterface
 {
-    private $util;
+	private $util;
 
-    /**
-     * Initializes prediction.
-     *
-     * @param StringUtil $util
-     */
-    public function __construct(StringUtil $util = null)
-    {
-        $this->util = $util ?: new StringUtil;
-    }
+	/**
+	 * Initializes prediction.
+	 *
+	 * @param StringUtil $util
+	 */
+	public function __construct(StringUtil $util = null)
+	{
+		$this->util = $util ?: new StringUtil;
+	}
 
-    /**
-     * Tests that there was at least one call.
-     *
-     * @param Call[]         $calls
-     * @param ObjectProphecy $object
-     * @param MethodProphecy $method
-     *
-     * @throws \Prophecy\Exception\Prediction\NoCallsException
-     */
-    public function check(array $calls, ObjectProphecy $object, MethodProphecy $method)
-    {
-        if (count($calls)) {
-            return;
-        }
+	/**
+	 * Tests that there was at least one call.
+	 *
+	 * @param Call[]         $calls
+	 * @param ObjectProphecy $object
+	 * @param MethodProphecy $method
+	 *
+	 * @throws \Prophecy\Exception\Prediction\NoCallsException
+	 */
+	public function check(array $calls, ObjectProphecy $object, MethodProphecy $method)
+	{
+		if (count($calls)) {
+			return;
+		}
 
-        $methodCalls = $object->findProphecyMethodCalls(
-            $method->getMethodName(),
-            new ArgumentsWildcard(array(new AnyValuesToken))
-        );
+		$methodCalls = $object->findProphecyMethodCalls(
+			$method->getMethodName(),
+			new ArgumentsWildcard(array(new AnyValuesToken))
+		);
 
-        if (count($methodCalls)) {
-            throw new NoCallsException(sprintf(
-                "No calls have been made that match:\n".
-                "  %s->%s(%s)\n".
-                "but expected at least one.\n".
-                "Recorded `%s(...)` calls:\n%s",
+		if (count($methodCalls)) {
+			throw new NoCallsException(sprintf(
+				"No calls have been made that match:\n".
+				"  %s->%s(%s)\n".
+				"but expected at least one.\n".
+				"Recorded `%s(...)` calls:\n%s",
 
-                get_class($object->reveal()),
-                $method->getMethodName(),
-                $method->getArgumentsWildcard(),
-                $method->getMethodName(),
-                $this->util->stringifyCalls($methodCalls)
-            ), $method);
-        }
+				get_class($object->reveal()),
+				$method->getMethodName(),
+				$method->getArgumentsWildcard(),
+				$method->getMethodName(),
+				$this->util->stringifyCalls($methodCalls)
+			), $method);
+		}
 
-        throw new NoCallsException(sprintf(
-            "No calls have been made that match:\n".
-            "  %s->%s(%s)\n".
-            "but expected at least one.",
+		throw new NoCallsException(sprintf(
+			"No calls have been made that match:\n".
+			"  %s->%s(%s)\n".
+			"but expected at least one.",
 
-            get_class($object->reveal()),
-            $method->getMethodName(),
-            $method->getArgumentsWildcard()
-        ), $method);
-    }
+			get_class($object->reveal()),
+			$method->getMethodName(),
+			$method->getArgumentsWildcard()
+		), $method);
+	}
 }

vendor/phpspec/prophecy/src/Prophecy/Prediction/PredictionInterface.php

Indentation +11 added lines, -11 removed lines

@@ -23,15 +23,15 @@
  */
 interface PredictionInterface
 {
-    /**
-     * Tests that double fulfilled prediction.
-     *
-     * @param Call[]        $calls
-     * @param ObjectProphecy $object
-     * @param MethodProphecy $method
-     *
-     * @throws object
-     * @return void
-     */
-    public function check(array $calls, ObjectProphecy $object, MethodProphecy $method);
+	/**
+	 * Tests that double fulfilled prediction.
+	 *
+	 * @param Call[]        $calls
+	 * @param ObjectProphecy $object
+	 * @param MethodProphecy $method
+	 *
+	 * @throws object
+	 * @return void
+	 */
+	public function check(array $calls, ObjectProphecy $object, MethodProphecy $method);
 }

vendor/phpspec/prophecy/src/Prophecy/Call/CallCenter.php

Indentation +212 added lines, -212 removed lines

@@ -25,216 +25,216 @@
  */
 class CallCenter
 {
-    private $util;
-
-    /**
-     * @var Call[]
-     */
-    private $recordedCalls = array();
-
-    /**
-     * @var SplObjectStorage
-     */
-    private $unexpectedCalls;
-
-    /**
-     * Initializes call center.
-     *
-     * @param StringUtil $util
-     */
-    public function __construct(StringUtil $util = null)
-    {
-        $this->util = $util ?: new StringUtil;
-        $this->unexpectedCalls = new SplObjectStorage();
-    }
-
-    /**
-     * Makes and records specific method call for object prophecy.
-     *
-     * @param ObjectProphecy $prophecy
-     * @param string         $methodName
-     * @param array          $arguments
-     *
-     * @return mixed Returns null if no promise for prophecy found or promise return value.
-     *
-     * @throws \Prophecy\Exception\Call\UnexpectedCallException If no appropriate method prophecy found
-     */
-    public function makeCall(ObjectProphecy $prophecy, $methodName, array $arguments)
-    {
-        // For efficiency exclude 'args' from the generated backtrace
-        // Limit backtrace to last 3 calls as we don't use the rest
-        $backtrace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 3);
-
-        $file = $line = null;
-        if (isset($backtrace[2]) && isset($backtrace[2]['file'])) {
-            $file = $backtrace[2]['file'];
-            $line = $backtrace[2]['line'];
-        }
-
-        // If no method prophecies defined, then it's a dummy, so we'll just return null
-        if ('__destruct' === strtolower($methodName) || 0 == count($prophecy->getMethodProphecies())) {
-            $this->recordedCalls[] = new Call($methodName, $arguments, null, null, $file, $line);
-
-            return null;
-        }
-
-        // There are method prophecies, so it's a fake/stub. Searching prophecy for this call
-        $matches = $this->findMethodProphecies($prophecy, $methodName, $arguments);
-
-        // If fake/stub doesn't have method prophecy for this call - throw exception
-        if (!count($matches)) {
-            $this->unexpectedCalls->attach(new Call($methodName, $arguments, null, null, $file, $line), $prophecy);
-            $this->recordedCalls[] = new Call($methodName, $arguments, null, null, $file, $line);
-
-            return null;
-        }
-
-        // Sort matches by their score value
-        @usort($matches, function ($match1, $match2) { return $match2[0] - $match1[0]; });
-
-        $score = $matches[0][0];
-        // If Highest rated method prophecy has a promise - execute it or return null instead
-        $methodProphecy = $matches[0][1];
-        $returnValue = null;
-        $exception   = null;
-        if ($promise = $methodProphecy->getPromise()) {
-            try {
-                $returnValue = $promise->execute($arguments, $prophecy, $methodProphecy);
-            } catch (\Exception $e) {
-                $exception = $e;
-            }
-        }
-
-        if ($methodProphecy->hasReturnVoid() && $returnValue !== null) {
-            throw new MethodProphecyException(
-                "The method \"$methodName\" has a void return type, but the promise returned a value",
-                $methodProphecy
-            );
-        }
-
-        $this->recordedCalls[] = $call = new Call(
-            $methodName, $arguments, $returnValue, $exception, $file, $line
-        );
-        $call->addScore($methodProphecy->getArgumentsWildcard(), $score);
-
-        if (null !== $exception) {
-            throw $exception;
-        }
-
-        return $returnValue;
-    }
-
-    /**
-     * Searches for calls by method name & arguments wildcard.
-     *
-     * @param string            $methodName
-     * @param ArgumentsWildcard $wildcard
-     *
-     * @return Call[]
-     */
-    public function findCalls($methodName, ArgumentsWildcard $wildcard)
-    {
-        $methodName = strtolower($methodName);
-
-        return array_values(
-            array_filter($this->recordedCalls, function (Call $call) use ($methodName, $wildcard) {
-                return $methodName === strtolower($call->getMethodName())
-                    && 0 < $call->getScore($wildcard)
-                ;
-            })
-        );
-    }
-
-    /**
-     * @throws UnexpectedCallException
-     */
-    public function checkUnexpectedCalls()
-    {
-        /** @var Call $call */
-        foreach ($this->unexpectedCalls as $call) {
-            $prophecy = $this->unexpectedCalls[$call];
-
-            // If fake/stub doesn't have method prophecy for this call - throw exception
-            if (!count($this->findMethodProphecies($prophecy, $call->getMethodName(), $call->getArguments()))) {
-                throw $this->createUnexpectedCallException($prophecy, $call->getMethodName(), $call->getArguments());
-            }
-        }
-    }
-
-    private function createUnexpectedCallException(ObjectProphecy $prophecy, $methodName,
-                                                   array $arguments)
-    {
-        $classname = get_class($prophecy->reveal());
-        $indentationLength = 8; // looks good
-        $argstring = implode(
-            ",\n",
-            $this->indentArguments(
-                array_map(array($this->util, 'stringify'), $arguments),
-                $indentationLength
-            )
-        );
-
-        $expected = array();
-
-        foreach (array_merge(...array_values($prophecy->getMethodProphecies())) as $methodProphecy) {
-            $expected[] = sprintf(
-                "  - %s(\n" .
-                "%s\n" .
-                "    )",
-                $methodProphecy->getMethodName(),
-                implode(
-                    ",\n",
-                    $this->indentArguments(
-                        array_map('strval', $methodProphecy->getArgumentsWildcard()->getTokens()),
-                        $indentationLength
-                    )
-                )
-            );
-        }
-
-        return new UnexpectedCallException(
-            sprintf(
-                "Unexpected method call on %s:\n".
-                "  - %s(\n".
-                "%s\n".
-                "    )\n".
-                "expected calls were:\n".
-                "%s",
-
-                $classname, $methodName, $argstring, implode("\n", $expected)
-            ),
-            $prophecy, $methodName, $arguments
-
-        );
-    }
-
-    private function indentArguments(array $arguments, $indentationLength)
-    {
-        return preg_replace_callback(
-            '/^/m',
-            function () use ($indentationLength) {
-                return str_repeat(' ', $indentationLength);
-            },
-            $arguments
-        );
-    }
-
-    /**
-     * @param ObjectProphecy $prophecy
-     * @param string $methodName
-     * @param array $arguments
-     *
-     * @return array
-     */
-    private function findMethodProphecies(ObjectProphecy $prophecy, $methodName, array $arguments)
-    {
-        $matches = array();
-        foreach ($prophecy->getMethodProphecies($methodName) as $methodProphecy) {
-            if (0 < $score = $methodProphecy->getArgumentsWildcard()->scoreArguments($arguments)) {
-                $matches[] = array($score, $methodProphecy);
-            }
-        }
-
-        return $matches;
-    }
+	private $util;
+
+	/**
+	 * @var Call[]
+	 */
+	private $recordedCalls = array();
+
+	/**
+	 * @var SplObjectStorage
+	 */
+	private $unexpectedCalls;
+
+	/**
+	 * Initializes call center.
+	 *
+	 * @param StringUtil $util
+	 */
+	public function __construct(StringUtil $util = null)
+	{
+		$this->util = $util ?: new StringUtil;
+		$this->unexpectedCalls = new SplObjectStorage();
+	}
+
+	/**
+	 * Makes and records specific method call for object prophecy.
+	 *
+	 * @param ObjectProphecy $prophecy
+	 * @param string         $methodName
+	 * @param array          $arguments
+	 *
+	 * @return mixed Returns null if no promise for prophecy found or promise return value.
+	 *
+	 * @throws \Prophecy\Exception\Call\UnexpectedCallException If no appropriate method prophecy found
+	 */
+	public function makeCall(ObjectProphecy $prophecy, $methodName, array $arguments)
+	{
+		// For efficiency exclude 'args' from the generated backtrace
+		// Limit backtrace to last 3 calls as we don't use the rest
+		$backtrace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 3);
+
+		$file = $line = null;
+		if (isset($backtrace[2]) && isset($backtrace[2]['file'])) {
+			$file = $backtrace[2]['file'];
+			$line = $backtrace[2]['line'];
+		}
+
+		// If no method prophecies defined, then it's a dummy, so we'll just return null
+		if ('__destruct' === strtolower($methodName) || 0 == count($prophecy->getMethodProphecies())) {
+			$this->recordedCalls[] = new Call($methodName, $arguments, null, null, $file, $line);
+
+			return null;
+		}
+
+		// There are method prophecies, so it's a fake/stub. Searching prophecy for this call
+		$matches = $this->findMethodProphecies($prophecy, $methodName, $arguments);
+
+		// If fake/stub doesn't have method prophecy for this call - throw exception
+		if (!count($matches)) {
+			$this->unexpectedCalls->attach(new Call($methodName, $arguments, null, null, $file, $line), $prophecy);
+			$this->recordedCalls[] = new Call($methodName, $arguments, null, null, $file, $line);
+
+			return null;
+		}
+
+		// Sort matches by their score value
+		@usort($matches, function ($match1, $match2) { return $match2[0] - $match1[0]; });
+
+		$score = $matches[0][0];
+		// If Highest rated method prophecy has a promise - execute it or return null instead
+		$methodProphecy = $matches[0][1];
+		$returnValue = null;
+		$exception   = null;
+		if ($promise = $methodProphecy->getPromise()) {
+			try {
+				$returnValue = $promise->execute($arguments, $prophecy, $methodProphecy);
+			} catch (\Exception $e) {
+				$exception = $e;
+			}
+		}
+
+		if ($methodProphecy->hasReturnVoid() && $returnValue !== null) {
+			throw new MethodProphecyException(
+				"The method \"$methodName\" has a void return type, but the promise returned a value",
+				$methodProphecy
+			);
+		}
+
+		$this->recordedCalls[] = $call = new Call(
+			$methodName, $arguments, $returnValue, $exception, $file, $line
+		);
+		$call->addScore($methodProphecy->getArgumentsWildcard(), $score);
+
+		if (null !== $exception) {
+			throw $exception;
+		}
+
+		return $returnValue;
+	}
+
+	/**
+	 * Searches for calls by method name & arguments wildcard.
+	 *
+	 * @param string            $methodName
+	 * @param ArgumentsWildcard $wildcard
+	 *
+	 * @return Call[]
+	 */
+	public function findCalls($methodName, ArgumentsWildcard $wildcard)
+	{
+		$methodName = strtolower($methodName);
+
+		return array_values(
+			array_filter($this->recordedCalls, function (Call $call) use ($methodName, $wildcard) {
+				return $methodName === strtolower($call->getMethodName())
+					&& 0 < $call->getScore($wildcard)
+				;
+			})
+		);
+	}
+
+	/**
+	 * @throws UnexpectedCallException
+	 */
+	public function checkUnexpectedCalls()
+	{
+		/** @var Call $call */
+		foreach ($this->unexpectedCalls as $call) {
+			$prophecy = $this->unexpectedCalls[$call];
+
+			// If fake/stub doesn't have method prophecy for this call - throw exception
+			if (!count($this->findMethodProphecies($prophecy, $call->getMethodName(), $call->getArguments()))) {
+				throw $this->createUnexpectedCallException($prophecy, $call->getMethodName(), $call->getArguments());
+			}
+		}
+	}
+
+	private function createUnexpectedCallException(ObjectProphecy $prophecy, $methodName,
+												   array $arguments)
+	{
+		$classname = get_class($prophecy->reveal());
+		$indentationLength = 8; // looks good
+		$argstring = implode(
+			",\n",
+			$this->indentArguments(
+				array_map(array($this->util, 'stringify'), $arguments),
+				$indentationLength
+			)
+		);
+
+		$expected = array();
+
+		foreach (array_merge(...array_values($prophecy->getMethodProphecies())) as $methodProphecy) {
+			$expected[] = sprintf(
+				"  - %s(\n" .
+				"%s\n" .
+				"    )",
+				$methodProphecy->getMethodName(),
+				implode(
+					",\n",
+					$this->indentArguments(
+						array_map('strval', $methodProphecy->getArgumentsWildcard()->getTokens()),
+						$indentationLength
+					)
+				)
+			);
+		}
+
+		return new UnexpectedCallException(
+			sprintf(
+				"Unexpected method call on %s:\n".
+				"  - %s(\n".
+				"%s\n".
+				"    )\n".
+				"expected calls were:\n".
+				"%s",
+
+				$classname, $methodName, $argstring, implode("\n", $expected)
+			),
+			$prophecy, $methodName, $arguments
+
+		);
+	}
+
+	private function indentArguments(array $arguments, $indentationLength)
+	{
+		return preg_replace_callback(
+			'/^/m',
+			function () use ($indentationLength) {
+				return str_repeat(' ', $indentationLength);
+			},
+			$arguments
+		);
+	}
+
+	/**
+	 * @param ObjectProphecy $prophecy
+	 * @param string $methodName
+	 * @param array $arguments
+	 *
+	 * @return array
+	 */
+	private function findMethodProphecies(ObjectProphecy $prophecy, $methodName, array $arguments)
+	{
+		$matches = array();
+		foreach ($prophecy->getMethodProphecies($methodName) as $methodProphecy) {
+			if (0 < $score = $methodProphecy->getArgumentsWildcard()->scoreArguments($arguments)) {
+				$matches[] = array($score, $methodProphecy);
+			}
+		}
+
+		return $matches;
+	}
 }

Spacing +7 added lines, -7 removed lines

@@ -82,7 +82,7 @@ 
         $matches = $this->findMethodProphecies($prophecy, $methodName, $arguments);
 
         // If fake/stub doesn't have method prophecy for this call - throw exception
-        if (!count($matches)) {
+        if ( ! count($matches)) {
             $this->unexpectedCalls->attach(new Call($methodName, $arguments, null, null, $file, $line), $prophecy);
             $this->recordedCalls[] = new Call($methodName, $arguments, null, null, $file, $line);
 
@@ -90,7 +90,7 @@ 
         }
 
         // Sort matches by their score value
-        @usort($matches, function ($match1, $match2) { return $match2[0] - $match1[0]; });
+        @usort($matches, function($match1, $match2) { return $match2[0] - $match1[0]; });
 
         $score = $matches[0][0];
         // If Highest rated method prophecy has a promise - execute it or return null instead
@@ -137,7 +137,7 @@ 
         $methodName = strtolower($methodName);
 
         return array_values(
-            array_filter($this->recordedCalls, function (Call $call) use ($methodName, $wildcard) {
+            array_filter($this->recordedCalls, function(Call $call) use ($methodName, $wildcard) {
                 return $methodName === strtolower($call->getMethodName())
                     && 0 < $call->getScore($wildcard)
                 ;
@@ -155,7 +155,7 @@ 
             $prophecy = $this->unexpectedCalls[$call];
 
             // If fake/stub doesn't have method prophecy for this call - throw exception
-            if (!count($this->findMethodProphecies($prophecy, $call->getMethodName(), $call->getArguments()))) {
+            if ( ! count($this->findMethodProphecies($prophecy, $call->getMethodName(), $call->getArguments()))) {
                 throw $this->createUnexpectedCallException($prophecy, $call->getMethodName(), $call->getArguments());
             }
         }
@@ -178,8 +178,8 @@ 
 
         foreach (array_merge(...array_values($prophecy->getMethodProphecies())) as $methodProphecy) {
             $expected[] = sprintf(
-                "  - %s(\n" .
-                "%s\n" .
+                "  - %s(\n".
+                "%s\n".
                 "    )",
                 $methodProphecy->getMethodName(),
                 implode(
@@ -212,7 +212,7 @@ 
     {
         return preg_replace_callback(
             '/^/m',
-            function () use ($indentationLength) {
+            function() use ($indentationLength) {
                 return str_repeat(' ', $indentationLength);
             },
             $arguments

vendor/phpspec/prophecy/src/Prophecy/Call/Call.php

Indentation +138 added lines, -138 removed lines

@@ -21,142 +21,142 @@
  */
 class Call
 {
-    private $methodName;
-    private $arguments;
-    private $returnValue;
-    private $exception;
-    private $file;
-    private $line;
-    private $scores;
-
-    /**
-     * Initializes call.
-     *
-     * @param string      $methodName
-     * @param array       $arguments
-     * @param mixed       $returnValue
-     * @param Exception   $exception
-     * @param null|string $file
-     * @param null|int    $line
-     */
-    public function __construct($methodName, array $arguments, $returnValue,
-                                Exception $exception = null, $file, $line)
-    {
-        $this->methodName  = $methodName;
-        $this->arguments   = $arguments;
-        $this->returnValue = $returnValue;
-        $this->exception   = $exception;
-        $this->scores      = new \SplObjectStorage();
-
-        if ($file) {
-            $this->file = $file;
-            $this->line = intval($line);
-        }
-    }
-
-    /**
-     * Returns called method name.
-     *
-     * @return string
-     */
-    public function getMethodName()
-    {
-        return $this->methodName;
-    }
-
-    /**
-     * Returns called method arguments.
-     *
-     * @return array
-     */
-    public function getArguments()
-    {
-        return $this->arguments;
-    }
-
-    /**
-     * Returns called method return value.
-     *
-     * @return null|mixed
-     */
-    public function getReturnValue()
-    {
-        return $this->returnValue;
-    }
-
-    /**
-     * Returns exception that call thrown.
-     *
-     * @return null|Exception
-     */
-    public function getException()
-    {
-        return $this->exception;
-    }
-
-    /**
-     * Returns callee filename.
-     *
-     * @return string
-     */
-    public function getFile()
-    {
-        return $this->file;
-    }
-
-    /**
-     * Returns callee line number.
-     *
-     * @return int
-     */
-    public function getLine()
-    {
-        return $this->line;
-    }
-
-    /**
-     * Returns short notation for callee place.
-     *
-     * @return string
-     */
-    public function getCallPlace()
-    {
-        if (null === $this->file) {
-            return 'unknown';
-        }
-
-        return sprintf('%s:%d', $this->file, $this->line);
-    }
-
-    /**
-     * Adds the wildcard match score for the provided wildcard.
-     *
-     * @param ArgumentsWildcard $wildcard
-     * @param false|int $score
-     *
-     * @return $this
-     */
-    public function addScore(ArgumentsWildcard $wildcard, $score)
-    {
-        $this->scores[$wildcard] = $score;
-
-        return $this;
-    }
-
-    /**
-     * Returns wildcard match score for the provided wildcard. The score is
-     * calculated if not already done.
-     *
-     * @param ArgumentsWildcard $wildcard
-     *
-     * @return false|int False OR integer score (higher - better)
-     */
-    public function getScore(ArgumentsWildcard $wildcard)
-    {
-        if (isset($this->scores[$wildcard])) {
-            return $this->scores[$wildcard];
-        }
-
-        return $this->scores[$wildcard] = $wildcard->scoreArguments($this->getArguments());
-    }
+	private $methodName;
+	private $arguments;
+	private $returnValue;
+	private $exception;
+	private $file;
+	private $line;
+	private $scores;
+
+	/**
+	 * Initializes call.
+	 *
+	 * @param string      $methodName
+	 * @param array       $arguments
+	 * @param mixed       $returnValue
+	 * @param Exception   $exception
+	 * @param null|string $file
+	 * @param null|int    $line
+	 */
+	public function __construct($methodName, array $arguments, $returnValue,
+								Exception $exception = null, $file, $line)
+	{
+		$this->methodName  = $methodName;
+		$this->arguments   = $arguments;
+		$this->returnValue = $returnValue;
+		$this->exception   = $exception;
+		$this->scores      = new \SplObjectStorage();
+
+		if ($file) {
+			$this->file = $file;
+			$this->line = intval($line);
+		}
+	}
+
+	/**
+	 * Returns called method name.
+	 *
+	 * @return string
+	 */
+	public function getMethodName()
+	{
+		return $this->methodName;
+	}
+
+	/**
+	 * Returns called method arguments.
+	 *
+	 * @return array
+	 */
+	public function getArguments()
+	{
+		return $this->arguments;
+	}
+
+	/**
+	 * Returns called method return value.
+	 *
+	 * @return null|mixed
+	 */
+	public function getReturnValue()
+	{
+		return $this->returnValue;
+	}
+
+	/**
+	 * Returns exception that call thrown.
+	 *
+	 * @return null|Exception
+	 */
+	public function getException()
+	{
+		return $this->exception;
+	}
+
+	/**
+	 * Returns callee filename.
+	 *
+	 * @return string
+	 */
+	public function getFile()
+	{
+		return $this->file;
+	}
+
+	/**
+	 * Returns callee line number.
+	 *
+	 * @return int
+	 */
+	public function getLine()
+	{
+		return $this->line;
+	}
+
+	/**
+	 * Returns short notation for callee place.
+	 *
+	 * @return string
+	 */
+	public function getCallPlace()
+	{
+		if (null === $this->file) {
+			return 'unknown';
+		}
+
+		return sprintf('%s:%d', $this->file, $this->line);
+	}
+
+	/**
+	 * Adds the wildcard match score for the provided wildcard.
+	 *
+	 * @param ArgumentsWildcard $wildcard
+	 * @param false|int $score
+	 *
+	 * @return $this
+	 */
+	public function addScore(ArgumentsWildcard $wildcard, $score)
+	{
+		$this->scores[$wildcard] = $score;
+
+		return $this;
+	}
+
+	/**
+	 * Returns wildcard match score for the provided wildcard. The score is
+	 * calculated if not already done.
+	 *
+	 * @param ArgumentsWildcard $wildcard
+	 *
+	 * @return false|int False OR integer score (higher - better)
+	 */
+	public function getScore(ArgumentsWildcard $wildcard)
+	{
+		if (isset($this->scores[$wildcard])) {
+			return $this->scores[$wildcard];
+		}
+
+		return $this->scores[$wildcard] = $wildcard->scoreArguments($this->getArguments());
+	}
 }

vendor/phpspec/prophecy/src/Prophecy/Prophecy/RevealerInterface.php

Indentation +8 added lines, -8 removed lines

@@ -18,12 +18,12 @@
  */
 interface RevealerInterface
 {
-    /**
-     * Unwraps value(s).
-     *
-     * @param mixed $value
-     *
-     * @return mixed
-     */
-    public function reveal($value);
+	/**
+	 * Unwraps value(s).
+	 *
+	 * @param mixed $value
+	 *
+	 * @return mixed
+	 */
+	public function reveal($value);
 }

vendor/phpspec/prophecy/src/Prophecy/Prophecy/MethodProphecy.php

Indentation +541 added lines, -541 removed lines

@@ -29,545 +29,545 @@
  */
 class MethodProphecy
 {
-    private $objectProphecy;
-    private $methodName;
-    private $argumentsWildcard;
-    private $promise;
-    private $prediction;
-    private $checkedPredictions = array();
-    private $bound = false;
-    private $voidReturnType = false;
-
-    /**
-     * Initializes method prophecy.
-     *
-     * @param ObjectProphecy                        $objectProphecy
-     * @param string                                $methodName
-     * @param null|Argument\ArgumentsWildcard|array $arguments
-     *
-     * @throws \Prophecy\Exception\Doubler\MethodNotFoundException If method not found
-     */
-    public function __construct(ObjectProphecy $objectProphecy, $methodName, $arguments = null)
-    {
-        $double = $objectProphecy->reveal();
-        if (!method_exists($double, $methodName)) {
-            throw new MethodNotFoundException(sprintf(
-                'Method `%s::%s()` is not defined.', get_class($double), $methodName
-            ), get_class($double), $methodName, $arguments);
-        }
-
-        $this->objectProphecy = $objectProphecy;
-        $this->methodName     = $methodName;
-
-        $reflectedMethod = new \ReflectionMethod($double, $methodName);
-        if ($reflectedMethod->isFinal()) {
-            throw new MethodProphecyException(sprintf(
-                "Can not add prophecy for a method `%s::%s()`\n".
-                "as it is a final method.",
-                get_class($double),
-                $methodName
-            ), $this);
-        }
-
-        if (null !== $arguments) {
-            $this->withArguments($arguments);
-        }
-
-        $hasTentativeReturnType = method_exists($reflectedMethod, 'hasTentativeReturnType')
-            && $reflectedMethod->hasTentativeReturnType();
-
-        if (true === $reflectedMethod->hasReturnType() || $hasTentativeReturnType) {
-            if ($hasTentativeReturnType) {
-                $reflectionType = $reflectedMethod->getTentativeReturnType();
-            }
-            else {
-                $reflectionType = $reflectedMethod->getReturnType();
-            }
-
-            if ($reflectionType instanceof ReflectionNamedType) {
-                $types = [$reflectionType];
-            }
-            elseif ($reflectionType instanceof ReflectionUnionType) {
-                $types = $reflectionType->getTypes();
-            }
-
-            $types = array_map(
-                function(ReflectionType $type) { return $type->getName(); },
-                $types
-            );
-
-            usort(
-                $types,
-                static function(string $type1, string $type2) {
-
-                    // null is lowest priority
-                    if ($type2 == 'null') {
-                        return -1;
-                    }
-                    elseif ($type1 == 'null') {
-                        return 1;
-                    }
-
-                    // objects are higher priority than scalars
-                    $isObject = static function($type) {
-                        return class_exists($type) || interface_exists($type);
-                    };
-
-                    if($isObject($type1) && !$isObject($type2)) {
-                        return -1;
-                    }
-                    elseif(!$isObject($type1) && $isObject($type2))
-                    {
-                        return 1;
-                    }
-
-                    // don't sort both-scalars or both-objects
-                    return 0;
-                }
-            );
-
-            $defaultType = $types[0];
-
-            if ('void' === $defaultType) {
-                $this->voidReturnType = true;
-            }
-
-            $this->will(function () use ($defaultType) {
-                switch ($defaultType) {
-                    case 'void': return;
-                    case 'string': return '';
-                    case 'float':  return 0.0;
-                    case 'int':    return 0;
-                    case 'bool':   return false;
-                    case 'array':  return array();
-
-                    case 'callable':
-                    case 'Closure':
-                        return function () {};
-
-                    case 'Traversable':
-                    case 'Generator':
-                        return (function () { yield; })();
-
-                    default:
-                        $prophet = new Prophet;
-                        return $prophet->prophesize($defaultType)->reveal();
-                }
-            });
-        }
-    }
-
-    /**
-     * Sets argument wildcard.
-     *
-     * @param array|Argument\ArgumentsWildcard $arguments
-     *
-     * @return $this
-     *
-     * @throws \Prophecy\Exception\InvalidArgumentException
-     */
-    public function withArguments($arguments)
-    {
-        if (is_array($arguments)) {
-            $arguments = new Argument\ArgumentsWildcard($arguments);
-        }
-
-        if (!$arguments instanceof Argument\ArgumentsWildcard) {
-            throw new InvalidArgumentException(sprintf(
-                "Either an array or an instance of ArgumentsWildcard expected as\n".
-                'a `MethodProphecy::withArguments()` argument, but got %s.',
-                gettype($arguments)
-            ));
-        }
-
-        $this->argumentsWildcard = $arguments;
-
-        return $this;
-    }
-
-    /**
-     * Sets custom promise to the prophecy.
-     *
-     * @param callable|Promise\PromiseInterface $promise
-     *
-     * @return $this
-     *
-     * @throws \Prophecy\Exception\InvalidArgumentException
-     */
-    public function will($promise)
-    {
-        if (is_callable($promise)) {
-            $promise = new Promise\CallbackPromise($promise);
-        }
-
-        if (!$promise instanceof Promise\PromiseInterface) {
-            throw new InvalidArgumentException(sprintf(
-                'Expected callable or instance of PromiseInterface, but got %s.',
-                gettype($promise)
-            ));
-        }
-
-        $this->bindToObjectProphecy();
-        $this->promise = $promise;
-
-        return $this;
-    }
-
-    /**
-     * Sets return promise to the prophecy.
-     *
-     * @see \Prophecy\Promise\ReturnPromise
-     *
-     * @return $this
-     */
-    public function willReturn()
-    {
-        if ($this->voidReturnType) {
-            throw new MethodProphecyException(
-                "The method \"$this->methodName\" has a void return type, and so cannot return anything",
-                $this
-            );
-        }
-
-        return $this->will(new Promise\ReturnPromise(func_get_args()));
-    }
-
-    /**
-     * @param array $items
-     * @param mixed $return
-     *
-     * @return $this
-     *
-     * @throws \Prophecy\Exception\InvalidArgumentException
-     */
-    public function willYield($items, $return = null)
-    {
-        if ($this->voidReturnType) {
-            throw new MethodProphecyException(
-                "The method \"$this->methodName\" has a void return type, and so cannot yield anything",
-                $this
-            );
-        }
-
-        if (!is_array($items)) {
-            throw new InvalidArgumentException(sprintf(
-                'Expected array, but got %s.',
-                gettype($items)
-            ));
-        }
-
-        $generator =  function() use ($items, $return) {
-            yield from $items;
-
-            return $return;
-        };
-
-        return $this->will($generator);
-    }
-
-    /**
-     * Sets return argument promise to the prophecy.
-     *
-     * @param int $index The zero-indexed number of the argument to return
-     *
-     * @see \Prophecy\Promise\ReturnArgumentPromise
-     *
-     * @return $this
-     */
-    public function willReturnArgument($index = 0)
-    {
-        if ($this->voidReturnType) {
-            throw new MethodProphecyException("The method \"$this->methodName\" has a void return type", $this);
-        }
-
-        return $this->will(new Promise\ReturnArgumentPromise($index));
-    }
-
-    /**
-     * Sets throw promise to the prophecy.
-     *
-     * @see \Prophecy\Promise\ThrowPromise
-     *
-     * @param string|\Exception $exception Exception class or instance
-     *
-     * @return $this
-     */
-    public function willThrow($exception)
-    {
-        return $this->will(new Promise\ThrowPromise($exception));
-    }
-
-    /**
-     * Sets custom prediction to the prophecy.
-     *
-     * @param callable|Prediction\PredictionInterface $prediction
-     *
-     * @return $this
-     *
-     * @throws \Prophecy\Exception\InvalidArgumentException
-     */
-    public function should($prediction)
-    {
-        if (is_callable($prediction)) {
-            $prediction = new Prediction\CallbackPrediction($prediction);
-        }
-
-        if (!$prediction instanceof Prediction\PredictionInterface) {
-            throw new InvalidArgumentException(sprintf(
-                'Expected callable or instance of PredictionInterface, but got %s.',
-                gettype($prediction)
-            ));
-        }
-
-        $this->bindToObjectProphecy();
-        $this->prediction = $prediction;
-
-        return $this;
-    }
-
-    /**
-     * Sets call prediction to the prophecy.
-     *
-     * @see \Prophecy\Prediction\CallPrediction
-     *
-     * @return $this
-     */
-    public function shouldBeCalled()
-    {
-        return $this->should(new Prediction\CallPrediction);
-    }
-
-    /**
-     * Sets no calls prediction to the prophecy.
-     *
-     * @see \Prophecy\Prediction\NoCallsPrediction
-     *
-     * @return $this
-     */
-    public function shouldNotBeCalled()
-    {
-        return $this->should(new Prediction\NoCallsPrediction);
-    }
-
-    /**
-     * Sets call times prediction to the prophecy.
-     *
-     * @see \Prophecy\Prediction\CallTimesPrediction
-     *
-     * @param $count
-     *
-     * @return $this
-     */
-    public function shouldBeCalledTimes($count)
-    {
-        return $this->should(new Prediction\CallTimesPrediction($count));
-    }
-
-    /**
-     * Sets call times prediction to the prophecy.
-     *
-     * @see \Prophecy\Prediction\CallTimesPrediction
-     *
-     * @return $this
-     */
-    public function shouldBeCalledOnce()
-    {
-        return $this->shouldBeCalledTimes(1);
-    }
-
-    /**
-     * Checks provided prediction immediately.
-     *
-     * @param callable|Prediction\PredictionInterface $prediction
-     *
-     * @return $this
-     *
-     * @throws \Prophecy\Exception\InvalidArgumentException
-     */
-    public function shouldHave($prediction)
-    {
-        if (is_callable($prediction)) {
-            $prediction = new Prediction\CallbackPrediction($prediction);
-        }
-
-        if (!$prediction instanceof Prediction\PredictionInterface) {
-            throw new InvalidArgumentException(sprintf(
-                'Expected callable or instance of PredictionInterface, but got %s.',
-                gettype($prediction)
-            ));
-        }
-
-        if (null === $this->promise && !$this->voidReturnType) {
-            $this->willReturn();
-        }
-
-        $calls = $this->getObjectProphecy()->findProphecyMethodCalls(
-            $this->getMethodName(),
-            $this->getArgumentsWildcard()
-        );
-
-        try {
-            $prediction->check($calls, $this->getObjectProphecy(), $this);
-            $this->checkedPredictions[] = $prediction;
-        } catch (\Exception $e) {
-            $this->checkedPredictions[] = $prediction;
-
-            throw $e;
-        }
-
-        return $this;
-    }
-
-    /**
-     * Checks call prediction.
-     *
-     * @see \Prophecy\Prediction\CallPrediction
-     *
-     * @return $this
-     */
-    public function shouldHaveBeenCalled()
-    {
-        return $this->shouldHave(new Prediction\CallPrediction);
-    }
-
-    /**
-     * Checks no calls prediction.
-     *
-     * @see \Prophecy\Prediction\NoCallsPrediction
-     *
-     * @return $this
-     */
-    public function shouldNotHaveBeenCalled()
-    {
-        return $this->shouldHave(new Prediction\NoCallsPrediction);
-    }
-
-    /**
-     * Checks no calls prediction.
-     *
-     * @see \Prophecy\Prediction\NoCallsPrediction
-     * @deprecated
-     *
-     * @return $this
-     */
-    public function shouldNotBeenCalled()
-    {
-        return $this->shouldNotHaveBeenCalled();
-    }
-
-    /**
-     * Checks call times prediction.
-     *
-     * @see \Prophecy\Prediction\CallTimesPrediction
-     *
-     * @param int $count
-     *
-     * @return $this
-     */
-    public function shouldHaveBeenCalledTimes($count)
-    {
-        return $this->shouldHave(new Prediction\CallTimesPrediction($count));
-    }
-
-    /**
-     * Checks call times prediction.
-     *
-     * @see \Prophecy\Prediction\CallTimesPrediction
-     *
-     * @return $this
-     */
-    public function shouldHaveBeenCalledOnce()
-    {
-        return $this->shouldHaveBeenCalledTimes(1);
-    }
-
-    /**
-     * Checks currently registered [with should(...)] prediction.
-     */
-    public function checkPrediction()
-    {
-        if (null === $this->prediction) {
-            return;
-        }
-
-        $this->shouldHave($this->prediction);
-    }
-
-    /**
-     * Returns currently registered promise.
-     *
-     * @return null|Promise\PromiseInterface
-     */
-    public function getPromise()
-    {
-        return $this->promise;
-    }
-
-    /**
-     * Returns currently registered prediction.
-     *
-     * @return null|Prediction\PredictionInterface
-     */
-    public function getPrediction()
-    {
-        return $this->prediction;
-    }
-
-    /**
-     * Returns predictions that were checked on this object.
-     *
-     * @return Prediction\PredictionInterface[]
-     */
-    public function getCheckedPredictions()
-    {
-        return $this->checkedPredictions;
-    }
-
-    /**
-     * Returns object prophecy this method prophecy is tied to.
-     *
-     * @return ObjectProphecy
-     */
-    public function getObjectProphecy()
-    {
-        return $this->objectProphecy;
-    }
-
-    /**
-     * Returns method name.
-     *
-     * @return string
-     */
-    public function getMethodName()
-    {
-        return $this->methodName;
-    }
-
-    /**
-     * Returns arguments wildcard.
-     *
-     * @return Argument\ArgumentsWildcard
-     */
-    public function getArgumentsWildcard()
-    {
-        return $this->argumentsWildcard;
-    }
-
-    /**
-     * @return bool
-     */
-    public function hasReturnVoid()
-    {
-        return $this->voidReturnType;
-    }
-
-    private function bindToObjectProphecy()
-    {
-        if ($this->bound) {
-            return;
-        }
-
-        $this->getObjectProphecy()->addMethodProphecy($this);
-        $this->bound = true;
-    }
+	private $objectProphecy;
+	private $methodName;
+	private $argumentsWildcard;
+	private $promise;
+	private $prediction;
+	private $checkedPredictions = array();
+	private $bound = false;
+	private $voidReturnType = false;
+
+	/**
+	 * Initializes method prophecy.
+	 *
+	 * @param ObjectProphecy                        $objectProphecy
+	 * @param string                                $methodName
+	 * @param null|Argument\ArgumentsWildcard|array $arguments
+	 *
+	 * @throws \Prophecy\Exception\Doubler\MethodNotFoundException If method not found
+	 */
+	public function __construct(ObjectProphecy $objectProphecy, $methodName, $arguments = null)
+	{
+		$double = $objectProphecy->reveal();
+		if (!method_exists($double, $methodName)) {
+			throw new MethodNotFoundException(sprintf(
+				'Method `%s::%s()` is not defined.', get_class($double), $methodName
+			), get_class($double), $methodName, $arguments);
+		}
+
+		$this->objectProphecy = $objectProphecy;
+		$this->methodName     = $methodName;
+
+		$reflectedMethod = new \ReflectionMethod($double, $methodName);
+		if ($reflectedMethod->isFinal()) {
+			throw new MethodProphecyException(sprintf(
+				"Can not add prophecy for a method `%s::%s()`\n".
+				"as it is a final method.",
+				get_class($double),
+				$methodName
+			), $this);
+		}
+
+		if (null !== $arguments) {
+			$this->withArguments($arguments);
+		}
+
+		$hasTentativeReturnType = method_exists($reflectedMethod, 'hasTentativeReturnType')
+			&& $reflectedMethod->hasTentativeReturnType();
+
+		if (true === $reflectedMethod->hasReturnType() || $hasTentativeReturnType) {
+			if ($hasTentativeReturnType) {
+				$reflectionType = $reflectedMethod->getTentativeReturnType();
+			}
+			else {
+				$reflectionType = $reflectedMethod->getReturnType();
+			}
+
+			if ($reflectionType instanceof ReflectionNamedType) {
+				$types = [$reflectionType];
+			}
+			elseif ($reflectionType instanceof ReflectionUnionType) {
+				$types = $reflectionType->getTypes();
+			}
+
+			$types = array_map(
+				function(ReflectionType $type) { return $type->getName(); },
+				$types
+			);
+
+			usort(
+				$types,
+				static function(string $type1, string $type2) {
+
+					// null is lowest priority
+					if ($type2 == 'null') {
+						return -1;
+					}
+					elseif ($type1 == 'null') {
+						return 1;
+					}
+
+					// objects are higher priority than scalars
+					$isObject = static function($type) {
+						return class_exists($type) || interface_exists($type);
+					};
+
+					if($isObject($type1) && !$isObject($type2)) {
+						return -1;
+					}
+					elseif(!$isObject($type1) && $isObject($type2))
+					{
+						return 1;
+					}
+
+					// don't sort both-scalars or both-objects
+					return 0;
+				}
+			);
+
+			$defaultType = $types[0];
+
+			if ('void' === $defaultType) {
+				$this->voidReturnType = true;
+			}
+
+			$this->will(function () use ($defaultType) {
+				switch ($defaultType) {
+					case 'void': return;
+					case 'string': return '';
+					case 'float':  return 0.0;
+					case 'int':    return 0;
+					case 'bool':   return false;
+					case 'array':  return array();
+
+					case 'callable':
+					case 'Closure':
+						return function () {};
+
+					case 'Traversable':
+					case 'Generator':
+						return (function () { yield; })();
+
+					default:
+						$prophet = new Prophet;
+						return $prophet->prophesize($defaultType)->reveal();
+				}
+			});
+		}
+	}
+
+	/**
+	 * Sets argument wildcard.
+	 *
+	 * @param array|Argument\ArgumentsWildcard $arguments
+	 *
+	 * @return $this
+	 *
+	 * @throws \Prophecy\Exception\InvalidArgumentException
+	 */
+	public function withArguments($arguments)
+	{
+		if (is_array($arguments)) {
+			$arguments = new Argument\ArgumentsWildcard($arguments);
+		}
+
+		if (!$arguments instanceof Argument\ArgumentsWildcard) {
+			throw new InvalidArgumentException(sprintf(
+				"Either an array or an instance of ArgumentsWildcard expected as\n".
+				'a `MethodProphecy::withArguments()` argument, but got %s.',
+				gettype($arguments)
+			));
+		}
+
+		$this->argumentsWildcard = $arguments;
+
+		return $this;
+	}
+
+	/**
+	 * Sets custom promise to the prophecy.
+	 *
+	 * @param callable|Promise\PromiseInterface $promise
+	 *
+	 * @return $this
+	 *
+	 * @throws \Prophecy\Exception\InvalidArgumentException
+	 */
+	public function will($promise)
+	{
+		if (is_callable($promise)) {
+			$promise = new Promise\CallbackPromise($promise);
+		}
+
+		if (!$promise instanceof Promise\PromiseInterface) {
+			throw new InvalidArgumentException(sprintf(
+				'Expected callable or instance of PromiseInterface, but got %s.',
+				gettype($promise)
+			));
+		}
+
+		$this->bindToObjectProphecy();
+		$this->promise = $promise;
+
+		return $this;
+	}
+
+	/**
+	 * Sets return promise to the prophecy.
+	 *
+	 * @see \Prophecy\Promise\ReturnPromise
+	 *
+	 * @return $this
+	 */
+	public function willReturn()
+	{
+		if ($this->voidReturnType) {
+			throw new MethodProphecyException(
+				"The method \"$this->methodName\" has a void return type, and so cannot return anything",
+				$this
+			);
+		}
+
+		return $this->will(new Promise\ReturnPromise(func_get_args()));
+	}
+
+	/**
+	 * @param array $items
+	 * @param mixed $return
+	 *
+	 * @return $this
+	 *
+	 * @throws \Prophecy\Exception\InvalidArgumentException
+	 */
+	public function willYield($items, $return = null)
+	{
+		if ($this->voidReturnType) {
+			throw new MethodProphecyException(
+				"The method \"$this->methodName\" has a void return type, and so cannot yield anything",
+				$this
+			);
+		}
+
+		if (!is_array($items)) {
+			throw new InvalidArgumentException(sprintf(
+				'Expected array, but got %s.',
+				gettype($items)
+			));
+		}
+
+		$generator =  function() use ($items, $return) {
+			yield from $items;
+
+			return $return;
+		};
+
+		return $this->will($generator);
+	}
+
+	/**
+	 * Sets return argument promise to the prophecy.
+	 *
+	 * @param int $index The zero-indexed number of the argument to return
+	 *
+	 * @see \Prophecy\Promise\ReturnArgumentPromise
+	 *
+	 * @return $this
+	 */
+	public function willReturnArgument($index = 0)
+	{
+		if ($this->voidReturnType) {
+			throw new MethodProphecyException("The method \"$this->methodName\" has a void return type", $this);
+		}
+
+		return $this->will(new Promise\ReturnArgumentPromise($index));
+	}
+
+	/**
+	 * Sets throw promise to the prophecy.
+	 *
+	 * @see \Prophecy\Promise\ThrowPromise
+	 *
+	 * @param string|\Exception $exception Exception class or instance
+	 *
+	 * @return $this
+	 */
+	public function willThrow($exception)
+	{
+		return $this->will(new Promise\ThrowPromise($exception));
+	}
+
+	/**
+	 * Sets custom prediction to the prophecy.
+	 *
+	 * @param callable|Prediction\PredictionInterface $prediction
+	 *
+	 * @return $this
+	 *
+	 * @throws \Prophecy\Exception\InvalidArgumentException
+	 */
+	public function should($prediction)
+	{
+		if (is_callable($prediction)) {
+			$prediction = new Prediction\CallbackPrediction($prediction);
+		}
+
+		if (!$prediction instanceof Prediction\PredictionInterface) {
+			throw new InvalidArgumentException(sprintf(
+				'Expected callable or instance of PredictionInterface, but got %s.',
+				gettype($prediction)
+			));
+		}
+
+		$this->bindToObjectProphecy();
+		$this->prediction = $prediction;
+
+		return $this;
+	}
+
+	/**
+	 * Sets call prediction to the prophecy.
+	 *
+	 * @see \Prophecy\Prediction\CallPrediction
+	 *
+	 * @return $this
+	 */
+	public function shouldBeCalled()
+	{
+		return $this->should(new Prediction\CallPrediction);
+	}
+
+	/**
+	 * Sets no calls prediction to the prophecy.
+	 *
+	 * @see \Prophecy\Prediction\NoCallsPrediction
+	 *
+	 * @return $this
+	 */
+	public function shouldNotBeCalled()
+	{
+		return $this->should(new Prediction\NoCallsPrediction);
+	}
+
+	/**
+	 * Sets call times prediction to the prophecy.
+	 *
+	 * @see \Prophecy\Prediction\CallTimesPrediction
+	 *
+	 * @param $count
+	 *
+	 * @return $this
+	 */
+	public function shouldBeCalledTimes($count)
+	{
+		return $this->should(new Prediction\CallTimesPrediction($count));
+	}
+
+	/**
+	 * Sets call times prediction to the prophecy.
+	 *
+	 * @see \Prophecy\Prediction\CallTimesPrediction
+	 *
+	 * @return $this
+	 */
+	public function shouldBeCalledOnce()
+	{
+		return $this->shouldBeCalledTimes(1);
+	}
+
+	/**
+	 * Checks provided prediction immediately.
+	 *
+	 * @param callable|Prediction\PredictionInterface $prediction
+	 *
+	 * @return $this
+	 *
+	 * @throws \Prophecy\Exception\InvalidArgumentException
+	 */
+	public function shouldHave($prediction)
+	{
+		if (is_callable($prediction)) {
+			$prediction = new Prediction\CallbackPrediction($prediction);
+		}
+
+		if (!$prediction instanceof Prediction\PredictionInterface) {
+			throw new InvalidArgumentException(sprintf(
+				'Expected callable or instance of PredictionInterface, but got %s.',
+				gettype($prediction)
+			));
+		}
+
+		if (null === $this->promise && !$this->voidReturnType) {
+			$this->willReturn();
+		}
+
+		$calls = $this->getObjectProphecy()->findProphecyMethodCalls(
+			$this->getMethodName(),
+			$this->getArgumentsWildcard()
+		);
+
+		try {
+			$prediction->check($calls, $this->getObjectProphecy(), $this);
+			$this->checkedPredictions[] = $prediction;
+		} catch (\Exception $e) {
+			$this->checkedPredictions[] = $prediction;
+
+			throw $e;
+		}
+
+		return $this;
+	}
+
+	/**
+	 * Checks call prediction.
+	 *
+	 * @see \Prophecy\Prediction\CallPrediction
+	 *
+	 * @return $this
+	 */
+	public function shouldHaveBeenCalled()
+	{
+		return $this->shouldHave(new Prediction\CallPrediction);
+	}
+
+	/**
+	 * Checks no calls prediction.
+	 *
+	 * @see \Prophecy\Prediction\NoCallsPrediction
+	 *
+	 * @return $this
+	 */
+	public function shouldNotHaveBeenCalled()
+	{
+		return $this->shouldHave(new Prediction\NoCallsPrediction);
+	}
+
+	/**
+	 * Checks no calls prediction.
+	 *
+	 * @see \Prophecy\Prediction\NoCallsPrediction
+	 * @deprecated
+	 *
+	 * @return $this
+	 */
+	public function shouldNotBeenCalled()
+	{
+		return $this->shouldNotHaveBeenCalled();
+	}
+
+	/**
+	 * Checks call times prediction.
+	 *
+	 * @see \Prophecy\Prediction\CallTimesPrediction
+	 *
+	 * @param int $count
+	 *
+	 * @return $this
+	 */
+	public function shouldHaveBeenCalledTimes($count)
+	{
+		return $this->shouldHave(new Prediction\CallTimesPrediction($count));
+	}
+
+	/**
+	 * Checks call times prediction.
+	 *
+	 * @see \Prophecy\Prediction\CallTimesPrediction
+	 *
+	 * @return $this
+	 */
+	public function shouldHaveBeenCalledOnce()
+	{
+		return $this->shouldHaveBeenCalledTimes(1);
+	}
+
+	/**
+	 * Checks currently registered [with should(...)] prediction.
+	 */
+	public function checkPrediction()
+	{
+		if (null === $this->prediction) {
+			return;
+		}
+
+		$this->shouldHave($this->prediction);
+	}
+
+	/**
+	 * Returns currently registered promise.
+	 *
+	 * @return null|Promise\PromiseInterface
+	 */
+	public function getPromise()
+	{
+		return $this->promise;
+	}
+
+	/**
+	 * Returns currently registered prediction.
+	 *
+	 * @return null|Prediction\PredictionInterface
+	 */
+	public function getPrediction()
+	{
+		return $this->prediction;
+	}
+
+	/**
+	 * Returns predictions that were checked on this object.
+	 *
+	 * @return Prediction\PredictionInterface[]
+	 */
+	public function getCheckedPredictions()
+	{
+		return $this->checkedPredictions;
+	}
+
+	/**
+	 * Returns object prophecy this method prophecy is tied to.
+	 *
+	 * @return ObjectProphecy
+	 */
+	public function getObjectProphecy()
+	{
+		return $this->objectProphecy;
+	}
+
+	/**
+	 * Returns method name.
+	 *
+	 * @return string
+	 */
+	public function getMethodName()
+	{
+		return $this->methodName;
+	}
+
+	/**
+	 * Returns arguments wildcard.
+	 *
+	 * @return Argument\ArgumentsWildcard
+	 */
+	public function getArgumentsWildcard()
+	{
+		return $this->argumentsWildcard;
+	}
+
+	/**
+	 * @return bool
+	 */
+	public function hasReturnVoid()
+	{
+		return $this->voidReturnType;
+	}
+
+	private function bindToObjectProphecy()
+	{
+		if ($this->bound) {
+			return;
+		}
+
+		$this->getObjectProphecy()->addMethodProphecy($this);
+		$this->bound = true;
+	}
 }

Spacing +13 added lines, -13 removed lines

@@ -50,7 +50,7 @@ 
     public function __construct(ObjectProphecy $objectProphecy, $methodName, $arguments = null)
     {
         $double = $objectProphecy->reveal();
-        if (!method_exists($double, $methodName)) {
+        if ( ! method_exists($double, $methodName)) {
             throw new MethodNotFoundException(sprintf(
                 'Method `%s::%s()` is not defined.', get_class($double), $methodName
             ), get_class($double), $methodName, $arguments);
@@ -113,10 +113,10 @@ 
                         return class_exists($type) || interface_exists($type);
                     };
 
-                    if($isObject($type1) && !$isObject($type2)) {
+                    if ($isObject($type1) && ! $isObject($type2)) {
                         return -1;
                     }
-                    elseif(!$isObject($type1) && $isObject($type2))
+                    elseif ( ! $isObject($type1) && $isObject($type2))
                     {
                         return 1;
                     }
@@ -132,7 +132,7 @@ 
                 $this->voidReturnType = true;
             }
 
-            $this->will(function () use ($defaultType) {
+            $this->will(function() use ($defaultType) {
                 switch ($defaultType) {
                     case 'void': return;
                     case 'string': return '';
@@ -143,11 +143,11 @@ 
 
                     case 'callable':
                     case 'Closure':
-                        return function () {};
+                        return function() {};
 
                     case 'Traversable':
                     case 'Generator':
-                        return (function () { yield; })();
+                        return (function() { yield; })();
 
                     default:
                         $prophet = new Prophet;
@@ -172,7 +172,7 @@ 
             $arguments = new Argument\ArgumentsWildcard($arguments);
         }
 
-        if (!$arguments instanceof Argument\ArgumentsWildcard) {
+        if ( ! $arguments instanceof Argument\ArgumentsWildcard) {
             throw new InvalidArgumentException(sprintf(
                 "Either an array or an instance of ArgumentsWildcard expected as\n".
                 'a `MethodProphecy::withArguments()` argument, but got %s.',
@@ -200,7 +200,7 @@ 
             $promise = new Promise\CallbackPromise($promise);
         }
 
-        if (!$promise instanceof Promise\PromiseInterface) {
+        if ( ! $promise instanceof Promise\PromiseInterface) {
             throw new InvalidArgumentException(sprintf(
                 'Expected callable or instance of PromiseInterface, but got %s.',
                 gettype($promise)
@@ -249,14 +249,14 @@ 
             );
         }
 
-        if (!is_array($items)) {
+        if ( ! is_array($items)) {
             throw new InvalidArgumentException(sprintf(
                 'Expected array, but got %s.',
                 gettype($items)
             ));
         }
 
-        $generator =  function() use ($items, $return) {
+        $generator = function() use ($items, $return) {
             yield from $items;
 
             return $return;
@@ -312,7 +312,7 @@ 
             $prediction = new Prediction\CallbackPrediction($prediction);
         }
 
-        if (!$prediction instanceof Prediction\PredictionInterface) {
+        if ( ! $prediction instanceof Prediction\PredictionInterface) {
             throw new InvalidArgumentException(sprintf(
                 'Expected callable or instance of PredictionInterface, but got %s.',
                 gettype($prediction)
@@ -390,14 +390,14 @@ 
             $prediction = new Prediction\CallbackPrediction($prediction);
         }
 
-        if (!$prediction instanceof Prediction\PredictionInterface) {
+        if ( ! $prediction instanceof Prediction\PredictionInterface) {
             throw new InvalidArgumentException(sprintf(
                 'Expected callable or instance of PredictionInterface, but got %s.',
                 gettype($prediction)
             ));
         }
 
-        if (null === $this->promise && !$this->voidReturnType) {
+        if (null === $this->promise && ! $this->voidReturnType) {
             $this->willReturn();
         }
 

Braces +4 added lines, -8 removed lines

@@ -79,15 +79,13 @@ 
         if (true === $reflectedMethod->hasReturnType() || $hasTentativeReturnType) {
             if ($hasTentativeReturnType) {
                 $reflectionType = $reflectedMethod->getTentativeReturnType();
-            }
-            else {
+            } else {
                 $reflectionType = $reflectedMethod->getReturnType();
             }
 
             if ($reflectionType instanceof ReflectionNamedType) {
                 $types = [$reflectionType];
-            }
-            elseif ($reflectionType instanceof ReflectionUnionType) {
+            } elseif ($reflectionType instanceof ReflectionUnionType) {
                 $types = $reflectionType->getTypes();
             }
 
@@ -103,8 +101,7 @@ 
                     // null is lowest priority
                     if ($type2 == 'null') {
                         return -1;
-                    }
-                    elseif ($type1 == 'null') {
+                    } elseif ($type1 == 'null') {
                         return 1;
                     }
 
@@ -115,8 +112,7 @@ 
 
                     if($isObject($type1) && !$isObject($type2)) {
                         return -1;
-                    }
-                    elseif(!$isObject($type1) && $isObject($type2))
+                    } elseif(!$isObject($type1) && $isObject($type2))
                     {
                         return 1;
                     }

vendor/phpspec/prophecy/src/Prophecy/Prophecy/ObjectProphecy.php

Indentation +254 added lines, -254 removed lines

@@ -29,258 +29,258 @@
  */
 class ObjectProphecy implements ProphecyInterface
 {
-    private $lazyDouble;
-    private $callCenter;
-    private $revealer;
-    private $comparatorFactory;
-
-    /**
-     * @var MethodProphecy[][]
-     */
-    private $methodProphecies = array();
-
-    /**
-     * Initializes object prophecy.
-     *
-     * @param LazyDouble        $lazyDouble
-     * @param CallCenter        $callCenter
-     * @param RevealerInterface $revealer
-     * @param ComparatorFactory $comparatorFactory
-     */
-    public function __construct(
-        LazyDouble $lazyDouble,
-        CallCenter $callCenter = null,
-        RevealerInterface $revealer = null,
-        ComparatorFactory $comparatorFactory = null
-    ) {
-        $this->lazyDouble = $lazyDouble;
-        $this->callCenter = $callCenter ?: new CallCenter;
-        $this->revealer   = $revealer ?: new Revealer;
-
-        $this->comparatorFactory = $comparatorFactory ?: ComparatorFactory::getInstance();
-    }
-
-    /**
-     * Forces double to extend specific class.
-     *
-     * @param string $class
-     *
-     * @return $this
-     */
-    public function willExtend($class)
-    {
-        $this->lazyDouble->setParentClass($class);
-
-        return $this;
-    }
-
-    /**
-     * Forces double to implement specific interface.
-     *
-     * @param string $interface
-     *
-     * @return $this
-     */
-    public function willImplement($interface)
-    {
-        $this->lazyDouble->addInterface($interface);
-
-        return $this;
-    }
-
-    /**
-     * Sets constructor arguments.
-     *
-     * @param array $arguments
-     *
-     * @return $this
-     */
-    public function willBeConstructedWith(array $arguments = null)
-    {
-        $this->lazyDouble->setArguments($arguments);
-
-        return $this;
-    }
-
-    /**
-     * Reveals double.
-     *
-     * @return object
-     *
-     * @throws \Prophecy\Exception\Prophecy\ObjectProphecyException If double doesn't implement needed interface
-     */
-    public function reveal()
-    {
-        $double = $this->lazyDouble->getInstance();
-
-        if (null === $double || !$double instanceof ProphecySubjectInterface) {
-            throw new ObjectProphecyException(
-                "Generated double must implement ProphecySubjectInterface, but it does not.\n".
-                'It seems you have wrongly configured doubler without required ClassPatch.',
-                $this
-            );
-        }
-
-        $double->setProphecy($this);
-
-        return $double;
-    }
-
-    /**
-     * Adds method prophecy to object prophecy.
-     *
-     * @param MethodProphecy $methodProphecy
-     *
-     * @throws \Prophecy\Exception\Prophecy\MethodProphecyException If method prophecy doesn't
-     *                                                              have arguments wildcard
-     */
-    public function addMethodProphecy(MethodProphecy $methodProphecy)
-    {
-        $argumentsWildcard = $methodProphecy->getArgumentsWildcard();
-        if (null === $argumentsWildcard) {
-            throw new MethodProphecyException(sprintf(
-                "Can not add prophecy for a method `%s::%s()`\n".
-                "as you did not specify arguments wildcard for it.",
-                get_class($this->reveal()),
-                $methodProphecy->getMethodName()
-            ), $methodProphecy);
-        }
-
-        $methodName = strtolower($methodProphecy->getMethodName());
-
-        if (!isset($this->methodProphecies[$methodName])) {
-            $this->methodProphecies[$methodName] = array();
-        }
-
-        $this->methodProphecies[$methodName][] = $methodProphecy;
-    }
-
-    /**
-     * Returns either all or related to single method prophecies.
-     *
-     * @param null|string $methodName
-     *
-     * @return MethodProphecy[]
-     */
-    public function getMethodProphecies($methodName = null)
-    {
-        if (null === $methodName) {
-            return $this->methodProphecies;
-        }
-
-        $methodName = strtolower($methodName);
-
-        if (!isset($this->methodProphecies[$methodName])) {
-            return array();
-        }
-
-        return $this->methodProphecies[$methodName];
-    }
-
-    /**
-     * Makes specific method call.
-     *
-     * @param string $methodName
-     * @param array  $arguments
-     *
-     * @return mixed
-     */
-    public function makeProphecyMethodCall($methodName, array $arguments)
-    {
-        $arguments = $this->revealer->reveal($arguments);
-        $return    = $this->callCenter->makeCall($this, $methodName, $arguments);
-
-        return $this->revealer->reveal($return);
-    }
-
-    /**
-     * Finds calls by method name & arguments wildcard.
-     *
-     * @param string            $methodName
-     * @param ArgumentsWildcard $wildcard
-     *
-     * @return Call[]
-     */
-    public function findProphecyMethodCalls($methodName, ArgumentsWildcard $wildcard)
-    {
-        return $this->callCenter->findCalls($methodName, $wildcard);
-    }
-
-    /**
-     * Checks that registered method predictions do not fail.
-     *
-     * @throws \Prophecy\Exception\Prediction\AggregateException If any of registered predictions fail
-     * @throws \Prophecy\Exception\Call\UnexpectedCallException
-     */
-    public function checkProphecyMethodsPredictions()
-    {
-        $exception = new AggregateException(sprintf("%s:\n", get_class($this->reveal())));
-        $exception->setObjectProphecy($this);
-
-        $this->callCenter->checkUnexpectedCalls();
-
-        foreach ($this->methodProphecies as $prophecies) {
-            foreach ($prophecies as $prophecy) {
-                try {
-                    $prophecy->checkPrediction();
-                } catch (PredictionException $e) {
-                    $exception->append($e);
-                }
-            }
-        }
-
-        if (count($exception->getExceptions())) {
-            throw $exception;
-        }
-    }
-
-    /**
-     * Creates new method prophecy using specified method name and arguments.
-     *
-     * @param string $methodName
-     * @param array  $arguments
-     *
-     * @return MethodProphecy
-     */
-    public function __call($methodName, array $arguments)
-    {
-        $arguments = new ArgumentsWildcard($this->revealer->reveal($arguments));
-
-        foreach ($this->getMethodProphecies($methodName) as $prophecy) {
-            $argumentsWildcard = $prophecy->getArgumentsWildcard();
-            $comparator = $this->comparatorFactory->getComparatorFor(
-                $argumentsWildcard, $arguments
-            );
-
-            try {
-                $comparator->assertEquals($argumentsWildcard, $arguments);
-                return $prophecy;
-            } catch (ComparisonFailure $failure) {}
-        }
-
-        return new MethodProphecy($this, $methodName, $arguments);
-    }
-
-    /**
-     * Tries to get property value from double.
-     *
-     * @param string $name
-     *
-     * @return mixed
-     */
-    public function __get($name)
-    {
-        return $this->reveal()->$name;
-    }
-
-    /**
-     * Tries to set property value to double.
-     *
-     * @param string $name
-     * @param mixed  $value
-     */
-    public function __set($name, $value)
-    {
-        $this->reveal()->$name = $this->revealer->reveal($value);
-    }
+	private $lazyDouble;
+	private $callCenter;
+	private $revealer;
+	private $comparatorFactory;
+
+	/**
+	 * @var MethodProphecy[][]
+	 */
+	private $methodProphecies = array();
+
+	/**
+	 * Initializes object prophecy.
+	 *
+	 * @param LazyDouble        $lazyDouble
+	 * @param CallCenter        $callCenter
+	 * @param RevealerInterface $revealer
+	 * @param ComparatorFactory $comparatorFactory
+	 */
+	public function __construct(
+		LazyDouble $lazyDouble,
+		CallCenter $callCenter = null,
+		RevealerInterface $revealer = null,
+		ComparatorFactory $comparatorFactory = null
+	) {
+		$this->lazyDouble = $lazyDouble;
+		$this->callCenter = $callCenter ?: new CallCenter;
+		$this->revealer   = $revealer ?: new Revealer;
+
+		$this->comparatorFactory = $comparatorFactory ?: ComparatorFactory::getInstance();
+	}
+
+	/**
+	 * Forces double to extend specific class.
+	 *
+	 * @param string $class
+	 *
+	 * @return $this
+	 */
+	public function willExtend($class)
+	{
+		$this->lazyDouble->setParentClass($class);
+
+		return $this;
+	}
+
+	/**
+	 * Forces double to implement specific interface.
+	 *
+	 * @param string $interface
+	 *
+	 * @return $this
+	 */
+	public function willImplement($interface)
+	{
+		$this->lazyDouble->addInterface($interface);
+
+		return $this;
+	}
+
+	/**
+	 * Sets constructor arguments.
+	 *
+	 * @param array $arguments
+	 *
+	 * @return $this
+	 */
+	public function willBeConstructedWith(array $arguments = null)
+	{
+		$this->lazyDouble->setArguments($arguments);
+
+		return $this;
+	}
+
+	/**
+	 * Reveals double.
+	 *
+	 * @return object
+	 *
+	 * @throws \Prophecy\Exception\Prophecy\ObjectProphecyException If double doesn't implement needed interface
+	 */
+	public function reveal()
+	{
+		$double = $this->lazyDouble->getInstance();
+
+		if (null === $double || !$double instanceof ProphecySubjectInterface) {
+			throw new ObjectProphecyException(
+				"Generated double must implement ProphecySubjectInterface, but it does not.\n".
+				'It seems you have wrongly configured doubler without required ClassPatch.',
+				$this
+			);
+		}
+
+		$double->setProphecy($this);
+
+		return $double;
+	}
+
+	/**
+	 * Adds method prophecy to object prophecy.
+	 *
+	 * @param MethodProphecy $methodProphecy
+	 *
+	 * @throws \Prophecy\Exception\Prophecy\MethodProphecyException If method prophecy doesn't
+	 *                                                              have arguments wildcard
+	 */
+	public function addMethodProphecy(MethodProphecy $methodProphecy)
+	{
+		$argumentsWildcard = $methodProphecy->getArgumentsWildcard();
+		if (null === $argumentsWildcard) {
+			throw new MethodProphecyException(sprintf(
+				"Can not add prophecy for a method `%s::%s()`\n".
+				"as you did not specify arguments wildcard for it.",
+				get_class($this->reveal()),
+				$methodProphecy->getMethodName()
+			), $methodProphecy);
+		}
+
+		$methodName = strtolower($methodProphecy->getMethodName());
+
+		if (!isset($this->methodProphecies[$methodName])) {
+			$this->methodProphecies[$methodName] = array();
+		}
+
+		$this->methodProphecies[$methodName][] = $methodProphecy;
+	}
+
+	/**
+	 * Returns either all or related to single method prophecies.
+	 *
+	 * @param null|string $methodName
+	 *
+	 * @return MethodProphecy[]
+	 */
+	public function getMethodProphecies($methodName = null)
+	{
+		if (null === $methodName) {
+			return $this->methodProphecies;
+		}
+
+		$methodName = strtolower($methodName);
+
+		if (!isset($this->methodProphecies[$methodName])) {
+			return array();
+		}
+
+		return $this->methodProphecies[$methodName];
+	}
+
+	/**
+	 * Makes specific method call.
+	 *
+	 * @param string $methodName
+	 * @param array  $arguments
+	 *
+	 * @return mixed
+	 */
+	public function makeProphecyMethodCall($methodName, array $arguments)
+	{
+		$arguments = $this->revealer->reveal($arguments);
+		$return    = $this->callCenter->makeCall($this, $methodName, $arguments);
+
+		return $this->revealer->reveal($return);
+	}
+
+	/**
+	 * Finds calls by method name & arguments wildcard.
+	 *
+	 * @param string            $methodName
+	 * @param ArgumentsWildcard $wildcard
+	 *
+	 * @return Call[]
+	 */
+	public function findProphecyMethodCalls($methodName, ArgumentsWildcard $wildcard)
+	{
+		return $this->callCenter->findCalls($methodName, $wildcard);
+	}
+
+	/**
+	 * Checks that registered method predictions do not fail.
+	 *
+	 * @throws \Prophecy\Exception\Prediction\AggregateException If any of registered predictions fail
+	 * @throws \Prophecy\Exception\Call\UnexpectedCallException
+	 */
+	public function checkProphecyMethodsPredictions()
+	{
+		$exception = new AggregateException(sprintf("%s:\n", get_class($this->reveal())));
+		$exception->setObjectProphecy($this);
+
+		$this->callCenter->checkUnexpectedCalls();
+
+		foreach ($this->methodProphecies as $prophecies) {
+			foreach ($prophecies as $prophecy) {
+				try {
+					$prophecy->checkPrediction();
+				} catch (PredictionException $e) {
+					$exception->append($e);
+				}
+			}
+		}
+
+		if (count($exception->getExceptions())) {
+			throw $exception;
+		}
+	}
+
+	/**
+	 * Creates new method prophecy using specified method name and arguments.
+	 *
+	 * @param string $methodName
+	 * @param array  $arguments
+	 *
+	 * @return MethodProphecy
+	 */
+	public function __call($methodName, array $arguments)
+	{
+		$arguments = new ArgumentsWildcard($this->revealer->reveal($arguments));
+
+		foreach ($this->getMethodProphecies($methodName) as $prophecy) {
+			$argumentsWildcard = $prophecy->getArgumentsWildcard();
+			$comparator = $this->comparatorFactory->getComparatorFor(
+				$argumentsWildcard, $arguments
+			);
+
+			try {
+				$comparator->assertEquals($argumentsWildcard, $arguments);
+				return $prophecy;
+			} catch (ComparisonFailure $failure) {}
+		}
+
+		return new MethodProphecy($this, $methodName, $arguments);
+	}
+
+	/**
+	 * Tries to get property value from double.
+	 *
+	 * @param string $name
+	 *
+	 * @return mixed
+	 */
+	public function __get($name)
+	{
+		return $this->reveal()->$name;
+	}
+
+	/**
+	 * Tries to set property value to double.
+	 *
+	 * @param string $name
+	 * @param mixed  $value
+	 */
+	public function __set($name, $value)
+	{
+		$this->reveal()->$name = $this->revealer->reveal($value);
+	}
 }

Spacing +3 added lines, -3 removed lines

@@ -113,7 +113,7 @@ 
     {
         $double = $this->lazyDouble->getInstance();
 
-        if (null === $double || !$double instanceof ProphecySubjectInterface) {
+        if (null === $double || ! $double instanceof ProphecySubjectInterface) {
             throw new ObjectProphecyException(
                 "Generated double must implement ProphecySubjectInterface, but it does not.\n".
                 'It seems you have wrongly configured doubler without required ClassPatch.',
@@ -148,7 +148,7 @@ 
 
         $methodName = strtolower($methodProphecy->getMethodName());
 
-        if (!isset($this->methodProphecies[$methodName])) {
+        if ( ! isset($this->methodProphecies[$methodName])) {
             $this->methodProphecies[$methodName] = array();
         }
 
@@ -170,7 +170,7 @@ 
 
         $methodName = strtolower($methodName);
 
-        if (!isset($this->methodProphecies[$methodName])) {
+        if ( ! isset($this->methodProphecies[$methodName])) {
             return array();
         }