PatchRegistry.php

Go to the documentation of this file.

<?php
namespace Magento\Framework\Setup\Patch;

class PatchRegistry implements \IteratorAggregate
{
    private $dependents = [];

    private $patches = [];

    private $patchFactory;

    private $appliedPatches = [];

    private $patchHistory;

    private $iterator = null;

    private $reverseIterator = null;

    private $cyclomaticStack = [];

    public function __construct(PatchFactory $patchFactory, PatchHistory $patchHistory)
    {
        $this->patchFactory = $patchFactory;
        $this->patchHistory = $patchHistory;
    }

    private function registerDependents(string $patchName)
    {
        $dependencies = $patchName::getDependencies();

        foreach ($dependencies as $dependency) {
            $this->dependents[$dependency][] = $patchName;
        }
    }

    public function registerPatch(string $patchName)
    {
        if ($this->patchHistory->isApplied($patchName)) {
            $this->appliedPatches[$patchName] = $patchName;
            $this->registerDependents($patchName);
            return false;
        }

        if (isset($this->patches[$patchName])) {
            return $this->patches[$patchName];
        }

        $this->patches[$patchName] = $patchName;
        return $patchName;
    }

    private function getDependentPatches(string $patch)
    {
        $patches = [];
        $patchName = $patch;

        if (isset($this->dependents[$patchName])) {
            foreach ($this->dependents[$patchName] as $dependent) {
                if (isset($this->appliedPatches[$dependent])) {
                    $dependent = $this->appliedPatches[$dependent];
                    $patches = array_replace($patches, $this->getDependentPatches($dependent));
                    $patches[$dependent] = $dependent;
                    unset($this->appliedPatches[$dependent]);
                }
            }
        }

        return $patches;
    }

    private function getDependencies(string $patch)
    {
        $depInstances = [];
        $deps = call_user_func([$patch, 'getDependencies']);
        $this->cyclomaticStack[$patch] = true;

        foreach ($deps as $dep) {
            if (isset($this->cyclomaticStack[$dep])) {
                throw new \LogicException("Cyclomatic dependency during patch installation");
            }

            $depInstance = $this->registerPatch($dep);
            if (!$depInstance) {
                continue;
            }

            $depInstances = array_replace($depInstances, $this->getDependencies($this->patches[$dep]));
            $depInstances[$depInstance] = $depInstance;
        }

        unset($this->cyclomaticStack[$patch]);
        return $depInstances;
    }

    public function getReverseIterator()
    {
        if ($this->reverseIterator === null) {
            $reversePatches = [];

            while (!empty($this->appliedPatches)) {
                $patch = array_pop($this->appliedPatches);
                $reversePatches = array_replace($reversePatches, $this->getDependentPatches($patch));
                $reversePatches[$patch] = $patch;
            }

            $this->reverseIterator = new \ArrayIterator($reversePatches);
        }

        return $this->reverseIterator;
    }

    public function getIterator()
    {
        if ($this->iterator === null) {
            $installPatches = [];
            $patchInstances = $this->patches;

            while (!empty($patchInstances)) {
                $firstPatch = array_shift($patchInstances);
                $deps = $this->getDependencies($firstPatch);

                foreach ($deps as $dep) {
                    unset($patchInstances[$dep]);
                }

                $installPatches = array_replace($installPatches, $deps);
                $installPatches[$firstPatch] = $firstPatch;
            }

            $this->iterator = new \ArrayIterator($installPatches);
        }

        return $this->iterator;
    }
}