DownloaderComponent::process() - Code Metrics - vaimo/composer-patches - Measure and Improve Code Quality continuously with Scrutinizer

DownloaderComponent::process() B
last analyzed 2025-08-01 12:15 UTC

↳ Parent: DownloaderComponent

Complexity

Conditions	6
Paths	10

Size

Total Lines	65
Code Lines	46

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	6
eloc	46
nc	10
nop	2
dl	0
loc	65
rs	8.5559
c	0
b	0
f	0

How to fix Long Method

<?php
/**
 * Copyright © Vaimo Group. All rights reserved.
 * See LICENSE_VAIMO.txt for license details.
 */
namespace Vaimo\ComposerPatches\Patch\DefinitionList\LoaderComponents;

use Vaimo\ComposerPatches\Patch\Definition as PatchDefinition;
use Vaimo\ComposerPatches\Utils\PathUtils;

class DownloaderComponent implements \Vaimo\ComposerPatches\Interfaces\DefinitionListLoaderComponentInterface
{
    /**
     * @var \Composer\Composer
     */
    private $composer;

    /**
     * @var bool
     */
    private $gracefulMode;

    /**
     * @var \Composer\Downloader\FileDownloader
     */
    private $fileDownloader;

    /**
     * @var \Vaimo\ComposerPatches\Console\Silencer
     */
    private $consoleSilencer;

    /**
     * @var \Composer\Package\PackageInterface
     */
    private $ownerPackage;

    /**
     * @var string
     */
    private $vendorDir;

    /**
     * @var \Vaimo\ComposerPatches\Compatibility\Executor
     */
    private $compExecutor;

    /**
     * @var \Vaimo\ComposerPatches\ErrorHandlers\TransportErrorHandler
     */
    private $errorHandler;

    /**
     * @SuppressWarnings(PHPMD.BooleanArgumentFlag)
     *
     * @param \Composer\Package\PackageInterface $ownerPackage
     * @param \Composer\Downloader\FileDownloader $downloadManager
     * @param \Vaimo\ComposerPatches\Console\Silencer $consoleSilencer
     * @param string $vendorDir
     * @param bool $gracefulMode
     */
    public function __construct(
        \Composer\Composer $composer,
        \Composer\Package\PackageInterface $ownerPackage,
        \Composer\Downloader\FileDownloader $downloadManager,
        \Vaimo\ComposerPatches\Console\Silencer $consoleSilencer,
        $vendorDir,
        $gracefulMode = false
    ) {
        $this->composer = $composer;
        $this->ownerPackage = $ownerPackage;
        $this->fileDownloader = $downloadManager;
        $this->consoleSilencer = $consoleSilencer;
        $this->vendorDir = $vendorDir;
        $this->gracefulMode = $gracefulMode;
        $this->compExecutor = new \Vaimo\ComposerPatches\Compatibility\Executor();
        $this->errorHandler = new \Vaimo\ComposerPatches\ErrorHandlers\TransportErrorHandler($gracefulMode);
    }

    /**
     * @param array $patches
     * @param \Composer\Package\PackageInterface[] $packagesByName
     * @return array
     * @throws \Exception
     */
    public function process(array $patches, array $packagesByName)
    {
        $ownerName = $this->ownerPackage->getName();
        $relativePath = PathUtils::composePath($ownerName, 'downloads');
        $absolutePath = PathUtils::composePath($this->vendorDir, $relativePath);
        $errors = array();
        $compExecutor = $this->compExecutor;
        $errorHandler = $this->errorHandler;

        foreach ($patches as &$packagePatches) {
            foreach ($packagePatches as &$patchData) {
                if (!$patchData[PatchDefinition::URL]) {
                    continue;
                }

                $source = $patchData[PatchDefinition::URL];
                $checksum = $patchData[PatchDefinition::CHECKSUM];
                $hashComponents = array($source, $checksum);
                $sourceHash = md5(implode('|', $hashComponents));
                $package = $this->createPackage($source, $sourceHash, $relativePath, $checksum);
                $destDir = PathUtils::composePath($absolutePath, $sourceHash);
                $destinationFile = PathUtils::composePath($destDir, basename($source));

                try {
                    $downloader = $this->fileDownloader;

                    $this->consoleSilencer->applyToCallback(
                        function () use (
                            $errorHandler,
                            $downloader,
                            $compExecutor,
                            $package,
                            $destDir,
                            $source,
                            &$patchData,
                            &$errors
                        ) {
                            $compExecutor->downloadPackage(
                                $downloader,
                                $package,
                                $source,
                                $destDir,
                                $errorHandler,
                                $patchData,
                                $errors
                            );
                        }
                    );
                } catch (\Composer\Downloader\TransportException $exception) {
                    $patchData[PatchDefinition::STATUS_LABEL] = $errorHandler->handleError($source, $exception);
                    $patchData[PatchDefinition::STATUS] = PatchDefinition::STATUS_ERRORS;
                }

                $compExecutor->assignTmpPathForPatchData($patchData, $destinationFile);
                $patchData[PatchDefinition::TMP] = true;
            }
        }

        $compExecutor->waitDownloadCompletion($this->composer);

        if (count($errors) > 0) {
            throw array_shift($errors);
        }

        return $patches;
    }

    private function createPackage($remoteFile, $name, $targetDir, $checksum = null)
    {
        $version = '0.0.0';
        $package = new \Composer\Package\Package($name, $version, $version);
        $package->setInstallationSource('dist');
        $package->setDistType('file');
        $package->setTargetDir($targetDir);
        $package->setDistUrl($remoteFile);

        if ($checksum) {
            $package->setDistSha1Checksum($checksum);
        }

        return $package;
    }
}


