gravityview / GravityView

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

Spacing +2 added lines, -2 removed lines

@@ -29,12 +29,12 @@
 {
     public function __construct()
     {
-        AggregatedType::__construct([new NumericString(), new Integer(), new Float_()], '|');
+        AggregatedType::__construct( [ new NumericString(), new Integer(), new Float_() ], '|' );
     }
 
     public function underlyingType(): Type
     {
-        return new Compound([new NumericString(), new Integer(), new Float_()]);
+        return new Compound( [ new NumericString(), new Integer(), new Float_() ] );
     }
 
     /**

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

Spacing +1 added lines, -1 removed lines

@@ -30,7 +30,7 @@
     /** @var string */
     private $maxValue;
 
-    public function __construct(string $minValue, string $maxValue)
+    public function __construct( string $minValue, string $maxValue )
     {
         $this->minValue = $minValue;
         $this->maxValue = $maxValue;

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

Spacing +3 added lines, -3 removed lines

@@ -31,9 +31,9 @@ 
         return new Array_();
     }
 
-    public function __construct(?Type $valueType = null)
+    public function __construct( ?Type $valueType = null )
     {
-        parent::__construct($valueType, new Integer());
+        parent::__construct( $valueType, new Integer() );
     }
 
     /**
@@ -41,7 +41,7 @@ 
      */
     public function __toString(): string
     {
-        if ($this->valueType instanceof Mixed_) {
+        if ( $this->valueType instanceof Mixed_ ) {
             return 'list';
         }
 

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

Spacing +52 added lines, -52 removed lines

@@ -54,11 +54,11 @@ 
 
     private static function getInstance() : InflectorObject
     {
-        if (self::$factory === null) {
+        if ( self::$factory === null ) {
             self::$factory = self::createFactory();
         }
 
-        if (self::$instance === null) {
+        if ( self::$instance === null ) {
             self::$instance = self::$factory->build();
         }
 
@@ -75,21 +75,21 @@ 
      *
      * @deprecated
      */
-    public static function tableize(string $word) : string
+    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);
+        @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
+    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);
+        @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 );
     }
 
     /**
@@ -97,11 +97,11 @@ 
      *
      * @deprecated
      */
-    public static function camelize(string $word) : string
+    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);
+        @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 );
     }
 
     /**
@@ -131,11 +131,11 @@ 
      *
      * @deprecated
      */
-    public static function ucwords(string $string, string $delimiters = " \n\t\r\0\x0B-") : string
+    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);
+        @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 );
     }
 
     /**
@@ -146,7 +146,7 @@ 
      */
     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);
+        @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;
@@ -175,45 +175,45 @@ 
      *
      * @deprecated
      */
-    public static function rules(string $type, iterable $rules, bool $reset = false) : void
+    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);
+        @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) {
+        if ( self::$factory === null ) {
             self::$factory = self::createFactory();
         }
 
         self::$instance = null;
 
-        switch ($type) {
+        switch ( $type ) {
             case 'singular':
-                self::$factory->withSingularRules(self::buildRuleset($rules), $reset);
+                self::$factory->withSingularRules( self::buildRuleset( $rules ), $reset );
                 break;
             case 'plural':
-                self::$factory->withPluralRules(self::buildRuleset($rules), $reset);
+                self::$factory->withPluralRules( self::buildRuleset( $rules ), $reset );
                 break;
             default:
-                throw new InvalidArgumentException(sprintf('Cannot define custom inflection rules for type "%s".', $type));
+                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
+    private static function buildRuleset( iterable $rules ) : Ruleset
     {
-        $regular = [];
-        $irregular = [];
-        $uninflected = [];
+        $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;
             }
 
-            switch ($rule) {
+            switch ( $rule ) {
                 case 'uninflected':
                     $uninflected = $pattern;
                     break;
@@ -227,26 +227,26 @@ 
         }
 
         return new Ruleset(
-            new Transformations(...array_map(
-                static function (string $pattern, string $replacement) : Transformation {
-                    return new Transformation(new Pattern($pattern), $replacement);
+            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);
+                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));
+            ) ),
+            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)
-            ))
+                array_keys( $irregular ),
+                array_values( $irregular )
+            ) )
         );
     }
 
@@ -259,11 +259,11 @@ 
      *
      * @deprecated
      */
