eventespresso / event-espresso-core

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

Indentation +215 added lines, -215 removed lines

@@ -20,220 +20,220 @@
  */
 class Argument
 {
-    /**
-     * Checks that argument is exact value or object.
-     *
-     * @param mixed $value
-     *
-     * @return Token\ExactValueToken
-     */
-    public static function exact($value)
-    {
-        return new Token\ExactValueToken($value);
-    }
-
-    /**
-     * Checks that argument is of specific type or instance of specific class.
-     *
-     * @param string $type Type name (`integer`, `string`) or full class name
-     *
-     * @return Token\TypeToken
-     */
-    public static function type($type)
-    {
-        return new Token\TypeToken($type);
-    }
-
-    /**
-     * Checks that argument object has specific state.
-     *
-     * @param string $methodName
-     * @param mixed  $value
-     *
-     * @return Token\ObjectStateToken
-     */
-    public static function which($methodName, $value)
-    {
-        return new Token\ObjectStateToken($methodName, $value);
-    }
-
-    /**
-     * Checks that argument matches provided callback.
-     *
-     * @param callable $callback
-     *
-     * @return Token\CallbackToken
-     */
-    public static function that($callback)
-    {
-        return new Token\CallbackToken($callback);
-    }
-
-    /**
-     * Matches any single value.
-     *
-     * @return Token\AnyValueToken
-     */
-    public static function any()
-    {
-        return new Token\AnyValueToken;
-    }
-
-    /**
-     * Matches all values to the rest of the signature.
-     *
-     * @return Token\AnyValuesToken
-     */
-    public static function cetera()
-    {
-        return new Token\AnyValuesToken;
-    }
-
-    /**
-     * Checks that argument matches all tokens
-     *
-     * @param mixed ... a list of tokens
-     *
-     * @return Token\LogicalAndToken
-     */
-    public static function allOf()
-    {
-        return new Token\LogicalAndToken(func_get_args());
-    }
-
-    /**
-     * Checks that argument array or countable object has exact number of elements.
-     *
-     * @param integer $value array elements count
-     *
-     * @return Token\ArrayCountToken
-     */
-    public static function size($value)
-    {
-        return new Token\ArrayCountToken($value);
-    }
-
-    /**
-     * Checks that argument array contains (key, value) pair
-     *
-     * @param mixed $key   exact value or token
-     * @param mixed $value exact value or token
-     *
-     * @return Token\ArrayEntryToken
-     */
-    public static function withEntry($key, $value)
-    {
-        return new Token\ArrayEntryToken($key, $value);
-    }
-
-    /**
-     * Checks that arguments array entries all match value
-     *
-     * @param mixed $value
-     *
-     * @return Token\ArrayEveryEntryToken
-     */
-    public static function withEveryEntry($value)
-    {
-        return new Token\ArrayEveryEntryToken($value);
-    }
-
-    /**
-     * Checks that argument array contains value
-     *
-     * @param mixed $value
-     *
-     * @return Token\ArrayEntryToken
-     */
-    public static function containing($value)
-    {
-        return new Token\ArrayEntryToken(self::any(), $value);
-    }
-
-    /**
-     * Checks that argument array has key
-     *
-     * @param mixed $key exact value or token
-     *
-     * @return Token\ArrayEntryToken
-     */
-    public static function withKey($key)
-    {
-        return new Token\ArrayEntryToken($key, self::any());
-    }
-
-    /**
-     * Checks that argument does not match the value|token.
-     *
-     * @param mixed $value either exact value or argument token
-     *
-     * @return Token\LogicalNotToken
-     */
-    public static function not($value)
-    {
-        return new Token\LogicalNotToken($value);
-    }
-
-    /**
-     * @param string $value
-     *
-     * @return Token\StringContainsToken
-     */
-    public static function containingString($value)
-    {
-        return new Token\StringContainsToken($value);
-    }
-
-    /**
-     * Checks that argument is identical value.
-     *
-     * @param mixed $value
-     *
-     * @return Token\IdenticalValueToken
-     */
-    public static function is($value)
-    {
-        return new Token\IdenticalValueToken($value);
-    }
-
-    /**
-     * Check that argument is same value when rounding to the
-     * given precision.
-     *
-     * @param float $value
-     * @param float $precision
-     *
-     * @return Token\ApproximateValueToken
-     */
-    public static function approximate($value, $precision = 0)
-    {
-        return new Token\ApproximateValueToken($value, $precision);
-    }
-
-    /**
-     * Checks that argument is in array.
-     *
-     * @param array $value
-     *
-     * @return Token\InArrayToken
-     */
-
-    public static function in($value)
-    {
-        return new Token\InArrayToken($value);
-    }
-
-    /**
-     * Checks that argument is not in array.
-     *
-     * @param array $value
-     *
-     * @return Token\NotInArrayToken
-     */
-
-    public static function notIn($value)
-    {
-        return new Token\NotInArrayToken($value);
-    }
+	/**
+	 * Checks that argument is exact value or object.
+	 *
+	 * @param mixed $value
+	 *
+	 * @return Token\ExactValueToken
+	 */
+	public static function exact($value)
+	{
+		return new Token\ExactValueToken($value);
+	}
+
+	/**
+	 * Checks that argument is of specific type or instance of specific class.
+	 *
+	 * @param string $type Type name (`integer`, `string`) or full class name
+	 *
+	 * @return Token\TypeToken
+	 */
+	public static function type($type)
+	{
+		return new Token\TypeToken($type);
+	}
+
+	/**
+	 * Checks that argument object has specific state.
+	 *
+	 * @param string $methodName
+	 * @param mixed  $value
+	 *
+	 * @return Token\ObjectStateToken
+	 */
+	public static function which($methodName, $value)
+	{
+		return new Token\ObjectStateToken($methodName, $value);
+	}
+
+	/**
+	 * Checks that argument matches provided callback.
+	 *
+	 * @param callable $callback
+	 *
+	 * @return Token\CallbackToken
+	 */
+	public static function that($callback)
+	{
+		return new Token\CallbackToken($callback);
+	}
+
+	/**
+	 * Matches any single value.
+	 *
+	 * @return Token\AnyValueToken
+	 */
+	public static function any()
+	{
+		return new Token\AnyValueToken;
+	}
+
+	/**
+	 * Matches all values to the rest of the signature.
+	 *
+	 * @return Token\AnyValuesToken
+	 */
+	public static function cetera()
+	{
+		return new Token\AnyValuesToken;
+	}
+
+	/**
+	 * Checks that argument matches all tokens
+	 *
+	 * @param mixed ... a list of tokens
+	 *
+	 * @return Token\LogicalAndToken
+	 */
+	public static function allOf()
+	{
+		return new Token\LogicalAndToken(func_get_args());
+	}
+
+	/**
+	 * Checks that argument array or countable object has exact number of elements.
+	 *
+	 * @param integer $value array elements count
+	 *
+	 * @return Token\ArrayCountToken
+	 */
+	public static function size($value)
+	{
+		return new Token\ArrayCountToken($value);
+	}
+
+	/**
+	 * Checks that argument array contains (key, value) pair
+	 *
+	 * @param mixed $key   exact value or token
+	 * @param mixed $value exact value or token
+	 *
+	 * @return Token\ArrayEntryToken
+	 */
+	public static function withEntry($key, $value)
+	{
+		return new Token\ArrayEntryToken($key, $value);
+	}
+
+	/**
+	 * Checks that arguments array entries all match value
+	 *
+	 * @param mixed $value
+	 *
+	 * @return Token\ArrayEveryEntryToken
+	 */
+	public static function withEveryEntry($value)
+	{
+		return new Token\ArrayEveryEntryToken($value);
+	}
+
+	/**
+	 * Checks that argument array contains value
+	 *
+	 * @param mixed $value
+	 *
+	 * @return Token\ArrayEntryToken
+	 */
+	public static function containing($value)
+	{
+		return new Token\ArrayEntryToken(self::any(), $value);
+	}
+
+	/**
+	 * Checks that argument array has key
+	 *
+	 * @param mixed $key exact value or token
+	 *
+	 * @return Token\ArrayEntryToken
+	 */
+	public static function withKey($key)
+	{
+		return new Token\ArrayEntryToken($key, self::any());
+	}
+
+	/**
+	 * Checks that argument does not match the value|token.
+	 *
+	 * @param mixed $value either exact value or argument token
+	 *
+	 * @return Token\LogicalNotToken
+	 */
+	public static function not($value)
+	{
+		return new Token\LogicalNotToken($value);
+	}
+
+	/**
+	 * @param string $value
+	 *
+	 * @return Token\StringContainsToken
+	 */
+	public static function containingString($value)
+	{
+		return new Token\StringContainsToken($value);
+	}
+
+	/**
+	 * Checks that argument is identical value.
+	 *
+	 * @param mixed $value
+	 *
+	 * @return Token\IdenticalValueToken
+	 */
+	public static function is($value)
+	{
+		return new Token\IdenticalValueToken($value);
+	}
+
+	/**
+	 * Check that argument is same value when rounding to the
+	 * given precision.
+	 *
+	 * @param float $value
+	 * @param float $precision
+	 *
+	 * @return Token\ApproximateValueToken
+	 */
+	public static function approximate($value, $precision = 0)
+	{
+		return new Token\ApproximateValueToken($value, $precision);
+	}
+
+	/**
+	 * Checks that argument is in array.
+	 *
+	 * @param array $value
+	 *
+	 * @return Token\InArrayToken
+	 */
+
+	public static function in($value)
+	{
+		return new Token\InArrayToken($value);
+	}
+
+	/**
+	 * Checks that argument is not in array.
+	 *
+	 * @param array $value
+	 *
+	 * @return Token\NotInArrayToken
+	 */
+
+	public static function notIn($value)
+	{
+		return new Token\NotInArrayToken($value);
+	}
 
 }