1			<?php
2			/**
3			* Copyright © Vaimo Group. All rights reserved.
4			* See LICENSE_VAIMO.txt for license details.
5			*/
6			namespace Vaimo\ComposerPatches\Patch\DefinitionList\LoaderComponents;
7
8			use Vaimo\ComposerPatches\Patch\Definition as PatchDefinition;
9			use Vaimo\ComposerPatches\Utils\PathUtils;
10
11			class DownloaderComponent implements \Vaimo\ComposerPatches\Interfaces\DefinitionListLoaderComponentInterface
12			{
13			/**
14			* @var \Composer\Composer
15			*/
16			private $composer;
17
18			/**
19			* @var bool
20			*/
21			private $gracefulMode;
22
23			/**
24			* @var \Composer\Downloader\FileDownloader
25			*/
26			private $fileDownloader;
27
28			/**
29			* @var \Vaimo\ComposerPatches\Console\Silencer
30			*/
31			private $consoleSilencer;
32
33			/**
34			* @var \Composer\Package\PackageInterface
35			*/
36			private $ownerPackage;
37
38			/**
39			* @var string
40			*/
41			private $vendorDir;
42
43			/**
44			* @var \Vaimo\ComposerPatches\Compatibility\Executor
45			*/
46			private $compExecutor;
47
48			/**
49			* @var \Vaimo\ComposerPatches\ErrorHandlers\TransportErrorHandler
50			*/
51			private $errorHandler;
52
53			/**
54			* @SuppressWarnings(PHPMD.BooleanArgumentFlag)
55			*
56			* @param \Composer\Package\PackageInterface $ownerPackage
57			* @param \Composer\Downloader\FileDownloader $downloadManager
58			* @param \Vaimo\ComposerPatches\Console\Silencer $consoleSilencer
59			* @param string $vendorDir
60			* @param bool $gracefulMode
61			*/
62			public function __construct(
63			\Composer\Composer $composer,
64			\Composer\Package\PackageInterface $ownerPackage,
65			\Composer\Downloader\FileDownloader $downloadManager,
66			\Vaimo\ComposerPatches\Console\Silencer $consoleSilencer,
67			$vendorDir,
68			$gracefulMode = false
69			) {
70			$this->composer = $composer;
71			$this->ownerPackage = $ownerPackage;
72			$this->fileDownloader = $downloadManager;
73			$this->consoleSilencer = $consoleSilencer;
74			$this->vendorDir = $vendorDir;
75			$this->gracefulMode = $gracefulMode;
76			$this->compExecutor = new \Vaimo\ComposerPatches\Compatibility\Executor();
77			$this->errorHandler = new \Vaimo\ComposerPatches\ErrorHandlers\TransportErrorHandler($gracefulMode);
78			}
79
80			/**
81			* @param array $patches
82			* @param \Composer\Package\PackageInterface[] $packagesByName
83			* @return array
84			* @throws \Exception
85			*/
86			public function process(array $patches, array $packagesByName)
87			{
88			$ownerName = $this->ownerPackage->getName();
89			$relativePath = PathUtils::composePath($ownerName, 'downloads');
90			$absolutePath = PathUtils::composePath($this->vendorDir, $relativePath);
91			$errors = array();
92			$compExecutor = $this->compExecutor;
93			$errorHandler = $this->errorHandler;
94
95			foreach ($patches as &$packagePatches) {
96			foreach ($packagePatches as &$patchData) {
97			if (!$patchData[PatchDefinition::URL]) {
98			continue;
99			}
100
101			$source = $patchData[PatchDefinition::URL];
102			$checksum = $patchData[PatchDefinition::CHECKSUM];
103			$hashComponents = array($source, $checksum);
104			$sourceHash = md5(implode('\|', $hashComponents));
105			$package = $this->createPackage($source, $sourceHash, $relativePath, $checksum);
106			$destDir = PathUtils::composePath($absolutePath, $sourceHash);
107			$destinationFile = PathUtils::composePath($destDir, basename($source));
108
109			try {
110			$downloader = $this->fileDownloader;
111
112			$this->consoleSilencer->applyToCallback(
113			function () use (
114			$errorHandler,
115			$downloader,
116			$compExecutor,
117			$package,
118			$destDir,
119			$source,
120			&$patchData,
121			&$errors
122			) {
123			$compExecutor->downloadPackage(
124			$downloader,
125			$package,
126			$source,
127			$destDir,
128			$errorHandler,
129			$patchData,
130			$errors
131			);
132			}
133			);
134			} catch (\Composer\Downloader\TransportException $exception) {
135			$patchData[PatchDefinition::STATUS_LABEL] = $errorHandler->handleError($source, $exception);
136			$patchData[PatchDefinition::STATUS] = PatchDefinition::STATUS_ERRORS;
137			}
138
139			$compExecutor->assignTmpPathForPatchData($patchData, $destinationFile);
140			$patchData[PatchDefinition::TMP] = true;
141			}
142			}
143
144			$compExecutor->waitDownloadCompletion($this->composer);
145
146			if (count($errors) > 0) {
147			throw array_shift($errors);
148			}
149
150			return $patches;
151			}
152
153			private function createPackage($remoteFile, $name, $targetDir, $checksum = null)
154			{
155			$version = '0.0.0';
156			$package = new \Composer\Package\Package($name, $version, $version);
157			$package->setInstallationSource('dist');
158			$package->setDistType('file');
159			$package->setTargetDir($targetDir);
160			$package->setDistUrl($remoteFile);
161
162			if ($checksum) {
163			$package->setDistSha1Checksum($checksum);
164			}
165
166			return $package;
167			}
168			}
169

vaimo / composer-patches

DownloaderComponent::process() B last analyzed 2025-08-01 12:15 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like

DownloaderComponent::process() B
last analyzed 2025-08-01 12:15 UTC