ModuleManager::createVersion() - Code Metrics - Inspection of "Merge pull request #90 from erfanimani/3.0" - Cotya/magento-composer-installer - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — 3.0 ( ac6a55...46111f )

by Daniel

created 2016-01-16 23:03 UTC

ModuleManager::createVersion() A

↳ Parent: ModuleManager

Complexity

Conditions	2
Paths	2

Size

Total Lines	10
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	5
CRAP Score	2

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
c	1
b	0
f	1
dl	0
loc	10
ccs	5
cts	5
cp	1
rs	9.4285
cc	2
eloc	5
nc	2
nop	1
crap	2

<?php

namespace MagentoHackathon\Composer\Magento;

use Composer\Package\PackageInterface;
use MagentoHackathon\Composer\Magento\Deploy\Manager\Entry;
use MagentoHackathon\Composer\Magento\Event\EventManager;
use MagentoHackathon\Composer\Magento\Event\PackageDeployEvent;
use MagentoHackathon\Composer\Magento\Event\PackageUnInstallEvent;
use MagentoHackathon\Composer\Magento\Factory\InstallStrategyFactory;
use MagentoHackathon\Composer\Magento\Repository\InstalledPackageRepositoryInterface;
use MagentoHackathon\Composer\Magento\UnInstallStrategy\UnInstallStrategyInterface;

/**
 * Class ModuleManager
 * @package MagentoHackathon\Composer\Magento
 * @author  Aydin Hassan <[email protected]>
 */
class ModuleManager
{
    /**
     * @var InstalledPackageRepositoryInterface
     */
    protected $installedPackageRepository;

    /**
     * @var EventManager
     */
    protected $eventManager;

    /**
     * @var ProjectConfig
     */
    protected $config;

    /**
     * @var UnInstallStrategyInterface
     */
    protected $unInstallStrategy;

    /**
     * @var InstallStrategyFactory
     */
    protected $installStrategyFactory;

    /**
     * @param InstalledPackageRepositoryInterface $installedRepository
     * @param EventManager $eventManager
     * @param ProjectConfig $config
     * @param UnInstallStrategyInterface $unInstallStrategy
     * @param InstallStrategyFactory $installStrategyFactory
     */
    public function __construct(
        InstalledPackageRepositoryInterface $installedRepository,
        EventManager $eventManager,
        ProjectConfig $config,
        UnInstallStrategyInterface $unInstallStrategy,
        InstallStrategyFactory $installStrategyFactory
    ) {
        $this->installedPackageRepository = $installedRepository;
        $this->eventManager = $eventManager;
        $this->config = $config;
        $this->unInstallStrategy = $unInstallStrategy;
        $this->installStrategyFactory = $installStrategyFactory;
    }

    /**
     * @param array $currentComposerInstalledPackages
     * @return array
     */
    public function updateInstalledPackages(array $currentComposerInstalledPackages)
    {
        $packagesToRemove = $this->getRemoves(
            $currentComposerInstalledPackages,
            $this->installedPackageRepository->findAll()
        );

        $packagesToInstall  = $this->getInstalls($currentComposerInstalledPackages);

        $this->doRemoves($packagesToRemove);
        $this->doInstalls($packagesToInstall);

        return array(
            $packagesToRemove,
            $packagesToInstall
        );
    }

    /**
     * @param PackageInterface[] $packagesToInstall
     */
    public function doInstalls(array $packagesToInstall)
    {
        foreach ($packagesToInstall as $install) {
            $installStrategy = $this->installStrategyFactory->make(
                $install,
                $this->getPackageSourceDirectory($install)
            );

            $deployEntry = new Entry();
            $deployEntry->setPackageName($install->getPrettyName());
            $deployEntry->setDeployStrategy($installStrategy);
            $this->eventManager->dispatch(
                new PackageDeployEvent('pre-package-deploy', $deployEntry)
            );
            $files = $installStrategy->deploy()->getDeployedFiles();
            $this->eventManager->dispatch(
                new PackageDeployEvent('post-package-deploy', $deployEntry)
            );
            $this->installedPackageRepository->add(new InstalledPackage(
                $install->getName(),
                $this->createVersion($install),
                $files
            ));
        }
    }

    /**
     * @param InstalledPackage[] $packagesToRemove
     */
    public function doRemoves(array $packagesToRemove)
    {
        foreach ($packagesToRemove as $remove) {
            $this->eventManager->dispatch(new PackageUnInstallEvent('pre-package-uninstall', $remove));
            $this->unInstallStrategy->unInstall($remove->getInstalledFiles());
            $this->eventManager->dispatch(new PackageUnInstallEvent('post-package-uninstall', $remove));
            $this->installedPackageRepository->remove($remove);
        }
    }

    /**
     * @param PackageInterface[] $currentComposerInstalledPackages
     * @param InstalledPackage[] $magentoInstalledPackages
     * @return InstalledPackage[]
     */
    public function getRemoves(array $currentComposerInstalledPackages, array $magentoInstalledPackages)
    {
        //make the package names as the array keys
        if (count($currentComposerInstalledPackages)) {
            $currentComposerInstalledPackages = array_combine(
                array_map(
                    function (PackageInterface $package) {
                        return $package->getName();
                    },
                    $currentComposerInstalledPackages
                ),
                $currentComposerInstalledPackages
            );
        }
        return array_filter(
            $magentoInstalledPackages,
            function (InstalledPackage $package) use ($currentComposerInstalledPackages) {
                if (!isset($currentComposerInstalledPackages[$package->getName()])) {
                    return true;
                }

                $composerPackage = $currentComposerInstalledPackages[$package->getName()];
                return $package->getVersion() !== $this->createVersion($composerPackage);
            }
        );
    }

    /**
     * @param PackageInterface[] $currentComposerInstalledPackages
     * @return PackageInterface[]
     */
    public function getInstalls(array $currentComposerInstalledPackages)
    {
        $repo = $this->installedPackageRepository;
        $packages = array_filter($currentComposerInstalledPackages, function (PackageInterface $package) use ($repo) {
            return !$repo->has($package->getName(), $this->createVersion($package));
        });

        $config = $this->config;
        usort($packages, function (PackageInterface $aObject, PackageInterface $bObject) use ($config) {
            $a = $config->getModuleSpecificSortValue($aObject->getName());
            $b = $config->getModuleSpecificSortValue($bObject->getName());
            if ($a == $b) {
                return strcmp($aObject->getName(), $bObject->getName());
                /**
                 * still changes sort order and breaks a test, so for now strcmp as workaround
                 * to keep the test working.
                 */
                // return 0;
            }
            return ($a < $b) ? -1 : 1;
        });

        return $packages;
    }

    /**
     * @param PackageInterface $package
     * @return string
     */
    private function getPackageSourceDirectory(PackageInterface $package)
    {
        $path = sprintf("%s/%s", $this->config->getVendorDir(), $package->getPrettyName());
        $targetDir = $package->getTargetDir();

        if ($targetDir) {
            $path = sprintf("%s/%s", $path, $targetDir);
        }

        $path = realpath($path);
        return $path;
    }

    /**
     * Create a version string which is unique. dev-master
     * packages report a version of 9999999-dev. We need a unique version
     * so we can detect changes. here we use the source reference which
     * in the case of git is the commit hash
     *
     * @param PackageInterface $package
     *
     * @return string
     */
    private function createVersion(PackageInterface $package)
    {
        $version = $package->getVersion();

        if (null !== $package->getSourceReference()) {
            $version = sprintf('%s-%s', $version, $package->getSourceReference());
        }

        return $version;
    }
}


1		<?php
2
3		namespace MagentoHackathon\Composer\Magento;
4
5		use Composer\Package\PackageInterface;
6		use MagentoHackathon\Composer\Magento\Deploy\Manager\Entry;
7		use MagentoHackathon\Composer\Magento\Event\EventManager;
8		use MagentoHackathon\Composer\Magento\Event\PackageDeployEvent;
9		use MagentoHackathon\Composer\Magento\Event\PackageUnInstallEvent;
10		use MagentoHackathon\Composer\Magento\Factory\InstallStrategyFactory;
11		use MagentoHackathon\Composer\Magento\Repository\InstalledPackageRepositoryInterface;
12		use MagentoHackathon\Composer\Magento\UnInstallStrategy\UnInstallStrategyInterface;
13
14		/**
15		* Class ModuleManager
16		* @package MagentoHackathon\Composer\Magento
17		* @author Aydin Hassan <[email protected]>
18		*/
19		class ModuleManager
20		{
21		/**
22		* @var InstalledPackageRepositoryInterface
23		*/
24		protected $installedPackageRepository;
25
26		/**
27		* @var EventManager
28		*/
29		protected $eventManager;
30
31		/**
32		* @var ProjectConfig
33		*/
34		protected $config;
35
36		/**
37		* @var UnInstallStrategyInterface
38		*/
39		protected $unInstallStrategy;
40
41		/**
42		* @var InstallStrategyFactory
43		*/
44		protected $installStrategyFactory;
45
46		/**
47		* @param InstalledPackageRepositoryInterface $installedRepository
48		* @param EventManager $eventManager
49		* @param ProjectConfig $config
50		* @param UnInstallStrategyInterface $unInstallStrategy
51		* @param InstallStrategyFactory $installStrategyFactory
52		*/
53	7	public function __construct(
54		InstalledPackageRepositoryInterface $installedRepository,
55		EventManager $eventManager,
56		ProjectConfig $config,
57		UnInstallStrategyInterface $unInstallStrategy,
58		InstallStrategyFactory $installStrategyFactory
59		) {
60	7	$this->installedPackageRepository = $installedRepository;
61	7	$this->eventManager = $eventManager;
62	7	$this->config = $config;
63	7	$this->unInstallStrategy = $unInstallStrategy;
64	7	$this->installStrategyFactory = $installStrategyFactory;
65	7	}
66
67		/**
68		* @param array $currentComposerInstalledPackages
69		* @return array
70		*/
71	7	public function updateInstalledPackages(array $currentComposerInstalledPackages)
72		{
73	7	$packagesToRemove = $this->getRemoves(
74		$currentComposerInstalledPackages,
75	7	$this->installedPackageRepository->findAll()
76		);
77
78	7	$packagesToInstall = $this->getInstalls($currentComposerInstalledPackages);
79
80	7	$this->doRemoves($packagesToRemove);
81	7	$this->doInstalls($packagesToInstall);
82
83		return array(
84	7	$packagesToRemove,
85	7	$packagesToInstall
86		);
87		}
88
89		/**
90		* @param PackageInterface[] $packagesToInstall
91		*/
92	7	public function doInstalls(array $packagesToInstall)
93		{
94	7	foreach ($packagesToInstall as $install) {
95	5	$installStrategy = $this->installStrategyFactory->make(
96		$install,
97	5	$this->getPackageSourceDirectory($install)
98		);
99
100	5	$deployEntry = new Entry();
101	5	$deployEntry->setPackageName($install->getPrettyName());
102	5	$deployEntry->setDeployStrategy($installStrategy);
103	5	$this->eventManager->dispatch(
104	5	new PackageDeployEvent('pre-package-deploy', $deployEntry)
105		);
106	5	$files = $installStrategy->deploy()->getDeployedFiles();
107	5	$this->eventManager->dispatch(
108	5	new PackageDeployEvent('post-package-deploy', $deployEntry)
109		);
110	5	$this->installedPackageRepository->add(new InstalledPackage(
111	5	$install->getName(),
112	5	$this->createVersion($install),
113		$files
114		));
115		}
116	7	}
117
118		/**
119		* @param InstalledPackage[] $packagesToRemove
120		*/
121	7	public function doRemoves(array $packagesToRemove)
122		{
123	7	foreach ($packagesToRemove as $remove) {
124	5	$this->eventManager->dispatch(new PackageUnInstallEvent('pre-package-uninstall', $remove));
125	5	$this->unInstallStrategy->unInstall($remove->getInstalledFiles());
126	5	$this->eventManager->dispatch(new PackageUnInstallEvent('post-package-uninstall', $remove));
127	5	$this->installedPackageRepository->remove($remove);
128		}
129	7	}
130
131		/**
132		* @param PackageInterface[] $currentComposerInstalledPackages
133		* @param InstalledPackage[] $magentoInstalledPackages
134		* @return InstalledPackage[]
135		*/
136	7	public function getRemoves(array $currentComposerInstalledPackages, array $magentoInstalledPackages)
137		{
138		//make the package names as the array keys
139	7	if (count($currentComposerInstalledPackages)) {
140	6	$currentComposerInstalledPackages = array_combine(
141		array_map(
142		function (PackageInterface $package) {
143	6	return $package->getName();
144	6	},
145		$currentComposerInstalledPackages
146		),
147		$currentComposerInstalledPackages
148		);
149		}
150	7	return array_filter(
151		$magentoInstalledPackages,
152		function (InstalledPackage $package) use ($currentComposerInstalledPackages) {
153	6	if (!isset($currentComposerInstalledPackages[$package->getName()])) {
154	2	return true;
155		}
156
157	5	$composerPackage = $currentComposerInstalledPackages[$package->getName()];
158	5	return $package->getVersion() !== $this->createVersion($composerPackage);
159	7	}
160		);
161		}
162
163		/**
164		* @param PackageInterface[] $currentComposerInstalledPackages
165		* @return PackageInterface[]
166		*/
167	7	public function getInstalls(array $currentComposerInstalledPackages)
168		{
169	7	$repo = $this->installedPackageRepository;
170		$packages = array_filter($currentComposerInstalledPackages, function (PackageInterface $package) use ($repo) {
171	6	return !$repo->has($package->getName(), $this->createVersion($package));
172	7	});
173
174	7	$config = $this->config;
175	7	usort($packages, function (PackageInterface $aObject, PackageInterface $bObject) use ($config) {
176	1	$a = $config->getModuleSpecificSortValue($aObject->getName());
177	1	$b = $config->getModuleSpecificSortValue($bObject->getName());
178	1	if ($a == $b) {
179	1	return strcmp($aObject->getName(), $bObject->getName());
180		/**
181		* still changes sort order and breaks a test, so for now strcmp as workaround
182		* to keep the test working.
183		*/
184		// return 0;
185		}
186		return ($a < $b) ? -1 : 1;
187	7	});
188
189	7	return $packages;
190		}
191
192		/**
193		* @param PackageInterface $package
194		* @return string
195		*/
196	5	private function getPackageSourceDirectory(PackageInterface $package)
197		{
198	5	$path = sprintf("%s/%s", $this->config->getVendorDir(), $package->getPrettyName());
199	5	$targetDir = $package->getTargetDir();
200
201	5	if ($targetDir) {
202		$path = sprintf("%s/%s", $path, $targetDir);
203		}
204
205	5	$path = realpath($path);
206	5	return $path;
207		}
208
209		/**
210		* Create a version string which is unique. dev-master
211		* packages report a version of 9999999-dev. We need a unique version
212		* so we can detect changes. here we use the source reference which
213		* in the case of git is the commit hash
214		*
215		* @param PackageInterface $package
216		*
217		* @return string
218		*/
219	6	private function createVersion(PackageInterface $package)
220		{
221	6	$version = $package->getVersion();
222
223	6	if (null !== $package->getSourceReference()) {
224	1	$version = sprintf('%s-%s', $version, $package->getSourceReference());
225		}
226
227	6	return $version;
228		}
229		}
230

Cotya / magento-composer-installer

Push — 3.0 ( ac6a55...46111f )

ModuleManager::createVersion() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like