gravityview / GravityView

vendor/phpdocumentor/type-resolver/src/PseudoTypes/IntegerRange.php

Indentation +34 added lines, -34 removed lines

@@ -24,38 +24,38 @@
  */
 final class IntegerRange extends Integer implements PseudoType
 {
-    /** @var string */
-    private $minValue;
-
-    /** @var string */
-    private $maxValue;
-
-    public function __construct(string $minValue, string $maxValue)
-    {
-        $this->minValue = $minValue;
-        $this->maxValue = $maxValue;
-    }
-
-    public function underlyingType(): Type
-    {
-        return new Integer();
-    }
-
-    public function getMinValue(): string
-    {
-        return $this->minValue;
-    }
-
-    public function getMaxValue(): string
-    {
-        return $this->maxValue;
-    }
-
-    /**
-     * Returns a rendered output of the Type as it would be used in a DocBlock.
-     */
-    public function __toString(): string
-    {
-        return 'int<' . $this->minValue . ', ' . $this->maxValue . '>';
-    }
+	/** @var string */
+	private $minValue;
+
+	/** @var string */
+	private $maxValue;
+
+	public function __construct(string $minValue, string $maxValue)
+	{
+		$this->minValue = $minValue;
+		$this->maxValue = $maxValue;
+	}
+
+	public function underlyingType(): Type
+	{
+		return new Integer();
+	}
+
+	public function getMinValue(): string
+	{
+		return $this->minValue;
+	}
+
+	public function getMaxValue(): string
+	{
+		return $this->maxValue;
+	}
+
+	/**
+	 * Returns a rendered output of the Type as it would be used in a DocBlock.
+	 */
+	public function __toString(): string
+	{
+		return 'int<' . $this->minValue . ', ' . $this->maxValue . '>';
+	}
 }

vendor/phpdocumentor/type-resolver/src/PseudoTypes/List_.php

Indentation +21 added lines, -21 removed lines

@@ -26,25 +26,25 @@
  */
 final class List_ extends Array_ implements PseudoType
 {
-    public function underlyingType(): Type
-    {
-        return new Array_();
-    }
-
-    public function __construct(?Type $valueType = null)
-    {
-        parent::__construct($valueType, new Integer());
-    }
-
-    /**
-     * Returns a rendered output of the Type as it would be used in a DocBlock.
-     */
-    public function __toString(): string
-    {
-        if ($this->valueType instanceof Mixed_) {
-            return 'list';
-        }
-
-        return 'list<' . $this->valueType . '>';
-    }
+	public function underlyingType(): Type
+	{
+		return new Array_();
+	}
+
+	public function __construct(?Type $valueType = null)
+	{
+		parent::__construct($valueType, new Integer());
+	}
+
+	/**
+	 * Returns a rendered output of the Type as it would be used in a DocBlock.
+	 */
+	public function __toString(): string
+	{
+		if ($this->valueType instanceof Mixed_) {
+			return 'list';
+		}
+
+		return 'list<' . $this->valueType . '>';
+	}
 }

vendor/doctrine/inflector/lib/Doctrine/Common/Inflector/Inflector.php

Indentation +209 added lines, -209 removed lines