-    public static function pluralize(string $word) : string
+    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);
+        @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 );
     }
 
     /**
@@ -275,10 +275,10 @@ 
      *
      * @deprecated
      */
-    public static function singularize(string $word) : string
+    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);
+        @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

Spacing +121 added lines, -121 removed lines

@@ -63,7 +63,7 @@ 
      */
     private $removedVersionsByPackage = array();
 
-    public function __construct(PolicyInterface $policy)
+    public function __construct( PolicyInterface $policy )
     {
         $this->policy = $policy;
     }
@@ -71,15 +71,15 @@ 
     /**
      * @return Pool
      */
-    public function optimize(Request $request, Pool $pool)
+    public function optimize( Request $request, Pool $pool )
     {
-        $this->prepare($request, $pool);
+        $this->prepare( $request, $pool );
 
-        $this->optimizeByIdenticalDependencies($request, $pool);
+        $this->optimizeByIdenticalDependencies( $request, $pool );
 
-        $this->optimizeImpossiblePackagesAway($request, $pool);
+        $this->optimizeImpossiblePackagesAway( $request, $pool );
 
-        $optimizedPool = $this->applyRemovalsToPool($pool);
+        $optimizedPool = $this->applyRemovalsToPool( $pool );
 
         // No need to run this recursively at the moment
         // because the current optimizations cannot provide
@@ -99,55 +99,55 @@ 
     /**
      * @return void
      */
-    private function prepare(Request $request, Pool $pool)
+    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());
+        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;
+        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) {
+        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;
+            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;
+            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;
+            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);
+        foreach ( $irremovablePackageConstraintGroups as $packageName => $constraints ) {
+            $irremovablePackageConstraints[ $packageName ] = 1 === \count( $constraints ) ? $constraints[ 0 ] : new MultiConstraint( $constraints, false );
         }
-        unset($irremovablePackageConstraintGroups);
+        unset( $irremovablePackageConstraintGroups );
 
         // Mark the packages as irremovable based on the constraints
-        foreach ($pool->getPackages() as $package) {
-            if (!isset($irremovablePackageConstraints[$package->getName()])) {
+        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);
+            if ( CompilingMatcher::match( $irremovablePackageConstraints[ $package->getName() ], Constraint::OP_EQ, $package->getVersion() ) ) {
+                $this->markPackageIrremovable( $package );
             }
         }
     }
@@ -155,17 +155,17 @@ 
     /**
      * @return void
      */
-    private function markPackageIrremovable(BasePackage $package)
+    private function markPackageIrremovable( BasePackage $package )
     {
-        $this->irremovablePackages[$package->id] = true;
-        if ($package instanceof AliasPackage) {
+        $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());
+            $this->markPackageIrremovable( $package->getAliasOf() );
         }