vendor/phpspec/prophecy/src/Prophecy/Doubler/Generator/Node/MethodNode.php

Indentation +186 added lines, -186 removed lines

@@ -21,190 +21,190 @@
  */
 class MethodNode
 {
-    private $name;
-    private $code;
-    private $visibility = 'public';
-    private $static = false;
-    private $returnsReference = false;
-
-    /** @var ReturnTypeNode */
-    private $returnTypeNode;
-
-    /**
-     * @var ArgumentNode[]
-     */
-    private $arguments = array();
-
-    /**
-     * @param string $name
-     * @param string $code
-     */
-    public function __construct($name, $code = null, TypeHintReference $typeHintReference = null)
-    {
-        $this->name = $name;
-        $this->code = $code;
-        $this->returnTypeNode = new ReturnTypeNode();
-    }
-
-    public function getVisibility()
-    {
-        return $this->visibility;
-    }
-
-    /**
-     * @param string $visibility
-     */
-    public function setVisibility($visibility)
-    {
-        $visibility = strtolower($visibility);
-
-        if (!in_array($visibility, array('public', 'private', 'protected'))) {
-            throw new InvalidArgumentException(sprintf(
-                '`%s` method visibility is not supported.', $visibility
-            ));
-        }
-
-        $this->visibility = $visibility;
-    }
-
-    public function isStatic()
-    {
-        return $this->static;
-    }
-
-    public function setStatic($static = true)
-    {
-        $this->static = (bool) $static;
-    }
-
-    public function returnsReference()
-    {
-        return $this->returnsReference;
-    }
-
-    public function setReturnsReference()
-    {
-        $this->returnsReference = true;
-    }
-
-    public function getName()
-    {
-        return $this->name;
-    }
-
-    public function addArgument(ArgumentNode $argument)
-    {
-        $this->arguments[] = $argument;
-    }
-
-    /**
-     * @return ArgumentNode[]
-     */
-    public function getArguments()
-    {
-        return $this->arguments;
-    }
-
-    /**
-     * @deprecated use getReturnTypeNode instead
-     * @return bool
-     */
-    public function hasReturnType()
-    {
-        return (bool) $this->returnTypeNode->getNonNullTypes();
-    }
-
-    public function setReturnTypeNode(ReturnTypeNode $returnTypeNode): void
-    {
-        $this->returnTypeNode = $returnTypeNode;
-    }
-
-    /**
-     * @deprecated use setReturnTypeNode instead
-     * @param string $type
-     */
-    public function setReturnType($type = null)
-    {
-        $this->returnTypeNode = ($type === '' || $type === null) ? new ReturnTypeNode() : new ReturnTypeNode($type);
-    }
-
-    /**
-     * @deprecated use setReturnTypeNode instead
-     * @param bool $bool
-     */
-    public function setNullableReturnType($bool = true)
-    {
-        if ($bool) {
-            $this->returnTypeNode = new ReturnTypeNode('null', ...$this->returnTypeNode->getTypes());
-        }
-        else {
-            $this->returnTypeNode = new ReturnTypeNode(...$this->returnTypeNode->getNonNullTypes());
-        }
-    }
-
-    /**
-     * @deprecated use getReturnTypeNode instead
-     * @return string|null
-     */
-    public function getReturnType()
-    {
-        if ($types = $this->returnTypeNode->getNonNullTypes())
-        {
-            return $types[0];
-        }
-
-        return null;
-    }
-
-    public function getReturnTypeNode() : ReturnTypeNode
-    {
-        return $this->returnTypeNode;
-    }
-
-    /**
-     * @deprecated use getReturnTypeNode instead
-     * @return bool
-     */
-    public function hasNullableReturnType()
-    {
-        return $this->returnTypeNode->canUseNullShorthand();
-    }
-
-    /**
-     * @param string $code
-     */
-    public function setCode($code)
-    {
-        $this->code = $code;
-    }
-
-    public function getCode()
-    {
-        if ($this->returnsReference)
-        {
-            return "throw new \Prophecy\Exception\Doubler\ReturnByReferenceException('Returning by reference not supported', get_class(\$this), '{$this->name}');";
-        }
-
-        return (string) $this->code;
-    }
-
-    public function useParentCode()
-    {
-        $this->code = sprintf(
-            'return parent::%s(%s);', $this->getName(), implode(', ',
-                array_map(array($this, 'generateArgument'), $this->arguments)
-            )
-        );
-    }
-
-    private function generateArgument(ArgumentNode $arg)
-    {
-        $argument = '$'.$arg->getName();
-
-        if ($arg->isVariadic()) {
-            $argument = '...'.$argument;
-        }
-
-        return $argument;
-    }
+	private $name;
+	private $code;
+	private $visibility = 'public';
+	private $static = false;
+	private $returnsReference = false;
+
+	/** @var ReturnTypeNode */
+	private $returnTypeNode;
+
+	/**
+	 * @var ArgumentNode[]
+	 */
+	private $arguments = array();
+
+	/**
+	 * @param string $name
+	 * @param string $code
+	 */
+	public function __construct($name, $code = null, TypeHintReference $typeHintReference = null)
+	{
+		$this->name = $name;
+		$this->code = $code;
+		$this->returnTypeNode = new ReturnTypeNode();
+	}
+
+	public function getVisibility()
+	{
+		return $this->visibility;
+	}
+
+	/**
+	 * @param string $visibility
+	 */
+	public function setVisibility($visibility)
+	{
+		$visibility = strtolower($visibility);
+
+		if (!in_array($visibility, array('public', 'private', 'protected'))) {
+			throw new InvalidArgumentException(sprintf(
+				'`%s` method visibility is not supported.', $visibility
+			));
+		}
+
+		$this->visibility = $visibility;
+	}
+
+	public function isStatic()
+	{
+		return $this->static;
+	}
+
+	public function setStatic($static = true)
+	{
+		$this->static = (bool) $static;
+	}
+
+	public function returnsReference()
+	{
+		return $this->returnsReference;
+	}
+
+	public function setReturnsReference()
+	{
+		$this->returnsReference = true;
+	}
+
+	public function getName()
+	{
+		return $this->name;
+	}
+
+	public function addArgument(ArgumentNode $argument)
+	{
+		$this->arguments[] = $argument;
+	}
+
+	/**
+	 * @return ArgumentNode[]
+	 */
+	public function getArguments()
+	{
+		return $this->arguments;
+	}
+
+	/**
+	 * @deprecated use getReturnTypeNode instead
+	 * @return bool
+	 */
+	public function hasReturnType()
+	{
+		return (bool) $this->returnTypeNode->getNonNullTypes();
+	}
+
+	public function setReturnTypeNode(ReturnTypeNode $returnTypeNode): void
+	{
+		$this->returnTypeNode = $returnTypeNode;
+	}
+
+	/**
+	 * @deprecated use setReturnTypeNode instead
+	 * @param string $type
+	 */
+	public function setReturnType($type = null)
+	{
+		$this->returnTypeNode = ($type === '' || $type === null) ? new ReturnTypeNode() : new ReturnTypeNode($type);
+	}
+
+	/**
+	 * @deprecated use setReturnTypeNode instead
+	 * @param bool $bool
+	 */
+	public function setNullableReturnType($bool = true)
+	{
+		if ($bool) {
+			$this->returnTypeNode = new ReturnTypeNode('null', ...$this->returnTypeNode->getTypes());
+		}
+		else {
+			$this->returnTypeNode = new ReturnTypeNode(...$this->returnTypeNode->getNonNullTypes());
+		}
+	}
+
+	/**
+	 * @deprecated use getReturnTypeNode instead
+	 * @return string|null
+	 */
+	public function getReturnType()
+	{
+		if ($types = $this->returnTypeNode->getNonNullTypes())
+		{
+			return $types[0];
+		}
+
+		return null;
+	}
+
+	public function getReturnTypeNode() : ReturnTypeNode
+	{
+		return $this->returnTypeNode;
+	}
+
+	/**
+	 * @deprecated use getReturnTypeNode instead
+	 * @return bool
+	 */
+	public function hasNullableReturnType()
+	{
+		return $this->returnTypeNode->canUseNullShorthand();
+	}
+
+	/**
+	 * @param string $code
+	 */
+	public function setCode($code)
+	{
+		$this->code = $code;
+	}
+
+	public function getCode()
+	{
+		if ($this->returnsReference)
+		{
+			return "throw new \Prophecy\Exception\Doubler\ReturnByReferenceException('Returning by reference not supported', get_class(\$this), '{$this->name}');";
+		}
+
+		return (string) $this->code;
+	}
+
+	public function useParentCode()
+	{
+		$this->code = sprintf(
+			'return parent::%s(%s);', $this->getName(), implode(', ',
+				array_map(array($this, 'generateArgument'), $this->arguments)
+			)
+		);
+	}
+
+	private function generateArgument(ArgumentNode $arg)
+	{
+		$argument = '$'.$arg->getName();
+
+		if ($arg->isVariadic()) {
+			$argument = '...'.$argument;
+		}
+
+		return $argument;
+	}
 }