@@ -44,241 +44,241 @@
  */
 class Inflector
 {
-    /**
-     * @var LanguageInflectorFactory|null
-     */
-    private static $factory;
+	/**
+	 * @var LanguageInflectorFactory|null
+	 */
+	private static $factory;
 
-    /** @var InflectorObject|null */
-    private static $instance;
+	/** @var InflectorObject|null */
+	private static $instance;
 
-    private static function getInstance() : InflectorObject
-    {
-        if (self::$factory === null) {
-            self::$factory = self::createFactory();
-        }
+	private static function getInstance() : InflectorObject
+	{
+		if (self::$factory === null) {
+			self::$factory = self::createFactory();
+		}
 
-        if (self::$instance === null) {
-            self::$instance = self::$factory->build();
-        }
+		if (self::$instance === null) {
+			self::$instance = self::$factory->build();
+		}
 
-        return self::$instance;
-    }
+		return self::$instance;
+	}
 
-    private static function createFactory() : LanguageInflectorFactory
-    {
-        return InflectorFactory::create();
-    }
+	private static function createFactory() : LanguageInflectorFactory
+	{
+		return InflectorFactory::create();
+	}
 
-    /**
-     * Converts a word into the format for a Doctrine table name. Converts 'ModelName' to 'model_name'.
-     *
-     * @deprecated
-     */
-    public static function tableize(string $word) : string
-    {
-        @trigger_error(sprintf('The "%s" method is deprecated and will be dropped in doctrine/inflector 2.0. Please update to the new Inflector API.', __METHOD__), E_USER_DEPRECATED);
+	/**
+	 * Converts a word into the format for a Doctrine table name. Converts 'ModelName' to 'model_name'.
+	 *
+	 * @deprecated
+	 */
+	public static function tableize(string $word) : string
+	{
+		@trigger_error(sprintf('The "%s" method is deprecated and will be dropped in doctrine/inflector 2.0. Please update to the new Inflector API.', __METHOD__), E_USER_DEPRECATED);
 
-        return self::getInstance()->tableize($word);
-    }
+		return self::getInstance()->tableize($word);
+	}
 
-    /**
-     * Converts a word into the format for a Doctrine class name. Converts 'table_name' to 'TableName'.
-     */
-    public static function classify(string $word) : string
-    {
-        @trigger_error(sprintf('The "%s" method is deprecated and will be dropped in doctrine/inflector 2.0. Please update to the new Inflector API.', __METHOD__), E_USER_DEPRECATED);
+	/**
+	 * Converts a word into the format for a Doctrine class name. Converts 'table_name' to 'TableName'.
+	 */
+	public static function classify(string $word) : string
+	{
+		@trigger_error(sprintf('The "%s" method is deprecated and will be dropped in doctrine/inflector 2.0. Please update to the new Inflector API.', __METHOD__), E_USER_DEPRECATED);
 
-        return self::getInstance()->classify($word);
-    }
+		return self::getInstance()->classify($word);
+	}
 
-    /**
-     * Camelizes a word. This uses the classify() method and turns the first character to lowercase.
-     *
-     * @deprecated
-     */
-    public static function camelize(string $word) : string
-    {
-        @trigger_error(sprintf('The "%s" method is deprecated and will be dropped in doctrine/inflector 2.0. Please update to the new Inflector API.', __METHOD__), E_USER_DEPRECATED);
+	/**
+	 * Camelizes a word. This uses the classify() method and turns the first character to lowercase.
+	 *
+	 * @deprecated
+	 */
+	public static function camelize(string $word) : string
+	{
+		@trigger_error(sprintf('The "%s" method is deprecated and will be dropped in doctrine/inflector 2.0. Please update to the new Inflector API.', __METHOD__), E_USER_DEPRECATED);
 
-        return self::getInstance()->camelize($word);
-    }
+		return self::getInstance()->camelize($word);
+	}
 
-    /**
-     * Uppercases words with configurable delimiters between words.
-     *
-     * Takes a string and capitalizes all of the words, like PHP's built-in
-     * ucwords function. This extends that behavior, however, by allowing the
-     * word delimiters to be configured, rather than only separating on
-     * whitespace.
-     *
-     * Here is an example:
-     * <code>
-     * <?php
-     * $string = 'top-o-the-morning to all_of_you!';
-     * echo \Doctrine\Common\Inflector\Inflector::ucwords($string);
-     * // Top-O-The-Morning To All_of_you!
-     *
-     * echo \Doctrine\Common\Inflector\Inflector::ucwords($string, '-_ ');
-     * // Top-O-The-Morning To All_Of_You!
-     * ?>
-     * </code>
-     *
-     * @param string $string The string to operate on.
-     * @param string $delimiters A list of word separators.
-     *
-     * @return string The string with all delimiter-separated words capitalized.
-     *
-     * @deprecated
-     */
-    public static function ucwords(string $string, string $delimiters = " \n\t\r\0\x0B-") : string
-    {
-        @trigger_error(sprintf('The "%s" method is deprecated and will be dropped in doctrine/inflector 2.0. Please use the "ucwords" function instead.', __METHOD__), E_USER_DEPRECATED);
+	/**
+	 * Uppercases words with configurable delimiters between words.
+	 *
+	 * Takes a string and capitalizes all of the words, like PHP's built-in
+	 * ucwords function. This extends that behavior, however, by allowing the
+	 * word delimiters to be configured, rather than only separating on
+	 * whitespace.
+	 *
+	 * Here is an example:
+	 * <code>
+	 * <?php
+	 * $string = 'top-o-the-morning to all_of_you!';
+	 * echo \Doctrine\Common\Inflector\Inflector::ucwords($string);
+	 * // Top-O-The-Morning To All_of_you!
+	 *
+	 * echo \Doctrine\Common\Inflector\Inflector::ucwords($string, '-_ ');
+	 * // Top-O-The-Morning To All_Of_You!
+	 * ?>
+	 * </code>
+	 *
+	 * @param string $string The string to operate on.
+	 * @param string $delimiters A list of word separators.
+	 *
+	 * @return string The string with all delimiter-separated words capitalized.
+	 *
+	 * @deprecated
+	 */
+	public static function ucwords(string $string, string $delimiters = " \n\t\r\0\x0B-") : string
+	{
+		@trigger_error(sprintf('The "%s" method is deprecated and will be dropped in doctrine/inflector 2.0. Please use the "ucwords" function instead.', __METHOD__), E_USER_DEPRECATED);
 
-        return ucwords($string, $delimiters);
-    }
+		return ucwords($string, $delimiters);
+	}
 
-    /**
-     * Clears Inflectors inflected value caches, and resets the inflection
-     * rules to the initial values.
-     *
-     * @deprecated
-     */
-    public static function reset() : void
-    {
-        @trigger_error(sprintf('The "%s" method is deprecated and will be dropped in doctrine/inflector 2.0. Please update to the new Inflector API.', __METHOD__), E_USER_DEPRECATED);
+	/**
+	 * Clears Inflectors inflected value caches, and resets the inflection
+	 * rules to the initial values.
+	 *
+	 * @deprecated
+	 */
+	public static function reset() : void
+	{
+		@trigger_error(sprintf('The "%s" method is deprecated and will be dropped in doctrine/inflector 2.0. Please update to the new Inflector API.', __METHOD__), E_USER_DEPRECATED);
 
-        self::$factory = null;
-        self::$instance = null;
-    }
+		self::$factory = null;
+		self::$instance = null;
+	}
 
-    /**
-     * Adds custom inflection $rules, of either 'plural' or 'singular' $type.
-     *
-     * ### Usage:
-     *
-     * {{{
-     * Inflector::rules('plural', array('/^(inflect)or$/i' => '\1ables'));
-     * Inflector::rules('plural', array(
-     *     'rules' => array('/^(inflect)ors$/i' => '\1ables'),
-     *     'uninflected' => array('dontinflectme'),
-     *     'irregular' => array('red' => 'redlings')
-     * ));
-     * }}}
-     *
-     * @param string  $type         The type of inflection, either 'plural' or 'singular'
-     * @param array<string,mixed>|iterable<string,mixed> $rules An array of rules to be added.
-     * @param boolean $reset        If true, will unset default inflections for all
-     *                              new rules that are being defined in $rules.
-     *
-     * @return void
-     *
-     * @deprecated
-     */
-    public static function rules(string $type, iterable $rules, bool $reset = false) : void
-    {
-        @trigger_error(sprintf('The "%s" method is deprecated and will be dropped in doctrine/inflector 2.0. Please update to the new Inflector API.', __METHOD__), E_USER_DEPRECATED);
+	/**
+	 * Adds custom inflection $rules, of either 'plural' or 'singular' $type.
+	 *
+	 * ### Usage:
+	 *
+	 * {{{
+	 * Inflector::rules('plural', array('/^(inflect)or$/i' => '\1ables'));
+	 * Inflector::rules('plural', array(
+	 *     'rules' => array('/^(inflect)ors$/i' => '\1ables'),
+	 *     'uninflected' => array('dontinflectme'),
+	 *     'irregular' => array('red' => 'redlings')
+	 * ));
+	 * }}}
+	 *
+	 * @param string  $type         The type of inflection, either 'plural' or 'singular'
+	 * @param array<string,mixed>|iterable<string,mixed> $rules An array of rules to be added.
+	 * @param boolean $reset        If true, will unset default inflections for all
+	 *                              new rules that are being defined in $rules.
+	 *
+	 * @return void
+	 *
+	 * @deprecated
+	 */
+	public static function rules(string $type, iterable $rules, bool $reset = false) : void
+	{
+		@trigger_error(sprintf('The "%s" method is deprecated and will be dropped in doctrine/inflector 2.0. Please update to the new Inflector API.', __METHOD__), E_USER_DEPRECATED);
 
-        if (self::$factory === null) {
-            self::$factory = self::createFactory();
-        }
+		if (self::$factory === null) {
+			self::$factory = self::createFactory();
+		}
 
-        self::$instance = null;
+		self::$instance = null;
 
-        switch ($type) {
-            case 'singular':
-                self::$factory->withSingularRules(self::buildRuleset($rules), $reset);
-                break;
-            case 'plural':
-                self::$factory->withPluralRules(self::buildRuleset($rules), $reset);
-                break;
-            default:
-                throw new InvalidArgumentException(sprintf('Cannot define custom inflection rules for type "%s".', $type));
-        }
-    }
+		switch ($type) {
+			case 'singular':
+				self::$factory->withSingularRules(self::buildRuleset($rules), $reset);
+				break;
+			case 'plural':
+				self::$factory->withPluralRules(self::buildRuleset($rules), $reset);
+				break;
+			default:
+				throw new InvalidArgumentException(sprintf('Cannot define custom inflection rules for type "%s".', $type));
+		}
+	}
 
-    /**
-      * @param array<string,mixed>|iterable<string,mixed> $rules An array of rules to be added.
-      */
-    private static function buildRuleset(iterable $rules) : Ruleset
-    {
-        $regular = [];
-        $irregular = [];
-        $uninflected = [];
+	/**
+	 * @param array<string,mixed>|iterable<string,mixed> $rules An array of rules to be added.
+	 */
+	private static function buildRuleset(iterable $rules) : Ruleset
+	{
+		$regular = [];
+		$irregular = [];
+		$uninflected = [];
 
-        foreach ($rules as $rule => $pattern) {
-            if ( ! is_array($pattern)) {
-                $regular[$rule] = $pattern;
+		foreach ($rules as $rule => $pattern) {
+			if ( ! is_array($pattern)) {
+				$regular[$rule] = $pattern;
 
-                continue;
-            }
+				continue;
+			}
 
-            switch ($rule) {
-                case 'uninflected':
-                    $uninflected = $pattern;
-                    break;
-                case 'irregular':
-                    $irregular = $pattern;
-                    break;
-                case 'rules':
-                    $regular = $pattern;
-                    break;
-            }
-        }
+			switch ($rule) {
+				case 'uninflected':
+					$uninflected = $pattern;
+					break;
+				case 'irregular':
+					$irregular = $pattern;
+					break;
+				case 'rules':
+					$regular = $pattern;
+					break;
+			}
+		}
 
-        return new Ruleset(
-            new Transformations(...array_map(
-                static function (string $pattern, string $replacement) : Transformation {
-                    return new Transformation(new Pattern($pattern), $replacement);
-                },
-                array_keys($regular),
-                array_values($regular)
-            )),
-            new Patterns(...array_map(
-                static function (string $pattern) : Pattern {
-                    return new Pattern($pattern);
-                },
-                $uninflected
-            )),
-            new Substitutions(...array_map(
-                static function (string $word, string $to) : Substitution {
-                    return new Substitution(new Word($word), new Word($to));
-                },
-                array_keys($irregular),
-                array_values($irregular)
-            ))
-        );
-    }
+		return new Ruleset(
+			new Transformations(...array_map(
+				static function (string $pattern, string $replacement) : Transformation {
+					return new Transformation(new Pattern($pattern), $replacement);
+				},
+				array_keys($regular),
+				array_values($regular)
+			)),
+			new Patterns(...array_map(
+				static function (string $pattern) : Pattern {
+					return new Pattern($pattern);
+				},
+				$uninflected
+			)),
+			new Substitutions(...array_map(
+				static function (string $word, string $to) : Substitution {
+					return new Substitution(new Word($word), new Word($to));
+				},
+				array_keys($irregular),
+				array_values($irregular)
+			))
+		);
+	}
 
-    /**
-     * Returns a word in plural form.
-     *
-     * @param string $word The word in singular form.
-     *
-     * @return string The word in plural form.
-     *
-     * @deprecated
-     */
-    public static function pluralize(string $word) : string
-    {
-        @trigger_error(sprintf('The "%s" method is deprecated and will be dropped in doctrine/inflector 2.0. Please update to the new Inflector API.', __METHOD__), E_USER_DEPRECATED);
+	/**
+	 * Returns a word in plural form.
+	 *
+	 * @param string $word The word in singular form.
+	 *
+	 * @return string The word in plural form.
+	 *
+	 * @deprecated
+	 */
+	public static function pluralize(string $word) : string
+	{
+		@trigger_error(sprintf('The "%s" method is deprecated and will be dropped in doctrine/inflector 2.0. Please update to the new Inflector API.', __METHOD__), E_USER_DEPRECATED);
 
-        return self::getInstance()->pluralize($word);
-    }
+		return self::getInstance()->pluralize($word);
+	}
 
-    /**
-     * Returns a word in singular form.
-     *
-     * @param string $word The word in plural form.
-     *
-     * @return string The word in singular form.
-     *
-     * @deprecated
-     */
-    public static function singularize(string $word) : string
-    {
-        @trigger_error(sprintf('The "%s" method is deprecated and will be dropped in doctrine/inflector 2.0. Please update to the new Inflector API.', __METHOD__), E_USER_DEPRECATED);
+	/**
+	 * Returns a word in singular form.
+	 *
+	 * @param string $word The word in plural form.
+	 *
+	 * @return string The word in singular form.
+	 *
+	 * @deprecated
+	 */
+	public static function singularize(string $word) : string
+	{
+		@trigger_error(sprintf('The "%s" method is deprecated and will be dropped in doctrine/inflector 2.0. Please update to the new Inflector API.', __METHOD__), E_USER_DEPRECATED);
 
-        return self::getInstance()->singularize($word);
-    }
+		return self::getInstance()->singularize($word);
+	}
 }

