eventespresso / event-espresso-core

vendor/sebastian/exporter/src/Exporter.php

Indentation +294 added lines, -294 removed lines

@@ -49,298 +49,298 @@
  */
 class Exporter
 {
-    /**
-     * Exports a value as a string.
-     *
-     * The output of this method is similar to the output of print_r(), but
-     * improved in various aspects:
-     *
-     *  - NULL is rendered as "null" (instead of "")
-     *  - TRUE is rendered as "true" (instead of "1")
-     *  - FALSE is rendered as "false" (instead of "")
-     *  - Strings are always quoted with single quotes
-     *  - Carriage returns and newlines are normalized to \n
-     *  - Recursion and repeated rendering is treated properly
-     *
-     * @param int $indentation The indentation level of the 2nd+ line
-     *
-     * @return string
-     */
-    public function export($value, $indentation = 0)
-    {
-        return $this->recursiveExport($value, $indentation);
-    }
-
-    /**
-     * @param array<mixed> $data
-     * @param Context      $context
-     *
-     * @return string
-     */
-    public function shortenedRecursiveExport(&$data, Context $context = null)
-    {
-        $result   = [];
-        $exporter = new self();
-
-        if (!$context) {
-            $context = new Context;
-        }
-
-        $array = $data;
-        $context->add($data);
-
-        foreach ($array as $key => $value) {
-            if (is_array($value)) {
-                if ($context->contains($data[$key]) !== false) {
-                    $result[] = '*RECURSION*';
-                } else {
-                    $result[] = sprintf(
-                        'array(%s)',
-                        $this->shortenedRecursiveExport($data[$key], $context)
-                    );
-                }
-            } else {
-                $result[] = $exporter->shortenedExport($value);
-            }
-        }
-
-        return implode(', ', $result);
-    }
-
-    /**
-     * Exports a value into a single-line string.
-     *
-     * The output of this method is similar to the output of
-     * SebastianBergmann\Exporter\Exporter::export().
-     *
-     * Newlines are replaced by the visible string '\n'.
-     * Contents of arrays and objects (if any) are replaced by '...'.
-     *
-     * @return string
-     *
-     * @see    SebastianBergmann\Exporter\Exporter::export
-     */
-    public function shortenedExport($value)
-    {
-        if (is_string($value)) {
-            $string = str_replace("\n", '', $this->export($value));
-
-            if (function_exists('mb_strlen')) {
-                if (mb_strlen($string) > 40) {
-                    $string = mb_substr($string, 0, 30) . '...' . mb_substr($string, -7);
-                }
-            } else {
-                if (strlen($string) > 40) {
-                    $string = substr($string, 0, 30) . '...' . substr($string, -7);
-                }
-            }
-
-            return $string;
-        }
-
-        if (is_object($value)) {
-            return sprintf(
-                '%s Object (%s)',
-                get_class($value),
-                count($this->toArray($value)) > 0 ? '...' : ''
-            );
-        }
-
-        if (is_array($value)) {
-            return sprintf(
-                'Array (%s)',
-                count($value) > 0 ? '...' : ''
-            );
-        }
-
-        return $this->export($value);
-    }
-
-    /**
-     * Converts an object to an array containing all of its private, protected
-     * and public properties.
-     *
-     * @return array
-     */
-    public function toArray($value)
-    {
-        if (!is_object($value)) {
-            return (array) $value;
-        }
-
-        $array = [];
-
-        foreach ((array) $value as $key => $val) {
-            // Exception traces commonly reference hundreds to thousands of
-            // objects currently loaded in memory. Including them in the result
-            // has a severe negative performance impact.
-            if ("\0Error\0trace" === $key || "\0Exception\0trace" === $key) {
-                continue;
-            }
-
-            // properties are transformed to keys in the following way:
-            // private   $property => "\0Classname\0property"
-            // protected $property => "\0*\0property"
-            // public    $property => "property"
-            if (preg_match('/^\0.+\0(.+)$/', (string) $key, $matches)) {
-                $key = $matches[1];
-            }
-
-            // See https://github.com/php/php-src/commit/5721132
-            if ($key === "\0gcdata") {
-                continue;
-            }
-
-            $array[$key] = $val;
-        }
-
-        // Some internal classes like SplObjectStorage don't work with the
-        // above (fast) mechanism nor with reflection in Zend.
-        // Format the output similarly to print_r() in this case
-        if ($value instanceof SplObjectStorage) {
-            foreach ($value as $key => $val) {
-                $array[spl_object_hash($val)] = [
-                    'obj' => $val,
-                    'inf' => $value->getInfo(),
-                ];
-            }
-        }
-
-        return $array;
-    }
-
-    /**
-     * Recursive implementation of export.
-     *
-     * @param mixed                                       $value       The value to export
-     * @param int                                         $indentation The indentation level of the 2nd+ line
-     * @param \SebastianBergmann\RecursionContext\Context $processed   Previously processed objects
-     *
-     * @return string
-     *
-     * @see    SebastianBergmann\Exporter\Exporter::export
-     */
-    protected function recursiveExport(&$value, $indentation, $processed = null)
-    {
-        if ($value === null) {
-            return 'null';
-        }
-
-        if ($value === true) {
-            return 'true';
-        }
-
-        if ($value === false) {
-            return 'false';
-        }
-
-        if (is_float($value)) {
-            $precisionBackup = ini_get('precision');
-
-            ini_set('precision', '-1');
-
-            try {
-                $valueStr = (string) $value;
-
-                if ((string) (int) $value === $valueStr) {
-                    return $valueStr . '.0';
-                }
-
-                return $valueStr;
-            } finally {
-                ini_set('precision', $precisionBackup);
-            }
-        }
-
-        if (gettype($value) === 'resource (closed)') {
-            return 'resource (closed)';
-        }
-
-        if (is_resource($value)) {
-            return sprintf(
-                'resource(%d) of type (%s)',
-                $value,
-                get_resource_type($value)
-            );
-        }
-
-        if (is_string($value)) {
-            // Match for most non printable chars somewhat taking multibyte chars into account
-            if (preg_match('/[^\x09-\x0d\x1b\x20-\xff]/', $value)) {
-                return 'Binary String: 0x' . bin2hex($value);
-            }
-
-            return "'" .
-            str_replace(
-                '<lf>',
-                "\n",
-                str_replace(
-                    ["\r\n", "\n\r", "\r", "\n"],
-                    ['\r\n<lf>', '\n\r<lf>', '\r<lf>', '\n<lf>'],
-                    $value
-                )
-            ) .
-            "'";
-        }
-
-        $whitespace = str_repeat(' ', 4 * $indentation);
-
-        if (!$processed) {
-            $processed = new Context;
-        }
-
-        if (is_array($value)) {
-            if (($key = $processed->contains($value)) !== false) {
-                return 'Array &' . $key;
-            }
-
-            $array  = $value;
-            $key    = $processed->add($value);
-            $values = '';
-
-            if (count($array) > 0) {
-                foreach ($array as $k => $v) {
-                    $values .= sprintf(
-                        '%s    %s => %s' . "\n",
-                        $whitespace,
-                        $this->recursiveExport($k, $indentation),
-                        $this->recursiveExport($value[$k], $indentation + 1, $processed)
-                    );
-                }
-
-                $values = "\n" . $values . $whitespace;
-            }
-
-            return sprintf('Array &%s (%s)', $key, $values);
-        }
-
-        if (is_object($value)) {
-            $class = get_class($value);
-
-            if ($hash = $processed->contains($value)) {
-                return sprintf('%s Object &%s', $class, $hash);
-            }
-
-            $hash   = $processed->add($value);
-            $values = '';
-            $array  = $this->toArray($value);
-
-            if (count($array) > 0) {
-                foreach ($array as $k => $v) {
-                    $values .= sprintf(
-                        '%s    %s => %s' . "\n",
-                        $whitespace,
-                        $this->recursiveExport($k, $indentation),
-                        $this->recursiveExport($v, $indentation + 1, $processed)
-                    );
-                }
-
-                $values = "\n" . $values . $whitespace;
-            }
-
-            return sprintf('%s Object &%s (%s)', $class, $hash, $values);
-        }
-
-        return var_export($value, true);
-    }
+	/**
+	 * Exports a value as a string.
+	 *
+	 * The output of this method is similar to the output of print_r(), but
+	 * improved in various aspects:
+	 *
+	 *  - NULL is rendered as "null" (instead of "")
+	 *  - TRUE is rendered as "true" (instead of "1")
+	 *  - FALSE is rendered as "false" (instead of "")
+	 *  - Strings are always quoted with single quotes
+	 *  - Carriage returns and newlines are normalized to \n
+	 *  - Recursion and repeated rendering is treated properly
+	 *
+	 * @param int $indentation The indentation level of the 2nd+ line
+	 *
+	 * @return string
+	 */
+	public function export($value, $indentation = 0)
+	{
+		return $this->recursiveExport($value, $indentation);
+	}
+
+	/**
+	 * @param array<mixed> $data
+	 * @param Context      $context
+	 *
+	 * @return string
+	 */
+	public function shortenedRecursiveExport(&$data, Context $context = null)
+	{
+		$result   = [];
+		$exporter = new self();
+
+		if (!$context) {
+			$context = new Context;
+		}
+
+		$array = $data;
+		$context->add($data);
+
+		foreach ($array as $key => $value) {
+			if (is_array($value)) {
+				if ($context->contains($data[$key]) !== false) {
+					$result[] = '*RECURSION*';
+				} else {
+					$result[] = sprintf(
+						'array(%s)',
+						$this->shortenedRecursiveExport($data[$key], $context)
+					);
+				}
+			} else {
+				$result[] = $exporter->shortenedExport($value);
+			}
+		}
+
+		return implode(', ', $result);
+	}
+
+	/**
+	 * Exports a value into a single-line string.
+	 *
+	 * The output of this method is similar to the output of
+	 * SebastianBergmann\Exporter\Exporter::export().
+	 *
+	 * Newlines are replaced by the visible string '\n'.
+	 * Contents of arrays and objects (if any) are replaced by '...'.
+	 *
+	 * @return string
+	 *
+	 * @see    SebastianBergmann\Exporter\Exporter::export
+	 */
+	public function shortenedExport($value)
+	{
+		if (is_string($value)) {
+			$string = str_replace("\n", '', $this->export($value));
+
+			if (function_exists('mb_strlen')) {
+				if (mb_strlen($string) > 40) {
+					$string = mb_substr($string, 0, 30) . '...' . mb_substr($string, -7);
+				}
+			} else {
+				if (strlen($string) > 40) {
+					$string = substr($string, 0, 30) . '...' . substr($string, -7);
+				}
+			}
+
+			return $string;
+		}
+
+		if (is_object($value)) {
+			return sprintf(
+				'%s Object (%s)',
+				get_class($value),
+				count($this->toArray($value)) > 0 ? '...' : ''
+			);
+		}
+
+		if (is_array($value)) {
+			return sprintf(
+				'Array (%s)',
+				count($value) > 0 ? '...' : ''
+			);
+		}
+
+		return $this->export($value);
+	}
+
+	/**
+	 * Converts an object to an array containing all of its private, protected
+	 * and public properties.
+	 *
+	 * @return array
+	 */
+	public function toArray($value)
+	{
+		if (!is_object($value)) {
+			return (array) $value;
+		}
+
+		$array = [];
+
+		foreach ((array) $value as $key => $val) {
+			// Exception traces commonly reference hundreds to thousands of
+			// objects currently loaded in memory. Including them in the result
+			// has a severe negative performance impact.
+			if ("\0Error\0trace" === $key || "\0Exception\0trace" === $key) {
+				continue;
+			}
+
+			// properties are transformed to keys in the following way:
+			// private   $property => "\0Classname\0property"
+			// protected $property => "\0*\0property"
+			// public    $property => "property"
+			if (preg_match('/^\0.+\0(.+)$/', (string) $key, $matches)) {
+				$key = $matches[1];
+			}
+
+			// See https://github.com/php/php-src/commit/5721132
+			if ($key === "\0gcdata") {
+				continue;
+			}
+
+			$array[$key] = $val;
+		}
+
+		// Some internal classes like SplObjectStorage don't work with the
+		// above (fast) mechanism nor with reflection in Zend.
+		// Format the output similarly to print_r() in this case
+		if ($value instanceof SplObjectStorage) {
+			foreach ($value as $key => $val) {
+				$array[spl_object_hash($val)] = [
+					'obj' => $val,
+					'inf' => $value->getInfo(),
+				];
+			}
+		}
+
+		return $array;
+	}
+
+	/**
+	 * Recursive implementation of export.
+	 *
+	 * @param mixed                                       $value       The value to export
+	 * @param int                                         $indentation The indentation level of the 2nd+ line
+	 * @param \SebastianBergmann\RecursionContext\Context $processed   Previously processed objects
+	 *
+	 * @return string
+	 *
+	 * @see    SebastianBergmann\Exporter\Exporter::export
+	 */
+	protected function recursiveExport(&$value, $indentation, $processed = null)
+	{
+		if ($value === null) {
+			return 'null';
+		}
+
+		if ($value === true) {
+			return 'true';
+		}
+
+		if ($value === false) {
+			return 'false';
+		}
+
+		if (is_float($value)) {
+			$precisionBackup = ini_get('precision');
+
+			ini_set('precision', '-1');
+
+			try {
+				$valueStr = (string) $value;
+
+				if ((string) (int) $value === $valueStr) {
+					return $valueStr . '.0';
+				}
+
+				return $valueStr;
+			} finally {
+				ini_set('precision', $precisionBackup);
+			}
+		}
+
+		if (gettype($value) === 'resource (closed)') {
+			return 'resource (closed)';
+		}
+
+		if (is_resource($value)) {
+			return sprintf(
+				'resource(%d) of type (%s)',
+				$value,
+				get_resource_type($value)
+			);
+		}
+
+		if (is_string($value)) {
+			// Match for most non printable chars somewhat taking multibyte chars into account
+			if (preg_match('/[^\x09-\x0d\x1b\x20-\xff]/', $value)) {
+				return 'Binary String: 0x' . bin2hex($value);
+			}
+
+			return "'" .
+			str_replace(
+				'<lf>',
+				"\n",
+				str_replace(
+					["\r\n", "\n\r", "\r", "\n"],
+					['\r\n<lf>', '\n\r<lf>', '\r<lf>', '\n<lf>'],
+					$value
+				)
+			) .
+			"'";
+		}
+
+		$whitespace = str_repeat(' ', 4 * $indentation);
+
+		if (!$processed) {
+			$processed = new Context;
+		}
+
+		if (is_array($value)) {
+			if (($key = $processed->contains($value)) !== false) {
+				return 'Array &' . $key;
+			}
+
+			$array  = $value;
+			$key    = $processed->add($value);
+			$values = '';
+
+			if (count($array) > 0) {
+				foreach ($array as $k => $v) {
+					$values .= sprintf(
+						'%s    %s => %s' . "\n",
+						$whitespace,
+						$this->recursiveExport($k, $indentation),
+						$this->recursiveExport($value[$k], $indentation + 1, $processed)
+					);
+				}
+
+				$values = "\n" . $values . $whitespace;
+			}
+
+			return sprintf('Array &%s (%s)', $key, $values);
+		}
+
+		if (is_object($value)) {
+			$class = get_class($value);
+
+			if ($hash = $processed->contains($value)) {
+				return sprintf('%s Object &%s', $class, $hash);
+			}
+
+			$hash   = $processed->add($value);
+			$values = '';
+			$array  = $this->toArray($value);
+
+			if (count($array) > 0) {
+				foreach ($array as $k => $v) {
+					$values .= sprintf(
+						'%s    %s => %s' . "\n",
+						$whitespace,
+						$this->recursiveExport($k, $indentation),
+						$this->recursiveExport($v, $indentation + 1, $processed)
+					);
+				}
+
+				$values = "\n" . $values . $whitespace;
+			}
+
+			return sprintf('%s Object &%s (%s)', $class, $hash, $values);
+		}
+
+		return var_export($value, true);
+	}
 }

