2501472934

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/GsTYPO3/core-patches/commit/<a class=hub.com/GsTYPO3/core-patches/commit/3bbff119d797ff0f6b1f7dee264ab74b52987e84">3bbff119d<a href="https://github.com/GsTYPO3/core-patches/commit/3bbff119d797ff0f6b1f7dee264ab74b52987e84">">Merge </a><a class="double-link" href="https://github.com/GsTYPO3/core-patches/commit/<a class="double-link" href="https://github.com/GsTYPO3/core-patches/commit/689e757fbde584a19d24d67985a7aee284314854">689e757fb</a>">689e757fb</a><a href="https://github.com/GsTYPO3/core-patches/commit/3bbff119d797ff0f6b1f7dee264ab74b52987e84"> into 976a3cd3d">976a3cd3d</a>

Pull Request Pull Request #55: [FEATURE] Check target branch

Run Details

50 of 104 new or added lines in 10 files covered. (48.08%)

221 existing lines in 3 files now uncovered.

376 of 675 relevant lines covered (55.7%)

1.44 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/Utility/ComposerUtils.php

<?php

declare(strict_types=1);

/*
 * This file is part of TYPO3 Core Patches.
 *
 * (c) Gilbertsoft LLC (gilbertsoft.org)
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace GsTYPO3\CorePatches\Utility;

use Composer\Composer;
use Composer\Console\Application;
use Composer\DependencyResolver\Operation\UninstallOperation;
use Composer\Factory;
use Composer\IO\IOInterface;
use Composer\Json\JsonFile;
use Composer\Package\PackageInterface;
use Composer\Semver\Semver;
use Composer\Semver\VersionParser;
use GsTYPO3\CorePatches\Config;
use GsTYPO3\CorePatches\Config\Patches;
use GsTYPO3\CorePatches\Config\PreferredInstall;
use GsTYPO3\CorePatches\Exception\CommandExecutionException;
use GsTYPO3\CorePatches\Exception\InvalidResponseException;
use GsTYPO3\CorePatches\Exception\NoPatchException;
use GsTYPO3\CorePatches\Exception\UnexpectedResponseException;
use GsTYPO3\CorePatches\Exception\UnexpectedValueException;
use GsTYPO3\CorePatches\Gerrit\RestApi;
use React\Promise\PromiseInterface;
use Symfony\Component\Console\Input\ArrayInput;
use Symfony\Component\Console\Output\OutputInterface;

final class ComposerUtils
{
    private Composer $composer;

    private IOInterface $io;

    private Config $config;

    private Application $application;

    private RestApi $gerritRestApi;

    private PatchUtils $patchUtils;

    private VersionParser $versionParser;

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

        $this->config = new Config(new JsonFile(Factory::getComposerFile(), null, $this->io));
        $this->application = new Application();
        $this->application->setAutoExit(false);

        $this->gerritRestApi = new RestApi(Factory::createHttpDownloader($this->io, $this->composer->getConfig()));
        $this->patchUtils = new PatchUtils($this->composer, $this->io);
        $this->versionParser = new VersionParser();
    }

    /**
     * @param array<string, array<string, string>> $patches
     */
    private function addPatchesToConfigFile(array $patches): void
    {
        $configPatches = $this->config->load()->getPatches();

        foreach ($patches as $packgeName => $packagePatches) {
            $configPatches->add($packgeName, $packagePatches);
        }

        $this->config->save();
    }

    /**
     * @param array<int, string> $packages
     */
    private function addAppliedChange(
        int $numericId,
        array $packages,
        bool $includeTests = false,
        string $destination = '',
        int $revision = -1
    ): void {
        $changes = $this->config->load()->getChanges();

        // Avoid saving the patch directory to the patches if default path is used.
        if ($destination === $this->config->getPatchDirectory()) {
            $destination = '';
        }

        if ($changes->has($numericId)) {
            // the package is already listed, skip addition
            return;
        }

        $changes->add($numericId, $packages, $includeTests, $destination, $revision);

        $this->config->save();
    }

    private function addPreferredInstallChanged(string $packageName): void
    {
        $packages = $this->config->load()->getPreferredInstallChanged();

        if ($packages->has($packageName)) {
            // the package is already listed, skip addition
            return;
        }

        $packages->add($packageName);
        $this->config->save();
    }

    private function removePreferredInstallChanged(string $packageName): void
    {
        $packages = $this->config->load()->getPreferredInstallChanged();

        if (!$packages->has($packageName)) {
            // the package is not listed, skip removal
            return;
        }

        $packages->remove($packageName);
        $this->config->save();
    }

    /**
     * @param array<int, string> $changeIds
     * @param array<int, string> $affectedPackages
     */
    private function createPatches(
        array $changeIds,
        string $destination,
        bool $includeTests,
        array &$affectedPackages
    ): int {
        // Process change IDs
        $patchesCount = 0;

        foreach ($changeIds as $changeId) {
            $this->io->write(sprintf('<info>Creating patches for change <comment>%s</comment></info>', $changeId));

            try {
                $subject = $this->gerritRestApi->getSubject($changeId);
                $this->io->write(sprintf('  - Subject is <comment>%s</comment>', $subject));

                $numericId = $this->gerritRestApi->getNumericId($changeId);
                $this->io->write(sprintf('  - Numeric ID is <comment>%s</comment>', $numericId));

                $branch = $this->gerritRestApi->getBranch($changeId);
                $this->io->write(sprintf('  - Branch is <comment>%s</comment>', $branch));
            } catch (UnexpectedResponseException | InvalidResponseException | UnexpectedValueException $th) {
                $this->io->writeError('<warning>Error getting change from Gerrit</warning>');
                $this->io->writeError(sprintf(
                    '<warning>%s</warning>',
                    $th->getMessage()
                ), true, IOInterface::VERBOSE);

                continue;
            }

            if (!$this->checkBranch($numericId, $branch)) {
                $this->io->writeError(sprintf(
                    '<warning>Skipping change %s not matching the installed branch</warning>',
                    $numericId
                ));

                continue;
            }

            try {
                $patches = $this->patchUtils->create(
                    $numericId,
                    $subject,
                    $this->gerritRestApi->getPatch($changeId),
                    $destination,
                    $includeTests
                );
            } catch (NoPatchException $noPatchException) {
                $this->io->writeError('<warning>No patches saved for this change</warning>');

                continue;
            }

            $patchesCreated = count($patches);

            $this->io->write(sprintf(
                '  - Change saved to <comment>%d</comment> patch%s',
                $patchesCreated,
                $patchesCreated === 1 ? '' : 'es'
            ));

            // Adding patches to configuration
            $this->io->write('  - Adding patches to <info>composer.json</info>');
            $this->addPatchesToConfigFile($patches);
            $this->addAppliedChange($numericId, array_keys($patches), $includeTests, $destination);

            $affectedPackages = [...$affectedPackages, ...array_keys($patches)];

            $patchesCount += $patchesCreated;
        }

        return $patchesCount;
    }

    private function checkBranch(int $changeId, string $targetBranch): bool
    {
        if (
            $this->composer->getRepositoryManager()->getLocalRepository()->findPackage(
                'typo3/cms-core',
                $this->versionParser->normalizeBranch($targetBranch)
            ) === null
        ) {
            return $this->io->askConfirmation(
                sprintf(
                    '<info>The change %d is related to the branch "%s" but another version appears to be installed.' .
                    ' Applying the patch may result in errors afterwards. Should the patch for this change be' .
                    ' installed anyway?</info> [<comment>y,N</comment>] ',
                    $changeId,
                    $targetBranch
                ),
                $this->config->load()->getIgnoreBranch()
            );
        }

        return true;
    }

    private function setSourceInstall(string $packageName): void
    {
        /*
        $currentValue = $this->getPreferredInstall();

        if (isset($currentValue[$packageName]) && $currentValue[$packageName] === 'source') {
            // source install for this package is already configured, skip it
            return;
        }

        $this->configSource->addConfigSetting(
            'preferred-install.' . $packageName,
            'source'
        );
        */

        $preferredInstall = $this->config->load()->getPreferredInstall();

        if ($preferredInstall->has($packageName, PreferredInstall::METHOD_SOURCE)) {
            // source install for this package is already configured, skip it
            return;
        }

        $preferredInstall->add($packageName, PreferredInstall::METHOD_SOURCE);

        $this->config->save();

        $this->addPreferredInstallChanged($packageName);
    }

    private function uninstallPackage(PackageInterface $package): ?PromiseInterface
    {
        return $this->composer->getInstallationManager()->uninstall(
            $this->composer->getRepositoryManager()->getLocalRepository(),
            new UninstallOperation($package)
        );
    }

    private function removePatchesFromConfigFile(Patches $patches): void
    {
        $configPatches = $this->config->load()->getPatches();

        foreach ($patches as $packageName => $packagePatches) {
            $configPatches->remove($packageName, $packagePatches);
        }

        $this->config->save();
    }

    private function unsetSourceInstall(string $packageName): void
    {
        $config = $this->config->load();
        $packages = $config->getPreferredInstallChanged();
        $preferredInstall = $config->getPreferredInstall();

        if (!$packages->has($packageName)) {
            // source was not set by this package, skip removal
            return;
        }

        $preferredInstall->remove($packageName);

        $this->config->save();

        $this->removePreferredInstallChanged($packageName);
    }

    private function removeAppliedChange(int $numericId): void
    {
        $changes = $this->config->load()->getChanges();

        if (!$changes->has($numericId)) {
            // the package is not listed, skip removal
            return;
        }

        $changes->remove($numericId);

        $this->config->save();
    }

    /**
     * @return array<int, string>
     */
    private function getPackagesForChange(int $changeId): array
    {
        $changePackages = [];

        $patches = $this->config->getPatches();

        foreach ($patches as $packageName => $packagePatches) {
            foreach ($packagePatches as $packagePatch) {
                if ($this->patchUtils->patchIsPartOfChange($packagePatch, $changeId)) {
                    $changePackages[] = $packageName;
                }
            }
        }

        return $changePackages;
    }

    private function askRemoval(int $changeId): bool
    {
        return $this->io->askConfirmation(
            sprintf(
                '<info>The change %d appears to be present in the version being installed or updated.' .
                ' Should the patch for this change be removed?</info> [<comment>Y,n</comment>] ',
                $changeId
            ),
            true
        );
    }

    /**
     * @throws CommandExecutionException
     */
    private function checkCommandResult(int $resultCode, int $expectedCode, string $errorMessage): void
    {
        if ($resultCode !== $expectedCode) {
            throw new CommandExecutionException($errorMessage, $resultCode);
        }
    }

    /**
     * @param  array<int, string> $changeIds
     * @return int                The number of patches added
     */
    public function addPatches(array $changeIds, string $destination, bool $includeTests): int
    {
        $affectedPackages = [];
        $patchesCount = $this->createPatches($changeIds, $destination, $includeTests, $affectedPackages);

        if ($patchesCount > 0) {
            // Reconfigure preferred-install for packages if changes of tests are patched too
            if ($includeTests) {
                $this->io->write(
                    '<info>Reconfiguring <comment>preferred-install</comment> to <comment>source</comment></info>'
                );

                $affectedPackages = array_unique($affectedPackages);
                $packages = $this->composer->getRepositoryManager()->getLocalRepository()->getPackages();
                $promises = [];

                foreach ($packages as $package) {
                    $packageName = $package->getName();
                    if (in_array($packageName, $affectedPackages, true)) {
                        $this->io->write(sprintf(
                            '  - <info>%s</info>',
                            $packageName
                        ));

                        $this->setSourceInstall($packageName);

                        // Uninstall package to force reinstall from sources
                        $promises[] = $this->uninstallPackage($package);

                        // Remove package from the array
                        $affectedPackages = array_filter(
                            $affectedPackages,
                            fn ($value): bool => $value !== $packageName
                        );
                    }
                }

                // Let Composer remove the packages marked for uninstall
                $promises = array_filter($promises);
                if ($promises !== []) {
                    $this->composer->getLoop()->wait($promises);
                }

                // Show a warning for patches of missing packages
                if ($affectedPackages !== []) {
                    $this->io->write('<warning>Patches for non-existent packages found, these are:</warning>');
                    foreach ($affectedPackages as $affectedPackage) {
                        $this->io->write(sprintf(
                            '  - <info>%s</info>',
                            $affectedPackage
                        ));
                    }
                }
            }
        } else {
            $this->io->write('<warning>No patches created</warning>');
        }

        return $patchesCount;
    }

    /**
     * @param  array<int, string> $changeIds
     * @return int                The number of patches removed
     */
    public function removePatches(array $changeIds, bool $skipUninstall = false): int
    {
        // Process change IDs
        $appliedChanges = $this->config->load()->getChanges();
        $numericIds = [];

        foreach ($changeIds as $changeId) {
            $this->io->write(sprintf(
                '<info>Collecting information for change <comment>%s</comment></info>',
                $changeId
            ));

            try {
                $numericId = $this->gerritRestApi->getNumericId($changeId);
                $this->io->write(sprintf('  - Numeric ID is <comment>%s</comment>', $numericId));
            } catch (UnexpectedResponseException | InvalidResponseException | UnexpectedValueException $th) {
                $this->io->writeError('<warning>Error getting numeric ID</warning>');
                $this->io->writeError(sprintf(
                    '<warning>%s</warning>',
                    $th->getMessage()
                ), true, IOInterface::VERBOSE);

                continue;
            }

            // Check if change was previously added by this plugin or skip
            if (!$appliedChanges->has($numericId)) {
                $this->io->writeError('<warning>Change was not applied by this plugin, skipping</warning>');

                continue;
            }

            $numericIds[] = $numericId;
        }

        // Remove patches
        $patchesCount = 0;
        $patches = $this->config->getPatches();

        if (!$patches->isEmpty() && $numericIds !== []) {
            $this->io->write('<info>Removing patches</info>');

            $patchesToRemove = $this->patchUtils->remove($numericIds, $patches);

            $this->io->write('  - Removing patches from <info>composer.json</info>');
            $this->removePatchesFromConfigFile($patchesToRemove);

            if (!$patchesToRemove->isEmpty()) {
                // Revert source install if the last patch was removed
                $patches = $this->config->getPatches();

                foreach ($patchesToRemove as $packageName => $packagePatches) {
                    if (!isset($patches[$packageName])) {
                        $this->io->write(sprintf(
                            '  - Reconfiguring <info>preferred-install</info> for package <info>%s</info>',
                            $packageName
                        ));
                        $this->unsetSourceInstall($packageName);
                    }

                    $patchesCount += count($packagePatches);
                }

                if (!$skipUninstall) {
                    // Uninstall packages with removed patches
                    $packages = $this->composer->getRepositoryManager()->getLocalRepository()->getPackages();
                    $promises = [];

                    foreach ($packages as $package) {
                        $packageName = $package->getName();
                        if (isset($patchesToRemove[$packageName])) {
                            $this->io->write(sprintf(
                                '<info>Removing package %s so that it can be reinstalled without the patch.</info>',
                                $packageName
                            ));
                            $promises[] = $this->uninstallPackage($package);
                        }
                    }

                    // Let Composer remove the packages marked for uninstall
                    $promises = array_filter($promises);
                    if ($promises !== []) {
                        $this->composer->getLoop()->wait($promises);
                    }
                }
            }

            // Remove patches from applied changes
            foreach ($numericIds as $numericId) {
                $this->removeAppliedChange($numericId);
            }
        } else {
            $this->io->write('<warning>No patches removed</warning>');
        }

        return $patchesCount;
    }

    /**
     * @param  array<int, string> $changeIds
     * @return int                The number of patches added
     */
    public function updatePatches(array $changeIds): int
    {
        $patchesCount = 0;
        $affectedPackages = [];

        $appliedChanges = $this->config->load()->getChanges();
        $patchDirectory = $this->config->getPatchDirectory();

        foreach ($appliedChanges as $appliedChange) {
            if ($changeIds === [] || in_array((string)$appliedChange->getNumber(), $changeIds, true)) {
                $patchesCount += $this->createPatches(
                    [(string)$appliedChange->getNumber()],
                    $appliedChange->getPatchDirectory() !== ''
                        ? $appliedChange->getPatchDirectory() : $patchDirectory,
                    $appliedChange->getTests(),
                    $affectedPackages
                );
            }
        }

        return $patchesCount;
    }

    /**
     * @return array<int, string>
     */
    public function verifyPatchesForPackage(PackageInterface $package): array
    {
        $obsoleteChanges = [];
        $appliedChanges = $this->config->load()->getChanges();
        $patches = $this->config->getPatches();

        foreach ($appliedChanges as $appliedChange) {
            $packages = $this->getPackagesForChange($appliedChange->getNumber());

            if (in_array($package->getName(), $packages, true)) {
                $includedInInfo = $this->gerritRestApi->getIncludedIn((string)$appliedChange->getNumber());

                foreach ($includedInInfo->tags as $tag) {
                    if (Semver::satisfies($package->getVersion(), $tag)) {
                        if ($this->askRemoval($appliedChange->getNumber())) {
                            $obsoleteChanges[] = (string)$appliedChange->getNumber();
                            $this->patchUtils->prepareRemove([$appliedChange->getNumber()], $patches);
                        }

                        continue 2;
                    }
                }

                foreach ($includedInInfo->branches as $branch) {
                    if (Semver::satisfies($package->getVersion(), $branch)) {
                        if ($this->askRemoval($appliedChange->getNumber())) {
                            $obsoleteChanges[] = (string)$appliedChange->getNumber();
                            $this->patchUtils->prepareRemove([$appliedChange->getNumber()], $patches);
                        }

                        continue 2;
                    }
                }
            }
        }

        return $obsoleteChanges;
    }

    /**
     * @throws CommandExecutionException
     */
    public function updateLock(OutputInterface $output): void
    {
        $this->checkCommandResult(
            $this->application->run(
                new ArrayInput([
                    'command' => 'update',
                    '--lock' => true,
                ]),
                $output
            ),
            0,
            'Error while updating the Composer lock file.'
        );
    }
}