vendor/composer/composer/src/Composer/DependencyResolver/PoolOptimizer.php

Indentation +420 added lines, -420 removed lines

@@ -28,424 +28,424 @@
  */
 class PoolOptimizer
 {
-    /**
-     * @var PolicyInterface
-     */
-    private $policy;
-
-    /**
-     * @var array<int, true>
-     */
-    private $irremovablePackages = array();
-
-    /**
-     * @var array<string, array<string, ConstraintInterface>>
-     */
-    private $requireConstraintsPerPackage = array();
-
-    /**
-     * @var array<string, array<string, ConstraintInterface>>
-     */
-    private $conflictConstraintsPerPackage = array();
-
-    /**
-     * @var array<int, true>
-     */
-    private $packagesToRemove = array();
-
-    /**
-     * @var array<int, BasePackage[]>
-     */
-    private $aliasesPerPackage = array();
-
-    /**
-     * @var array<string, array<string, string>>
-     */
-    private $removedVersionsByPackage = array();
-
-    public function __construct(PolicyInterface $policy)
-    {
-        $this->policy = $policy;
-    }
-
-    /**
-     * @return Pool
-     */
-    public function optimize(Request $request, Pool $pool)
-    {
-        $this->prepare($request, $pool);
-
-        $this->optimizeByIdenticalDependencies($request, $pool);
-
-        $this->optimizeImpossiblePackagesAway($request, $pool);
-
-        $optimizedPool = $this->applyRemovalsToPool($pool);
-
-        // No need to run this recursively at the moment
-        // because the current optimizations cannot provide
-        // even more gains when ran again. Might change
-        // in the future with additional optimizations.
-
-        $this->irremovablePackages = array();
-        $this->requireConstraintsPerPackage = array();
-        $this->conflictConstraintsPerPackage = array();
-        $this->packagesToRemove = array();
-        $this->aliasesPerPackage = array();
-        $this->removedVersionsByPackage = array();
-
-        return $optimizedPool;
-    }
-
-    /**
-     * @return void
-     */
-    private function prepare(Request $request, Pool $pool)
-    {
-        $irremovablePackageConstraintGroups = array();
-
-        // Mark fixed or locked packages as irremovable
-        foreach ($request->getFixedOrLockedPackages() as $package) {
-            $irremovablePackageConstraintGroups[$package->getName()][] = new Constraint('==', $package->getVersion());
-        }
-
-        // Extract requested package requirements
-        foreach ($request->getRequires() as $require => $constraint) {
-            $constraint = Intervals::compactConstraint($constraint);
-            $this->requireConstraintsPerPackage[$require][(string) $constraint] = $constraint;
-        }
-
-        // First pass over all packages to extract information and mark package constraints irremovable
-        foreach ($pool->getPackages() as $package) {
-            // Extract package requirements
-            foreach ($package->getRequires() as $link) {
-                $constraint = Intervals::compactConstraint($link->getConstraint());
-                $this->requireConstraintsPerPackage[$link->getTarget()][(string) $constraint] = $constraint;
-            }
-            // Extract package conflicts
-            foreach ($package->getConflicts() as $link) {
-                $constraint = Intervals::compactConstraint($link->getConstraint());
-                $this->conflictConstraintsPerPackage[$link->getTarget()][(string) $constraint] = $constraint;
-            }
-
-            // Keep track of alias packages for every package so if either the alias or aliased is kept
-            // we keep the others as they are a unit of packages really
-            if ($package instanceof AliasPackage) {
-                $this->aliasesPerPackage[$package->getAliasOf()->id][] = $package;
-            }
-        }
-
-        $irremovablePackageConstraints = array();
-        foreach ($irremovablePackageConstraintGroups as $packageName => $constraints) {
-            $irremovablePackageConstraints[$packageName] = 1 === \count($constraints) ? $constraints[0] : new MultiConstraint($constraints, false);
-        }
-        unset($irremovablePackageConstraintGroups);
-
-        // Mark the packages as irremovable based on the constraints
-        foreach ($pool->getPackages() as $package) {
-            if (!isset($irremovablePackageConstraints[$package->getName()])) {
-                continue;
-            }
-
-            if (CompilingMatcher::match($irremovablePackageConstraints[$package->getName()], Constraint::OP_EQ, $package->getVersion())) {
-                $this->markPackageIrremovable($package);
-            }
-        }
-    }
-
-    /**
-     * @return void
-     */
-    private function markPackageIrremovable(BasePackage $package)
-    {
-        $this->irremovablePackages[$package->id] = true;
-        if ($package instanceof AliasPackage) {
-            // recursing here so aliasesPerPackage for the aliasOf can be checked
-            // and all its aliases marked as irremovable as well
-            $this->markPackageIrremovable($package->getAliasOf());
-        }
-        if (isset($this->aliasesPerPackage[$package->id])) {
-            foreach ($this->aliasesPerPackage[$package->id] as $aliasPackage) {
-                $this->irremovablePackages[$aliasPackage->id] = true;
-            }
-        }
-    }
-
-    /**
-     * @return Pool Optimized pool
-     */
-    private function applyRemovalsToPool(Pool $pool)
-    {
-        $packages = array();
-        $removedVersions = array();
-        foreach ($pool->getPackages() as $package) {
-            if (!isset($this->packagesToRemove[$package->id])) {
-                $packages[] = $package;
-            } else {
-                $removedVersions[$package->getName()][$package->getVersion()] = $package->getPrettyVersion();
-            }
-        }
-
-        $optimizedPool = new Pool($packages, $pool->getUnacceptableFixedOrLockedPackages(), $removedVersions, $this->removedVersionsByPackage);
-
-        return $optimizedPool;
-    }
-
-    /**
-     * @return void
-     */
-    private function optimizeByIdenticalDependencies(Request $request, Pool $pool)
-    {
-        $identicalDefinitionsPerPackage = array();
-        $packageIdenticalDefinitionLookup = array();
-
-        foreach ($pool->getPackages() as $package) {
-
-            // If that package was already marked irremovable, we can skip
-            // the entire process for it
-            if (isset($this->irremovablePackages[$package->id])) {
-                continue;
-            }
-
-            $this->markPackageForRemoval($package->id);
-
-            $dependencyHash = $this->calculateDependencyHash($package);
-
-            foreach ($package->getNames(false) as $packageName) {
-
-                if (!isset($this->requireConstraintsPerPackage[$packageName])) {
-                    continue;
-                }
-
-                foreach ($this->requireConstraintsPerPackage[$packageName] as $requireConstraint) {
-                    $groupHashParts = array();
-
-                    if (CompilingMatcher::match($requireConstraint, Constraint::OP_EQ, $package->getVersion())) {
-                        $groupHashParts[] = 'require:' . (string) $requireConstraint;
-                    }
-
-                    if ($package->getReplaces()) {
-                        foreach ($package->getReplaces() as $link) {
-                            if (CompilingMatcher::match($link->getConstraint(), Constraint::OP_EQ, $package->getVersion())) {
-                                // Use the same hash part as the regular require hash because that's what the replacement does
-                                $groupHashParts[] = 'require:' . (string) $link->getConstraint();
-                            }
-                        }
-                    }
-
-                    if (isset($this->conflictConstraintsPerPackage[$packageName])) {
-                        foreach ($this->conflictConstraintsPerPackage[$packageName] as $conflictConstraint) {
-                            if (CompilingMatcher::match($conflictConstraint, Constraint::OP_EQ, $package->getVersion())) {
-                                $groupHashParts[] = 'conflict:' . (string) $conflictConstraint;
-                            }
-                        }
-                    }
-
-                    if (!$groupHashParts) {
-                        continue;
-                    }
-
-                    $groupHash = implode('', $groupHashParts);
-                    $identicalDefinitionsPerPackage[$packageName][$groupHash][$dependencyHash][] = $package;
-                    $packageIdenticalDefinitionLookup[$package->id][$packageName] = array('groupHash' => $groupHash, 'dependencyHash' => $dependencyHash);
-                }
-            }
-        }
-
-        foreach ($identicalDefinitionsPerPackage as $constraintGroups) {
-            foreach ($constraintGroups as $constraintGroup) {
-                foreach ($constraintGroup as $packages) {
-                    // Only one package in this constraint group has the same requirements, we're not allowed to remove that package
-                    if (1 === \count($packages)) {
-                        $this->keepPackage($packages[0], $identicalDefinitionsPerPackage, $packageIdenticalDefinitionLookup);
-                        continue;
-                    }
-
-                    // Otherwise we find out which one is the preferred package in this constraint group which is
-                    // then not allowed to be removed either
-                    $literals = array();
-
-                    foreach ($packages as $package) {
-                        $literals[] = $package->id;
-                    }
-
-                    foreach ($this->policy->selectPreferredPackages($pool, $literals) as $preferredLiteral) {
-                        $this->keepPackage($pool->literalToPackage($preferredLiteral), $identicalDefinitionsPerPackage, $packageIdenticalDefinitionLookup);
-                    }
-                }
-            }
-        }
-    }
-
-    /**
-     * @return string
-     */
-    private function calculateDependencyHash(BasePackage $package)
-    {
-        $hash = '';
-
-        $hashRelevantLinks = array(
-            'requires' => $package->getRequires(),
-            'conflicts' => $package->getConflicts(),
-            'replaces' => $package->getReplaces(),
-            'provides' => $package->getProvides()
-        );
-
-        foreach ($hashRelevantLinks as $key => $links) {
-            if (0 === \count($links)) {
-                continue;
-            }
-
-            // start new hash section
-            $hash .= $key . ':';
-
-            $subhash = array();
-
-            foreach ($links as $link) {
-                // To get the best dependency hash matches we should use Intervals::compactConstraint() here.
-                // However, the majority of projects are going to specify their constraints already pretty
-                // much in the best variant possible. In other words, we'd be wasting time here and it would actually hurt
-                // performance more than the additional few packages that could be filtered out would benefit the process.
-                $subhash[$link->getTarget()] = (string) $link->getConstraint();
-            }
-
-            // Sort for best result
-            ksort($subhash);
-
-            foreach ($subhash as $target => $constraint) {
-                $hash .= $target . '@' . $constraint;
-            }
-        }
-
-        return $hash;
-    }
-
-    /**
-     * @param int $id
-     * @return void
-     */
-    private function markPackageForRemoval($id)
-    {
-        // We are not allowed to remove packages if they have been marked as irremovable
-        if (isset($this->irremovablePackages[$id])) {
-            throw new \LogicException('Attempted removing a package which was previously marked irremovable');
-        }
-
-        $this->packagesToRemove[$id] = true;
-    }
-
-    /**
-     * @param array<string, array<string, array<string, list<BasePackage>>>> $identicalDefinitionsPerPackage
-     * @param array<int, array<string, array{groupHash: string, dependencyHash: string}>> $packageIdenticalDefinitionLookup
-     * @return void
-     */
-    private function keepPackage(BasePackage $package, $identicalDefinitionsPerPackage, $packageIdenticalDefinitionLookup)
-    {
-        unset($this->packagesToRemove[$package->id]);
-
-        if ($package instanceof AliasPackage) {
-            // recursing here so aliasesPerPackage for the aliasOf can be checked
-            // and all its aliases marked to be kept as well
-            $this->keepPackage($package->getAliasOf(), $identicalDefinitionsPerPackage, $packageIdenticalDefinitionLookup);
-        }
-
-        // record all the versions of the package group so we can list them later in Problem output
-        foreach ($package->getNames(false) as $name) {
-            if (isset($packageIdenticalDefinitionLookup[$package->id][$name])) {
-                $packageGroupPointers = $packageIdenticalDefinitionLookup[$package->id][$name];
-                $packageGroup = $identicalDefinitionsPerPackage[$name][$packageGroupPointers['groupHash']][$packageGroupPointers['dependencyHash']];
-                foreach ($packageGroup as $pkg) {
-                    if ($pkg instanceof AliasPackage && $pkg->getPrettyVersion() === VersionParser::DEFAULT_BRANCH_ALIAS) {
-                        $pkg = $pkg->getAliasOf();
-                    }
-                    $this->removedVersionsByPackage[spl_object_hash($package)][$pkg->getVersion()] = $pkg->getPrettyVersion();
-                }
-            }
-        }
-
-        if (isset($this->aliasesPerPackage[$package->id])) {
-            foreach ($this->aliasesPerPackage[$package->id] as $aliasPackage) {
-                unset($this->packagesToRemove[$aliasPackage->id]);
-
-                // record all the versions of the package group so we can list them later in Problem output
-                foreach ($aliasPackage->getNames(false) as $name) {
-                    if (isset($packageIdenticalDefinitionLookup[$aliasPackage->id][$name])) {
-                        $packageGroupPointers = $packageIdenticalDefinitionLookup[$aliasPackage->id][$name];
-                        $packageGroup = $identicalDefinitionsPerPackage[$name][$packageGroupPointers['groupHash']][$packageGroupPointers['dependencyHash']];
-                        foreach ($packageGroup as $pkg) {
-                            if ($pkg instanceof AliasPackage && $pkg->getPrettyVersion() === VersionParser::DEFAULT_BRANCH_ALIAS) {
-                                $pkg = $pkg->getAliasOf();
-                            }
-                            $this->removedVersionsByPackage[spl_object_hash($aliasPackage)][$pkg->getVersion()] = $pkg->getPrettyVersion();
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    /**
-     * Use the list of locked packages to constrain the loaded packages
-     * This will reduce packages with significant numbers of historical versions to a smaller number
-     * and reduce the resulting rule set that is generated
-     *
-     * @return void
-     */
-    private function optimizeImpossiblePackagesAway(Request $request, Pool $pool)
-    {
-        if (count($request->getLockedPackages()) === 0) {
-            return;
-        }
-
-        $packageIndex = array();
-
-        foreach ($pool->getPackages() as $package) {
-            $id = $package->id;
-
-            // Do not remove irremovable packages
-            if (isset($this->irremovablePackages[$id])) {
-                continue;
-            }
-            // Do not remove a package aliased by another package, nor aliases
-            if (isset($this->aliasesPerPackage[$id]) || $package instanceof AliasPackage) {
-                continue;
-            }
-            // Do not remove locked packages
-            if ($request->isFixedPackage($package) || $request->isLockedPackage($package)) {
-                continue;
-            }
-
-            $packageIndex[$package->getName()][$package->id] = $package;
-        }
-
-        foreach ($request->getLockedPackages() as $package) {
-            // If this locked package is no longer required by root or anything in the pool, it may get uninstalled so do not apply its requirements
-            // In a case where a requirement WERE to appear in the pool by a package that would not be used, it would've been unlocked and so not filtered still
-            $isUnusedPackage = true;
-            foreach ($package->getNames(false) as $packageName) {
-                if (isset($this->requireConstraintsPerPackage[$packageName])) {
-                    $isUnusedPackage = false;
-                    break;
-                }
-            }
-
-            if ($isUnusedPackage) {
-                continue;
-            }
-
-            foreach ($package->getRequires() as $link) {
-                $require = $link->getTarget();
-                if (!isset($packageIndex[$require])) {
-                    continue;
-                }
-
-                $linkConstraint = $link->getConstraint();
-                foreach ($packageIndex[$require] as $id => $requiredPkg) {
-                    if (false === CompilingMatcher::match($linkConstraint, Constraint::OP_EQ, $requiredPkg->getVersion())) {
-                        $this->markPackageForRemoval($id);
-                        unset($packageIndex[$require][$id]);
-                    }
-                }
-            }
-        }
-    }
+	/**
+	 * @var PolicyInterface
+	 */
+	private $policy;
+
+	/**
+	 * @var array<int, true>
+	 */
+	private $irremovablePackages = array();
+
+	/**
+	 * @var array<string, array<string, ConstraintInterface>>
+	 */
+	private $requireConstraintsPerPackage = array();
+
+	/**
+	 * @var array<string, array<string, ConstraintInterface>>
+	 */
+	private $conflictConstraintsPerPackage = array();
+
+	/**
+	 * @var array<int, true>
+	 */
+	private $packagesToRemove = array();
+
+	/**
+	 * @var array<int, BasePackage[]>
+	 */
+	private $aliasesPerPackage = array();
+
+	/**
+	 * @var array<string, array<string, string>>
+	 */
+	private $removedVersionsByPackage = array();
+
+	public function __construct(PolicyInterface $policy)
+	{
+		$this->policy = $policy;
+	}
+
+	/**
+	 * @return Pool
+	 */
+	public function optimize(Request $request, Pool $pool)
+	{
+		$this->prepare($request, $pool);
+
+		$this->optimizeByIdenticalDependencies($request, $pool);
+
+		$this->optimizeImpossiblePackagesAway($request, $pool);
+
+		$optimizedPool = $this->applyRemovalsToPool($pool);
+
+		// No need to run this recursively at the moment
+		// because the current optimizations cannot provide
+		// even more gains when ran again. Might change
+		// in the future with additional optimizations.
+
+		$this->irremovablePackages = array();
+		$this->requireConstraintsPerPackage = array();
+		$this->conflictConstraintsPerPackage = array();
+		$this->packagesToRemove = array();
+		$this->aliasesPerPackage = array();
+		$this->removedVersionsByPackage = array();
+
+		return $optimizedPool;
+	}
+
+	/**
+	 * @return void
+	 */
+	private function prepare(Request $request, Pool $pool)
+	{
+		$irremovablePackageConstraintGroups = array();
+
+		// Mark fixed or locked packages as irremovable
+		foreach ($request->getFixedOrLockedPackages() as $package) {
+			$irremovablePackageConstraintGroups[$package->getName()][] = new Constraint('==', $package->getVersion());
+		}
+
+		// Extract requested package requirements
+		foreach ($request->getRequires() as $require => $constraint) {
+			$constraint = Intervals::compactConstraint($constraint);
+			$this->requireConstraintsPerPackage[$require][(string) $constraint] = $constraint;
+		}
+
+		// First pass over all packages to extract information and mark package constraints irremovable
+		foreach ($pool->getPackages() as $package) {
+			// Extract package requirements
+			foreach ($package->getRequires() as $link) {
+				$constraint = Intervals::compactConstraint($link->getConstraint());
+				$this->requireConstraintsPerPackage[$link->getTarget()][(string) $constraint] = $constraint;
+			}
+			// Extract package conflicts
+			foreach ($package->getConflicts() as $link) {
+				$constraint = Intervals::compactConstraint($link->getConstraint());
+				$this->conflictConstraintsPerPackage[$link->getTarget()][(string) $constraint] = $constraint;
+			}
+
+			// Keep track of alias packages for every package so if either the alias or aliased is kept
+			// we keep the others as they are a unit of packages really
+			if ($package instanceof AliasPackage) {
+				$this->aliasesPerPackage[$package->getAliasOf()->id][] = $package;
+			}
+		}
+
+		$irremovablePackageConstraints = array();
+		foreach ($irremovablePackageConstraintGroups as $packageName => $constraints) {
+			$irremovablePackageConstraints[$packageName] = 1 === \count($constraints) ? $constraints[0] : new MultiConstraint($constraints, false);
+		}
+		unset($irremovablePackageConstraintGroups);
+
+		// Mark the packages as irremovable based on the constraints
+		foreach ($pool->getPackages() as $package) {
+			if (!isset($irremovablePackageConstraints[$package->getName()])) {
+				continue;
+			}
+
+			if (CompilingMatcher::match($irremovablePackageConstraints[$package->getName()], Constraint::OP_EQ, $package->getVersion())) {
+				$this->markPackageIrremovable($package);
+			}
+		}
+	}
+
+	/**
+	 * @return void
+	 */
+	private function markPackageIrremovable(BasePackage $package)
+	{
+		$this->irremovablePackages[$package->id] = true;
+		if ($package instanceof AliasPackage) {
+			// recursing here so aliasesPerPackage for the aliasOf can be checked
+			// and all its aliases marked as irremovable as well
+			$this->markPackageIrremovable($package->getAliasOf());
+		}
+		if (isset($this->aliasesPerPackage[$package->id])) {
+			foreach ($this->aliasesPerPackage[$package->id] as $aliasPackage) {
+				$this->irremovablePackages[$aliasPackage->id] = true;
+			}
+		}
+	}
+
+	/**
+	 * @return Pool Optimized pool
+	 */
+	private function applyRemovalsToPool(Pool $pool)
+	{
+		$packages = array();
+		$removedVersions = array();
+		foreach ($pool->getPackages() as $package) {
+			if (!isset($this->packagesToRemove[$package->id])) {
+				$packages[] = $package;
+			} else {
+				$removedVersions[$package->getName()][$package->getVersion()] = $package->getPrettyVersion();
+			}
+		}
+
+		$optimizedPool = new Pool($packages, $pool->getUnacceptableFixedOrLockedPackages(), $removedVersions, $this->removedVersionsByPackage);
+
+		return $optimizedPool;
+	}
+
+	/**
+	 * @return void
+	 */
+	private function optimizeByIdenticalDependencies(Request $request, Pool $pool)
+	{
+		$identicalDefinitionsPerPackage = array();
+		$packageIdenticalDefinitionLookup = array();
+
+		foreach ($pool->getPackages() as $package) {
+
+			// If that package was already marked irremovable, we can skip
+			// the entire process for it
+			if (isset($this->irremovablePackages[$package->id])) {
+				continue;
+			}
+
+			$this->markPackageForRemoval($package->id);
+
+			$dependencyHash = $this->calculateDependencyHash($package);
+
+			foreach ($package->getNames(false) as $packageName) {
+
+				if (!isset($this->requireConstraintsPerPackage[$packageName])) {
+					continue;
+				}
+
+				foreach ($this->requireConstraintsPerPackage[$packageName] as $requireConstraint) {
+					$groupHashParts = array();
+
+					if (CompilingMatcher::match($requireConstraint, Constraint::OP_EQ, $package->getVersion())) {
+						$groupHashParts[] = 'require:' . (string) $requireConstraint;
+					}
+
+					if ($package->getReplaces()) {
+						foreach ($package->getReplaces() as $link) {
+							if (CompilingMatcher::match($link->getConstraint(), Constraint::OP_EQ, $package->getVersion())) {
+								// Use the same hash part as the regular require hash because that's what the replacement does
+								$groupHashParts[] = 'require:' . (string) $link->getConstraint();
+							}
+						}
+					}
+
+					if (isset($this->conflictConstraintsPerPackage[$packageName])) {
+						foreach ($this->conflictConstraintsPerPackage[$packageName] as $conflictConstraint) {
+							if (CompilingMatcher::match($conflictConstraint, Constraint::OP_EQ, $package->getVersion())) {
+								$groupHashParts[] = 'conflict:' . (string) $conflictConstraint;
+							}
+						}
+					}
+
+					if (!$groupHashParts) {
+						continue;
+					}
+
+					$groupHash = implode('', $groupHashParts);
+					$identicalDefinitionsPerPackage[$packageName][$groupHash][$dependencyHash][] = $package;
+					$packageIdenticalDefinitionLookup[$package->id][$packageName] = array('groupHash' => $groupHash, 'dependencyHash' => $dependencyHash);
+				}
+			}
+		}
+
+		foreach ($identicalDefinitionsPerPackage as $constraintGroups) {
+			foreach ($constraintGroups as $constraintGroup) {
+				foreach ($constraintGroup as $packages) {
+					// Only one package in this constraint group has the same requirements, we're not allowed to remove that package
+					if (1 === \count($packages)) {
+						$this->keepPackage($packages[0], $identicalDefinitionsPerPackage, $packageIdenticalDefinitionLookup);
+						continue;
+					}
+
+					// Otherwise we find out which one is the preferred package in this constraint group which is
+					// then not allowed to be removed either
+					$literals = array();
+
+					foreach ($packages as $package) {
+						$literals[] = $package->id;
+					}
+
+					foreach ($this->policy->selectPreferredPackages($pool, $literals) as $preferredLiteral) {
+						$this->keepPackage($pool->literalToPackage($preferredLiteral), $identicalDefinitionsPerPackage, $packageIdenticalDefinitionLookup);
+					}
+				}
+			}
+		}
+	}
+
+	/**
+	 * @return string
+	 */
+	private function calculateDependencyHash(BasePackage $package)
+	{
+		$hash = '';
+
+		$hashRelevantLinks = array(
+			'requires' => $package->getRequires(),
+			'conflicts' => $package->getConflicts(),
+			'replaces' => $package->getReplaces(),
+			'provides' => $package->getProvides()
+		);
+
+		foreach ($hashRelevantLinks as $key => $links) {
+			if (0 === \count($links)) {
+				continue;
+			}
+
+			// start new hash section
+			$hash .= $key . ':';
+
+			$subhash = array();
+
+			foreach ($links as $link) {
+				// To get the best dependency hash matches we should use Intervals::compactConstraint() here.
+				// However, the majority of projects are going to specify their constraints already pretty
+				// much in the best variant possible. In other words, we'd be wasting time here and it would actually hurt
+				// performance more than the additional few packages that could be filtered out would benefit the process.
+				$subhash[$link->getTarget()] = (string) $link->getConstraint();
+			}
+
+			// Sort for best result
+			ksort($subhash);
+
+			foreach ($subhash as $target => $constraint) {
+				$hash .= $target . '@' . $constraint;
+			}
+		}
+
+		return $hash;
+	}
+
+	/**
+	 * @param int $id
+	 * @return void
+	 */
+	private function markPackageForRemoval($id)
+	{
+		// We are not allowed to remove packages if they have been marked as irremovable
+		if (isset($this->irremovablePackages[$id])) {
+			throw new \LogicException('Attempted removing a package which was previously marked irremovable');
+		}
+
+		$this->packagesToRemove[$id] = true;
+	}
+
+	/**
+	 * @param array<string, array<string, array<string, list<BasePackage>>>> $identicalDefinitionsPerPackage
+	 * @param array<int, array<string, array{groupHash: string, dependencyHash: string}>> $packageIdenticalDefinitionLookup
+	 * @return void
+	 */
+	private function keepPackage(BasePackage $package, $identicalDefinitionsPerPackage, $packageIdenticalDefinitionLookup)
+	{
+		unset($this->packagesToRemove[$package->id]);
+
+		if ($package instanceof AliasPackage) {
+			// recursing here so aliasesPerPackage for the aliasOf can be checked
+			// and all its aliases marked to be kept as well
+			$this->keepPackage($package->getAliasOf(), $identicalDefinitionsPerPackage, $packageIdenticalDefinitionLookup);
+		}
+
+		// record all the versions of the package group so we can list them later in Problem output
+		foreach ($package->getNames(false) as $name) {
+			if (isset($packageIdenticalDefinitionLookup[$package->id][$name])) {
+				$packageGroupPointers = $packageIdenticalDefinitionLookup[$package->id][$name];
+				$packageGroup = $identicalDefinitionsPerPackage[$name][$packageGroupPointers['groupHash']][$packageGroupPointers['dependencyHash']];
+				foreach ($packageGroup as $pkg) {
+					if ($pkg instanceof AliasPackage && $pkg->getPrettyVersion() === VersionParser::DEFAULT_BRANCH_ALIAS) {
+						$pkg = $pkg->getAliasOf();
+					}
+					$this->removedVersionsByPackage[spl_object_hash($package)][$pkg->getVersion()] = $pkg->getPrettyVersion();
+				}
+			}
+		}
+
+		if (isset($this->aliasesPerPackage[$package->id])) {
+			foreach ($this->aliasesPerPackage[$package->id] as $aliasPackage) {
+				unset($this->packagesToRemove[$aliasPackage->id]);
+
+				// record all the versions of the package group so we can list them later in Problem output
+				foreach ($aliasPackage->getNames(false) as $name) {
+					if (isset($packageIdenticalDefinitionLookup[$aliasPackage->id][$name])) {
+						$packageGroupPointers = $packageIdenticalDefinitionLookup[$aliasPackage->id][$name];
+						$packageGroup = $identicalDefinitionsPerPackage[$name][$packageGroupPointers['groupHash']][$packageGroupPointers['dependencyHash']];
+						foreach ($packageGroup as $pkg) {
+							if ($pkg instanceof AliasPackage && $pkg->getPrettyVersion() === VersionParser::DEFAULT_BRANCH_ALIAS) {
+								$pkg = $pkg->getAliasOf();
+							}
+							$this->removedVersionsByPackage[spl_object_hash($aliasPackage)][$pkg->getVersion()] = $pkg->getPrettyVersion();
+						}
+					}
+				}
+			}
+		}
+	}
+
+	/**
+	 * Use the list of locked packages to constrain the loaded packages
+	 * This will reduce packages with significant numbers of historical versions to a smaller number
+	 * and reduce the resulting rule set that is generated
+	 *
+	 * @return void
+	 */
+	private function optimizeImpossiblePackagesAway(Request $request, Pool $pool)
+	{
+		if (count($request->getLockedPackages()) === 0) {
+			return;
+		}
+
+		$packageIndex = array();
+
+		foreach ($pool->getPackages() as $package) {
+			$id = $package->id;
+
+			// Do not remove irremovable packages
+			if (isset($this->irremovablePackages[$id])) {
+				continue;
+			}
+			// Do not remove a package aliased by another package, nor aliases
+			if (isset($this->aliasesPerPackage[$id]) || $package instanceof AliasPackage) {
+				continue;
+			}
+			// Do not remove locked packages
+			if ($request->isFixedPackage($package) || $request->isLockedPackage($package)) {
+				continue;
+			}
+
+			$packageIndex[$package->getName()][$package->id] = $package;
+		}
+
+		foreach ($request->getLockedPackages() as $package) {
+			// If this locked package is no longer required by root or anything in the pool, it may get uninstalled so do not apply its requirements
+			// In a case where a requirement WERE to appear in the pool by a package that would not be used, it would've been unlocked and so not filtered still
+			$isUnusedPackage = true;
+			foreach ($package->getNames(false) as $packageName) {
+				if (isset($this->requireConstraintsPerPackage[$packageName])) {
+					$isUnusedPackage = false;
+					break;
+				}
+			}
+
+			if ($isUnusedPackage) {
+				continue;
+			}
+
+			foreach ($package->getRequires() as $link) {
+				$require = $link->getTarget();
+				if (!isset($packageIndex[$require])) {
+					continue;
+				}
+
+				$linkConstraint = $link->getConstraint();
+				foreach ($packageIndex[$require] as $id => $requiredPkg) {
+					if (false === CompilingMatcher::match($linkConstraint, Constraint::OP_EQ, $requiredPkg->getVersion())) {
+						$this->markPackageForRemoval($id);
+						unset($packageIndex[$require][$id]);
+					}
+				}
+			}
+		}
+	}
 }

vendor/composer/composer/src/Composer/Filter/PlatformRequirementFilter/PlatformRequirementFilterInterface.php

Indentation +5 added lines, -5 removed lines

@@ -4,9 +4,9 @@
 
 interface PlatformRequirementFilterInterface
 {
-    /**
-     * @param string $req
-     * @return bool
-     */
-    public function isIgnored($req);
+	/**
+	 * @param string $req
+	 * @return bool
+	 */
+	public function isIgnored($req);
 }

vendor/composer/composer/src/Composer/Filter/PlatformRequirementFilter/IgnoreNothingPlatformRequirementFilter.php

Indentation +8 added lines, -8 removed lines

@@ -4,12 +4,12 @@
 
 final class IgnoreNothingPlatformRequirementFilter implements PlatformRequirementFilterInterface
 {
-    /**
-     * @param string $req
-     * @return false
-     */
-    public function isIgnored($req)
-    {
-        return false;
-    }
+	/**
+	 * @param string $req
+	 * @return false
+	 */
+	public function isIgnored($req)
+	{
+		return false;
+	}
 }

vendor/composer/composer/src/Composer/Filter/PlatformRequirementFilter/IgnoreAllPlatformRequirementFilter.php

Indentation +8 added lines, -8 removed lines

@@ -6,12 +6,12 @@
 
 final class IgnoreAllPlatformRequirementFilter implements PlatformRequirementFilterInterface
 {
-    /**
-     * @param string $req
-     * @return bool
-     */
-    public function isIgnored($req)
-    {
-        return PlatformRepository::isPlatformPackage($req);
-    }
+	/**
+	 * @param string $req
+	 * @return bool
+	 */
+	public function isIgnored($req)
+	{
+		return PlatformRepository::isPlatformPackage($req);
+	}
 }

vendor/composer/composer/src/Composer/Filter/PlatformRequirementFilter/PlatformRequirementFilterFactory.php

Indentation +34 added lines, -34 removed lines

@@ -4,42 +4,42 @@
 
 final class PlatformRequirementFilterFactory
 {
-    /**
-     * @param mixed $boolOrList
-     *
-     * @return PlatformRequirementFilterInterface
-     */
-    public static function fromBoolOrList($boolOrList)
-    {
-        if (is_bool($boolOrList)) {
-            return $boolOrList ? self::ignoreAll() : self::ignoreNothing();
-        }
+	/**
+	 * @param mixed $boolOrList
+	 *
+	 * @return PlatformRequirementFilterInterface
+	 */
+	public static function fromBoolOrList($boolOrList)
+	{
+		if (is_bool($boolOrList)) {
+			return $boolOrList ? self::ignoreAll() : self::ignoreNothing();
+		}
 
-        if (is_array($boolOrList)) {
-            return new IgnoreListPlatformRequirementFilter($boolOrList);
-        }
+		if (is_array($boolOrList)) {
+			return new IgnoreListPlatformRequirementFilter($boolOrList);
+		}
 
-        throw new \InvalidArgumentException(
-            sprintf(
-                'PlatformRequirementFilter: Unknown $boolOrList parameter %s. Please report at https://github.com/composer/composer/issues/new.',
-                gettype($boolOrList)
-            )
-        );
-    }
+		throw new \InvalidArgumentException(
+			sprintf(
+				'PlatformRequirementFilter: Unknown $boolOrList parameter %s. Please report at https://github.com/composer/composer/issues/new.',
+				gettype($boolOrList)
+			)
+		);
+	}
 
-    /**
-     * @return PlatformRequirementFilterInterface
-     */
-    public static function ignoreAll()
-    {
-        return new IgnoreAllPlatformRequirementFilter();
-    }
+	/**
+	 * @return PlatformRequirementFilterInterface
+	 */
+	public static function ignoreAll()
+	{
+		return new IgnoreAllPlatformRequirementFilter();
+	}
 
-    /**
-     * @return PlatformRequirementFilterInterface
-     */
-    public static function ignoreNothing()
-    {
-        return new IgnoreNothingPlatformRequirementFilter();
-    }
+	/**
+	 * @return PlatformRequirementFilterInterface
+	 */
+	public static function ignoreNothing()
+	{
+		return new IgnoreNothingPlatformRequirementFilter();
+	}
 }

vendor/composer/composer/src/Composer/Filter/PlatformRequirementFilter/IgnoreListPlatformRequirementFilter.php

Indentation +57 added lines, -57 removed lines

@@ -14,70 +14,70 @@
 
 final class IgnoreListPlatformRequirementFilter implements PlatformRequirementFilterInterface
 {
-    /**
-     * @var string
-     */
-    private $ignoreRegex;
+	/**
+	 * @var string
+	 */
+	private $ignoreRegex;
 
-    /**
-     * @var string
-     */
-    private $ignoreUpperBoundRegex;
+	/**
+	 * @var string
+	 */
+	private $ignoreUpperBoundRegex;
 
-    /**
-     * @param string[] $reqList
-     */
-    public function __construct(array $reqList)
-    {
-        $ignoreAll = $ignoreUpperBound = array();
-        foreach ($reqList as $req) {
-            if (substr($req, -1) === '+') {
-                $ignoreUpperBound[] = substr($req, 0, -1);
-            } else {
-                $ignoreAll[] = $req;
-            }
-        }
-        $this->ignoreRegex = BasePackage::packageNamesToRegexp($ignoreAll);
-        $this->ignoreUpperBoundRegex = BasePackage::packageNamesToRegexp($ignoreUpperBound);
-    }
+	/**
+	 * @param string[] $reqList
+	 */
+	public function __construct(array $reqList)
+	{
+		$ignoreAll = $ignoreUpperBound = array();
+		foreach ($reqList as $req) {
+			if (substr($req, -1) === '+') {
+				$ignoreUpperBound[] = substr($req, 0, -1);
+			} else {
+				$ignoreAll[] = $req;
+			}
+		}
+		$this->ignoreRegex = BasePackage::packageNamesToRegexp($ignoreAll);
+		$this->ignoreUpperBoundRegex = BasePackage::packageNamesToRegexp($ignoreUpperBound);
+	}
 
-    /**
-     * @param string $req
-     * @return bool
-     */
-    public function isIgnored($req)
-    {
-        if (!PlatformRepository::isPlatformPackage($req)) {
-            return false;
-        }
+	/**
+	 * @param string $req
+	 * @return bool
+	 */
+	public function isIgnored($req)
+	{
+		if (!PlatformRepository::isPlatformPackage($req)) {
+			return false;
+		}
 
-        return Preg::isMatch($this->ignoreRegex, $req);
-    }
+		return Preg::isMatch($this->ignoreRegex, $req);
+	}
 
-    /**
-     * @param string $req
-     * @return ConstraintInterface
-     */
-    public function filterConstraint($req, ConstraintInterface $constraint)
-    {
-        if (!PlatformRepository::isPlatformPackage($req)) {
-            return $constraint;
-        }
+	/**
+	 * @param string $req
+	 * @return ConstraintInterface
+	 */
+	public function filterConstraint($req, ConstraintInterface $constraint)
+	{
+		if (!PlatformRepository::isPlatformPackage($req)) {
+			return $constraint;
+		}
 
-        if (!Preg::isMatch($this->ignoreUpperBoundRegex, $req)) {
-            return $constraint;
-        }
+		if (!Preg::isMatch($this->ignoreUpperBoundRegex, $req)) {
+			return $constraint;
+		}
 
-        if (Preg::isMatch($this->ignoreRegex, $req)) {
-            return new MatchAllConstraint;
-        }
+		if (Preg::isMatch($this->ignoreRegex, $req)) {
+			return new MatchAllConstraint;
+		}
 
-        $intervals = Intervals::get($constraint);
-        $last = end($intervals['numeric']);
-        if ($last !== false && (string) $last->getEnd() !== (string) Interval::untilPositiveInfinity()) {
-            $constraint = new MultiConstraint(array($constraint, new Constraint('>=', $last->getEnd()->getVersion())), false);
-        }
+		$intervals = Intervals::get($constraint);
+		$last = end($intervals['numeric']);
+		if ($last !== false && (string) $last->getEnd() !== (string) Interval::untilPositiveInfinity()) {
+			$constraint = new MultiConstraint(array($constraint, new Constraint('>=', $last->getEnd()->getVersion())), false);
+		}
 
-        return $constraint;
-    }
+		return $constraint;
+	}
 }