Spacing +14 added lines, -14 removed lines

@@ -82,7 +82,7 @@ 
         $result   = [];
         $exporter = new self();
 
-        if (!$context) {
+        if ( ! $context) {
             $context = new Context;
         }
 
@@ -127,11 +127,11 @@ 
 
             if (function_exists('mb_strlen')) {
                 if (mb_strlen($string) > 40) {
-                    $string = mb_substr($string, 0, 30) . '...' . mb_substr($string, -7);
+                    $string = mb_substr($string, 0, 30).'...'.mb_substr($string, -7);
                 }
             } else {
                 if (strlen($string) > 40) {
-                    $string = substr($string, 0, 30) . '...' . substr($string, -7);
+                    $string = substr($string, 0, 30).'...'.substr($string, -7);
                 }
             }
 
@@ -164,7 +164,7 @@ 
      */
     public function toArray($value)
     {
-        if (!is_object($value)) {
+        if ( ! is_object($value)) {
             return (array) $value;
         }
 
@@ -243,7 +243,7 @@ 
                 $valueStr = (string) $value;
 
                 if ((string) (int) $value === $valueStr) {
-                    return $valueStr . '.0';
+                    return $valueStr.'.0';
                 }
 
                 return $valueStr;
@@ -267,10 +267,10 @@ 
         if (is_string($value)) {
             // Match for most non printable chars somewhat taking multibyte chars into account
             if (preg_match('/[^\x09-\x0d\x1b\x20-\xff]/', $value)) {
-                return 'Binary String: 0x' . bin2hex($value);
+                return 'Binary String: 0x'.bin2hex($value);
             }
 
-            return "'" .
+            return "'".
             str_replace(
                 '<lf>',
                 "\n",
@@ -279,19 +279,19 @@ 
                     ['\r\n<lf>', '\n\r<lf>', '\r<lf>', '\n<lf>'],
                     $value
                 )
-            ) .
+            ).
             "'";
         }
 
         $whitespace = str_repeat(' ', 4 * $indentation);
 
-        if (!$processed) {
+        if ( ! $processed) {
             $processed = new Context;
         }
 
         if (is_array($value)) {
             if (($key = $processed->contains($value)) !== false) {
-                return 'Array &' . $key;
+                return 'Array &'.$key;
             }
 
             $array  = $value;
@@ -301,14 +301,14 @@ 
             if (count($array) > 0) {
                 foreach ($array as $k => $v) {
                     $values .= sprintf(
-                        '%s    %s => %s' . "\n",
+                        '%s    %s => %s'."\n",
                         $whitespace,
                         $this->recursiveExport($k, $indentation),
                         $this->recursiveExport($value[$k], $indentation + 1, $processed)
                     );
                 }
 
-                $values = "\n" . $values . $whitespace;
+                $values = "\n".$values.$whitespace;
             }
 
             return sprintf('Array &%s (%s)', $key, $values);
@@ -328,14 +328,14 @@ 
             if (count($array) > 0) {
                 foreach ($array as $k => $v) {
                     $values .= sprintf(
-                        '%s    %s => %s' . "\n",
+                        '%s    %s => %s'."\n",
                         $whitespace,
                         $this->recursiveExport($k, $indentation),
                         $this->recursiveExport($v, $indentation + 1, $processed)
                     );
                 }
 
-                $values = "\n" . $values . $whitespace;
+                $values = "\n".$values.$whitespace;
             }
 
             return sprintf('%s Object &%s (%s)', $class, $hash, $values);

vendor/sebastian/comparator/src/NumericComparator.php

Indentation +55 added lines, -55 removed lines

@@ -22,63 +22,63 @@
  */
 class NumericComparator extends ScalarComparator
 {
-    /**
-     * Returns whether the comparator can compare two values.
-     *
-     * @param mixed $expected The first value to compare
-     * @param mixed $actual   The second value to compare
-     *
-     * @return bool
-     */
-    public function accepts($expected, $actual)
-    {
-        // all numerical values, but not if both of them are strings
-        return is_numeric($expected) && is_numeric($actual) &&
-               !(is_string($expected) && is_string($actual));
-    }
+	/**
+	 * Returns whether the comparator can compare two values.
+	 *
+	 * @param mixed $expected The first value to compare
+	 * @param mixed $actual   The second value to compare
+	 *
+	 * @return bool
+	 */
+	public function accepts($expected, $actual)
+	{
+		// all numerical values, but not if both of them are strings
+		return is_numeric($expected) && is_numeric($actual) &&
+			   !(is_string($expected) && is_string($actual));
+	}
 
-    /**
-     * Asserts that two values are equal.
-     *
-     * @param mixed $expected     First value to compare
-     * @param mixed $actual       Second value to compare
-     * @param float $delta        Allowed numerical distance between two values to consider them equal
-     * @param bool  $canonicalize Arrays are sorted before comparison when set to true
-     * @param bool  $ignoreCase   Case is ignored when set to true
-     *
-     * @throws ComparisonFailure
-     */
-    public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false)/*: void*/
-    {
-        if ($this->isInfinite($actual) && $this->isInfinite($expected)) {
-            return;
-        }
+	/**
+	 * Asserts that two values are equal.
+	 *
+	 * @param mixed $expected     First value to compare
+	 * @param mixed $actual       Second value to compare
+	 * @param float $delta        Allowed numerical distance between two values to consider them equal
+	 * @param bool  $canonicalize Arrays are sorted before comparison when set to true
+	 * @param bool  $ignoreCase   Case is ignored when set to true
+	 *
+	 * @throws ComparisonFailure
+	 */
+	public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false)/*: void*/
+	{
+		if ($this->isInfinite($actual) && $this->isInfinite($expected)) {
+			return;
+		}
 
-        if (($this->isInfinite($actual) xor $this->isInfinite($expected)) ||
-            ($this->isNan($actual) || $this->isNan($expected)) ||
-            abs($actual - $expected) > $delta) {
-            throw new ComparisonFailure(
-                $expected,
-                $actual,
-                '',
-                '',
-                false,
-                sprintf(
-                    'Failed asserting that %s matches expected %s.',
-                    $this->exporter->export($actual),
-                    $this->exporter->export($expected)
-                )
-            );
-        }
-    }
+		if (($this->isInfinite($actual) xor $this->isInfinite($expected)) ||
+			($this->isNan($actual) || $this->isNan($expected)) ||
+			abs($actual - $expected) > $delta) {
+			throw new ComparisonFailure(
+				$expected,
+				$actual,
+				'',
+				'',
+				false,
+				sprintf(
+					'Failed asserting that %s matches expected %s.',
+					$this->exporter->export($actual),
+					$this->exporter->export($expected)
+				)
+			);
+		}
+	}
 
-    private function isInfinite($value): bool
-    {
-        return is_float($value) && is_infinite($value);
-    }
+	private function isInfinite($value): bool
+	{
+		return is_float($value) && is_infinite($value);
+	}
 
-    private function isNan($value): bool
-    {
-        return is_float($value) && is_nan($value);
-    }
+	private function isNan($value): bool
+	{
+		return is_float($value) && is_nan($value);
+	}
 }

Spacing +1 added lines, -1 removed lines

@@ -34,7 +34,7 @@
     {
         // all numerical values, but not if both of them are strings
         return is_numeric($expected) && is_numeric($actual) &&
-               !(is_string($expected) && is_string($actual));
+               ! (is_string($expected) && is_string($actual));
     }
 
     /**

vendor/sebastian/comparator/src/Factory.php

Indentation +122 added lines, -122 removed lines

@@ -16,126 +16,126 @@
  */
 class Factory
 {
-    /**
-     * @var Factory
-     */
-    private static $instance;
-
-    /**
-     * @var Comparator[]
-     */
-    private $customComparators = [];
-
-    /**
-     * @var Comparator[]
-     */
-    private $defaultComparators = [];
-
-    /**
-     * @return Factory
-     */
-    public static function getInstance()
-    {
-        if (self::$instance === null) {
-            self::$instance = new self; // @codeCoverageIgnore
-        }
-
-        return self::$instance;
-    }
-
-    /**
-     * Constructs a new factory.
-     */
-    public function __construct()
-    {
-        $this->registerDefaultComparators();
-    }
-
-    /**
-     * Returns the correct comparator for comparing two values.
-     *
-     * @param mixed $expected The first value to compare
-     * @param mixed $actual   The second value to compare
-     *
-     * @return Comparator
-     */
-    public function getComparatorFor($expected, $actual)
-    {
-        foreach ($this->customComparators as $comparator) {
-            if ($comparator->accepts($expected, $actual)) {
-                return $comparator;
-            }
-        }
-
-        foreach ($this->defaultComparators as $comparator) {
-            if ($comparator->accepts($expected, $actual)) {
-                return $comparator;
-            }
-        }
-
-        throw new RuntimeException('No suitable Comparator implementation found');
-    }
-
-    /**
-     * Registers a new comparator.
-     *
-     * This comparator will be returned by getComparatorFor() if its accept() method
-     * returns TRUE for the compared values. It has higher priority than the
-     * existing comparators, meaning that its accept() method will be invoked
-     * before those of the other comparators.
-     *
-     * @param Comparator $comparator The comparator to be registered
-     */
-    public function register(Comparator $comparator)/*: void*/
-    {
-        array_unshift($this->customComparators, $comparator);
-
-        $comparator->setFactory($this);
-    }
-
-    /**
-     * Unregisters a comparator.
-     *
-     * This comparator will no longer be considered by getComparatorFor().
-     *
-     * @param Comparator $comparator The comparator to be unregistered
-     */
-    public function unregister(Comparator $comparator)/*: void*/
-    {
-        foreach ($this->customComparators as $key => $_comparator) {
-            if ($comparator === $_comparator) {
-                unset($this->customComparators[$key]);
-            }
-        }
-    }
-
-    /**
-     * Unregisters all non-default comparators.
-     */
-    public function reset()/*: void*/
-    {
-        $this->customComparators = [];
-    }
-
-    private function registerDefaultComparators(): void
-    {
-        $this->registerDefaultComparator(new MockObjectComparator);
-        $this->registerDefaultComparator(new DateTimeComparator);
-        $this->registerDefaultComparator(new DOMNodeComparator);
-        $this->registerDefaultComparator(new SplObjectStorageComparator);
-        $this->registerDefaultComparator(new ExceptionComparator);
-        $this->registerDefaultComparator(new ObjectComparator);
-        $this->registerDefaultComparator(new ResourceComparator);
-        $this->registerDefaultComparator(new ArrayComparator);
-        $this->registerDefaultComparator(new NumericComparator);
-        $this->registerDefaultComparator(new ScalarComparator);
-        $this->registerDefaultComparator(new TypeComparator);
-    }
-
-    private function registerDefaultComparator(Comparator $comparator): void
-    {
-        $this->defaultComparators[] = $comparator;
-
-        $comparator->setFactory($this);
-    }
+	/**
+	 * @var Factory
+	 */
+	private static $instance;
+
+	/**
+	 * @var Comparator[]
+	 */
+	private $customComparators = [];
+
+	/**
+	 * @var Comparator[]
+	 */
+	private $defaultComparators = [];
+
+	/**
+	 * @return Factory
+	 */
+	public static function getInstance()
+	{
+		if (self::$instance === null) {
+			self::$instance = new self; // @codeCoverageIgnore
+		}
+
+		return self::$instance;
+	}
+
+	/**
+	 * Constructs a new factory.
+	 */
+	public function __construct()
+	{
+		$this->registerDefaultComparators();
+	}
+
+	/**
+	 * Returns the correct comparator for comparing two values.
+	 *
+	 * @param mixed $expected The first value to compare
+	 * @param mixed $actual   The second value to compare
+	 *
+	 * @return Comparator
+	 */
+	public function getComparatorFor($expected, $actual)
+	{
+		foreach ($this->customComparators as $comparator) {
+			if ($comparator->accepts($expected, $actual)) {
+				return $comparator;
+			}
+		}
+
+		foreach ($this->defaultComparators as $comparator) {
+			if ($comparator->accepts($expected, $actual)) {
+				return $comparator;
+			}
+		}
+
+		throw new RuntimeException('No suitable Comparator implementation found');
+	}
+
+	/**
+	 * Registers a new comparator.
+	 *
+	 * This comparator will be returned by getComparatorFor() if its accept() method
+	 * returns TRUE for the compared values. It has higher priority than the
+	 * existing comparators, meaning that its accept() method will be invoked
+	 * before those of the other comparators.
+	 *
+	 * @param Comparator $comparator The comparator to be registered
+	 */
+	public function register(Comparator $comparator)/*: void*/
+	{
+		array_unshift($this->customComparators, $comparator);
+
+		$comparator->setFactory($this);
+	}
+
+	/**
+	 * Unregisters a comparator.
+	 *
+	 * This comparator will no longer be considered by getComparatorFor().
+	 *
+	 * @param Comparator $comparator The comparator to be unregistered
+	 */
+	public function unregister(Comparator $comparator)/*: void*/
+	{
+		foreach ($this->customComparators as $key => $_comparator) {
+			if ($comparator === $_comparator) {
+				unset($this->customComparators[$key]);
+			}
+		}
+	}
+
+	/**
+	 * Unregisters all non-default comparators.
+	 */
+	public function reset()/*: void*/
+	{
+		$this->customComparators = [];
+	}
+
+	private function registerDefaultComparators(): void
+	{
+		$this->registerDefaultComparator(new MockObjectComparator);
+		$this->registerDefaultComparator(new DateTimeComparator);
+		$this->registerDefaultComparator(new DOMNodeComparator);
+		$this->registerDefaultComparator(new SplObjectStorageComparator);
+		$this->registerDefaultComparator(new ExceptionComparator);
+		$this->registerDefaultComparator(new ObjectComparator);
+		$this->registerDefaultComparator(new ResourceComparator);
+		$this->registerDefaultComparator(new ArrayComparator);
+		$this->registerDefaultComparator(new NumericComparator);
+		$this->registerDefaultComparator(new ScalarComparator);
+		$this->registerDefaultComparator(new TypeComparator);
+	}
+
+	private function registerDefaultComparator(Comparator $comparator): void
+	{
+		$this->defaultComparators[] = $comparator;
+
+		$comparator->setFactory($this);
+	}
 }

vendor/sebastian/comparator/src/ScalarComparator.php

Indentation +69 added lines, -69 removed lines

@@ -22,78 +22,78 @@
  */
 class ScalarComparator extends Comparator
 {
-    /**
-     * Returns whether the comparator can compare two values.
-     *
-     * @param mixed $expected The first value to compare
-     * @param mixed $actual   The second value to compare
-     *
-     * @return bool
-     *
-     * @since  Method available since Release 3.6.0
-     */
-    public function accepts($expected, $actual)
-    {
-        return ((is_scalar($expected) xor null === $expected) &&
-               (is_scalar($actual) xor null === $actual))
-               // allow comparison between strings and objects featuring __toString()
-               || (is_string($expected) && is_object($actual) && method_exists($actual, '__toString'))
-               || (is_object($expected) && method_exists($expected, '__toString') && is_string($actual));
-    }
+	/**
+	 * Returns whether the comparator can compare two values.
+	 *
+	 * @param mixed $expected The first value to compare
+	 * @param mixed $actual   The second value to compare
+	 *
+	 * @return bool
+	 *
+	 * @since  Method available since Release 3.6.0
+	 */
+	public function accepts($expected, $actual)
+	{
+		return ((is_scalar($expected) xor null === $expected) &&
+			   (is_scalar($actual) xor null === $actual))
+			   // allow comparison between strings and objects featuring __toString()
+			   || (is_string($expected) && is_object($actual) && method_exists($actual, '__toString'))
+			   || (is_object($expected) && method_exists($expected, '__toString') && is_string($actual));
+	}
 
-    /**
-     * Asserts that two values are equal.
-     *
-     * @param mixed $expected     First value to compare
-     * @param mixed $actual       Second value to compare
-     * @param float $delta        Allowed numerical distance between two values to consider them equal
-     * @param bool  $canonicalize Arrays are sorted before comparison when set to true
-     * @param bool  $ignoreCase   Case is ignored when set to true
-     *
-     * @throws ComparisonFailure
-     */
-    public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false)/*: void*/
-    {
-        $expectedToCompare = $expected;
-        $actualToCompare   = $actual;
+	/**
+	 * Asserts that two values are equal.
+	 *
+	 * @param mixed $expected     First value to compare
+	 * @param mixed $actual       Second value to compare
+	 * @param float $delta        Allowed numerical distance between two values to consider them equal
+	 * @param bool  $canonicalize Arrays are sorted before comparison when set to true
+	 * @param bool  $ignoreCase   Case is ignored when set to true
+	 *
+	 * @throws ComparisonFailure
+	 */
+	public function assertEquals($expected, $actual, $delta = 0.0, $canonicalize = false, $ignoreCase = false)/*: void*/
+	{
+		$expectedToCompare = $expected;
+		$actualToCompare   = $actual;
 
-        // always compare as strings to avoid strange behaviour
-        // otherwise 0 == 'Foobar'
-        if ((is_string($expected) && !is_bool($actual)) || (is_string($actual) && !is_bool($expected))) {
-            $expectedToCompare = (string) $expectedToCompare;
-            $actualToCompare   = (string) $actualToCompare;
+		// always compare as strings to avoid strange behaviour
+		// otherwise 0 == 'Foobar'
+		if ((is_string($expected) && !is_bool($actual)) || (is_string($actual) && !is_bool($expected))) {
+			$expectedToCompare = (string) $expectedToCompare;
+			$actualToCompare   = (string) $actualToCompare;
 
-            if ($ignoreCase) {
-                $expectedToCompare = strtolower($expectedToCompare);
-                $actualToCompare   = strtolower($actualToCompare);
-            }
-        }
+			if ($ignoreCase) {
+				$expectedToCompare = strtolower($expectedToCompare);
+				$actualToCompare   = strtolower($actualToCompare);
+			}
+		}
 
-        if ($expectedToCompare !== $actualToCompare && is_string($expected) && is_string($actual)) {
-            throw new ComparisonFailure(
-                $expected,
-                $actual,
-                $this->exporter->export($expected),
-                $this->exporter->export($actual),
-                false,
-                'Failed asserting that two strings are equal.'
-            );
-        }
+		if ($expectedToCompare !== $actualToCompare && is_string($expected) && is_string($actual)) {
+			throw new ComparisonFailure(
+				$expected,
+				$actual,
+				$this->exporter->export($expected),
+				$this->exporter->export($actual),
+				false,
+				'Failed asserting that two strings are equal.'
+			);
+		}
 
-        if ($expectedToCompare != $actualToCompare) {
-            throw new ComparisonFailure(
-                $expected,
-                $actual,
-                // no diff is required
-                '',
-                '',
-                false,
-                sprintf(
-                    'Failed asserting that %s matches expected %s.',
-                    $this->exporter->export($actual),
-                    $this->exporter->export($expected)
-                )
-            );
-        }
-    }
+		if ($expectedToCompare != $actualToCompare) {
+			throw new ComparisonFailure(
+				$expected,
+				$actual,
+				// no diff is required
+				'',
+				'',
+				false,
+				sprintf(
+					'Failed asserting that %s matches expected %s.',
+					$this->exporter->export($actual),
+					$this->exporter->export($expected)
+				)
+			);
+		}
+	}
 }