1	<?php
2
3	declare(strict_types=1);
4
5	/*
6	* This file is part of TYPO3 Core Patches.
7	*
8	* (c) Gilbertsoft LLC (gilbertsoft.org)
9	*
10	* For the full copyright and license information, please view the LICENSE
11	* file that was distributed with this source code.
12	*/
13
14	namespace GsTYPO3\CorePatches\Utility;
15
16	use Composer\Composer;
17	use Composer\Console\Application;
18	use Composer\DependencyResolver\Operation\UninstallOperation;
19	use Composer\Factory;
20	use Composer\IO\IOInterface;
21	use Composer\Json\JsonFile;
22	use Composer\Package\PackageInterface;
23	use Composer\Semver\Semver;
24	use Composer\Semver\VersionParser;
25	use GsTYPO3\CorePatches\Config;
26	use GsTYPO3\CorePatches\Config\Patches;
27	use GsTYPO3\CorePatches\Config\PreferredInstall;
28	use GsTYPO3\CorePatches\Exception\CommandExecutionException;
29	use GsTYPO3\CorePatches\Exception\InvalidResponseException;
30	use GsTYPO3\CorePatches\Exception\NoPatchException;
31	use GsTYPO3\CorePatches\Exception\UnexpectedResponseException;
32	use GsTYPO3\CorePatches\Exception\UnexpectedValueException;
33	use GsTYPO3\CorePatches\Gerrit\RestApi;
34	use React\Promise\PromiseInterface;
35	use Symfony\Component\Console\Input\ArrayInput;
36	use Symfony\Component\Console\Output\OutputInterface;
37
38	final class ComposerUtils
39	{
40	private Composer $composer;
41
42	private IOInterface $io;
43
44	private Config $config;
45
46	private Application $application;
47
48	private RestApi $gerritRestApi;
49
50	private PatchUtils $patchUtils;
51
52	private VersionParser $versionParser;
53
54	public function __construct(Composer $composer, IOInterface $io)
55	{
UNCOV 56	$this->composer = $composer;	×
UNCOV 57	$this->io = $io;	×
58
NEW UNCOV 59	$this->config = new Config(new JsonFile(Factory::getComposerFile(), null, $this->io));	×
UNCOV 60	$this->application = new Application();	×
61	$this->application->setAutoExit(false);	×
62
UNCOV 63	$this->gerritRestApi = new RestApi(Factory::createHttpDownloader($this->io, $this->composer->getConfig()));	×
UNCOV 64	$this->patchUtils = new PatchUtils($this->composer, $this->io);	×
NEW UNCOV 65	$this->versionParser = new VersionParser();	×
66	}
67
68	/**
69	* @param array<string, array<string, string>> $patches
70	*/
71	private function addPatchesToConfigFile(array $patches): void
72	{
NEW UNCOV 73	$configPatches = $this->config->load()->getPatches();	×
74
UNCOV 75	foreach ($patches as $packgeName => $packagePatches) {	×
UNCOV 76	$configPatches->add($packgeName, $packagePatches);	×
77	}
78
NEW 79	$this->config->save();	×
80	}
81
82	/**
83	* @param array<int, string> $packages
84	*/
85	private function addAppliedChange(
86	int $numericId,
87	array $packages,
88	bool $includeTests = false,
89	string $destination = '',
90	int $revision = -1
91	): void {
NEW UNCOV 92	$changes = $this->config->load()->getChanges();	×
93
94	// Avoid saving the patch directory to the patches if default path is used.
NEW UNCOV 95	if ($destination === $this->config->getPatchDirectory()) {	×
NEW UNCOV 96	$destination = '';	×
97	}
98
UNCOV 99	if ($changes->has($numericId)) {	×
100	// the package is already listed, skip addition
UNCOV 101	return;	×
102	}
103
UNCOV 104	$changes->add($numericId, $packages, $includeTests, $destination, $revision);	×
105
NEW UNCOV 106	$this->config->save();	×
107	}
108
109	private function addPreferredInstallChanged(string $packageName): void
110	{
NEW UNCOV 111	$packages = $this->config->load()->getPreferredInstallChanged();	×
112
NEW UNCOV 113	if ($packages->has($packageName)) {	×
114	// the package is already listed, skip addition
115	return;	×
116	}
117
NEW UNCOV 118	$packages->add($packageName);	×
NEW 119	$this->config->save();	×
120	}
121
122	private function removePreferredInstallChanged(string $packageName): void
123	{
NEW UNCOV 124	$packages = $this->config->load()->getPreferredInstallChanged();	×
125
NEW UNCOV 126	if (!$packages->has($packageName)) {	×
127	// the package is not listed, skip removal
128	return;	×
129	}
130
NEW UNCOV 131	$packages->remove($packageName);	×
NEW 132	$this->config->save();	×
133	}
134
135	/**
136	* @param array<int, string> $changeIds
137	* @param array<int, string> $affectedPackages
138	*/
139	private function createPatches(
140	array $changeIds,
141	string $destination,
142	bool $includeTests,
143	array &$affectedPackages
144	): int {
145	// Process change IDs
UNCOV 146	$patchesCount = 0;	×
147
UNCOV 148	foreach ($changeIds as $changeId) {	×
UNCOV 149	$this->io->write(sprintf('<info>Creating patches for change <comment>%s</comment></info>', $changeId));	×
150
151	try {
UNCOV 152	$subject = $this->gerritRestApi->getSubject($changeId);	×
UNCOV 153	$this->io->write(sprintf(' - Subject is <comment>%s</comment>', $subject));	×
154
UNCOV 155	$numericId = $this->gerritRestApi->getNumericId($changeId);	×
UNCOV 156	$this->io->write(sprintf(' - Numeric ID is <comment>%s</comment>', $numericId));	×
157
NEW UNCOV 158	$branch = $this->gerritRestApi->getBranch($changeId);	×
NEW UNCOV 159	$this->io->write(sprintf(' - Branch is <comment>%s</comment>', $branch));	×
UNCOV 160	} catch (UnexpectedResponseException \| InvalidResponseException \| UnexpectedValueException $th) {	×
UNCOV 161	$this->io->writeError('<warning>Error getting change from Gerrit</warning>');	×
UNCOV 162	$this->io->writeError(sprintf(	×
163	'<warning>%s</warning>',
UNCOV 164	$th->getMessage()	×
165	), true, IOInterface::VERBOSE);
166
UNCOV 167	continue;	×
168	}
169
NEW UNCOV 170	if (!$this->checkBranch($numericId, $branch)) {	×
NEW 171	$this->io->writeError(sprintf(	×
172	'<warning>Skipping change %s not matching the installed branch</warning>',
173	$numericId
174	));
175
NEW UNCOV 176	continue;	×
177	}
178
179	try {
UNCOV 180	$patches = $this->patchUtils->create(	×
181	$numericId,
182	$subject,
183	$this->gerritRestApi->getPatch($changeId),	×
184	$destination,
185	$includeTests
186	);
187	} catch (NoPatchException $noPatchException) {	×
188	$this->io->writeError('<warning>No patches saved for this change</warning>');	×
189
190	continue;	×
191	}
192
193	$patchesCreated = count($patches);	×
194
UNCOV 195	$this->io->write(sprintf(	×
196	' - Change saved to <comment>%d</comment> patch%s',
197	$patchesCreated,
UNCOV 198	$patchesCreated === 1 ? '' : 'es'	×
199	));
200
201	// Adding patches to configuration
UNCOV 202	$this->io->write(' - Adding patches to <info>composer.json</info>');	×
UNCOV 203	$this->addPatchesToConfigFile($patches);	×
UNCOV 204	$this->addAppliedChange($numericId, array_keys($patches), $includeTests, $destination);	×
205
UNCOV 206	$affectedPackages = [...$affectedPackages, ...array_keys($patches)];	×
207
UNCOV 208	$patchesCount += $patchesCreated;	×
209	}
210
211	return $patchesCount;	×
212	}
213
214	private function checkBranch(int $changeId, string $targetBranch): bool
215	{
216	if (
NEW UNCOV 217	$this->composer->getRepositoryManager()->getLocalRepository()->findPackage(	×
218	'typo3/cms-core',
NEW UNCOV 219	$this->versionParser->normalizeBranch($targetBranch)	×
220	) === null
221	) {
NEW UNCOV 222	return $this->io->askConfirmation(	×
NEW UNCOV 223	sprintf(	×
224	'<info>The change %d is related to the branch "%s" but another version appears to be installed.' .
225	' Applying the patch may result in errors afterwards. Should the patch for this change be' .
226	' installed anyway?</info> [<comment>y,N</comment>] ',
227	$changeId,
228	$targetBranch
229	),
NEW 230	$this->config->load()->getIgnoreBranch()	×
231	);
232	}
233
NEW 234	return true;	×
235	}
236
237	private function setSourceInstall(string $packageName): void
238	{
239	/*
240	$currentValue = $this->getPreferredInstall();
241
242	if (isset($currentValue[$packageName]) && $currentValue[$packageName] === 'source') {
243	// source install for this package is already configured, skip it
244	return;
245	}
246
247	$this->configSource->addConfigSetting(
248	'preferred-install.' . $packageName,
249	'source'
250	);
251	*/
252
NEW 253	$preferredInstall = $this->config->load()->getPreferredInstall();	×
254
UNCOV 255	if ($preferredInstall->has($packageName, PreferredInstall::METHOD_SOURCE)) {	×
256	// source install for this package is already configured, skip it
UNCOV 257	return;	×
258	}
259
UNCOV 260	$preferredInstall->add($packageName, PreferredInstall::METHOD_SOURCE);	×
261
NEW UNCOV 262	$this->config->save();	×
263
UNCOV 264	$this->addPreferredInstallChanged($packageName);	×
265	}
266
267	private function uninstallPackage(PackageInterface $package): ?PromiseInterface
268	{
UNCOV 269	return $this->composer->getInstallationManager()->uninstall(	×
UNCOV 270	$this->composer->getRepositoryManager()->getLocalRepository(),	×
UNCOV 271	new UninstallOperation($package)	×
272	);
273	}
274
275	private function removePatchesFromConfigFile(Patches $patches): void
276	{
NEW UNCOV 277	$configPatches = $this->config->load()->getPatches();	×
278
NEW UNCOV 279	foreach ($patches as $packageName => $packagePatches) {	×
NEW 280	$configPatches->remove($packageName, $packagePatches);	×
281	}
282
NEW UNCOV 283	$this->config->save();	×
284	}
285
286	private function unsetSourceInstall(string $packageName): void
287	{
NEW UNCOV 288	$config = $this->config->load();	×
289	$packages = $config->getPreferredInstallChanged();	×
UNCOV 290	$preferredInstall = $config->getPreferredInstall();	×
291
UNCOV 292	if (!$packages->has($packageName)) {	×
293	// source was not set by this package, skip removal
UNCOV 294	return;	×
295	}
296
297	$preferredInstall->remove($packageName);	×
298
NEW UNCOV 299	$this->config->save();	×
300
UNCOV 301	$this->removePreferredInstallChanged($packageName);	×
302	}
303
304	private function removeAppliedChange(int $numericId): void
305	{
NEW UNCOV 306	$changes = $this->config->load()->getChanges();	×
307
UNCOV 308	if (!$changes->has($numericId)) {	×
309	// the package is not listed, skip removal
310	return;	×
311	}
312
313	$changes->remove($numericId);	×
314
NEW UNCOV 315	$this->config->save();	×
316	}
317
318	/**
319	* @return array<int, string>
320	*/
321	private function getPackagesForChange(int $changeId): array
322	{
UNCOV 323	$changePackages = [];	×
324
NEW UNCOV 325	$patches = $this->config->getPatches();	×
326
327	foreach ($patches as $packageName => $packagePatches) {	×
UNCOV 328	foreach ($packagePatches as $packagePatch) {	×
329	if ($this->patchUtils->patchIsPartOfChange($packagePatch, $changeId)) {	×
UNCOV 330	$changePackages[] = $packageName;	×
331	}
332	}
333	}
334
UNCOV 335	return $changePackages;	×
336	}
337
338	private function askRemoval(int $changeId): bool
339	{
340	return $this->io->askConfirmation(	×
UNCOV 341	sprintf(	×
342	'<info>The change %d appears to be present in the version being installed or updated.' .
343	' Should the patch for this change be removed?</info> [<comment>Y,n</comment>] ',
344	$changeId
345	),
346	true
347	);
348	}
349
350	/**
351	* @throws CommandExecutionException
352	*/
353	private function checkCommandResult(int $resultCode, int $expectedCode, string $errorMessage): void
354	{
UNCOV 355	if ($resultCode !== $expectedCode) {	×
UNCOV 356	throw new CommandExecutionException($errorMessage, $resultCode);	×
357	}
358	}
359
360	/**
361	* @param array<int, string> $changeIds
362	* @return int The number of patches added
363	*/
364	public function addPatches(array $changeIds, string $destination, bool $includeTests): int
365	{
UNCOV 366	$affectedPackages = [];	×
UNCOV 367	$patchesCount = $this->createPatches($changeIds, $destination, $includeTests, $affectedPackages);	×
368
UNCOV 369	if ($patchesCount > 0) {	×
370	// Reconfigure preferred-install for packages if changes of tests are patched too
371	if ($includeTests) {	×
UNCOV 372	$this->io->write(	×
373	'<info>Reconfiguring <comment>preferred-install</comment> to <comment>source</comment></info>'
374	);
375
UNCOV 376	$affectedPackages = array_unique($affectedPackages);	×
UNCOV 377	$packages = $this->composer->getRepositoryManager()->getLocalRepository()->getPackages();	×
UNCOV 378	$promises = [];	×
379
UNCOV 380	foreach ($packages as $package) {	×
UNCOV 381	$packageName = $package->getName();	×
UNCOV 382	if (in_array($packageName, $affectedPackages, true)) {	×
UNCOV 383	$this->io->write(sprintf(	×
384	' - <info>%s</info>',
385	$packageName
386	));
387
UNCOV 388	$this->setSourceInstall($packageName);	×
389
390	// Uninstall package to force reinstall from sources
UNCOV 391	$promises[] = $this->uninstallPackage($package);	×
392
393	// Remove package from the array
UNCOV 394	$affectedPackages = array_filter(	×
395	$affectedPackages,
UNCOV 396	fn ($value): bool => $value !== $packageName	×
397	);
398	}
399	}
400
401	// Let Composer remove the packages marked for uninstall
402	$promises = array_filter($promises);	×
UNCOV 403	if ($promises !== []) {	×
UNCOV 404	$this->composer->getLoop()->wait($promises);	×
405	}
406
407	// Show a warning for patches of missing packages
408	if ($affectedPackages !== []) {	×
UNCOV 409	$this->io->write('<warning>Patches for non-existent packages found, these are:</warning>');	×
410	foreach ($affectedPackages as $affectedPackage) {	×
411	$this->io->write(sprintf(	×
412	' - <info>%s</info>',
413	$affectedPackage
414	));
415	}
416	}
417	}
418	} else {
UNCOV 419	$this->io->write('<warning>No patches created</warning>');	×
420	}
421
UNCOV 422	return $patchesCount;	×
423	}
424
425	/**
426	* @param array<int, string> $changeIds
427	* @return int The number of patches removed
428	*/
429	public function removePatches(array $changeIds, bool $skipUninstall = false): int
430	{
431	// Process change IDs
NEW 432	$appliedChanges = $this->config->load()->getChanges();	×
433	$numericIds = [];	×
434
UNCOV 435	foreach ($changeIds as $changeId) {	×
UNCOV 436	$this->io->write(sprintf(	×
437	'<info>Collecting information for change <comment>%s</comment></info>',
438	$changeId
439	));
440
441	try {
UNCOV 442	$numericId = $this->gerritRestApi->getNumericId($changeId);	×
UNCOV 443	$this->io->write(sprintf(' - Numeric ID is <comment>%s</comment>', $numericId));	×
UNCOV 444	} catch (UnexpectedResponseException \| InvalidResponseException \| UnexpectedValueException $th) {	×
UNCOV 445	$this->io->writeError('<warning>Error getting numeric ID</warning>');	×
UNCOV 446	$this->io->writeError(sprintf(	×
447	'<warning>%s</warning>',
UNCOV 448	$th->getMessage()	×
449	), true, IOInterface::VERBOSE);
450
UNCOV 451	continue;	×
452	}
453
454	// Check if change was previously added by this plugin or skip
UNCOV 455	if (!$appliedChanges->has($numericId)) {	×
UNCOV 456	$this->io->writeError('<warning>Change was not applied by this plugin, skipping</warning>');	×
457
UNCOV 458	continue;	×
459	}
460
UNCOV 461	$numericIds[] = $numericId;	×
462	}
463
464	// Remove patches
UNCOV 465	$patchesCount = 0;	×
NEW UNCOV 466	$patches = $this->config->getPatches();	×
467
NEW UNCOV 468	if (!$patches->isEmpty() && $numericIds !== []) {	×
UNCOV 469	$this->io->write('<info>Removing patches</info>');	×
470
UNCOV 471	$patchesToRemove = $this->patchUtils->remove($numericIds, $patches);	×
472
UNCOV 473	$this->io->write(' - Removing patches from <info>composer.json</info>');	×
474	$this->removePatchesFromConfigFile($patchesToRemove);	×
475
NEW 476	if (!$patchesToRemove->isEmpty()) {	×
477	// Revert source install if the last patch was removed
NEW 478	$patches = $this->config->getPatches();	×
479
UNCOV 480	foreach ($patchesToRemove as $packageName => $packagePatches) {	×
481	if (!isset($patches[$packageName])) {	×
UNCOV 482	$this->io->write(sprintf(	×
483	' - Reconfiguring <info>preferred-install</info> for package <info>%s</info>',
484	$packageName
485	));
UNCOV 486	$this->unsetSourceInstall($packageName);	×
487	}
488
UNCOV 489	$patchesCount += count($packagePatches);	×
490	}
491
NEW UNCOV 492	if (!$skipUninstall) {	×
493	// Uninstall packages with removed patches
UNCOV 494	$packages = $this->composer->getRepositoryManager()->getLocalRepository()->getPackages();	×
UNCOV 495	$promises = [];	×
496
UNCOV 497	foreach ($packages as $package) {	×
UNCOV 498	$packageName = $package->getName();	×
499	if (isset($patchesToRemove[$packageName])) {	×
UNCOV 500	$this->io->write(sprintf(	×
501	'<info>Removing package %s so that it can be reinstalled without the patch.</info>',
502	$packageName
503	));
504	$promises[] = $this->uninstallPackage($package);	×
505	}
506	}
507
508	// Let Composer remove the packages marked for uninstall
UNCOV 509	$promises = array_filter($promises);	×
510	if ($promises !== []) {	×
511	$this->composer->getLoop()->wait($promises);	×
512	}
513	}
514	}
515
516	// Remove patches from applied changes
UNCOV 517	foreach ($numericIds as $numericId) {	×
UNCOV 518	$this->removeAppliedChange($numericId);	×
519	}
520	} else {
UNCOV 521	$this->io->write('<warning>No patches removed</warning>');	×
522	}
523
524	return $patchesCount;	×
525	}
526
527	/**
528	* @param array<int, string> $changeIds
529	* @return int The number of patches added
530	*/
531	public function updatePatches(array $changeIds): int
532	{
UNCOV 533	$patchesCount = 0;	×
534	$affectedPackages = [];	×
535
NEW UNCOV 536	$appliedChanges = $this->config->load()->getChanges();	×
NEW UNCOV 537	$patchDirectory = $this->config->getPatchDirectory();	×
538
539	foreach ($appliedChanges as $appliedChange) {	×
540	if ($changeIds === [] \|\| in_array((string)$appliedChange->getNumber(), $changeIds, true)) {	×
541	$patchesCount += $this->createPatches(	×
UNCOV 542	[(string)$appliedChange->getNumber()],	×
NEW UNCOV 543	$appliedChange->getPatchDirectory() !== ''	×
NEW UNCOV 544	? $appliedChange->getPatchDirectory() : $patchDirectory,	×
UNCOV 545	$appliedChange->getTests(),	×
546	$affectedPackages
547	);
548	}
549	}
550
UNCOV 551	return $patchesCount;	×
552	}
553
554	/**
555	* @return array<int, string>
556	*/
557	public function verifyPatchesForPackage(PackageInterface $package): array
558	{
UNCOV 559	$obsoleteChanges = [];	×
NEW UNCOV 560	$appliedChanges = $this->config->load()->getChanges();	×
NEW UNCOV 561	$patches = $this->config->getPatches();	×
562
UNCOV 563	foreach ($appliedChanges as $appliedChange) {	×
UNCOV 564	$packages = $this->getPackagesForChange($appliedChange->getNumber());	×
565
UNCOV 566	if (in_array($package->getName(), $packages, true)) {	×
UNCOV 567	$includedInInfo = $this->gerritRestApi->getIncludedIn((string)$appliedChange->getNumber());	×
568
569	foreach ($includedInInfo->tags as $tag) {	×
570	if (Semver::satisfies($package->getVersion(), $tag)) {	×
571	if ($this->askRemoval($appliedChange->getNumber())) {	×
572	$obsoleteChanges[] = (string)$appliedChange->getNumber();	×
573	$this->patchUtils->prepareRemove([$appliedChange->getNumber()], $patches);	×
574	}
575
UNCOV 576	continue 2;	×
577	}
578	}
579
UNCOV 580	foreach ($includedInInfo->branches as $branch) {	×
UNCOV 581	if (Semver::satisfies($package->getVersion(), $branch)) {	×
UNCOV 582	if ($this->askRemoval($appliedChange->getNumber())) {	×
UNCOV 583	$obsoleteChanges[] = (string)$appliedChange->getNumber();	×
UNCOV 584	$this->patchUtils->prepareRemove([$appliedChange->getNumber()], $patches);	×
585	}
586
UNCOV 587	continue 2;	×
588	}
589	}
590	}
591	}
592
UNCOV 593	return $obsoleteChanges;	×
594	}
595
596	/**
597	* @throws CommandExecutionException
598	*/
599	public function updateLock(OutputInterface $output): void
600	{
601	$this->checkCommandResult(	×
UNCOV 602	$this->application->run(	×
UNCOV 603	new ArrayInput([	×
604	'command' => 'update',
605	'--lock' => true,
606	]),
607	$output
608	),
609	0,
610	'Error while updating the Composer lock file.'
611	);
612	}
613	}

GsTYPO3 / core-patches / 2501472934

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous