CheckComposerUpdatesTask::run() - Code Metrics - Inspection of "API Remove Packagist API and use Composer to deter..." - bringyourownideas/silverstripe-composer-update-checker - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#28)

by Robbie

created 2018-05-23 01:54 UTC

CheckComposerUpdatesTask::run() A

↳ Parent: CheckComposerUpdatesTask

Complexity

Conditions	2
Paths	2

Size

Total Lines	14
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	14
rs	9.4285
c	0
b	0
f	0
cc	2
eloc	7
nc	2
nop	1

<?php

use BringYourOwnIdeas\Maintenance\Tasks\UpdatePackageInfo;
use BringYourOwnIdeas\Maintenance\Util\ComposerLoader;
use BringYourOwnIdeas\UpdateChecker\UpdateChecker;
use Composer\Composer;
use Composer\Package\Link;
use Composer\Repository\ArrayRepository;
use Composer\Repository\BaseRepository;
use Composer\Repository\CompositeRepository;

/**
 * Task which does the actual checking of updates
 *
 * Originally from https://github.com/XploreNet/silverstripe-composerupdates
 *
 * @author Matt Dwen
 * @license MIT
 */
class CheckComposerUpdatesTask extends BuildTask
namespace YourVendor;

class YourClass { }
{
    /**
     * @var string
     */
    protected $title = 'Composer update checker';

    /**
     * @var string
     */
    protected $description = 'Checks if any composer dependencies can be updated.';

    private static $dependencies = [

        'ComposerLoader' => '%$BringYourOwnIdeas\\Maintenance\\Util\\ComposerLoader',
        'UpdateChecker' => '%$BringYourOwnIdeas\\UpdateChecker\\UpdateChecker',
    ];

    /**
     * @var ComposerLoader
     */
    protected $composerLoader;

    /**
     * @var UpdateChecker
     */
    protected $updateChecker;

    /**
     * Runs the actual steps to verify if there are updates available
     *
     * @param SS_HTTPRequest $request
     */
    public function run($request)
    {
        $packages = $this->getPackages();

        // Run through the packages and check each for updates
        foreach ($packages as $packageData) {
            $this->getUpdateChecker()->checkForUpdates(
                $packageData['package'],
                $packageData['constraint']
            );
        }

        $this->message('The task finished running. You can find the updated information in the database now.');
    }

    /**
     * Retrieve an array of primary composer dependencies from composer.json.
     *
     * Packages are filtered by allowed type.
     *
     * @return array[]
     */
    protected function getPackages()
    {
        /** @var Composer $composer */
        $composer = $this->getComposerLoader()->getComposer();

        /** @var BaseRepository $repository */
        $repository = new CompositeRepository([
            new ArrayRepository([$composer->getPackage()]),
            $composer->getRepositoryManager()->getLocalRepository(),
        ]);

        $packages = [];
        foreach ($repository->getPackages() as $package) {
            // Filter out packages that are not "allowed types"
            if (!$this->isAllowedType($package->getType())) {
                continue;
            }

            // Find the constraint used for installation
            $constraint = $this->getInstalledConstraint($repository, $package->getName());
            $packages[$package->getName()] = [
                'constraint' => $constraint,
                'package' => $package,
            ];
        }
        return $packages;
    }

    /**
     * Find all dependency constraints for the given package in the current repository and return the strictest one
     *
     * @param BaseRepository $repository
     * @param string $packageName
     * @return string
     */
    protected function getInstalledConstraint(BaseRepository $repository, $packageName)
    {
        $constraints = [];
        foreach ($repository->getDependents($packageName) as $dependent) {
            /** @var Link $link */
            list (, $link) = $dependent;
            $constraints[] = $link->getPrettyConstraint();
        }

        usort($constraints, 'version_compare');

        return array_pop($constraints);
    }

    /**
     * Check whether the package type is "allowed", which will include it in reports. If the type is not allowed
     * then the package will be skipped.
     *
     * @param string $type
     * @return bool
     */
    protected function isAllowedType($type)
    {
        $allowedTypes = Config::inst()->get(UpdatePackageInfo::class, 'allowed_types');

        return in_array($type, $allowedTypes);
    }

    /**
     * prints a message during the run of the task
     *
     * @param string $text
     */
    protected function message($text)
    {
        if (!Director::is_cli()) {
            $text = '<p>' . $text . '</p>';
        }

        echo $text . PHP_EOL;
    }

    /**
     * @param ComposerLoader $composerLoader
     * @return $this
     */
    public function setComposerLoader(ComposerLoader $composerLoader)
    {
        $this->composerLoader = $composerLoader;
        return $this;
    }

    /**
     * @return ComposerLoader
     */
    public function getComposerLoader()
    {
        return $this->composerLoader;
    }

    /**
     * @param UpdateChecker $updateChecker
     * @return $this
     */
    public function setUpdateChecker(UpdateChecker $updateChecker)
    {
        $this->updateChecker = $updateChecker;
        return $this;
    }

    /**
     * @return UpdateChecker
     */
    public function getUpdateChecker()
    {
        return $this->updateChecker;
    }
}