Spacing +1 added lines, -1 removed lines

@@ -59,7 +59,7 @@
 
         // always compare as strings to avoid strange behaviour
         // otherwise 0 == 'Foobar'
-        if ((is_string($expected) && !is_bool($actual)) || (is_string($actual) && !is_bool($expected))) {
+        if ((is_string($expected) && ! is_bool($actual)) || (is_string($actual) && ! is_bool($expected))) {
             $expectedToCompare = (string) $expectedToCompare;
             $actualToCompare   = (string) $actualToCompare;
 

vendor/sebastian/type/src/Parameter.php

Indentation +24 added lines, -24 removed lines

@@ -11,32 +11,32 @@
 
 final class Parameter
 {
-    /**
-     * @psalm-var non-empty-string
-     */
-    private $name;
+	/**
+	 * @psalm-var non-empty-string
+	 */
+	private $name;
 
-    /**
-     * @var Type
-     */
-    private $type;
+	/**
+	 * @var Type
+	 */
+	private $type;
 
-    /**
-     * @psalm-param non-empty-string $name
-     */
-    public function __construct(string $name, Type $type)
-    {
-        $this->name = $name;
-        $this->type = $type;
-    }
+	/**
+	 * @psalm-param non-empty-string $name
+	 */
+	public function __construct(string $name, Type $type)
+	{
+		$this->name = $name;
+		$this->type = $type;
+	}
 
-    public function name(): string
-    {
-        return $this->name;
-    }
+	public function name(): string
+	{
+		return $this->name;
+	}
 
-    public function type(): Type
-    {
-        return $this->type;
-    }
+	public function type(): Type
+	{
+		return $this->type;
+	}
 }

vendor/sebastian/type/src/ReflectionMapper.php

Indentation +162 added lines, -162 removed lines

@@ -19,166 +19,166 @@
 
 final class ReflectionMapper
 {
-    /**
-     * @psalm-return list<Parameter>
-     */
-    public function fromParameterTypes(ReflectionFunctionAbstract $functionOrMethod): array
-    {
-        $parameters = [];
-
-        foreach ($functionOrMethod->getParameters() as $parameter) {
-            $name = $parameter->getName();
-
-            assert($name !== '');
-
-            if (!$parameter->hasType()) {
-                $parameters[] = new Parameter($name, new UnknownType);
-
-                continue;
-            }
-
-            $type = $parameter->getType();
-
-            if ($type instanceof ReflectionNamedType) {
-                $parameters[] = new Parameter(
-                    $name,
-                    $this->mapNamedType($type, $functionOrMethod)
-                );
-
-                continue;
-            }
-
-            if ($type instanceof ReflectionUnionType) {
-                $parameters[] = new Parameter(
-                    $name,
-                    $this->mapUnionType($type, $functionOrMethod)
-                );
-
-                continue;
-            }
-
-            if ($type instanceof ReflectionIntersectionType) {
-                $parameters[] = new Parameter(
-                    $name,
-                    $this->mapIntersectionType($type, $functionOrMethod)
-                );
-            }
-        }
-
-        return $parameters;
-    }
-
-    public function fromReturnType(ReflectionFunctionAbstract $functionOrMethod): Type
-    {
-        if (!$this->hasReturnType($functionOrMethod)) {
-            return new UnknownType;
-        }
-
-        $returnType = $this->returnType($functionOrMethod);
-
-        assert($returnType instanceof ReflectionNamedType || $returnType instanceof ReflectionUnionType || $returnType instanceof ReflectionIntersectionType);
-
-        if ($returnType instanceof ReflectionNamedType) {
-            return $this->mapNamedType($returnType, $functionOrMethod);
-        }
-
-        if ($returnType instanceof ReflectionUnionType) {
-            return $this->mapUnionType($returnType, $functionOrMethod);
-        }
-
-        if ($returnType instanceof ReflectionIntersectionType) {
-            return $this->mapIntersectionType($returnType, $functionOrMethod);
-        }
-    }
-
-    private function mapNamedType(ReflectionNamedType $type, ReflectionFunctionAbstract $functionOrMethod): Type
-    {
-        if ($functionOrMethod instanceof ReflectionMethod && $type->getName() === 'self') {
-            return ObjectType::fromName(
-                $functionOrMethod->getDeclaringClass()->getName(),
-                $type->allowsNull()
-            );
-        }
-
-        if ($functionOrMethod instanceof ReflectionMethod && $type->getName() === 'static') {
-            return new StaticType(
-                TypeName::fromReflection($functionOrMethod->getDeclaringClass()),
-                $type->allowsNull()
-            );
-        }
-
-        if ($type->getName() === 'mixed') {
-            return new MixedType;
-        }
-
-        if ($functionOrMethod instanceof ReflectionMethod && $type->getName() === 'parent') {
-            return ObjectType::fromName(
-                $functionOrMethod->getDeclaringClass()->getParentClass()->getName(),
-                $type->allowsNull()
-            );
-        }
-
-        return Type::fromName(
-            $type->getName(),
-            $type->allowsNull()
-        );
-    }
-
-    private function mapUnionType(ReflectionUnionType $type, ReflectionFunctionAbstract $functionOrMethod): Type
-    {
-        $types = [];
-
-        foreach ($type->getTypes() as $_type) {
-            assert($_type instanceof ReflectionNamedType || $_type instanceof ReflectionIntersectionType);
-
-            if ($_type instanceof ReflectionNamedType) {
-                $types[] = $this->mapNamedType($_type, $functionOrMethod);
-
-                continue;
-            }
-
-            $types[] = $this->mapIntersectionType($_type, $functionOrMethod);
-        }
-
-        return new UnionType(...$types);
-    }
-
-    private function mapIntersectionType(ReflectionIntersectionType $type, ReflectionFunctionAbstract $functionOrMethod): Type
-    {
-        $types = [];
-
-        foreach ($type->getTypes() as $_type) {
-            assert($_type instanceof ReflectionNamedType);
-
-            $types[] = $this->mapNamedType($_type, $functionOrMethod);
-        }
-
-        return new IntersectionType(...$types);
-    }
-
-    private function hasReturnType(ReflectionFunctionAbstract $functionOrMethod): bool
-    {
-        if ($functionOrMethod->hasReturnType()) {
-            return true;
-        }
-
-        if (!method_exists($functionOrMethod, 'hasTentativeReturnType')) {
-            return false;
-        }
-
-        return $functionOrMethod->hasTentativeReturnType();
-    }
-
-    private function returnType(ReflectionFunctionAbstract $functionOrMethod): ?ReflectionType
-    {
-        if ($functionOrMethod->hasReturnType()) {
-            return $functionOrMethod->getReturnType();
-        }
-
-        if (!method_exists($functionOrMethod, 'getTentativeReturnType')) {
-            return null;
-        }
-
-        return $functionOrMethod->getTentativeReturnType();
-    }
+	/**
+	 * @psalm-return list<Parameter>
+	 */
+	public function fromParameterTypes(ReflectionFunctionAbstract $functionOrMethod): array
+	{
+		$parameters = [];
+
+		foreach ($functionOrMethod->getParameters() as $parameter) {
+			$name = $parameter->getName();
+
+			assert($name !== '');
+
+			if (!$parameter->hasType()) {
+				$parameters[] = new Parameter($name, new UnknownType);
+
+				continue;
+			}
+
+			$type = $parameter->getType();
+
+			if ($type instanceof ReflectionNamedType) {
+				$parameters[] = new Parameter(
+					$name,
+					$this->mapNamedType($type, $functionOrMethod)
+				);
+
+				continue;
+			}
+
+			if ($type instanceof ReflectionUnionType) {
+				$parameters[] = new Parameter(
+					$name,
+					$this->mapUnionType($type, $functionOrMethod)
+				);
+
+				continue;
+			}
+
+			if ($type instanceof ReflectionIntersectionType) {
+				$parameters[] = new Parameter(
+					$name,
+					$this->mapIntersectionType($type, $functionOrMethod)
+				);
+			}
+		}
+
+		return $parameters;
+	}
+
+	public function fromReturnType(ReflectionFunctionAbstract $functionOrMethod): Type
+	{
+		if (!$this->hasReturnType($functionOrMethod)) {
+			return new UnknownType;
+		}
+
+		$returnType = $this->returnType($functionOrMethod);
+
+		assert($returnType instanceof ReflectionNamedType || $returnType instanceof ReflectionUnionType || $returnType instanceof ReflectionIntersectionType);
+
+		if ($returnType instanceof ReflectionNamedType) {
+			return $this->mapNamedType($returnType, $functionOrMethod);
+		}
+
+		if ($returnType instanceof ReflectionUnionType) {
+			return $this->mapUnionType($returnType, $functionOrMethod);
+		}
+
+		if ($returnType instanceof ReflectionIntersectionType) {
+			return $this->mapIntersectionType($returnType, $functionOrMethod);
+		}
+	}
+
+	private function mapNamedType(ReflectionNamedType $type, ReflectionFunctionAbstract $functionOrMethod): Type
+	{
+		if ($functionOrMethod instanceof ReflectionMethod && $type->getName() === 'self') {
+			return ObjectType::fromName(
+				$functionOrMethod->getDeclaringClass()->getName(),
+				$type->allowsNull()
+			);
+		}
+
+		if ($functionOrMethod instanceof ReflectionMethod && $type->getName() === 'static') {
+			return new StaticType(
+				TypeName::fromReflection($functionOrMethod->getDeclaringClass()),
+				$type->allowsNull()
+			);
+		}
+
+		if ($type->getName() === 'mixed') {
+			return new MixedType;
+		}
+
+		if ($functionOrMethod instanceof ReflectionMethod && $type->getName() === 'parent') {
+			return ObjectType::fromName(
+				$functionOrMethod->getDeclaringClass()->getParentClass()->getName(),
+				$type->allowsNull()
+			);
+		}
+
+		return Type::fromName(
+			$type->getName(),
+			$type->allowsNull()
+		);
+	}
+
+	private function mapUnionType(ReflectionUnionType $type, ReflectionFunctionAbstract $functionOrMethod): Type
+	{
+		$types = [];
+
+		foreach ($type->getTypes() as $_type) {
+			assert($_type instanceof ReflectionNamedType || $_type instanceof ReflectionIntersectionType);
+
+			if ($_type instanceof ReflectionNamedType) {
+				$types[] = $this->mapNamedType($_type, $functionOrMethod);
+
+				continue;
+			}
+
+			$types[] = $this->mapIntersectionType($_type, $functionOrMethod);
+		}
+
+		return new UnionType(...$types);
+	}
+
+	private function mapIntersectionType(ReflectionIntersectionType $type, ReflectionFunctionAbstract $functionOrMethod): Type
+	{
+		$types = [];
+
+		foreach ($type->getTypes() as $_type) {
+			assert($_type instanceof ReflectionNamedType);
+
+			$types[] = $this->mapNamedType($_type, $functionOrMethod);
+		}
+
+		return new IntersectionType(...$types);
+	}
+
+	private function hasReturnType(ReflectionFunctionAbstract $functionOrMethod): bool
+	{
+		if ($functionOrMethod->hasReturnType()) {
+			return true;
+		}
+
+		if (!method_exists($functionOrMethod, 'hasTentativeReturnType')) {
+			return false;
+		}
+
+		return $functionOrMethod->hasTentativeReturnType();
+	}
+
+	private function returnType(ReflectionFunctionAbstract $functionOrMethod): ?ReflectionType
+	{
+		if ($functionOrMethod->hasReturnType()) {
+			return $functionOrMethod->getReturnType();
+		}
+
+		if (!method_exists($functionOrMethod, 'getTentativeReturnType')) {
+			return null;
+		}
+
+		return $functionOrMethod->getTentativeReturnType();
+	}
 }

Spacing +4 added lines, -4 removed lines

@@ -31,7 +31,7 @@ 
 
             assert($name !== '');
 
-            if (!$parameter->hasType()) {
+            if ( ! $parameter->hasType()) {
                 $parameters[] = new Parameter($name, new UnknownType);
 
                 continue;
@@ -70,7 +70,7 @@ 
 
     public function fromReturnType(ReflectionFunctionAbstract $functionOrMethod): Type
     {
-        if (!$this->hasReturnType($functionOrMethod)) {
+        if ( ! $this->hasReturnType($functionOrMethod)) {
             return new UnknownType;
         }
 
@@ -162,7 +162,7 @@ 
             return true;
         }
 
-        if (!method_exists($functionOrMethod, 'hasTentativeReturnType')) {
+        if ( ! method_exists($functionOrMethod, 'hasTentativeReturnType')) {
             return false;
         }
 
@@ -175,7 +175,7 @@ 
             return $functionOrMethod->getReturnType();
         }
 
-        if (!method_exists($functionOrMethod, 'getTentativeReturnType')) {
+        if ( ! method_exists($functionOrMethod, 'getTentativeReturnType')) {
             return null;
         }
 

vendor/sebastian/type/src/type/SimpleType.php

Indentation +88 added lines, -88 removed lines

@@ -13,92 +13,92 @@
 
 final class SimpleType extends Type
 {
-    /**
-     * @var string
-     */
-    private $name;
-
-    /**
-     * @var bool
-     */
-    private $allowsNull;
-
-    /**
-     * @var mixed
-     */
-    private $value;
-
-    public function __construct(string $name, bool $nullable, $value = null)
-    {
-        $this->name       = $this->normalize($name);
-        $this->allowsNull = $nullable;
-        $this->value      = $value;
-    }
-
-    public function isAssignable(Type $other): bool
-    {
-        if ($this->allowsNull && $other instanceof NullType) {
-            return true;
-        }
-
-        if ($this->name === 'bool' && $other->name() === 'true') {
-            return true;
-        }
-
-        if ($this->name === 'bool' && $other->name() === 'false') {
-            return true;
-        }
-
-        if ($other instanceof self) {
-            return $this->name === $other->name;
-        }
-
-        return false;
-    }
-
-    public function name(): string
-    {
-        return $this->name;
-    }
-
-    public function allowsNull(): bool
-    {
-        return $this->allowsNull;
-    }
-
-    public function value()
-    {
-        return $this->value;
-    }
-
-    /**
-     * @psalm-assert-if-true SimpleType $this
-     */
-    public function isSimple(): bool
-    {
-        return true;
-    }
-
-    private function normalize(string $name): string
-    {
-        $name = strtolower($name);
-
-        switch ($name) {
-            case 'boolean':
-                return 'bool';
-
-            case 'real':
-            case 'double':
-                return 'float';
-
-            case 'integer':
-                return 'int';
-
-            case '[]':
-                return 'array';
-
-            default:
-                return $name;
-        }
-    }
+	/**
+	 * @var string
+	 */
+	private $name;
+
+	/**
+	 * @var bool
+	 */
+	private $allowsNull;
+
+	/**
+	 * @var mixed
+	 */
+	private $value;
+
+	public function __construct(string $name, bool $nullable, $value = null)
+	{
+		$this->name       = $this->normalize($name);
+		$this->allowsNull = $nullable;
+		$this->value      = $value;
+	}
+
+	public function isAssignable(Type $other): bool
+	{
+		if ($this->allowsNull && $other instanceof NullType) {
+			return true;
+		}
+
+		if ($this->name === 'bool' && $other->name() === 'true') {
+			return true;
+		}
+
+		if ($this->name === 'bool' && $other->name() === 'false') {
+			return true;
+		}
+
+		if ($other instanceof self) {
+			return $this->name === $other->name;
+		}
+
+		return false;
+	}
+
+	public function name(): string
+	{
+		return $this->name;
+	}
+
+	public function allowsNull(): bool
+	{
+		return $this->allowsNull;
+	}
+
+	public function value()
+	{
+		return $this->value;
+	}
+
+	/**
+	 * @psalm-assert-if-true SimpleType $this
+	 */
+	public function isSimple(): bool
+	{
+		return true;
+	}
+
+	private function normalize(string $name): string
+	{
+		$name = strtolower($name);
+
+		switch ($name) {
+			case 'boolean':
+				return 'bool';
+
+			case 'real':
+			case 'double':
+				return 'float';
+
+			case 'integer':
+				return 'int';
+
+			case '[]':
+				return 'array';
+
+			default:
+				return $name;
+		}
+	}
 }

vendor/sebastian/type/src/type/Type.php

Indentation +206 added lines, -206 removed lines

@@ -17,210 +17,210 @@
 
 abstract class Type
 {
-    public static function fromValue($value, bool $allowsNull): self
-    {
-        if ($allowsNull === false) {
-            if ($value === true) {
-                return new TrueType;
-            }
-
-            if ($value === false) {
-                return new FalseType;
-            }
-        }
-
-        $typeName = gettype($value);
-
-        if ($typeName === 'object') {
-            return new ObjectType(TypeName::fromQualifiedName(get_class($value)), $allowsNull);
-        }
-
-        $type = self::fromName($typeName, $allowsNull);
-
-        if ($type instanceof SimpleType) {
-            $type = new SimpleType($typeName, $allowsNull, $value);
-        }
-
-        return $type;
-    }
-
-    public static function fromName(string $typeName, bool $allowsNull): self
-    {
-        if (version_compare(PHP_VERSION, '8.1.0-dev', '>=') && strtolower($typeName) === 'never') {
-            return new NeverType;
-        }
-
-        switch (strtolower($typeName)) {
-            case 'callable':
-                return new CallableType($allowsNull);
-
-            case 'true':
-                return new TrueType;
-
-            case 'false':
-                return new FalseType;
-
-            case 'iterable':
-                return new IterableType($allowsNull);
-
-            case 'null':
-                return new NullType;
-
-            case 'object':
-                return new GenericObjectType($allowsNull);
-
-            case 'unknown type':
-                return new UnknownType;
-
-            case 'void':
-                return new VoidType;
-
-            case 'array':
-            case 'bool':
-            case 'boolean':
-            case 'double':
-            case 'float':
-            case 'int':
-            case 'integer':
-            case 'real':
-            case 'resource':
-            case 'resource (closed)':
-            case 'string':
-                return new SimpleType($typeName, $allowsNull);
-
-            default:
-                return new ObjectType(TypeName::fromQualifiedName($typeName), $allowsNull);
-        }
-    }
-
-    public function asString(): string
-    {
-        return ($this->allowsNull() ? '?' : '') . $this->name();
-    }
-
-    /**
-     * @psalm-assert-if-true CallableType $this
-     */
-    public function isCallable(): bool
-    {
-        return false;
-    }
-
-    /**
-     * @psalm-assert-if-true TrueType $this
-     */
-    public function isTrue(): bool
-    {
-        return false;
-    }
-
-    /**
-     * @psalm-assert-if-true FalseType $this
-     */
-    public function isFalse(): bool
-    {
-        return false;
-    }
-
-    /**
-     * @psalm-assert-if-true GenericObjectType $this
-     */
-    public function isGenericObject(): bool
-    {
-        return false;
-    }
-
-    /**
-     * @psalm-assert-if-true IntersectionType $this
-     */
-    public function isIntersection(): bool
-    {
-        return false;
-    }
-
-    /**
-     * @psalm-assert-if-true IterableType $this
-     */
-    public function isIterable(): bool
-    {
-        return false;
-    }
-
-    /**
-     * @psalm-assert-if-true MixedType $this
-     */
-    public function isMixed(): bool
-    {
-        return false;
-    }
-
-    /**
-     * @psalm-assert-if-true NeverType $this
-     */
-    public function isNever(): bool
-    {
-        return false;
-    }
-
-    /**
-     * @psalm-assert-if-true NullType $this
-     */
-    public function isNull(): bool
-    {
-        return false;
-    }
-
-    /**
-     * @psalm-assert-if-true ObjectType $this
-     */
-    public function isObject(): bool
-    {
-        return false;
-    }
-
-    /**
-     * @psalm-assert-if-true SimpleType $this
-     */
-    public function isSimple(): bool
-    {
-        return false;
-    }
-
-    /**
-     * @psalm-assert-if-true StaticType $this
-     */
-    public function isStatic(): bool
-    {
-        return false;
-    }
-
-    /**
-     * @psalm-assert-if-true UnionType $this
-     */
-    public function isUnion(): bool
-    {
-        return false;
-    }
-
-    /**
-     * @psalm-assert-if-true UnknownType $this
-     */
-    public function isUnknown(): bool
-    {
-        return false;
-    }
-
-    /**
-     * @psalm-assert-if-true VoidType $this
-     */
-    public function isVoid(): bool
-    {
-        return false;
-    }
-
-    abstract public function isAssignable(self $other): bool;
-
-    abstract public function name(): string;
-
-    abstract public function allowsNull(): bool;
+	public static function fromValue($value, bool $allowsNull): self
+	{
+		if ($allowsNull === false) {
+			if ($value === true) {
+				return new TrueType;
+			}
+
+			if ($value === false) {
+				return new FalseType;
+			}
+		}
+
+		$typeName = gettype($value);
+
+		if ($typeName === 'object') {
+			return new ObjectType(TypeName::fromQualifiedName(get_class($value)), $allowsNull);
+		}
+
+		$type = self::fromName($typeName, $allowsNull);
+
+		if ($type instanceof SimpleType) {
+			$type = new SimpleType($typeName, $allowsNull, $value);
+		}
+
+		return $type;
+	}
+
+	public static function fromName(string $typeName, bool $allowsNull): self
+	{
+		if (version_compare(PHP_VERSION, '8.1.0-dev', '>=') && strtolower($typeName) === 'never') {
+			return new NeverType;
+		}
+
+		switch (strtolower($typeName)) {
+			case 'callable':
+				return new CallableType($allowsNull);
+
+			case 'true':
+				return new TrueType;
+
+			case 'false':
+				return new FalseType;
+
+			case 'iterable':
+				return new IterableType($allowsNull);
+
+			case 'null':
+				return new NullType;
+
+			case 'object':
+				return new GenericObjectType($allowsNull);
+
+			case 'unknown type':
+				return new UnknownType;
+
+			case 'void':
+				return new VoidType;
+
+			case 'array':
+			case 'bool':
+			case 'boolean':
+			case 'double':
+			case 'float':
+			case 'int':
+			case 'integer':
+			case 'real':
+			case 'resource':
+			case 'resource (closed)':
+			case 'string':
+				return new SimpleType($typeName, $allowsNull);
+
+			default:
+				return new ObjectType(TypeName::fromQualifiedName($typeName), $allowsNull);
+		}
+	}
+
+	public function asString(): string
+	{
+		return ($this->allowsNull() ? '?' : '') . $this->name();
+	}
+
+	/**
+	 * @psalm-assert-if-true CallableType $this
+	 */
+	public function isCallable(): bool
+	{
+		return false;
+	}
+
+	/**
+	 * @psalm-assert-if-true TrueType $this
+	 */
+	public function isTrue(): bool
+	{
+		return false;
+	}
+
+	/**
+	 * @psalm-assert-if-true FalseType $this
+	 */
+	public function isFalse(): bool
+	{
+		return false;
+	}
+
+	/**
+	 * @psalm-assert-if-true GenericObjectType $this
+	 */
+	public function isGenericObject(): bool
+	{
+		return false;
+	}
+
+	/**
+	 * @psalm-assert-if-true IntersectionType $this
+	 */
+	public function isIntersection(): bool
+	{
+		return false;
+	}
+
+	/**
+	 * @psalm-assert-if-true IterableType $this
+	 */
+	public function isIterable(): bool
+	{
+		return false;
+	}
+
+	/**
+	 * @psalm-assert-if-true MixedType $this
+	 */
+	public function isMixed(): bool
+	{
+		return false;
+	}
+
+	/**
+	 * @psalm-assert-if-true NeverType $this
+	 */
+	public function isNever(): bool
+	{
+		return false;
+	}
+
+	/**
+	 * @psalm-assert-if-true NullType $this
+	 */
+	public function isNull(): bool
+	{
+		return false;
+	}
+
+	/**
+	 * @psalm-assert-if-true ObjectType $this
+	 */
+	public function isObject(): bool
+	{
+		return false;
+	}
+
+	/**
+	 * @psalm-assert-if-true SimpleType $this
+	 */
+	public function isSimple(): bool
+	{
+		return false;
+	}
+
+	/**
+	 * @psalm-assert-if-true StaticType $this
+	 */
+	public function isStatic(): bool
+	{
+		return false;
+	}
+
+	/**
+	 * @psalm-assert-if-true UnionType $this
+	 */
+	public function isUnion(): bool
+	{
+		return false;
+	}
+
+	/**
+	 * @psalm-assert-if-true UnknownType $this
+	 */
+	public function isUnknown(): bool
+	{
+		return false;
+	}
+
+	/**
+	 * @psalm-assert-if-true VoidType $this
+	 */
+	public function isVoid(): bool
+	{
+		return false;
+	}
+
+	abstract public function isAssignable(self $other): bool;
+
+	abstract public function name(): string;
+
+	abstract public function allowsNull(): bool;
 }

Spacing +1 added lines, -1 removed lines

@@ -95,7 +95,7 @@
 
     public function asString(): string
     {
-        return ($this->allowsNull() ? '?' : '') . $this->name();
+        return ($this->allowsNull() ? '?' : '').$this->name();
     }
 
     /**

vendor/sebastian/type/src/type/ObjectType.php

Indentation +47 added lines, -47 removed lines

@@ -14,61 +14,61 @@
 
 final class ObjectType extends Type
 {
-    /**
-     * @var TypeName
-     */
-    private $className;
+	/**
+	 * @var TypeName
+	 */
+	private $className;
 
-    /**
-     * @var bool
-     */
-    private $allowsNull;
+	/**
+	 * @var bool
+	 */
+	private $allowsNull;
 
-    public function __construct(TypeName $className, bool $allowsNull)
-    {
-        $this->className  = $className;
-        $this->allowsNull = $allowsNull;
-    }
+	public function __construct(TypeName $className, bool $allowsNull)
+	{
+		$this->className  = $className;
+		$this->allowsNull = $allowsNull;
+	}
 
-    public function isAssignable(Type $other): bool
-    {
-        if ($this->allowsNull && $other instanceof NullType) {
-            return true;
-        }
+	public function isAssignable(Type $other): bool
+	{
+		if ($this->allowsNull && $other instanceof NullType) {
+			return true;
+		}
 
-        if ($other instanceof self) {
-            if (0 === strcasecmp($this->className->qualifiedName(), $other->className->qualifiedName())) {
-                return true;
-            }
+		if ($other instanceof self) {
+			if (0 === strcasecmp($this->className->qualifiedName(), $other->className->qualifiedName())) {
+				return true;
+			}
 
-            if (is_subclass_of($other->className->qualifiedName(), $this->className->qualifiedName(), true)) {
-                return true;
-            }
-        }
+			if (is_subclass_of($other->className->qualifiedName(), $this->className->qualifiedName(), true)) {
+				return true;
+			}
+		}
 
-        return false;
-    }
+		return false;
+	}
 
-    public function name(): string
-    {
-        return $this->className->qualifiedName();
-    }
+	public function name(): string
+	{
+		return $this->className->qualifiedName();
+	}
 
-    public function allowsNull(): bool
-    {
-        return $this->allowsNull;
-    }
+	public function allowsNull(): bool
+	{
+		return $this->allowsNull;
+	}
 
-    public function className(): TypeName
-    {
-        return $this->className;
-    }
+	public function className(): TypeName
+	{
+		return $this->className;
+	}
 
-    /**
-     * @psalm-assert-if-true ObjectType $this
-     */
-    public function isObject(): bool
-    {
-        return true;
-    }
+	/**
+	 * @psalm-assert-if-true ObjectType $this
+	 */
+	public function isObject(): bool
+	{
+		return true;
+	}
 }