-        if (isset($this->aliasesPerPackage[$package->id])) {
-            foreach ($this->aliasesPerPackage[$package->id] as $aliasPackage) {
-                $this->irremovablePackages[$aliasPackage->id] = true;
+        if ( isset( $this->aliasesPerPackage[ $package->id ] ) ) {
+            foreach ( $this->aliasesPerPackage[ $package->id ] as $aliasPackage ) {
+                $this->irremovablePackages[ $aliasPackage->id ] = true;
             }
         }
     }
@@ -173,19 +173,19 @@ 
     /**
      * @return Pool Optimized pool
      */
-    private function applyRemovalsToPool(Pool $pool)
+    private function applyRemovalsToPool( Pool $pool )
     {
         $packages = array();
         $removedVersions = array();
-        foreach ($pool->getPackages() as $package) {
-            if (!isset($this->packagesToRemove[$package->id])) {
-                $packages[] = $package;
+        foreach ( $pool->getPackages() as $package ) {
+            if ( ! isset( $this->packagesToRemove[ $package->id ] ) ) {
+                $packages[ ] = $package;
             } else {
-                $removedVersions[$package->getName()][$package->getVersion()] = $package->getPrettyVersion();
+                $removedVersions[ $package->getName() ][ $package->getVersion() ] = $package->getPrettyVersion();
             }
         }
 
-        $optimizedPool = new Pool($packages, $pool->getUnacceptableFixedOrLockedPackages(), $removedVersions, $this->removedVersionsByPackage);
+        $optimizedPool = new Pool( $packages, $pool->getUnacceptableFixedOrLockedPackages(), $removedVersions, $this->removedVersionsByPackage );
 
         return $optimizedPool;
     }
@@ -193,70 +193,70 @@ 
     /**
      * @return void
      */
-    private function optimizeByIdenticalDependencies(Request $request, Pool $pool)
+    private function optimizeByIdenticalDependencies( Request $request, Pool $pool )
     {
         $identicalDefinitionsPerPackage = array();
         $packageIdenticalDefinitionLookup = array();
 
-        foreach ($pool->getPackages() as $package) {
+        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])) {
+            if ( isset( $this->irremovablePackages[ $package->id ] ) ) {
                 continue;
             }
 
-            $this->markPackageForRemoval($package->id);
+            $this->markPackageForRemoval( $package->id );
 
-            $dependencyHash = $this->calculateDependencyHash($package);
+            $dependencyHash = $this->calculateDependencyHash( $package );
 
-            foreach ($package->getNames(false) as $packageName) {
+            foreach ( $package->getNames( false ) as $packageName ) {
 
-                if (!isset($this->requireConstraintsPerPackage[$packageName])) {
+                if ( ! isset( $this->requireConstraintsPerPackage[ $packageName ] ) ) {
                     continue;
                 }
 
-                foreach ($this->requireConstraintsPerPackage[$packageName] as $requireConstraint) {
+                foreach ( $this->requireConstraintsPerPackage[ $packageName ] as $requireConstraint ) {
                     $groupHashParts = array();
 
-                    if (CompilingMatcher::match($requireConstraint, Constraint::OP_EQ, $package->getVersion())) {
-                        $groupHashParts[] = 'require:' . (string) $requireConstraint;
+                    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())) {
+                    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();
+                                $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 ( 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) {
+                    if ( ! $groupHashParts ) {
                         continue;
                     }
 
-                    $groupHash = implode('', $groupHashParts);
-                    $identicalDefinitionsPerPackage[$packageName][$groupHash][$dependencyHash][] = $package;
-                    $packageIdenticalDefinitionLookup[$package->id][$packageName] = array('groupHash' => $groupHash, 'dependencyHash' => $dependencyHash);
+                    $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) {
+        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);
+                    if ( 1 === \count( $packages ) ) {
+                        $this->keepPackage( $packages[ 0 ], $identicalDefinitionsPerPackage, $packageIdenticalDefinitionLookup );
                         continue;
                     }
 
@@ -264,12 +264,12 @@ 
                     // then not allowed to be removed either
                     $literals = array();
 
-                    foreach ($packages as $package) {
-                        $literals[] = $package->id;
+                    foreach ( $packages as $package ) {
+                        $literals[ ] = $package->id;
                     }
 
-                    foreach ($this->policy->selectPreferredPackages($pool, $literals) as $preferredLiteral) {
-                        $this->keepPackage($pool->literalToPackage($preferredLiteral), $identicalDefinitionsPerPackage, $packageIdenticalDefinitionLookup);
+                    foreach ( $this->policy->selectPreferredPackages( $pool, $literals ) as $preferredLiteral ) {
+                        $this->keepPackage( $pool->literalToPackage( $preferredLiteral ), $identicalDefinitionsPerPackage, $packageIdenticalDefinitionLookup );
                     }
                 }
             }
@@ -279,7 +279,7 @@ 
     /**
      * @return string
      */
-    private function calculateDependencyHash(BasePackage $package)
+    private function calculateDependencyHash( BasePackage $package )
     {
         $hash = '';
 
@@ -290,8 +290,8 @@ 
             'provides' => $package->getProvides()
         );
 
-        foreach ($hashRelevantLinks as $key => $links) {
-            if (0 === \count($links)) {
+        foreach ( $hashRelevantLinks as $key => $links ) {
+            if ( 0 === \count( $links ) ) {
                 continue;
             }
 
@@ -300,18 +300,18 @@ 
 
             $subhash = array();
 
-            foreach ($links as $link) {
+            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();
+                $subhash[ $link->getTarget() ] = (string)$link->getConstraint();
             }
 
             // Sort for best result
-            ksort($subhash);
+            ksort( $subhash );
 
-            foreach ($subhash as $target => $constraint) {
+            foreach ( $subhash as $target => $constraint ) {
                 $hash .= $target . '@' . $constraint;
             }
         }
@@ -323,14 +323,14 @@ 
      * @param int $id
      * @return void
      */
-    private function markPackageForRemoval($id)
+    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');
+        if ( isset( $this->irremovablePackages[ $id ] ) ) {
+            throw new \LogicException( 'Attempted removing a package which was previously marked irremovable' );
         }
 
-        $this->packagesToRemove[$id] = true;
+        $this->packagesToRemove[ $id ] = true;
     }
 
     /**
@@ -338,44 +338,44 @@ 
      * @param array<int, array<string, array{groupHash: string, dependencyHash: string}>> $packageIdenticalDefinitionLookup
      * @return void
      */
-    private function keepPackage(BasePackage $package, $identicalDefinitionsPerPackage, $packageIdenticalDefinitionLookup)
+    private function keepPackage( BasePackage $package, $identicalDefinitionsPerPackage, $packageIdenticalDefinitionLookup )
     {
-        unset($this->packagesToRemove[$package->id]);
+        unset( $this->packagesToRemove[ $package->id ] );
 
-        if ($package instanceof AliasPackage) {
+        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);
+            $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) {
+        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();
+                    $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]);
+        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) {
+                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();
+                            $this->removedVersionsByPackage[ spl_object_hash( $aliasPackage ) ][ $pkg->getVersion() ] = $pkg->getPrettyVersion();
                         }
                     }
                 }
@@ -390,59 +390,59 @@ 
      *
      * @return void
      */
-    private function optimizeImpossiblePackagesAway(Request $request, Pool $pool)
+    private function optimizeImpossiblePackagesAway( Request $request, Pool $pool )
     {
-        if (count($request->getLockedPackages()) === 0) {
+        if ( count( $request->getLockedPackages() ) === 0 ) {
             return;
         }
 
         $packageIndex = array();
 
-        foreach ($pool->getPackages() as $package) {
+        foreach ( $pool->getPackages() as $package ) {
             $id = $package->id;
 
             // Do not remove irremovable packages
-            if (isset($this->irremovablePackages[$id])) {
+            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) {
+            if ( isset( $this->aliasesPerPackage[ $id ] ) || $package instanceof AliasPackage ) {
                 continue;
             }
             // Do not remove locked packages
-            if ($request->isFixedPackage($package) || $request->isLockedPackage($package)) {
+            if ( $request->isFixedPackage( $package ) || $request->isLockedPackage( $package ) ) {
                 continue;
             }
 
-            $packageIndex[$package->getName()][$package->id] = $package;
+            $packageIndex[ $package->getName() ][ $package->id ] = $package;
         }
 
-        foreach ($request->getLockedPackages() as $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])) {
+            foreach ( $package->getNames( false ) as $packageName ) {
+                if ( isset( $this->requireConstraintsPerPackage[ $packageName ] ) ) {
                     $isUnusedPackage = false;
                     break;
                 }
             }
 
-            if ($isUnusedPackage) {
+            if ( $isUnusedPackage ) {
                 continue;
             }
 
-            foreach ($package->getRequires() as $link) {
+            foreach ( $package->getRequires() as $link ) {
                 $require = $link->getTarget();
-                if (!isset($packageIndex[$require])) {
+                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]);
+                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

Spacing +1 added lines, -1 removed lines

@@ -8,5 +8,5 @@
      * @param string $req
      * @return bool
      */
-    public function isIgnored($req);
+    public function isIgnored( $req );
 }

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

Spacing +1 added lines, -1 removed lines

@@ -8,7 +8,7 @@
      * @param string $req
      * @return false
      */
-    public function isIgnored($req)
+    public function isIgnored( $req )
     {
         return false;
     }

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

Spacing +2 added lines, -2 removed lines

@@ -10,8 +10,8 @@
      * @param string $req
      * @return bool
      */
-    public function isIgnored($req)
+    public function isIgnored( $req )
     {
-        return PlatformRepository::isPlatformPackage($req);
+        return PlatformRepository::isPlatformPackage( $req );
     }
 }

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

Spacing +5 added lines, -5 removed lines

@@ -9,20 +9,20 @@
      *
      * @return PlatformRequirementFilterInterface
      */
-    public static function fromBoolOrList($boolOrList)
+    public static function fromBoolOrList( $boolOrList )
     {
-        if (is_bool($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)
+                gettype( $boolOrList )
             )
         );
     }