Merge pull request #37 from wayfair-contribs/fix_native_function_invocation

clue · web-flow · commit 8846e11958c5 · 2019-11-16T12:38:07.000+01:00
Automated native_function_invocation fixes
diff --git a/src/Bipartit.php b/src/Bipartit.php
@@ -60,7 +60,7 @@ public function getColors()
                 // breadth search all vertices in same component
                 do {
                     // next vertex in color
-                    $vertex = array_shift($queue);
+                    $vertex = \array_shift($queue);
                     $color = $colors[$vertex->getId()];
                     $nextColor = 1-$color;
 
diff --git a/src/ConnectedComponents.php b/src/ConnectedComponents.php
@@ -78,7 +78,7 @@ public function isSingle()
         }
         $alg = $this->createSearch($vertex);
 
-        return (count($this->graph->getVertices()) === count($alg->getVertices()));
+        return (\count($this->graph->getVertices()) === \count($alg->getVertices()));
     }
 
     /**
diff --git a/src/Degree.php b/src/Degree.php
@@ -164,7 +164,7 @@ public function isVertexSink(Vertex $vertex)
      */
     public function getDegreeVertex(Vertex $vertex)
     {
-        return count($vertex->getEdges());
+        return \count($vertex->getEdges());
     }
 
     /**
diff --git a/src/Groups.php b/src/Groups.php
@@ -16,7 +16,7 @@ class Groups extends BaseGraph
      */
     public function getNumberOfGroups()
     {
-        return count($this->getGroups());
+        return \count($this->getGroups());
     }
 
     /**
@@ -63,7 +63,7 @@ public function getGroups()
             $groups[$vertex->getGroup()] = true;
         }
 
-        return array_keys($groups);
+        return \array_keys($groups);
     }
 
     /**
diff --git a/src/MaximumMatching/Base.php b/src/MaximumMatching/Base.php
@@ -18,7 +18,7 @@ abstract class Base extends BaseGraph
      */
     public function getNumberOfMatches()
     {
-        return count($this->getEdges());
+        return \count($this->getEdges());
     }
 
     /**
diff --git a/src/MinimumSpanningTree/Kruskal.php b/src/MinimumSpanningTree/Kruskal.php
@@ -103,7 +103,7 @@ public function getEdges()
                 $worseColor  = $bColor;
 
                 // more vertices with color a => paint all in b in a's color
-                if (count($colorVertices[$bColor]) > count($colorVertices[$aColor])) {
+                if (\count($colorVertices[$bColor]) > \count($colorVertices[$aColor])) {
                     $betterColor = $bColor;
                     $worseColor = $aColor;
                 }
@@ -125,7 +125,7 @@ public function getEdges()
 
         // definition of spanning tree: number of edges = number of vertices - 1
         // above algorithm does not check isolated edges or may otherwise return multiple connected components => force check
-        if (count($returnEdges) !== (count($this->graph->getVertices()) - 1)) {
+        if (\count($returnEdges) !== (\count($this->graph->getVertices()) - 1)) {
             throw new UnexpectedValueException('Graph is not connected');
         }
 
diff --git a/src/MinimumSpanningTree/Prim.php b/src/MinimumSpanningTree/Prim.php
@@ -35,7 +35,7 @@ public function getEdges()
         $returnEdges = array();
 
         // iterate n-1 times (per definition, resulting MST MUST have n-1 edges)
-        for ($i = 0, $n = count($this->startVertex->getGraph()->getVertices()) - 1; $i < $n; ++$i) {
+        for ($i = 0, $n = \count($this->startVertex->getGraph()->getVertices()) - 1; $i < $n; ++$i) {
             $markInserted[$vertexCurrent->getId()] = true;
 
             // get unvisited vertex of the edge and add edges from new vertex
diff --git a/src/Parallel.php b/src/Parallel.php
@@ -68,7 +68,7 @@ public function getEdgesParallelEdge(Edge $edge)
             $edges = $ends->getVertexFirst()->getEdges()->getEdgesIntersection($ends->getVertexLast()->getEdges())->getVector();
         }
 
-        $pos = array_search($edge, $edges, true);
+        $pos = \array_search($edge, $edges, true);
 
         if ($pos === false) {
             // @codeCoverageIgnoreStart
@@ -79,6 +79,6 @@ public function getEdgesParallelEdge(Edge $edge)
         // exclude current edge from parallel edges
         unset($edges[$pos]);
 
-        return new Edges(array_values($edges));
+        return new Edges(\array_values($edges));
     }
 }
diff --git a/src/Property/GraphProperty.php b/src/Property/GraphProperty.php
@@ -46,6 +46,6 @@ public function isNull()
      */
     public function isTrivial()
     {
-        return ($this->graph->getEdges()->isEmpty() && count($this->graph->getVertices()) === 1);
+        return ($this->graph->getEdges()->isEmpty() && \count($this->graph->getVertices()) === 1);
     }
 }
