DependencyResolver::resolveForPackage() - Code Metrics - Inspection of "Implement dependency resolver on link command" - SanderSander/composer-link - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#47)

by Sander

created 2022-11-22 23:23 UTC

DependencyResolver::resolveForPackage() A

↳ Parent: DependencyResolver

Complexity

Conditions	4
Paths	1

Size

Total Lines	88
Code Lines	54

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
eloc	54
c	2
b	0
f	0
dl	0
loc	88
rs	9.0036
cc	4
nc	1
nop	1

How to fix Long Method

<?php

declare(strict_types=1);

/*
 * This file is part of the composer-link plugin.
 *
 * Copyright (c) 2021-2022 Sander Visser <[email protected]>.
 *
 * For the full copyright and license information, please view the LICENSE.md
 * file that was distributed with this source code.
 *
 * @link https://github.com/SanderSander/composer-link
 */

namespace ComposerLink;

use Composer\Composer;
use Composer\Config;
use Composer\Config\JsonConfigSource;
use Composer\DependencyResolver\DefaultPolicy;
use Composer\DependencyResolver\Operation\OperationInterface;
use Composer\DependencyResolver\Request;
use Composer\DependencyResolver\Solver;
use Composer\DependencyResolver\SolverProblemsException;
use Composer\EventDispatcher\EventDispatcher;
use Composer\Filter\PlatformRequirementFilter\PlatformRequirementFilterFactory;
use Composer\Installer;
use Composer\IO\IOInterface;
use Composer\Json\JsonFile;
use Composer\Package\Locker;
use Composer\Repository\PathRepository;
use Composer\Repository\RepositorySet;
use Composer\Repository\RootPackageRepository;
use Composer\Semver\Constraint\Constraint;
use Composer\Util\ProcessExecutor;
use ComposerLink\Config\MemoryConfigSource;

class DependencyResolver
{
    protected Composer $composer;

    protected IOInterface $io;

    public function __construct(Composer $composer, IOInterface $io)
    {
        $this->composer = $composer;
        $this->io = $io;
    }

