PackageRequirementsResolver::resolveGraph() - Code Metrics - Inspection of "1.1.0 - Package requirements resolver" - mediact/dependency-guard - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Pull Request — master (#35)

by Jan-Marten

created 2019-01-10 11:30 UTC

PackageRequirementsResolver::resolveGraph() B

↳ Parent: PackageRequirementsResolver

Complexity

Conditions	9
Paths	3

Size

Total Lines	56
Code Lines	23

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	9
eloc	23
nc	3
nop	1
dl	0
loc	56
rs	8.0555
c	0
b	0
f	0

How to fix Long Method

<?php
/**
 * Copyright MediaCT. All rights reserved.
 * https://www.mediact.nl
 */

namespace Mediact\DependencyGuard\Composer\Locker;

use Composer\Package\Locker;
use Composer\Package\PackageInterface;
use SplObjectStorage;

class PackageRequirementsResolver implements PackageRequirementsResolverInterface
{
    /** @var SplObjectStorage|PackageInterface[][][] */
    private $resolvedLockers;

    /**
     * Constructor.
     *
     * @param SplObjectStorage|null $resolvedLockers
     */
    public function __construct(SplObjectStorage $resolvedLockers = null)
    {
        $this->resolvedLockers = $resolvedLockers ?? new SplObjectStorage();
    }

    /**
     * Resolve the dependents graph for the given Composer locker.
     *
     * @param Locker $locker
     *
     * @return array|PackageInterface[][]
     */
    public function resolve(Locker $locker): array
    {
        if (!$this->resolvedLockers->contains($locker)) {
            $lockedPackages = $locker->getLockedRepository()->getPackages();

            $this->resolvedLockers->attach(
                $locker,
                array_map(
                    function (array $packages) use ($lockedPackages) : array {
                        return array_reduce(
                            $lockedPackages,
                            function (
                                array $carry,
                                PackageInterface $package
                            ) use ($packages) : array {
                                if (in_array(
                                    $package->getName(),
                                    $packages,
                                    true
                                )) {
                                    $carry[] = $package;
                                }

                                return $carry;
                            },
                            []
                        );
                    },
                    $this->resolveGraph(
                        ...$locker->getLockData()['packages'] ?? []
                    )
                )
            );
        }

        return $this->resolvedLockers->offsetGet($locker);
    }

    /**
     * Get the dependent packages for the given package, using the given locker.
     *
     * @param string $package
     * @param Locker $locker
     *
     * @return array|PackageInterface[]
     */
    public function getDependents(string $package, Locker $locker): array
    {
        return $this->resolve($locker)[$package] ?? [];
    }

    /**
     * Resolve the dependents graph for the given packages.
     *
     * @param array ...$packages
     *
     * @return string[]
     */
    private function resolveGraph(array ...$packages): array
    {
        $graph = array_reduce(
            $packages,
            function (array $carry, array $package): array {
                foreach (array_keys($package['require'] ?? []) as $link) {
                    if (!preg_match('/^[^\/]+\/[^\/]+$/', $link)) {
                        // Most likely a platform requirement.
                        // E.g.: php
                        // E.g.: ext-openssl
                        continue;
                    }

                    if (!array_key_exists($link, $carry)) {
                        $carry[$link] = [];
                    }

                    if (!in_array($package['name'], $carry[$link], true)) {
                        $carry[$link][] = $package['name'];
                    }
                }

                return $carry;
            },
            []
        );

        // While the graph keeps receiving updates, keep on resolving.
        for ($previousGraph = []; $graph !== $previousGraph;) {
            // Do not update the previous graph before the current iteration
            // has started.
            $previousGraph = $graph;

            // For each package and its dependents in the graph ...
            foreach ($graph as $package => $dependents) {
                // ... Update the dependents of the package with grandparents.
                $graph[$package] = array_reduce(
                    // Determine grandparents by looking up the parents of the
                    // available dependents.
                    $dependents,
                    function (array $carry, string $parent) use ($graph): array {
                        foreach ($graph[$parent] ?? [] as $grandparent) {
                            if (!in_array($grandparent, $carry, true)) {
                                $carry[] = $grandparent;
                            }
                        }

                        return $carry;
                    },
                    // Start out with the current list of dependents.
                    $dependents
                );
            }
        }

        return $graph;
    }
}


1			<?php
2			/**
3			* Copyright MediaCT. All rights reserved.
4			* https://www.mediact.nl
5			*/
6
7			namespace Mediact\DependencyGuard\Composer\Locker;
8
9			use Composer\Package\Locker;
10			use Composer\Package\PackageInterface;
11			use SplObjectStorage;
12
13			class PackageRequirementsResolver implements PackageRequirementsResolverInterface
14			{
15			/** @var SplObjectStorage\|PackageInterface[][][] */
16			private $resolvedLockers;
17
18			/**
19			* Constructor.
20			*
21			* @param SplObjectStorage\|null $resolvedLockers
22			*/
23			public function __construct(SplObjectStorage $resolvedLockers = null)
24			{
25			$this->resolvedLockers = $resolvedLockers ?? new SplObjectStorage();
26			}
27
28			/**
29			* Resolve the dependents graph for the given Composer locker.
30			*
31			* @param Locker $locker
32			*
33			* @return array\|PackageInterface[][]
34			*/
35			public function resolve(Locker $locker): array
36			{
37			if (!$this->resolvedLockers->contains($locker)) {
38			$lockedPackages = $locker->getLockedRepository()->getPackages();
39
40			$this->resolvedLockers->attach(
41			$locker,
42			array_map(
43			function (array $packages) use ($lockedPackages) : array {
44			return array_reduce(
45			$lockedPackages,
46			function (
47			array $carry,
48			PackageInterface $package
49			) use ($packages) : array {
50			if (in_array(
51			$package->getName(),
52			$packages,
53			true
54			)) {
55			$carry[] = $package;
56			}
57
58			return $carry;
59			},
60			[]
61			);
62			},
63			$this->resolveGraph(
64			...$locker->getLockData()['packages'] ?? []
65			)
66			)
67			);
68			}
69
70			return $this->resolvedLockers->offsetGet($locker);
71			}
72
73			/**
74			* Get the dependent packages for the given package, using the given locker.
75			*
76			* @param string $package
77			* @param Locker $locker
78			*
79			* @return array\|PackageInterface[]
80			*/
81			public function getDependents(string $package, Locker $locker): array
82			{
83			return $this->resolve($locker)[$package] ?? [];
84			}
85
86			/**
87			* Resolve the dependents graph for the given packages.
88			*
89			* @param array ...$packages
90			*
91			* @return string[]
92			*/
93			private function resolveGraph(array ...$packages): array
94			{
95			$graph = array_reduce(
96			$packages,
97			function (array $carry, array $package): array {
98			foreach (array_keys($package['require'] ?? []) as $link) {
99			if (!preg_match('/^[^\/]+\/[^\/]+$/', $link)) {
100			// Most likely a platform requirement.
101			// E.g.: php
102			// E.g.: ext-openssl
103			continue;
104			}
105
106			if (!array_key_exists($link, $carry)) {
107			$carry[$link] = [];
108			}
109
110			if (!in_array($package['name'], $carry[$link], true)) {
111			$carry[$link][] = $package['name'];
112			}
113			}
114
115			return $carry;
116			},
117			[]
118			);
119
120			// While the graph keeps receiving updates, keep on resolving.
121			for ($previousGraph = []; $graph !== $previousGraph;) {
122			// Do not update the previous graph before the current iteration
123			// has started.
124			$previousGraph = $graph;
125
126			// For each package and its dependents in the graph ...
127			foreach ($graph as $package => $dependents) {
128			// ... Update the dependents of the package with grandparents.
129			$graph[$package] = array_reduce(
130			// Determine grandparents by looking up the parents of the
131			// available dependents.
132			$dependents,
133			function (array $carry, string $parent) use ($graph): array {
134			foreach ($graph[$parent] ?? [] as $grandparent) {
135			if (!in_array($grandparent, $carry, true)) {
136			$carry[] = $grandparent;
137			}
138			}
139
140			return $carry;
141			},
142			// Start out with the current list of dependents.
143			$dependents
144			);
145			}
146			}
147
148			return $graph;
149			}
150			}
151

mediact / dependency-guard

Pull Request — master (#35)

PackageRequirementsResolver::resolveGraph() B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like