diff --git a/src/Property/WalkProperty.php b/src/Property/WalkProperty.php
@@ -162,7 +162,7 @@ public function hasCycle()
      */
     public function isLoop()
     {
-        return (count($this->walk->getEdges()) === 1 && $this->isCycle());
+        return (\count($this->walk->getEdges()) === 1 && $this->isCycle());
     }
 
     /**
@@ -214,11 +214,11 @@ public function hasLoop()
     public function isDigon()
     {
         // exactly 2 edges
-        return (count($this->walk->getEdges()) === 2 &&
+        return (\count($this->walk->getEdges()) === 2 &&
                 // no duplicate edges
                 !$this->hasArrayDuplicates($this->walk->getEdges()->getVector()) &&
                 // exactly two distinct vertices
-                count($this->walk->getVertices()->getVerticesDistinct()) === 2 &&
+                \count($this->walk->getVertices()->getVerticesDistinct()) === 2 &&
                 // this is actually a cycle
                 $this->isCycle());
     }
@@ -238,9 +238,9 @@ public function isDigon()
     public function isTriangle()
     {
         // exactly 3 (implicitly distinct) edges
-        return (count($this->walk->getEdges()) === 3 &&
+        return (\count($this->walk->getEdges()) === 3 &&
                 // exactly three distinct vertices
-                count($this->walk->getVertices()->getVerticesDistinct()) === 3 &&
+                \count($this->walk->getVertices()->getVerticesDistinct()) === 3 &&
                 // this is actually a cycle
                 $this->isCycle());
     }
@@ -347,7 +347,7 @@ private function hasArrayDuplicates($array)
         $compare = array();
         foreach ($array as $element) {
             // duplicate element found
-            if (in_array($element, $compare, true)) {
+            if (\in_array($element, $compare, true)) {
                 return true;
             } else {
                 // add element to temporary array to check for duplicates
@@ -368,7 +368,7 @@ private function hasArrayDuplicates($array)
     private function isArrayContentsEqual($a, $b)
     {
         foreach ($b as $one) {
-            $pos = array_search($one, $a, true);
+            $pos = \array_search($one, $a, true);
             if ($pos === false) {
                 return false;
             } else {
diff --git a/src/Search/BreadthFirst.php b/src/Search/BreadthFirst.php
@@ -27,7 +27,7 @@ public function getVertices($maxDepth = PHP_INT_MAX)
 
         do {
             // get first from queue
-            $t = array_shift($queue);
+            $t = \array_shift($queue);
             // save as visited
             $visited[$t->getId()] = $t;
 
diff --git a/src/Search/DepthFirst.php b/src/Search/DepthFirst.php
@@ -15,11 +15,11 @@ public function getVertices()
     {
         $visited = array();
         $todo = array($this->vertex);
-        while ($vertex = array_shift($todo)) {
+        while ($vertex = \array_shift($todo)) {
             if (!isset($visited[$vertex->getId()])) {
                 $visited[$vertex->getId()] = $vertex;
 
-                foreach (array_reverse($this->getVerticesAdjacent($vertex)->getMap(), true) as $vid => $nextVertex) {
+                foreach (\array_reverse($this->getVerticesAdjacent($vertex)->getMap(), true) as $vid => $nextVertex) {
                     $todo[] = $nextVertex;
                 }
             }
diff --git a/src/ShortestPath/Base.php b/src/ShortestPath/Base.php
@@ -111,7 +111,7 @@ protected function getEdgesToInternal(Vertex $endVertex, $edges)
             }
         } while ($currentVertex !== $this->vertex);
 
-        return new Edges(array_reverse($path));
+        return new Edges(\array_reverse($path));
     }
 
     /**
diff --git a/src/ShortestPath/BreadthFirst.php b/src/ShortestPath/BreadthFirst.php
@@ -32,7 +32,7 @@ class BreadthFirst extends Base
      */
     public function getDistance(Vertex $endVertex)
     {
-        return count($this->getEdgesTo($endVertex));
+        return \count($this->getEdgesTo($endVertex));
     }
 
     /**
@@ -56,12 +56,12 @@ public function getEdgesMap()
                 $vid = $vertexTarget->getId();
                 if (!isset($edges[$vid])) {
                     $vertexQueue []= $vertexTarget;
-                    $edges[$vid] = array_merge($edgesCurrent, array($edge));
+                    $edges[$vid] = \array_merge($edgesCurrent, array($edge));
                 }
             }
 
             // get next from queue
-            $vertexCurrent = array_shift($vertexQueue);
+            $vertexCurrent = \array_shift($vertexQueue);
             if ($vertexCurrent) {
                 $edgesCurrent = $edges[$vertexCurrent->getId()];
             }
@@ -93,7 +93,7 @@ public function getDistanceMap()
     {
         $ret = array();
         foreach ($this->getEdgesMap() as $vid => $edges) {
-            $ret[$vid] = count($edges);
+            $ret[$vid] = \count($edges);
         }
 
         return $ret;
@@ -121,7 +121,7 @@ public function getEdges()
         $ret = array();
         foreach ($this->getEdgesMap() as $edges) {
             foreach ($edges as $edge) {
-                if (!in_array($edge, $ret, true)) {
+                if (!\in_array($edge, $ret, true)) {
                     $ret []= $edge;
                 }
             }
diff --git a/src/ShortestPath/Dijkstra.php b/src/ShortestPath/Dijkstra.php
@@ -46,7 +46,7 @@ public function getEdges()
         $isFirst = true;
 
         // Repeat until all vertices have been marked
-        $totalCountOfVertices = count($this->vertex->getGraph()->getVertices());
+        $totalCountOfVertices = \count($this->vertex->getGraph()->getVertices());
         for ($i = 0; $i < $totalCountOfVertices; ++$i) {
             $currentVertex = NULL;
             $currentVertexId = NULL;
@@ -89,7 +89,7 @@ public function getEdges()
                 if (!isset($usedVertices[$targetVertexId])) {
                     // calculate new cost to vertex
                     $newCostsToTargetVertex = $totalCostOfCheapestPathTo[$currentVertexId] + $weight;
-                    if (is_infinite($newCostsToTargetVertex)) {
+                    if (\is_infinite($newCostsToTargetVertex)) {
                         $newCostsToTargetVertex = $weight;
                     }
 
diff --git a/src/ShortestPath/MooreBellmanFord.php b/src/ShortestPath/MooreBellmanFord.php
@@ -42,7 +42,7 @@ private function bigStep(Edges $edges, array &$totalCostOfCheapestPathTo, array
                 if (isset($totalCostOfCheapestPathTo[$fromVertex->getId()])) {
                     // New possible costs of this path
                     $newCost = $totalCostOfCheapestPathTo[$fromVertex->getId()] + $edge->getWeight();
-                    if (is_infinite($newCost)) {
+                    if (\is_infinite($newCost)) {
                         $newCost = $edge->getWeight() + 0;
                     }
 
@@ -79,7 +79,7 @@ public function getEdges()
         // the usal algorithm says we repeat (n-1) times.
         // but because we also want to check for loop edges on the start vertex,
         // we have to add an additional step:
-        $numSteps = count($this->vertex->getGraph()->getVertices());
+        $numSteps = \count($this->vertex->getGraph()->getVertices());
         $edges = $this->vertex->getGraph()->getEdges();
         $changed = true;
 
diff --git a/src/TopologicalSort.php b/src/TopologicalSort.php
@@ -32,27 +32,27 @@ public function getVertices()
         /** @var Vertex $top */
         // TODO: avoid having to reverse all vertices multiple times
         // pick a node to examine next - assume there are isolated nodes