1			<?php
2
3			use BringYourOwnIdeas\Maintenance\Tasks\UpdatePackageInfo;
4			use BringYourOwnIdeas\Maintenance\Util\ComposerLoader;
5			use BringYourOwnIdeas\UpdateChecker\UpdateChecker;
6			use Composer\Composer;
7			use Composer\Package\Link;
8			use Composer\Repository\ArrayRepository;
9			use Composer\Repository\BaseRepository;
10			use Composer\Repository\CompositeRepository;
11
12			/**
13			* Task which does the actual checking of updates
14			*
15			* Originally from https://github.com/XploreNet/silverstripe-composerupdates
16			*
17			* @author Matt Dwen
18			* @license MIT
19			*/
20			class CheckComposerUpdatesTask extends BuildTask
			0 ignored issues – show Coding Style Compatibility introduced 2018-04-20 11:04 UTC by Report Bug Copy Issue Report PSR1 recommends that each class must be in a namespace of at least one level to avoid collisions. You can fix this by adding a namespace to your class: namespace YourVendor; class YourClass { } When choosing a vendor namespace, try to pick something that is not too generic to avoid conflicts with other libraries. Loading history...
21			{
22			/**
23			* @var string
24			*/
25			protected $title = 'Composer update checker';
26
27			/**
28			* @var string
29			*/
30			protected $description = 'Checks if any composer dependencies can be updated.';
31
32			private static $dependencies = [
			0 ignored issues – show Unused Code introduced 2018-05-22 04:32 UTC by Report Bug Copy Issue Report The property `$dependencies` is not used and could be removed. This check marks private properties in classes that are never used. Those properties can be removed. Loading history...
33			'ComposerLoader' => '%$BringYourOwnIdeas\\Maintenance\\Util\\ComposerLoader',
34			'UpdateChecker' => '%$BringYourOwnIdeas\\UpdateChecker\\UpdateChecker',
35			];
36
37			/**
38			* @var ComposerLoader
39			*/
40			protected $composerLoader;
41
42			/**
43			* @var UpdateChecker
44			*/
45			protected $updateChecker;
46
47			/**
48			* Runs the actual steps to verify if there are updates available
49			*
50			* @param SS_HTTPRequest $request
51			*/
52			public function run($request)
53			{
54			$packages = $this->getPackages();
55
56			// Run through the packages and check each for updates
57			foreach ($packages as $packageData) {
58			$this->getUpdateChecker()->checkForUpdates(
59			$packageData['package'],
60			$packageData['constraint']
61			);
62			}
63
64			$this->message('The task finished running. You can find the updated information in the database now.');
65			}
66
67			/**
68			* Retrieve an array of primary composer dependencies from composer.json.
69			*
70			* Packages are filtered by allowed type.
71			*
72			* @return array[]
73			*/
74			protected function getPackages()
75			{
76			/** @var Composer $composer */
77			$composer = $this->getComposerLoader()->getComposer();
78
79			/** @var BaseRepository $repository */
80			$repository = new CompositeRepository([
81			new ArrayRepository([$composer->getPackage()]),
82			$composer->getRepositoryManager()->getLocalRepository(),
83			]);
84
85			$packages = [];
86			foreach ($repository->getPackages() as $package) {
87			// Filter out packages that are not "allowed types"
88			if (!$this->isAllowedType($package->getType())) {
89			continue;
90			}
91
92			// Find the constraint used for installation
93			$constraint = $this->getInstalledConstraint($repository, $package->getName());
94			$packages[$package->getName()] = [
95			'constraint' => $constraint,
96			'package' => $package,
97			];
98			}
99			return $packages;
100			}
101
102			/**
103			* Find all dependency constraints for the given package in the current repository and return the strictest one
104			*
105			* @param BaseRepository $repository
106			* @param string $packageName
107			* @return string
108			*/
109			protected function getInstalledConstraint(BaseRepository $repository, $packageName)
110			{
111			$constraints = [];
112			foreach ($repository->getDependents($packageName) as $dependent) {
113			/** @var Link $link */
114			list (, $link) = $dependent;
115			$constraints[] = $link->getPrettyConstraint();
116			}
117
118			usort($constraints, 'version_compare');
119
120			return array_pop($constraints);
121			}
122
123			/**
124			* Check whether the package type is "allowed", which will include it in reports. If the type is not allowed
125			* then the package will be skipped.
126			*
127			* @param string $type
128			* @return bool
129			*/
130			protected function isAllowedType($type)
131			{
132			$allowedTypes = Config::inst()->get(UpdatePackageInfo::class, 'allowed_types');
133
134			return in_array($type, $allowedTypes);
135			}
136
137			/**
138			* prints a message during the run of the task
139			*
140			* @param string $text
141			*/
142			protected function message($text)
143			{
144			if (!Director::is_cli()) {
145			$text = '<p>' . $text . '</p>';
146			}
147
148			echo $text . PHP_EOL;
149			}
150
151			/**
152			* @param ComposerLoader $composerLoader
153			* @return $this
154			*/
155			public function setComposerLoader(ComposerLoader $composerLoader)
156			{
157			$this->composerLoader = $composerLoader;
158			return $this;
159			}
160
161			/**
162			* @return ComposerLoader
163			*/
164			public function getComposerLoader()
165			{
166			return $this->composerLoader;
167			}
168
169			/**
170			* @param UpdateChecker $updateChecker
171			* @return $this
172			*/
173			public function setUpdateChecker(UpdateChecker $updateChecker)
174			{
175			$this->updateChecker = $updateChecker;
176			return $this;
177			}
178
179			/**
180			* @return UpdateChecker
181			*/
182			public function getUpdateChecker()
183			{
184			return $this->updateChecker;
185			}
186			}
187

bringyourownideas / silverstripe-composer-update-checker

Pull Request — master (#28)

CheckComposerUpdatesTask::run() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like