Spacing +1 added lines, -1 removed lines

@@ -58,7 +58,7 @@
     {
         $visibility = strtolower($visibility);
 
-        if (!in_array($visibility, array('public', 'private', 'protected'))) {
+        if ( ! in_array($visibility, array('public', 'private', 'protected'))) {
             throw new InvalidArgumentException(sprintf(
                 '`%s` method visibility is not supported.', $visibility
             ));

Braces +1 added lines, -2 removed lines

@@ -136,8 +136,7 @@
     {
         if ($bool) {
             $this->returnTypeNode = new ReturnTypeNode('null', ...$this->returnTypeNode->getTypes());
-        }
-        else {
+        } else {
             $this->returnTypeNode = new ReturnTypeNode(...$this->returnTypeNode->getNonNullTypes());
         }
     }

vendor/phpspec/prophecy/src/Prophecy/Doubler/Generator/Node/ReturnTypeNode.php

Indentation +32 added lines, -32 removed lines

@@ -6,40 +6,40 @@
 
 final class ReturnTypeNode extends TypeNodeAbstract
 {
-    protected function getRealType(string $type): string
-    {
-        switch ($type) {
-            case 'void':
-            case 'never':
-                return $type;
-            default:
-                return parent::getRealType($type);
-        }
-    }
+	protected function getRealType(string $type): string
+	{
+		switch ($type) {
+			case 'void':
+			case 'never':
+				return $type;
+			default:
+				return parent::getRealType($type);
+		}
+	}
 
-    protected function guardIsValidType()
-    {
-        if (isset($this->types['void']) && count($this->types) !== 1) {
-            throw new DoubleException('void cannot be part of a union');
-        }
-        if (isset($this->types['never']) && count($this->types) !== 1) {
-            throw new DoubleException('never cannot be part of a union');
-        }
+	protected function guardIsValidType()
+	{
+		if (isset($this->types['void']) && count($this->types) !== 1) {
+			throw new DoubleException('void cannot be part of a union');
+		}
+		if (isset($this->types['never']) && count($this->types) !== 1) {
+			throw new DoubleException('never cannot be part of a union');
+		}
 
-        parent::guardIsValidType();
-    }
+		parent::guardIsValidType();
+	}
 
-    /**
-     * @deprecated use hasReturnStatement
-     */
-    public function isVoid()
-    {
-        return $this->types == ['void' => 'void'];
-    }
+	/**
+	 * @deprecated use hasReturnStatement
+	 */
+	public function isVoid()
+	{
+		return $this->types == ['void' => 'void'];
+	}
 
-    public function hasReturnStatement(): bool
-    {
-        return $this->types !== ['void' => 'void']
-            && $this->types !== ['never' => 'never'];
-    }
+	public function hasReturnStatement(): bool
+	{
+		return $this->types !== ['void' => 'void']
+			&& $this->types !== ['never' => 'never'];
+	}
 }

vendor/phpspec/prophecy/src/Prophecy/Doubler/Generator/Node/TypeNodeAbstract.php

Indentation +88 added lines, -88 removed lines

@@ -6,92 +6,92 @@
 
 abstract class TypeNodeAbstract
 {
-    /** @var string[] */
-    protected $types = [];
-
-    public function __construct(string ...$types)
-    {
-        foreach ($types as $type) {
-            $type = $this->getRealType($type);
-            $this->types[$type] = $type;
-        }
-
-        $this->guardIsValidType();
-    }
-
-    public function canUseNullShorthand(): bool
-    {
-        return isset($this->types['null']) && count($this->types) <= 2;
-    }
-
-    public function getTypes(): array
-    {
-        return array_values($this->types);
-    }
-
-    public function getNonNullTypes(): array
-    {
-        $nonNullTypes = $this->types;
-        unset($nonNullTypes['null']);
-
-        return array_values($nonNullTypes);
-    }
-
-    protected function prefixWithNsSeparator(string $type): string
-    {
-        return '\\' . ltrim($type, '\\');
-    }
-
-    protected function getRealType(string $type): string
-    {
-        switch ($type) {
-            // type aliases
-            case 'double':
-            case 'real':
-                return 'float';
-            case 'boolean':
-                return 'bool';
-            case 'integer':
-                return 'int';
-
-            //  built in types
-            case 'self':
-            case 'static':
-            case 'array':
-            case 'callable':
-            case 'bool':
-            case 'false':
-            case 'float':
-            case 'int':
-            case 'string':
-            case 'iterable':
-            case 'object':
-            case 'null':
-                return $type;
-            case 'mixed':
-                return \PHP_VERSION_ID < 80000 ? $this->prefixWithNsSeparator($type) : $type;
-
-            default:
-                return $this->prefixWithNsSeparator($type);
-        }
-    }
-
-    protected function guardIsValidType()
-    {
-        if ($this->types == ['null' => 'null']) {
-            throw new DoubleException('Type cannot be standalone null');
-        }
-
-        if ($this->types == ['false' => 'false']) {
-            throw new DoubleException('Type cannot be standalone false');
-        }
-
-        if ($this->types == ['false' => 'false', 'null' => 'null']) {
-            throw new DoubleException('Type cannot be nullable false');
-        }
-
-        if (\PHP_VERSION_ID >= 80000 && isset($this->types['mixed']) && count($this->types) !== 1) {
-            throw new DoubleException('mixed cannot be part of a union');
-        }
-    }
+	/** @var string[] */
+	protected $types = [];
+
+	public function __construct(string ...$types)
+	{
+		foreach ($types as $type) {
+			$type = $this->getRealType($type);
+			$this->types[$type] = $type;
+		}
+
+		$this->guardIsValidType();
+	}
+
+	public function canUseNullShorthand(): bool
+	{
+		return isset($this->types['null']) && count($this->types) <= 2;
+	}
+
+	public function getTypes(): array
+	{
+		return array_values($this->types);
+	}
+
+	public function getNonNullTypes(): array
+	{
+		$nonNullTypes = $this->types;
+		unset($nonNullTypes['null']);
+
+		return array_values($nonNullTypes);
+	}
+
+	protected function prefixWithNsSeparator(string $type): string
+	{
+		return '\\' . ltrim($type, '\\');
+	}
+
+	protected function getRealType(string $type): string
+	{
+		switch ($type) {
+			// type aliases
+			case 'double':
+			case 'real':
+				return 'float';
+			case 'boolean':
+				return 'bool';
+			case 'integer':
+				return 'int';
+
+			//  built in types
+			case 'self':
+			case 'static':
+			case 'array':
+			case 'callable':
+			case 'bool':
+			case 'false':
+			case 'float':
+			case 'int':
+			case 'string':
+			case 'iterable':
+			case 'object':
+			case 'null':
+				return $type;
+			case 'mixed':
+				return \PHP_VERSION_ID < 80000 ? $this->prefixWithNsSeparator($type) : $type;
+
+			default:
+				return $this->prefixWithNsSeparator($type);
+		}
+	}
+
+	protected function guardIsValidType()
+	{
+		if ($this->types == ['null' => 'null']) {
+			throw new DoubleException('Type cannot be standalone null');
+		}
+
+		if ($this->types == ['false' => 'false']) {
+			throw new DoubleException('Type cannot be standalone false');
+		}
+
+		if ($this->types == ['false' => 'false', 'null' => 'null']) {
+			throw new DoubleException('Type cannot be nullable false');
+		}
+
+		if (\PHP_VERSION_ID >= 80000 && isset($this->types['mixed']) && count($this->types) !== 1) {
+			throw new DoubleException('mixed cannot be part of a union');
+		}
+	}
 }

Spacing +1 added lines, -1 removed lines

@@ -39,7 +39,7 @@
 
     protected function prefixWithNsSeparator(string $type): string
     {
-        return '\\' . ltrim($type, '\\');
+        return '\\'.ltrim($type, '\\');
     }
 
     protected function getRealType(string $type): string

vendor/phpspec/prophecy/src/Prophecy/Doubler/Generator/Node/ClassNode.php

Indentation +145 added lines, -145 removed lines

@@ -21,149 +21,149 @@
  */
 class ClassNode
 {
-    private $parentClass = 'stdClass';
-    private $interfaces  = array();
-    private $properties  = array();
-    private $unextendableMethods = array();
-
-    /**
-     * @var MethodNode[]
-     */
-    private $methods     = array();
-
-    public function getParentClass()
-    {
-        return $this->parentClass;
-    }
-
-    /**
-     * @param string $class
-     */
-    public function setParentClass($class)
-    {
-        $this->parentClass = $class ?: 'stdClass';
-    }
-
-    /**
-     * @return string[]
-     */
-    public function getInterfaces()
-    {
-        return $this->interfaces;
-    }
-
-    /**
-     * @param string $interface
-     */
-    public function addInterface($interface)
-    {
-        if ($this->hasInterface($interface)) {
-            return;
-        }
-
-        array_unshift($this->interfaces, $interface);
-    }
-
-    /**
-     * @param string $interface
-     *
-     * @return bool
-     */
-    public function hasInterface($interface)
-    {
-        return in_array($interface, $this->interfaces);
-    }
-
-    public function getProperties()
-    {
-        return $this->properties;
-    }
-
-    public function addProperty($name, $visibility = 'public')
-    {
-        $visibility = strtolower($visibility);
-
-        if (!in_array($visibility, array('public', 'private', 'protected'))) {
-            throw new InvalidArgumentException(sprintf(
-                '`%s` property visibility is not supported.', $visibility
-            ));
-        }
-
-        $this->properties[$name] = $visibility;
-    }
-
-    /**
-     * @return MethodNode[]
-     */
-    public function getMethods()
-    {
-        return $this->methods;
-    }
-
-    public function addMethod(MethodNode $method, $force = false)
-    {
-        if (!$this->isExtendable($method->getName())){
-            $message = sprintf(
-                'Method `%s` is not extendable, so can not be added.', $method->getName()
-            );
-            throw new MethodNotExtendableException($message, $this->getParentClass(), $method->getName());
-        }
-
-        if ($force || !isset($this->methods[$method->getName()])) {
-            $this->methods[$method->getName()] = $method;
-        }
-    }
-
-    public function removeMethod($name)
-    {
-        unset($this->methods[$name]);
-    }
-
-    /**
-     * @param string $name
-     *
-     * @return MethodNode|null
-     */
-    public function getMethod($name)
-    {
-        return $this->hasMethod($name) ? $this->methods[$name] : null;
-    }
-
-    /**
-     * @param string $name
-     *
-     * @return bool
-     */
-    public function hasMethod($name)
-    {
-        return isset($this->methods[$name]);
-    }
-
-    /**
-     * @return string[]
-     */
-    public function getUnextendableMethods()
-    {
-        return $this->unextendableMethods;
-    }
-
-    /**
-     * @param string $unextendableMethod
-     */
-    public function addUnextendableMethod($unextendableMethod)
-    {
-        if (!$this->isExtendable($unextendableMethod)){
-            return;
-        }
-        $this->unextendableMethods[] = $unextendableMethod;
-    }
-
-    /**
-     * @param string $method
-     * @return bool
-     */
-    public function isExtendable($method)
-    {
-        return !in_array($method, $this->unextendableMethods);
-    }
+	private $parentClass = 'stdClass';
+	private $interfaces  = array();
+	private $properties  = array();
+	private $unextendableMethods = array();
+
+	/**
+	 * @var MethodNode[]
+	 */
+	private $methods     = array();
+
+	public function getParentClass()
+	{
+		return $this->parentClass;
+	}
+
+	/**
+	 * @param string $class
+	 */
+	public function setParentClass($class)
+	{
+		$this->parentClass = $class ?: 'stdClass';
+	}
+
+	/**
+	 * @return string[]
+	 */
+	public function getInterfaces()
+	{
+		return $this->interfaces;
+	}
+
+	/**
+	 * @param string $interface
+	 */
+	public function addInterface($interface)
+	{
+		if ($this->hasInterface($interface)) {
+			return;
+		}
+
+		array_unshift($this->interfaces, $interface);
+	}
+
+	/**
+	 * @param string $interface
+	 *
+	 * @return bool
+	 */
+	public function hasInterface($interface)
+	{
+		return in_array($interface, $this->interfaces);
+	}
+
+	public function getProperties()
+	{
+		return $this->properties;
+	}
+
+	public function addProperty($name, $visibility = 'public')
+	{
+		$visibility = strtolower($visibility);
+
+		if (!in_array($visibility, array('public', 'private', 'protected'))) {
+			throw new InvalidArgumentException(sprintf(
+				'`%s` property visibility is not supported.', $visibility
+			));
+		}
+
+		$this->properties[$name] = $visibility;
+	}
+
+	/**
+	 * @return MethodNode[]
+	 */
+	public function getMethods()
+	{
+		return $this->methods;
+	}
+
+	public function addMethod(MethodNode $method, $force = false)
+	{
+		if (!$this->isExtendable($method->getName())){
+			$message = sprintf(
+				'Method `%s` is not extendable, so can not be added.', $method->getName()
+			);
+			throw new MethodNotExtendableException($message, $this->getParentClass(), $method->getName());
+		}
+
+		if ($force || !isset($this->methods[$method->getName()])) {
+			$this->methods[$method->getName()] = $method;
+		}
+	}
+
+	public function removeMethod($name)
+	{
+		unset($this->methods[$name]);
+	}
+
+	/**
+	 * @param string $name
+	 *
+	 * @return MethodNode|null
+	 */
+	public function getMethod($name)
+	{
+		return $this->hasMethod($name) ? $this->methods[$name] : null;
+	}
+
+	/**
+	 * @param string $name
+	 *
+	 * @return bool
+	 */
+	public function hasMethod($name)
+	{
+		return isset($this->methods[$name]);
+	}
+
+	/**
+	 * @return string[]
+	 */
+	public function getUnextendableMethods()
+	{
+		return $this->unextendableMethods;
+	}
+
+	/**
+	 * @param string $unextendableMethod
+	 */
+	public function addUnextendableMethod($unextendableMethod)
+	{
+		if (!$this->isExtendable($unextendableMethod)){
+			return;
+		}
+		$this->unextendableMethods[] = $unextendableMethod;
+	}
+
+	/**
+	 * @param string $method
+	 * @return bool
+	 */
+	public function isExtendable($method)
+	{
+		return !in_array($method, $this->unextendableMethods);
+	}
 }

Spacing +6 added lines, -6 removed lines

@@ -29,7 +29,7 @@ 
     /**
      * @var MethodNode[]
      */
-    private $methods     = array();
+    private $methods = array();
 
     public function getParentClass()
     {
@@ -83,7 +83,7 @@ 
     {
         $visibility = strtolower($visibility);
 
-        if (!in_array($visibility, array('public', 'private', 'protected'))) {
+        if ( ! in_array($visibility, array('public', 'private', 'protected'))) {
             throw new InvalidArgumentException(sprintf(
                 '`%s` property visibility is not supported.', $visibility
             ));
@@ -102,14 +102,14 @@ 
 
     public function addMethod(MethodNode $method, $force = false)
     {
-        if (!$this->isExtendable($method->getName())){
+        if ( ! $this->isExtendable($method->getName())) {
             $message = sprintf(
                 'Method `%s` is not extendable, so can not be added.', $method->getName()
             );
             throw new MethodNotExtendableException($message, $this->getParentClass(), $method->getName());
         }
 
-        if ($force || !isset($this->methods[$method->getName()])) {
+        if ($force || ! isset($this->methods[$method->getName()])) {
             $this->methods[$method->getName()] = $method;
         }
     }
@@ -152,7 +152,7 @@ 
      */
     public function addUnextendableMethod($unextendableMethod)
     {
-        if (!$this->isExtendable($unextendableMethod)){
+        if ( ! $this->isExtendable($unextendableMethod)) {
             return;
         }
         $this->unextendableMethods[] = $unextendableMethod;
@@ -164,6 +164,6 @@ 
      */
     public function isExtendable($method)
     {
-        return !in_array($method, $this->unextendableMethods);
+        return ! in_array($method, $this->unextendableMethods);
     }
 }

vendor/phpspec/prophecy/src/Prophecy/Doubler/Generator/Node/ArgumentNode.php

Indentation +112 added lines, -112 removed lines

@@ -18,116 +18,116 @@
  */
 class ArgumentNode
 {
-    private $name;
-    private $default;
-    private $optional    = false;
-    private $byReference = false;
-    private $isVariadic  = false;
-
-    /** @var ArgumentTypeNode */
-    private $typeNode;
-
-    /**
-     * @param string $name
-     */
-    public function __construct($name)
-    {
-        $this->name = $name;
-        $this->typeNode = new ArgumentTypeNode();
-    }
-
-    public function getName()
-    {
-        return $this->name;
-    }
-
-    public function setTypeNode(ArgumentTypeNode $typeNode)
-    {
-        $this->typeNode = $typeNode;
-    }
-
-    public function getTypeNode() : ArgumentTypeNode
-    {
-        return $this->typeNode;
-    }
-
-    public function hasDefault()
-    {
-        return $this->isOptional() && !$this->isVariadic();
-    }
-
-    public function getDefault()
-    {
-        return $this->default;
-    }
-
-    public function setDefault($default = null)
-    {
-        $this->optional = true;
-        $this->default  = $default;
-    }
-
-    public function isOptional()
-    {
-        return $this->optional;
-    }
-
-    public function setAsPassedByReference($byReference = true)
-    {
-        $this->byReference = $byReference;
-    }
-
-    public function isPassedByReference()
-    {
-        return $this->byReference;
-    }
-
-    public function setAsVariadic($isVariadic = true)
-    {
-        $this->isVariadic = $isVariadic;
-    }
-
-    public function isVariadic()
-    {
-        return $this->isVariadic;
-    }
-
-    /**
-     * @deprecated use getArgumentTypeNode instead
-     * @return string|null
-     */
-    public function getTypeHint()
-    {
-        $type = $this->typeNode->getNonNullTypes() ? $this->typeNode->getNonNullTypes()[0] : null;
-
-        return $type ? ltrim($type, '\\') : null;
-    }
-
-    /**
-     * @deprecated use setArgumentTypeNode instead
-     * @param string|null $typeHint
-     */
-    public function setTypeHint($typeHint = null)
-    {
-        $this->typeNode = ($typeHint === null) ? new ArgumentTypeNode() : new ArgumentTypeNode($typeHint);
-    }
-
-    /**
-     * @deprecated use getArgumentTypeNode instead
-     * @return bool
-     */
-    public function isNullable()
-    {
-        return $this->typeNode->canUseNullShorthand();
-    }
-
-    /**
-     * @deprecated use getArgumentTypeNode instead
-     * @param bool $isNullable
-     */
-    public function setAsNullable($isNullable = true)
-    {
-        $nonNullTypes = $this->typeNode->getNonNullTypes();
-        $this->typeNode = $isNullable ? new ArgumentTypeNode('null', ...$nonNullTypes) : new ArgumentTypeNode(...$nonNullTypes);
-    }
+	private $name;
+	private $default;
+	private $optional    = false;
+	private $byReference = false;
+	private $isVariadic  = false;
+
+	/** @var ArgumentTypeNode */
+	private $typeNode;
+
+	/**
+	 * @param string $name
+	 */
+	public function __construct($name)
+	{
+		$this->name = $name;
+		$this->typeNode = new ArgumentTypeNode();
+	}
+
+	public function getName()
+	{
+		return $this->name;
+	}
+
+	public function setTypeNode(ArgumentTypeNode $typeNode)
+	{
+		$this->typeNode = $typeNode;
+	}
+
+	public function getTypeNode() : ArgumentTypeNode
+	{
+		return $this->typeNode;
+	}
+
+	public function hasDefault()
+	{
+		return $this->isOptional() && !$this->isVariadic();
+	}
+
+	public function getDefault()
+	{
+		return $this->default;
+	}
+
+	public function setDefault($default = null)
+	{
+		$this->optional = true;
+		$this->default  = $default;
+	}
+
+	public function isOptional()
+	{
+		return $this->optional;
+	}
+
+	public function setAsPassedByReference($byReference = true)
+	{
+		$this->byReference = $byReference;
+	}
+
+	public function isPassedByReference()
+	{
+		return $this->byReference;
+	}
+
+	public function setAsVariadic($isVariadic = true)
+	{
+		$this->isVariadic = $isVariadic;
+	}
+
+	public function isVariadic()
+	{
+		return $this->isVariadic;
+	}
+
+	/**
+	 * @deprecated use getArgumentTypeNode instead
+	 * @return string|null
+	 */
+	public function getTypeHint()
+	{
+		$type = $this->typeNode->getNonNullTypes() ? $this->typeNode->getNonNullTypes()[0] : null;
+
+		return $type ? ltrim($type, '\\') : null;
+	}
+
+	/**
+	 * @deprecated use setArgumentTypeNode instead
+	 * @param string|null $typeHint
+	 */
+	public function setTypeHint($typeHint = null)
+	{
+		$this->typeNode = ($typeHint === null) ? new ArgumentTypeNode() : new ArgumentTypeNode($typeHint);
+	}
+
+	/**
+	 * @deprecated use getArgumentTypeNode instead
+	 * @return bool
+	 */
+	public function isNullable()
+	{
+		return $this->typeNode->canUseNullShorthand();
+	}
+
+	/**
+	 * @deprecated use getArgumentTypeNode instead
+	 * @param bool $isNullable
+	 */
+	public function setAsNullable($isNullable = true)
+	{
+		$nonNullTypes = $this->typeNode->getNonNullTypes();
+		$this->typeNode = $isNullable ? new ArgumentTypeNode('null', ...$nonNullTypes) : new ArgumentTypeNode(...$nonNullTypes);
+	}
 }

Spacing +1 added lines, -1 removed lines

@@ -53,7 +53,7 @@
 
     public function hasDefault()
     {
-        return $this->isOptional() && !$this->isVariadic();
+        return $this->isOptional() && ! $this->isVariadic();
     }
 
     public function getDefault()

vendor/phpspec/prophecy/src/Prophecy/Doubler/Generator/TypeHintReference.php

Indentation +26 added lines, -26 removed lines

@@ -10,34 +10,34 @@
  */
 final class TypeHintReference
 {
-    public function isBuiltInParamTypeHint($type)
-    {
-        switch ($type) {
-            case 'self':
-            case 'array':
-            case 'callable':
-            case 'bool':
-            case 'float':
-            case 'int':
-            case 'string':
-            case 'iterable':
-            case 'object':
-                return true;
+	public function isBuiltInParamTypeHint($type)
+	{
+		switch ($type) {
+			case 'self':
+			case 'array':
+			case 'callable':
+			case 'bool':
+			case 'float':
+			case 'int':
+			case 'string':
+			case 'iterable':
+			case 'object':
+				return true;
 
-            case 'mixed':
-                return PHP_VERSION_ID >= 80000;
+			case 'mixed':
+				return PHP_VERSION_ID >= 80000;
 
-            default:
-                return false;
-        }
-    }
+			default:
+				return false;
+		}
+	}
 
-    public function isBuiltInReturnTypeHint($type)
-    {
-        if ($type === 'void') {
-            return true;
-        }
+	public function isBuiltInReturnTypeHint($type)
+	{
+		if ($type === 'void') {
+			return true;
+		}
 
-        return $this->isBuiltInParamTypeHint($type);
-    }
+		return $this->isBuiltInParamTypeHint($type);
+	}
 }

vendor/phpspec/prophecy/src/Prophecy/Doubler/Generator/ClassCodeGenerator.php

Indentation +85 added lines, -85 removed lines

@@ -22,89 +22,89 @@
  */
 class ClassCodeGenerator
 {
-    public function __construct(TypeHintReference $typeHintReference = null)
-    {
-    }
-
-    /**
-     * Generates PHP code for class node.
-     *
-     * @param string         $classname
-     * @param Node\ClassNode $class
-     *
-     * @return string
-     */
-    public function generate($classname, Node\ClassNode $class)
-    {
-        $parts     = explode('\\', $classname);
-        $classname = array_pop($parts);
-        $namespace = implode('\\', $parts);
-
-        $code = sprintf("class %s extends \%s implements %s {\n",
-            $classname, $class->getParentClass(), implode(', ',
-                array_map(function ($interface) {return '\\'.$interface;}, $class->getInterfaces())
-            )
-        );
-
-        foreach ($class->getProperties() as $name => $visibility) {
-            $code .= sprintf("%s \$%s;\n", $visibility, $name);
-        }
-        $code .= "\n";
-
-        foreach ($class->getMethods() as $method) {
-            $code .= $this->generateMethod($method)."\n";
-        }
-        $code .= "\n}";
-
-        return sprintf("namespace %s {\n%s\n}", $namespace, $code);
-    }
-
-    private function generateMethod(Node\MethodNode $method)
-    {
-        $php = sprintf("%s %s function %s%s(%s)%s {\n",
-            $method->getVisibility(),
-            $method->isStatic() ? 'static' : '',
-            $method->returnsReference() ? '&':'',
-            $method->getName(),
-            implode(', ', $this->generateArguments($method->getArguments())),
-            ($ret = $this->generateTypes($method->getReturnTypeNode())) ? ': '.$ret : ''
-        );
-        $php .= $method->getCode()."\n";
-
-        return $php.'}';
-    }
-
-    private function generateTypes(TypeNodeAbstract $typeNode): string
-    {
-        if (!$typeNode->getTypes()) {
-            return '';
-        }
-
-        // When we require PHP 8 we can stop generating ?foo nullables and remove this first block
-        if ($typeNode->canUseNullShorthand()) {
-            return sprintf( '?%s', $typeNode->getNonNullTypes()[0]);
-        } else {
-            return join('|', $typeNode->getTypes());
-        }
-    }
-
-    private function generateArguments(array $arguments)
-    {
-        return array_map(function (Node\ArgumentNode $argument){
-
-            $php = $this->generateTypes($argument->getTypeNode());
-
-            $php .= ' '.($argument->isPassedByReference() ? '&' : '');
-
-            $php .= $argument->isVariadic() ? '...' : '';
-
-            $php .= '$'.$argument->getName();
-
-            if ($argument->isOptional() && !$argument->isVariadic()) {
-                $php .= ' = '.var_export($argument->getDefault(), true);
-            }
-
-            return $php;
-        }, $arguments);
-    }
+	public function __construct(TypeHintReference $typeHintReference = null)
+	{
+	}
+
+	/**
+	 * Generates PHP code for class node.
+	 *
+	 * @param string         $classname
+	 * @param Node\ClassNode $class
+	 *
+	 * @return string
+	 */
+	public function generate($classname, Node\ClassNode $class)
+	{
+		$parts     = explode('\\', $classname);
+		$classname = array_pop($parts);
+		$namespace = implode('\\', $parts);
+
+		$code = sprintf("class %s extends \%s implements %s {\n",
+			$classname, $class->getParentClass(), implode(', ',
+				array_map(function ($interface) {return '\\'.$interface;}, $class->getInterfaces())
+			)
+		);
+
+		foreach ($class->getProperties() as $name => $visibility) {
+			$code .= sprintf("%s \$%s;\n", $visibility, $name);
+		}
+		$code .= "\n";
+
+		foreach ($class->getMethods() as $method) {
+			$code .= $this->generateMethod($method)."\n";
+		}
+		$code .= "\n}";
+
+		return sprintf("namespace %s {\n%s\n}", $namespace, $code);
+	}
+
+	private function generateMethod(Node\MethodNode $method)
+	{
+		$php = sprintf("%s %s function %s%s(%s)%s {\n",
+			$method->getVisibility(),
+			$method->isStatic() ? 'static' : '',
+			$method->returnsReference() ? '&':'',
+			$method->getName(),
+			implode(', ', $this->generateArguments($method->getArguments())),
+			($ret = $this->generateTypes($method->getReturnTypeNode())) ? ': '.$ret : ''
+		);
+		$php .= $method->getCode()."\n";
+
+		return $php.'}';
+	}
+
+	private function generateTypes(TypeNodeAbstract $typeNode): string
+	{
+		if (!$typeNode->getTypes()) {
+			return '';
+		}
+
+		// When we require PHP 8 we can stop generating ?foo nullables and remove this first block
+		if ($typeNode->canUseNullShorthand()) {
+			return sprintf( '?%s', $typeNode->getNonNullTypes()[0]);
+		} else {
+			return join('|', $typeNode->getTypes());
+		}
+	}
+
+	private function generateArguments(array $arguments)
+	{
+		return array_map(function (Node\ArgumentNode $argument){
+
+			$php = $this->generateTypes($argument->getTypeNode());
+
+			$php .= ' '.($argument->isPassedByReference() ? '&' : '');
+
+			$php .= $argument->isVariadic() ? '...' : '';
+
+			$php .= '$'.$argument->getName();
+
+			if ($argument->isOptional() && !$argument->isVariadic()) {
+				$php .= ' = '.var_export($argument->getDefault(), true);
+			}
+
+			return $php;
+		}, $arguments);
+	}
 }

Spacing +6 added lines, -6 removed lines

@@ -42,7 +42,7 @@ 
 
         $code = sprintf("class %s extends \%s implements %s {\n",
             $classname, $class->getParentClass(), implode(', ',
-                array_map(function ($interface) {return '\\'.$interface;}, $class->getInterfaces())
+                array_map(function($interface) {return '\\'.$interface; }, $class->getInterfaces())
             )
         );
 
@@ -64,7 +64,7 @@ 
         $php = sprintf("%s %s function %s%s(%s)%s {\n",
             $method->getVisibility(),
             $method->isStatic() ? 'static' : '',
-            $method->returnsReference() ? '&':'',
+            $method->returnsReference() ? '&' : '',
             $method->getName(),
             implode(', ', $this->generateArguments($method->getArguments())),
             ($ret = $this->generateTypes($method->getReturnTypeNode())) ? ': '.$ret : ''
@@ -76,13 +76,13 @@ 
 
     private function generateTypes(TypeNodeAbstract $typeNode): string
     {
-        if (!$typeNode->getTypes()) {
+        if ( ! $typeNode->getTypes()) {
             return '';
         }
 
         // When we require PHP 8 we can stop generating ?foo nullables and remove this first block
         if ($typeNode->canUseNullShorthand()) {
-            return sprintf( '?%s', $typeNode->getNonNullTypes()[0]);
+            return sprintf('?%s', $typeNode->getNonNullTypes()[0]);
         } else {
             return join('|', $typeNode->getTypes());
         }
@@ -90,7 +90,7 @@ 
 
     private function generateArguments(array $arguments)
     {
-        return array_map(function (Node\ArgumentNode $argument){
+        return array_map(function(Node\ArgumentNode $argument) {
 
             $php = $this->generateTypes($argument->getTypeNode());
 
@@ -100,7 +100,7 @@ 
 
             $php .= '$'.$argument->getName();
 
-            if ($argument->isOptional() && !$argument->isVariadic()) {
+            if ($argument->isOptional() && ! $argument->isVariadic()) {
                 $php .= ' = '.var_export($argument->getDefault(), true);
             }
 

vendor/phpspec/prophecy/src/Prophecy/Doubler/Generator/ClassMirror.php

Indentation +220 added lines, -220 removed lines

@@ -31,224 +31,224 @@
  */
 class ClassMirror
 {
-    private static $reflectableMethods = array(
-        '__construct',
-        '__destruct',
-        '__sleep',
-        '__wakeup',
-        '__toString',
-        '__call',
-        '__invoke'
-    );
-
-    /**
-     * Reflects provided arguments into class node.
-     *
-     * @param ReflectionClass|null $class
-     * @param ReflectionClass[] $interfaces
-     *
-     * @return Node\ClassNode
-     *
-     */
-    public function reflect(?ReflectionClass $class, array $interfaces)
-    {
-        $node = new Node\ClassNode;
-
-        if (null !== $class) {
-            if (true === $class->isInterface()) {
-                throw new InvalidArgumentException(sprintf(
-                    "Could not reflect %s as a class, because it\n".
-                    "is interface - use the second argument instead.",
-                    $class->getName()
-                ));
-            }
-
-            $this->reflectClassToNode($class, $node);
-        }
-
-        foreach ($interfaces as $interface) {
-            if (!$interface instanceof ReflectionClass) {
-                throw new InvalidArgumentException(sprintf(
-                    "[ReflectionClass \$interface1 [, ReflectionClass \$interface2]] array expected as\n".
-                    "a second argument to `ClassMirror::reflect(...)`, but got %s.",
-                    is_object($interface) ? get_class($interface).' class' : gettype($interface)
-                ));
-            }
-            if (false === $interface->isInterface()) {
-                throw new InvalidArgumentException(sprintf(
-                    "Could not reflect %s as an interface, because it\n".
-                    "is class - use the first argument instead.",
-                    $interface->getName()
-                ));
-            }
-
-            $this->reflectInterfaceToNode($interface, $node);
-        }
-
-        $node->addInterface('Prophecy\Doubler\Generator\ReflectionInterface');
-
-        return $node;
-    }
-
-    private function reflectClassToNode(ReflectionClass $class, Node\ClassNode $node)
-    {
-        if (true === $class->isFinal()) {
-            throw new ClassMirrorException(sprintf(
-                'Could not reflect class %s as it is marked final.', $class->getName()
-            ), $class);
-        }
-
-        $node->setParentClass($class->getName());
-
-        foreach ($class->getMethods(ReflectionMethod::IS_ABSTRACT) as $method) {
-            if (false === $method->isProtected()) {
-                continue;
-            }
-
-            $this->reflectMethodToNode($method, $node);
-        }
-
-        foreach ($class->getMethods(ReflectionMethod::IS_PUBLIC) as $method) {
-            if (0 === strpos($method->getName(), '_')
-                && !in_array($method->getName(), self::$reflectableMethods)) {
-                continue;
-            }
-
-            if (true === $method->isFinal()) {
-                $node->addUnextendableMethod($method->getName());
-                continue;
-            }
-
-            $this->reflectMethodToNode($method, $node);
-        }
-    }
-
-    private function reflectInterfaceToNode(ReflectionClass $interface, Node\ClassNode $node)
-    {
-        $node->addInterface($interface->getName());
-
-        foreach ($interface->getMethods() as $method) {
-            $this->reflectMethodToNode($method, $node);
-        }
-    }
-
-    private function reflectMethodToNode(ReflectionMethod $method, Node\ClassNode $classNode)
-    {
-        $node = new Node\MethodNode($method->getName());
-
-        if (true === $method->isProtected()) {
-            $node->setVisibility('protected');
-        }
-
-        if (true === $method->isStatic()) {
-            $node->setStatic();
-        }
-
-        if (true === $method->returnsReference()) {
-            $node->setReturnsReference();
-        }
-
-        if ($method->hasReturnType()) {
-            $returnTypes = $this->getTypeHints($method->getReturnType(), $method->getDeclaringClass(), $method->getReturnType()->allowsNull());
-            $node->setReturnTypeNode(new ReturnTypeNode(...$returnTypes));
-        }
-        elseif (method_exists($method, 'hasTentativeReturnType') && $method->hasTentativeReturnType()) {
-            $returnTypes = $this->getTypeHints($method->getTentativeReturnType(), $method->getDeclaringClass(), $method->getTentativeReturnType()->allowsNull());
-            $node->setReturnTypeNode(new ReturnTypeNode(...$returnTypes));
-        }
-
-        if (is_array($params = $method->getParameters()) && count($params)) {
-            foreach ($params as $param) {
-                $this->reflectArgumentToNode($param, $node);
-            }
-        }
-
-        $classNode->addMethod($node);
-    }
-
-    private function reflectArgumentToNode(ReflectionParameter $parameter, Node\MethodNode $methodNode)
-    {
-        $name = $parameter->getName() == '...' ? '__dot_dot_dot__' : $parameter->getName();
-        $node = new Node\ArgumentNode($name);
-
-        $typeHints = $this->getTypeHints($parameter->getType(), $parameter->getDeclaringClass(), $parameter->allowsNull());
-
-        $node->setTypeNode(new ArgumentTypeNode(...$typeHints));
-
-        if ($parameter->isVariadic()) {
-            $node->setAsVariadic();
-        }
-
-        if ($this->hasDefaultValue($parameter)) {
-            $node->setDefault($this->getDefaultValue($parameter));
-        }
-
-        if ($parameter->isPassedByReference()) {
-            $node->setAsPassedByReference();
-        }
-
-
-        $methodNode->addArgument($node);
-    }
-
-    private function hasDefaultValue(ReflectionParameter $parameter)
-    {
-        if ($parameter->isVariadic()) {
-            return false;
-        }
-
-        if ($parameter->isDefaultValueAvailable()) {
-            return true;
-        }
-
-        return $parameter->isOptional() || ($parameter->allowsNull() && $parameter->getType() && \PHP_VERSION_ID < 80100);
-    }
-
-    private function getDefaultValue(ReflectionParameter $parameter)
-    {
-        if (!$parameter->isDefaultValueAvailable()) {
-            return null;
-        }
-
-        return $parameter->getDefaultValue();
-    }
-
-    private function getTypeHints(?ReflectionType $type, ?ReflectionClass $class, bool $allowsNull) : array
-    {
-        $types = [];
-
-        if ($type instanceof ReflectionNamedType) {
-            $types = [$type->getName()];
-
-        }
-        elseif ($type instanceof ReflectionUnionType) {
-            $types = $type->getTypes();
-        }
-        elseif ($type instanceof ReflectionIntersectionType) {
-            throw new ClassMirrorException('Doubling intersection types is not supported', $class);
-        }
-        elseif(is_object($type)) {
-            throw new ClassMirrorException('Unknown reflection type ' . get_class($type), $class);
-        }
-
-        $types = array_map(
-            function(string $type) use ($class) {
-                if ($type === 'self') {
-                    return $class->getName();
-                }
-                if ($type === 'parent') {
-                    return $class->getParentClass()->getName();
-                }
-
-                return $type;
-            },
-            $types
-        );
-
-        if ($types && $types != ['mixed'] && $allowsNull) {
-            $types[] = 'null';
-        }
-
-        return $types;
-    }
+	private static $reflectableMethods = array(
+		'__construct',
+		'__destruct',
+		'__sleep',
+		'__wakeup',
+		'__toString',
+		'__call',
+		'__invoke'
+	);
+
+	/**
+	 * Reflects provided arguments into class node.
+	 *
+	 * @param ReflectionClass|null $class
+	 * @param ReflectionClass[] $interfaces
+	 *
+	 * @return Node\ClassNode
+	 *
+	 */
+	public function reflect(?ReflectionClass $class, array $interfaces)
+	{
+		$node = new Node\ClassNode;
+
+		if (null !== $class) {
+			if (true === $class->isInterface()) {
+				throw new InvalidArgumentException(sprintf(
+					"Could not reflect %s as a class, because it\n".
+					"is interface - use the second argument instead.",
+					$class->getName()
+				));
+			}
+
+			$this->reflectClassToNode($class, $node);
+		}
+
+		foreach ($interfaces as $interface) {
+			if (!$interface instanceof ReflectionClass) {
+				throw new InvalidArgumentException(sprintf(
+					"[ReflectionClass \$interface1 [, ReflectionClass \$interface2]] array expected as\n".
+					"a second argument to `ClassMirror::reflect(...)`, but got %s.",
+					is_object($interface) ? get_class($interface).' class' : gettype($interface)
+				));
+			}
+			if (false === $interface->isInterface()) {
+				throw new InvalidArgumentException(sprintf(
+					"Could not reflect %s as an interface, because it\n".
+					"is class - use the first argument instead.",
+					$interface->getName()
+				));
+			}
+
+			$this->reflectInterfaceToNode($interface, $node);
+		}
+
+		$node->addInterface('Prophecy\Doubler\Generator\ReflectionInterface');
+
+		return $node;
+	}
+
+	private function reflectClassToNode(ReflectionClass $class, Node\ClassNode $node)
+	{
+		if (true === $class->isFinal()) {
+			throw new ClassMirrorException(sprintf(
+				'Could not reflect class %s as it is marked final.', $class->getName()
+			), $class);
+		}
+
+		$node->setParentClass($class->getName());
+
+		foreach ($class->getMethods(ReflectionMethod::IS_ABSTRACT) as $method) {
+			if (false === $method->isProtected()) {
+				continue;
+			}
+
+			$this->reflectMethodToNode($method, $node);
+		}
+
+		foreach ($class->getMethods(ReflectionMethod::IS_PUBLIC) as $method) {
+			if (0 === strpos($method->getName(), '_')
+				&& !in_array($method->getName(), self::$reflectableMethods)) {
+				continue;
+			}
+
+			if (true === $method->isFinal()) {
+				$node->addUnextendableMethod($method->getName());
+				continue;
+			}
+
+			$this->reflectMethodToNode($method, $node);
+		}
+	}
+
+	private function reflectInterfaceToNode(ReflectionClass $interface, Node\ClassNode $node)
+	{
+		$node->addInterface($interface->getName());
+
+		foreach ($interface->getMethods() as $method) {
+			$this->reflectMethodToNode($method, $node);
+		}
+	}
+
+	private function reflectMethodToNode(ReflectionMethod $method, Node\ClassNode $classNode)
+	{
+		$node = new Node\MethodNode($method->getName());
+
+		if (true === $method->isProtected()) {
+			$node->setVisibility('protected');
+		}
+
+		if (true === $method->isStatic()) {
+			$node->setStatic();
+		}
+
+		if (true === $method->returnsReference()) {
+			$node->setReturnsReference();
+		}
+
+		if ($method->hasReturnType()) {
+			$returnTypes = $this->getTypeHints($method->getReturnType(), $method->getDeclaringClass(), $method->getReturnType()->allowsNull());
+			$node->setReturnTypeNode(new ReturnTypeNode(...$returnTypes));
+		}
+		elseif (method_exists($method, 'hasTentativeReturnType') && $method->hasTentativeReturnType()) {
+			$returnTypes = $this->getTypeHints($method->getTentativeReturnType(), $method->getDeclaringClass(), $method->getTentativeReturnType()->allowsNull());
+			$node->setReturnTypeNode(new ReturnTypeNode(...$returnTypes));
+		}
+
+		if (is_array($params = $method->getParameters()) && count($params)) {
+			foreach ($params as $param) {
+				$this->reflectArgumentToNode($param, $node);
+			}
+		}
+
+		$classNode->addMethod($node);
+	}
+
+	private function reflectArgumentToNode(ReflectionParameter $parameter, Node\MethodNode $methodNode)
+	{
+		$name = $parameter->getName() == '...' ? '__dot_dot_dot__' : $parameter->getName();
+		$node = new Node\ArgumentNode($name);
+
+		$typeHints = $this->getTypeHints($parameter->getType(), $parameter->getDeclaringClass(), $parameter->allowsNull());
+
+		$node->setTypeNode(new ArgumentTypeNode(...$typeHints));
+
+		if ($parameter->isVariadic()) {
+			$node->setAsVariadic();
+		}
+
+		if ($this->hasDefaultValue($parameter)) {
+			$node->setDefault($this->getDefaultValue($parameter));
+		}
+
+		if ($parameter->isPassedByReference()) {
+			$node->setAsPassedByReference();
+		}
+
+
+		$methodNode->addArgument($node);
+	}
+
+	private function hasDefaultValue(ReflectionParameter $parameter)
+	{
+		if ($parameter->isVariadic()) {
+			return false;
+		}
+
+		if ($parameter->isDefaultValueAvailable()) {
+			return true;
+		}
+
+		return $parameter->isOptional() || ($parameter->allowsNull() && $parameter->getType() && \PHP_VERSION_ID < 80100);
+	}
+
+	private function getDefaultValue(ReflectionParameter $parameter)
+	{
+		if (!$parameter->isDefaultValueAvailable()) {
+			return null;
+		}
+
+		return $parameter->getDefaultValue();
+	}
+
+	private function getTypeHints(?ReflectionType $type, ?ReflectionClass $class, bool $allowsNull) : array
+	{
+		$types = [];
+
+		if ($type instanceof ReflectionNamedType) {
+			$types = [$type->getName()];
+
+		}
+		elseif ($type instanceof ReflectionUnionType) {
+			$types = $type->getTypes();
+		}
+		elseif ($type instanceof ReflectionIntersectionType) {
+			throw new ClassMirrorException('Doubling intersection types is not supported', $class);
+		}
+		elseif(is_object($type)) {
+			throw new ClassMirrorException('Unknown reflection type ' . get_class($type), $class);
+		}
+
+		$types = array_map(
+			function(string $type) use ($class) {
+				if ($type === 'self') {
+					return $class->getName();
+				}
+				if ($type === 'parent') {
+					return $class->getParentClass()->getName();
+				}
+
+				return $type;
+			},
+			$types
+		);
+
+		if ($types && $types != ['mixed'] && $allowsNull) {
+			$types[] = 'null';
+		}
+
+		return $types;
+	}
 }

Spacing +5 added lines, -5 removed lines

@@ -67,7 +67,7 @@ 
         }
 
         foreach ($interfaces as $interface) {
-            if (!$interface instanceof ReflectionClass) {
+            if ( ! $interface instanceof ReflectionClass) {
                 throw new InvalidArgumentException(sprintf(
                     "[ReflectionClass \$interface1 [, ReflectionClass \$interface2]] array expected as\n".
                     "a second argument to `ClassMirror::reflect(...)`, but got %s.",
@@ -110,7 +110,7 @@ 
 
         foreach ($class->getMethods(ReflectionMethod::IS_PUBLIC) as $method) {
             if (0 === strpos($method->getName(), '_')
-                && !in_array($method->getName(), self::$reflectableMethods)) {
+                && ! in_array($method->getName(), self::$reflectableMethods)) {
                 continue;
             }
 
@@ -206,7 +206,7 @@ 
 
     private function getDefaultValue(ReflectionParameter $parameter)
     {
-        if (!$parameter->isDefaultValueAvailable()) {
+        if ( ! $parameter->isDefaultValueAvailable()) {
             return null;
         }
 
@@ -227,8 +227,8 @@ 
         elseif ($type instanceof ReflectionIntersectionType) {
             throw new ClassMirrorException('Doubling intersection types is not supported', $class);
         }
-        elseif(is_object($type)) {
-            throw new ClassMirrorException('Unknown reflection type ' . get_class($type), $class);
+        elseif (is_object($type)) {
+            throw new ClassMirrorException('Unknown reflection type '.get_class($type), $class);
         }
 
         $types = array_map(

Braces +4 added lines, -8 removed lines

@@ -151,8 +151,7 @@ 
         if ($method->hasReturnType()) {
             $returnTypes = $this->getTypeHints($method->getReturnType(), $method->getDeclaringClass(), $method->getReturnType()->allowsNull());
             $node->setReturnTypeNode(new ReturnTypeNode(...$returnTypes));
-        }
-        elseif (method_exists($method, 'hasTentativeReturnType') && $method->hasTentativeReturnType()) {
+        } elseif (method_exists($method, 'hasTentativeReturnType') && $method->hasTentativeReturnType()) {
             $returnTypes = $this->getTypeHints($method->getTentativeReturnType(), $method->getDeclaringClass(), $method->getTentativeReturnType()->allowsNull());
             $node->setReturnTypeNode(new ReturnTypeNode(...$returnTypes));
         }
@@ -220,14 +219,11 @@ 
         if ($type instanceof ReflectionNamedType) {
             $types = [$type->getName()];
 
-        }
-        elseif ($type instanceof ReflectionUnionType) {
+        } elseif ($type instanceof ReflectionUnionType) {
             $types = $type->getTypes();
-        }
-        elseif ($type instanceof ReflectionIntersectionType) {
+        } elseif ($type instanceof ReflectionIntersectionType) {
             throw new ClassMirrorException('Doubling intersection types is not supported', $class);
-        }
-        elseif(is_object($type)) {
+        } elseif(is_object($type)) {
             throw new ClassMirrorException('Unknown reflection type ' . get_class($type), $class);
         }