-        foreach (array_reverse($this->graph->getVertices()->getVector()) as $top) {
+        foreach (\array_reverse($this->graph->getVertices()->getVector()) as $top) {
             $tid = $top->getId();
             if (!isset($visited[$tid])) { // don't examine if already found
-                array_push($stack, $top);
+                \array_push($stack, $top);
             }
 
             while ($stack) {
                 /** @var Vertex $current */
-                $node = end($stack);
+                $node = \end($stack);
                 $nid = $node->getId();
 
                 $visited[$nid] = false; // temporary mark
                 $found = false; // new children found during visit to this node
 
                 // find the next node to visit
                 /** @var Vertex $child */
-                foreach (array_reverse($node->getVerticesEdgeTo()->getVector()) as $child) {
+                foreach (\array_reverse($node->getVerticesEdgeTo()->getVector()) as $child) {
                     $cid = $child->getId();
                     if (!isset($visited[$cid])) {
                         // found a new node - push it onto the stack
-                        array_push($stack, $child);
+                        \array_push($stack, $child);
                         $found = true; // move onto the new node
                         break;
                     } else if ($visited[$cid] === false) {
@@ -62,13 +62,13 @@ public function getVertices()
                 }
 
                 if (!$found) {
-                    array_pop($stack); // no new children found - we're done with this node
+                    \array_pop($stack); // no new children found - we're done with this node
                     $visited[$nid] = true; // mark as visited
-                    array_push($output, $node); // add to results
+                    \array_push($output, $node); // add to results
                 }
             }
         }
 
-        return new Vertices(array_reverse($output, true));
+        return new Vertices(\array_reverse($output, true));
     }
 }
diff --git a/src/TravelingSalesmanProblem/Bruteforce.php b/src/TravelingSalesmanProblem/Bruteforce.php
@@ -114,7 +114,7 @@ protected function getGraph()
      */
     public function getEdges()
     {
-        $this->numEdges = count($this->graph->getVertices());
+        $this->numEdges = \count($this->graph->getVertices());
         if ($this->numEdges < 3) {
             throw new UnderflowException('Needs at least 3 vertices');
         }
@@ -152,7 +152,7 @@ private function step(Vertex $vertex, $totalWeight, array $visitedVertices, arra
             return NULL;
         }
         // kreis geschlossen am Ende
-        if ($vertex === $this->startVertex && count($visitedEdges) === $this->numEdges) {
+        if ($vertex === $this->startVertex && \count($visitedEdges) === $this->numEdges) {
             // new best result
             $this->bestWeight = $totalWeight;
 
@@ -180,7 +180,7 @@ private function step(Vertex $vertex, $totalWeight, array $visitedVertices, arra
             $result = $this->step($target,
                                   $totalWeight + $weight,
                                   $visitedVertices,
-                                  array_merge($visitedEdges, array($edge))
+                                  \array_merge($visitedEdges, array($edge))
                       );
 
             // new result found
diff --git a/src/TravelingSalesmanProblem/NearestNeighbor.php b/src/TravelingSalesmanProblem/NearestNeighbor.php
@@ -40,7 +40,7 @@ public function getEdges()
     {
         $returnEdges = array();
 
-        $n = count($this->vertex->getGraph()->getVertices());
+        $n = \count($this->vertex->getGraph()->getVertices());
 
         $vertex = $this->vertex;
         $visitedVertices = array($vertex->getId() => true);
diff --git a/src/Tree/BaseDirected.php b/src/Tree/BaseDirected.php
diff --git a/src/Tree/Undirected.php b/src/Tree/Undirected.php
diff --git a/tests/ConnectedComponentsTest.php b/tests/ConnectedComponentsTest.php
diff --git a/tests/Property/WalkPropertyTest.php b/tests/Property/WalkPropertyTest.php
diff --git a/tests/ShortestPath/BaseShortestPathTest.php b/tests/ShortestPath/BaseShortestPathTest.php
diff --git a/tests/ShortestPath/BreadthFirstTest.php b/tests/ShortestPath/BreadthFirstTest.php
diff --git a/tests/ShortestPath/MooreBellmanFordTest.php b/tests/ShortestPath/MooreBellmanFordTest.php
diff --git a/tests/bootstrap.php b/tests/bootstrap.php

Original file line number	Diff line number	Diff line change
`@@ -78,7 +78,7 @@ public function isSingle()`
`78`	`78`	`}`
`79`	`79`	`$alg = $this->createSearch($vertex);`
`80`	`80`
`81`		`- return (count($this->graph->getVertices()) === count($alg->getVertices()));`
	`81`	`+ return (\count($this->graph->getVertices()) === \count($alg->getVertices()));`
`82`	`82`	`}`
`83`	`83`
`84`	`84`	`/**`
Original file line number	Diff line number	Diff line change
`@@ -164,7 +164,7 @@ public function isVertexSink(Vertex $vertex)`
`164`	`164`	`*/`
`165`	`165`	`public function getDegreeVertex(Vertex $vertex)`
`166`	`166`	`{`
`167`		`- return count($vertex->getEdges());`
	`167`	`+ return \count($vertex->getEdges());`
`168`	`168`	`}`
`169`	`169`
`170`	`170`	`/**`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ class Groups extends BaseGraph`
`16`	`16`	`*/`
`17`	`17`	`public function getNumberOfGroups()`
`18`	`18`	`{`
`19`		`- return count($this->getGroups());`
	`19`	`+ return \count($this->getGroups());`
`20`	`20`	`}`
`21`	`21`
`22`	`22`	`/**`
`@@ -63,7 +63,7 @@ public function getGroups()`
`63`	`63`	`$groups[$vertex->getGroup()] = true;`
`64`	`64`	`}`
`65`	`65`
`66`		`- return array_keys($groups);`
	`66`	`+ return \array_keys($groups);`
`67`	`67`	`}`
`68`	`68`
`69`	`69`	`/**`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ abstract class Base extends BaseGraph`
`18`	`18`	`*/`
`19`	`19`	`public function getNumberOfMatches()`
`20`	`20`	`{`
`21`		`- return count($this->getEdges());`
	`21`	`+ return \count($this->getEdges());`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	`/**`
Original file line number	Diff line number	Diff line change
`@@ -103,7 +103,7 @@ public function getEdges()`
`103`	`103`	`$worseColor = $bColor;`
`104`	`104`
`105`	`105`	`// more vertices with color a => paint all in b in a's color`
`106`		`- if (count($colorVertices[$bColor]) > count($colorVertices[$aColor])) {`
	`106`	`+ if (\count($colorVertices[$bColor]) > \count($colorVertices[$aColor])) {`
`107`	`107`	`$betterColor = $bColor;`
`108`	`108`	`$worseColor = $aColor;`
`109`	`109`	`}`
`@@ -125,7 +125,7 @@ public function getEdges()`
`125`	`125`
`126`	`126`	`// definition of spanning tree: number of edges = number of vertices - 1`
`127`	`127`	`// above algorithm does not check isolated edges or may otherwise return multiple connected components => force check`
`128`		`- if (count($returnEdges) !== (count($this->graph->getVertices()) - 1)) {`
	`128`	`+ if (\count($returnEdges) !== (\count($this->graph->getVertices()) - 1)) {`
`129`	`129`	`throw new UnexpectedValueException('Graph is not connected');`
`130`	`130`	`}`
`131`	`131`
Original file line number	Diff line number	Diff line change
`@@ -68,7 +68,7 @@ public function getEdgesParallelEdge(Edge $edge)`
`68`	`68`	`$edges = $ends->getVertexFirst()->getEdges()->getEdgesIntersection($ends->getVertexLast()->getEdges())->getVector();`
`69`	`69`	`}`
`70`	`70`
`71`		`- $pos = array_search($edge, $edges, true);`
	`71`	`+ $pos = \array_search($edge, $edges, true);`
`72`	`72`
`73`	`73`	`if ($pos === false) {`
`74`	`74`	`// @codeCoverageIgnoreStart`
`@@ -79,6 +79,6 @@ public function getEdgesParallelEdge(Edge $edge)`
`79`	`79`	`// exclude current edge from parallel edges`
`80`	`80`	`unset($edges[$pos]);`
`81`	`81`
`82`		`- return new Edges(array_values($edges));`
	`82`	`+ return new Edges(\array_values($edges));`
`83`	`83`	`}`
`84`	`84`	`}`
Original file line number	Diff line number	Diff line change
`@@ -46,6 +46,6 @@ public function isNull()`
`46`	`46`	`*/`
`47`	`47`	`public function isTrivial()`
`48`	`48`	`{`
`49`		`- return ($this->graph->getEdges()->isEmpty() && count($this->graph->getVertices()) === 1);`
	`49`	`+ return ($this->graph->getEdges()->isEmpty() && \count($this->graph->getVertices()) === 1);`
`50`	`50`	`}`
`51`	`51`	`}`