* add phpunit as a dev dependency

 * add some basic tests for UrlHelper::rewrite_relative()
 * fix UrlHelper::rewrite_relative() to work better on non-absolute
   relative URL paths

11 files changed, 1160 insertions, 0 deletions

diff --git a/vendor/phpspec/prophecy/src/Prophecy/Doubler/Generator/ClassCodeGenerator.php b/vendor/phpspec/prophecy/src/Prophecy/Doubler/Generator/ClassCodeGenerator.php
new file mode 100644
index 000000000..52e5e0455
--- /dev/null
+++ b/vendor/phpspec/prophecy/src/Prophecy/Doubler/Generator/ClassCodeGenerator.php
@@ -0,0 +1,110 @@
+<?php
+
+/*
+ * This file is part of the Prophecy.
+ * (c) Konstantin Kudryashov <[email protected]>
+ *     Marcello Duarte <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Prophecy\Doubler\Generator;
+
+use Prophecy\Doubler\Generator\Node\ReturnTypeNode;
+use Prophecy\Doubler\Generator\Node\TypeNodeAbstract;
+
+/**
+ * Class code creator.
+ * Generates PHP code for specific class node tree.
+ *
+ * @author Konstantin Kudryashov <[email protected]>
+ */
+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);
+    }
+}
diff --git a/vendor/phpspec/prophecy/src/Prophecy/Doubler/Generator/ClassCreator.php b/vendor/phpspec/prophecy/src/Prophecy/Doubler/Generator/ClassCreator.php
new file mode 100644
index 000000000..882a4a4b7
--- /dev/null
+++ b/vendor/phpspec/prophecy/src/Prophecy/Doubler/Generator/ClassCreator.php
@@ -0,0 +1,67 @@
+<?php
+
+/*
+ * This file is part of the Prophecy.
+ * (c) Konstantin Kudryashov <[email protected]>
+ *     Marcello Duarte <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Prophecy\Doubler\Generator;
+
+use Prophecy\Exception\Doubler\ClassCreatorException;
+
+/**
+ * Class creator.
+ * Creates specific class in current environment.
+ *
+ * @author Konstantin Kudryashov <[email protected]>
+ */
+class ClassCreator
+{
+    private $generator;
+
+    /**
+     * Initializes creator.
+     *
+     * @param ClassCodeGenerator $generator
+     */
+    public function __construct(ClassCodeGenerator $generator = null)
+    {
+        $this->generator = $generator ?: new ClassCodeGenerator;
+    }
+
+    /**
+     * Creates class.
+     *
+     * @param string         $classname
+     * @param Node\ClassNode $class
+     *
+     * @return mixed
+     *
+     * @throws \Prophecy\Exception\Doubler\ClassCreatorException
+     */
+    public function create($classname, Node\ClassNode $class)
+    {
+        $code = $this->generator->generate($classname, $class);
+        $return = eval($code);
+
+        if (!class_exists($classname, false)) {
+            if (count($class->getInterfaces())) {
+                throw new ClassCreatorException(sprintf(
+                    'Could not double `%s` and implement interfaces: [%s].',
+                    $class->getParentClass(), implode(', ', $class->getInterfaces())
+                ), $class);
+            }
+
+            throw new ClassCreatorException(
+                sprintf('Could not double `%s`.', $class->getParentClass()),
+                $class
+            );
+        }
+
+        return $return;
+    }
+}
diff --git a/vendor/phpspec/prophecy/src/Prophecy/Doubler/Generator/ClassMirror.php b/vendor/phpspec/prophecy/src/Prophecy/Doubler/Generator/ClassMirror.php
new file mode 100644
index 000000000..5d9cd2d20
--- /dev/null
+++ b/vendor/phpspec/prophecy/src/Prophecy/Doubler/Generator/ClassMirror.php
@@ -0,0 +1,254 @@
+<?php
+
+/*
+ * This file is part of the Prophecy.
+ * (c) Konstantin Kudryashov <[email protected]>
+ *     Marcello Duarte <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Prophecy\Doubler\Generator;
+
+use Prophecy\Doubler\Generator\Node\ArgumentTypeNode;
+use Prophecy\Doubler\Generator\Node\ReturnTypeNode;
+use Prophecy\Exception\InvalidArgumentException;
+use Prophecy\Exception\Doubler\ClassMirrorException;
+use ReflectionClass;
+use ReflectionIntersectionType;
+use ReflectionMethod;
+use ReflectionNamedType;
+use ReflectionParameter;
+use ReflectionType;
+use ReflectionUnionType;
+
+/**
+ * Class mirror.
+ * Core doubler class. Mirrors specific class and/or interfaces into class node tree.
+ *
+ * @author Konstantin Kudryashov <[email protected]>
+ */
+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;
+    }
+}
diff --git a/vendor/phpspec/prophecy/src/Prophecy/Doubler/Generator/Node/ArgumentNode.php b/vendor/phpspec/prophecy/src/Prophecy/Doubler/Generator/Node/ArgumentNode.php
new file mode 100644
index 000000000..da7fed4e1
--- /dev/null
+++ b/vendor/phpspec/prophecy/src/Prophecy/Doubler/Generator/Node/ArgumentNode.php
@@ -0,0 +1,133 @@
+<?php
+
+/*
+ * This file is part of the Prophecy.
+ * (c) Konstantin Kudryashov <[email protected]>
+ *     Marcello Duarte <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Prophecy\Doubler\Generator\Node;
+
+/**
+ * Argument node.
+ *
+ * @author Konstantin Kudryashov <[email protected]>
+ */
+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);
+    }
+}
diff --git a/vendor/phpspec/prophecy/src/Prophecy/Doubler/Generator/Node/ArgumentTypeNode.php b/vendor/phpspec/prophecy/src/Prophecy/Doubler/Generator/Node/ArgumentTypeNode.php
new file mode 100644
index 000000000..0a18b91e1
--- /dev/null
+++ b/vendor/phpspec/prophecy/src/Prophecy/Doubler/Generator/Node/ArgumentTypeNode.php
@@ -0,0 +1,10 @@
+<?php
+
+namespace Prophecy\Doubler\Generator\Node;
+
+use Prophecy\Exception\Doubler\DoubleException;
+
+class ArgumentTypeNode extends TypeNodeAbstract
+{
+
+}
diff --git a/vendor/phpspec/prophecy/src/Prophecy/Doubler/Generator/Node/ClassNode.php b/vendor/phpspec/prophecy/src/Prophecy/Doubler/Generator/Node/ClassNode.php
new file mode 100644
index 000000000..f7bd2857a
--- /dev/null
+++ b/vendor/phpspec/prophecy/src/Prophecy/Doubler/Generator/Node/ClassNode.php
@@ -0,0 +1,169 @@
+<?php
+
+/*
+ * This file is part of the Prophecy.
+ * (c) Konstantin Kudryashov <[email protected]>
+ *     Marcello Duarte <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Prophecy\Doubler\Generator\Node;
+
+use Prophecy\Exception\Doubler\MethodNotExtendableException;
+use Prophecy\Exception\InvalidArgumentException;
+
+/**
+ * Class node.
+ *
+ * @author Konstantin Kudryashov <[email protected]>
+ */
+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);
+    }
+}
diff --git a/vendor/phpspec/prophecy/src/Prophecy/Doubler/Generator/Node/MethodNode.php b/vendor/phpspec/prophecy/src/Prophecy/Doubler/Generator/Node/MethodNode.php
new file mode 100644
index 000000000..ece652f9f
--- /dev/null
+++ b/vendor/phpspec/prophecy/src/Prophecy/Doubler/Generator/Node/MethodNode.php
@@ -0,0 +1,210 @@
+<?php
+
+/*
+ * This file is part of the Prophecy.
+ * (c) Konstantin Kudryashov <[email protected]>
+ *     Marcello Duarte <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Prophecy\Doubler\Generator\Node;
+
+use Prophecy\Doubler\Generator\TypeHintReference;
+use Prophecy\Exception\InvalidArgumentException;
+
+/**
+ * Method node.
+ *
+ * @author Konstantin Kudryashov <[email protected]>
+ */
+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;
+    }
+}
diff --git a/vendor/phpspec/prophecy/src/Prophecy/Doubler/Generator/Node/ReturnTypeNode.php b/vendor/phpspec/prophecy/src/Prophecy/Doubler/Generator/Node/ReturnTypeNode.php
new file mode 100644
index 000000000..5b5824988
--- /dev/null
+++ b/vendor/phpspec/prophecy/src/Prophecy/Doubler/Generator/Node/ReturnTypeNode.php
@@ -0,0 +1,45 @@
+<?php
+
+namespace Prophecy\Doubler\Generator\Node;
+
+use Prophecy\Exception\Doubler\DoubleException;
+
+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 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();
+    }
+
+    /**
+     * @deprecated use hasReturnStatement
+     */
+    public function isVoid()
+    {
+        return $this->types == ['void' => 'void'];
+    }
+
+    public function hasReturnStatement(): bool
+    {
+        return $this->types !== ['void' => 'void']
+            && $this->types !== ['never' => 'never'];
+    }
+}
diff --git a/vendor/phpspec/prophecy/src/Prophecy/Doubler/Generator/Node/TypeNodeAbstract.php b/vendor/phpspec/prophecy/src/Prophecy/Doubler/Generator/Node/TypeNodeAbstract.php
new file mode 100644
index 000000000..97fc54978
--- /dev/null
+++ b/vendor/phpspec/prophecy/src/Prophecy/Doubler/Generator/Node/TypeNodeAbstract.php
@@ -0,0 +1,97 @@
+<?php
+
+namespace Prophecy\Doubler\Generator\Node;
+
+use Prophecy\Exception\Doubler\DoubleException;
+
+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');
+        }
+    }
+}
diff --git a/vendor/phpspec/prophecy/src/Prophecy/Doubler/Generator/ReflectionInterface.php b/vendor/phpspec/prophecy/src/Prophecy/Doubler/Generator/ReflectionInterface.php
new file mode 100644
index 000000000..d720b1515
--- /dev/null
+++ b/vendor/phpspec/prophecy/src/Prophecy/Doubler/Generator/ReflectionInterface.php
@@ -0,0 +1,22 @@
+<?php
+
+/*
+ * This file is part of the Prophecy.
+ * (c) Konstantin Kudryashov <[email protected]>
+ *     Marcello Duarte <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Prophecy\Doubler\Generator;
+
+/**
+ * Reflection interface.
+ * All reflected classes implement this interface.
+ *
+ * @author Konstantin Kudryashov <[email protected]>
+ */
+interface ReflectionInterface
+{
+}
diff --git a/vendor/phpspec/prophecy/src/Prophecy/Doubler/Generator/TypeHintReference.php b/vendor/phpspec/prophecy/src/Prophecy/Doubler/Generator/TypeHintReference.php
new file mode 100644
index 000000000..5e8aa303d
--- /dev/null
+++ b/vendor/phpspec/prophecy/src/Prophecy/Doubler/Generator/TypeHintReference.php
@@ -0,0 +1,43 @@
+<?php
+
+namespace Prophecy\Doubler\Generator;
+
+/**
+ * Tells whether a keyword refers to a class or to a built-in type for the
+ * current version of php
+ *
+ * @deprecated in favour of Node\TypeNodeAbstract
+ */
+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;
+
+            case 'mixed':
+                return PHP_VERSION_ID >= 80000;
+
+            default:
+                return false;
+        }
+    }
+
+    public function isBuiltInReturnTypeHint($type)
+    {
+        if ($type === 'void') {
+            return true;
+        }
+
+        return $this->isBuiltInParamTypeHint($type);
+    }
+}