    /**
     * @return OperationInterface[]
     */
    public function resolveForPackage(LinkedPackage $package): array
    {
        $originalComposer = new JsonFile('./composer.json');
        $lockFile = new JsonFile('./vendor/linked-composer.lock');
        $replaceComposer = new JsonFile('./vendor/linked-composer.json');
        $replaceComposer->write($originalComposer->read());

        $jsonConfigSource = new JsonConfigSource($replaceComposer);
        $config = clone $this->composer->getConfig();
        $config->setConfigSource($jsonConfigSource);
        $jsonConfigSource->addRepository('', ['type' => 'path', 'url' => $package->getPath()]);
        $jsonConfigSource->addRepository('path-' . $package->getName(), ['type' => 'path', 'url' => $package->getPath()]);
        $jsonConfigSource->addLink('require', $package->getName(), 'dev-master');

        $locker = new Locker(
            $this->io,
            $lockFile,
            $this->composer->getInstallationManager(),
            JsonFile::encode($originalComposer->read())
        );

        $installer = new Installer(
            $this->io,
            $config,
            $this->composer->getPackage(),
            $this->composer->getDownloadManager(),
            $this->composer->getRepositoryManager(),
            $locker,
            $this->composer->getInstallationManager(),
            new EventDispatcher($this->composer, $this->io),
            $this->composer->getAutoloadGenerator()
        );

        $installer->setUpdate(true);
        $installer->setWriteLock(true);
        $installer->run();

        return [];
        // TODO use configuration of original composer.json
        $repositorySet = new RepositorySet(
function fx() {
    try {
        doSomething();
        return true;
    }
    catch (\Exception $e) {
        return false;
    }

    return false;
}
            'dev',
            [],
            [],
        );

        // TODO we can't use this
        $exexutor = new ProcessExecutor($this->io);
        $exexutor->enableAsync();

        // Fill repositories first the root package repository
        $repositorySet->addRepository(new RootPackageRepository($this->composer->getPackage()));

        // The locked repository, we don't do a full upgrade, so we want to keep as much as possible packages up to date
        $repositorySet->addRepository($this->composer->getLocker()->getLockedRepository(true));

        // No we add our custom path repositories, we  need to do this before we add the original repositories
        // otherwise we do not get precedence over the other repositories
        $repo = new PathRepository(['url' => $package->getPath()], $this->io, $this->composer->getConfig(), null, null, $exexutor);
        $repositorySet->addRepository($repo);

        // Add custom repositories defined in the composer file
        $repositories = $this->composer->getRepositoryManager()->getRepositories();
        foreach ($repositories as $repository) {
            $repositorySet->addRepository($repository);
        }

        // Make request for package, and fix all the currently existing packages
        $request = new Request();
        $request->requireName($package->getName(), new Constraint('=', 'dev-master'));
        foreach ($this->composer->getRepositoryManager()->getLocalRepository()->getPackages() as $localPackage) {
            $request->fixPackage($localPackage);
        }
        $policy = new DefaultPolicy(true);

        // Create pool and solve?
        $pool = $repositorySet->createPool($request, $this->io);
        $solver = new Solver($policy, $pool, $this->io);

        $operations = [];

        try {
            $transaction = $solver->solve($request, PlatformRequirementFilterFactory::ignoreAll());
            $operations = $transaction->getOperations();
        } catch (SolverProblemsException $exception) {
            $this->io->write($exception->getPrettyString($repositorySet, $request, $pool, true));
        }

        return $operations;
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			/*
6			* This file is part of the composer-link plugin.
7			*
8			* Copyright (c) 2021-2022 Sander Visser <[email protected]>.
9			*
10			* For the full copyright and license information, please view the LICENSE.md
11			* file that was distributed with this source code.
12			*
13			* @link https://github.com/SanderSander/composer-link
14			*/
15
16			namespace ComposerLink;
17
18			use Composer\Composer;
19			use Composer\Config;
20			use Composer\Config\JsonConfigSource;
21			use Composer\DependencyResolver\DefaultPolicy;
22			use Composer\DependencyResolver\Operation\OperationInterface;
23			use Composer\DependencyResolver\Request;
24			use Composer\DependencyResolver\Solver;
25			use Composer\DependencyResolver\SolverProblemsException;
26			use Composer\EventDispatcher\EventDispatcher;
27			use Composer\Filter\PlatformRequirementFilter\PlatformRequirementFilterFactory;
28			use Composer\Installer;
29			use Composer\IO\IOInterface;
30			use Composer\Json\JsonFile;
31			use Composer\Package\Locker;
32			use Composer\Repository\PathRepository;
33			use Composer\Repository\RepositorySet;
34			use Composer\Repository\RootPackageRepository;
35			use Composer\Semver\Constraint\Constraint;
36			use Composer\Util\ProcessExecutor;
37			use ComposerLink\Config\MemoryConfigSource;
38
39			class DependencyResolver
40			{
41			protected Composer $composer;
42
43			protected IOInterface $io;
44
45			public function __construct(Composer $composer, IOInterface $io)
46			{
47			$this->composer = $composer;
48			$this->io = $io;
49			}
50
51			/**
52			* @return OperationInterface[]
53			*/
54			public function resolveForPackage(LinkedPackage $package): array
55			{
56			$originalComposer = new JsonFile('./composer.json');
57			$lockFile = new JsonFile('./vendor/linked-composer.lock');
58			$replaceComposer = new JsonFile('./vendor/linked-composer.json');
59			$replaceComposer->write($originalComposer->read());
60
61			$jsonConfigSource = new JsonConfigSource($replaceComposer);
62			$config = clone $this->composer->getConfig();
63			$config->setConfigSource($jsonConfigSource);
64			$jsonConfigSource->addRepository('', ['type' => 'path', 'url' => $package->getPath()]);
65			$jsonConfigSource->addRepository('path-' . $package->getName(), ['type' => 'path', 'url' => $package->getPath()]);
66			$jsonConfigSource->addLink('require', $package->getName(), 'dev-master');
67
68			$locker = new Locker(
69			$this->io,
70			$lockFile,
71			$this->composer->getInstallationManager(),
72			JsonFile::encode($originalComposer->read())
73			);
74
75			$installer = new Installer(
76			$this->io,
77			$config,
78			$this->composer->getPackage(),
79			$this->composer->getDownloadManager(),
80			$this->composer->getRepositoryManager(),
81			$locker,
82			$this->composer->getInstallationManager(),
83			new EventDispatcher($this->composer, $this->io),
84			$this->composer->getAutoloadGenerator()
85			);
86
87			$installer->setUpdate(true);
88			$installer->setWriteLock(true);
89			$installer->run();
90
91			return [];
92			// TODO use configuration of original composer.json
93			$repositorySet = new RepositorySet(
			0 ignored issues – show Unused Code introduced 2022-11-22 23:32 UTC by Report Bug Copy Issue Report `$repositorySet = new Com...dev', array(), array())` is not reachable. This check looks for unreachable code. It uses sophisticated control flow analysis techniques to find statements which will never be executed. Unreachable code is most often the result of `return`, `die` or `exit` statements that have been added for debug purposes. function fx() { try { doSomething(); return true; } catch (\Exception $e) { return false; } return false; } In the above example, the last `return false` will never be executed, because a return statement has already been met in every possible execution path. Loading history...
94			'dev',
95			[],
96			[],
97			);
98
99			// TODO we can't use this
100			$exexutor = new ProcessExecutor($this->io);
101			$exexutor->enableAsync();
102
103			// Fill repositories first the root package repository
104			$repositorySet->addRepository(new RootPackageRepository($this->composer->getPackage()));
105
106			// The locked repository, we don't do a full upgrade, so we want to keep as much as possible packages up to date
107			$repositorySet->addRepository($this->composer->getLocker()->getLockedRepository(true));
108
109			// No we add our custom path repositories, we need to do this before we add the original repositories
110			// otherwise we do not get precedence over the other repositories
111			$repo = new PathRepository(['url' => $package->getPath()], $this->io, $this->composer->getConfig(), null, null, $exexutor);
112			$repositorySet->addRepository($repo);
113
114			// Add custom repositories defined in the composer file
115			$repositories = $this->composer->getRepositoryManager()->getRepositories();
116			foreach ($repositories as $repository) {
117			$repositorySet->addRepository($repository);
118			}
119
120			// Make request for package, and fix all the currently existing packages
121			$request = new Request();
122			$request->requireName($package->getName(), new Constraint('=', 'dev-master'));
123			foreach ($this->composer->getRepositoryManager()->getLocalRepository()->getPackages() as $localPackage) {
124			$request->fixPackage($localPackage);
125			}
126			$policy = new DefaultPolicy(true);
127
128			// Create pool and solve?
129			$pool = $repositorySet->createPool($request, $this->io);
130			$solver = new Solver($policy, $pool, $this->io);
131
132			$operations = [];
133
134			try {
135			$transaction = $solver->solve($request, PlatformRequirementFilterFactory::ignoreAll());
136			$operations = $transaction->getOperations();
137			} catch (SolverProblemsException $exception) {
138			$this->io->write($exception->getPrettyString($repositorySet, $request, $pool, true));
139			}
140
141			return $operations;
142			}
143			}
144

SanderSander / composer-link

Pull Request — master (#47)

DependencyResolver::resolveForPackage() A

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like