PackagePool.php

Go to the documentation of this file.

<?php
namespace Magento\Deploy\Package;

use Magento\Deploy\Collector\Collector;
use Magento\Deploy\Console\DeployStaticOptions as Options;
use Magento\Framework\AppInterface;
use Magento\Framework\View\Design\ThemeInterface;
use Magento\Framework\View\Design\Theme\ListInterface;

class PackagePool
{
    private $collector;

    private $themes;

    private $packageFactory;

    private $packages = [];

    private $collected = false;

    public function __construct(
        Collector $collector,
        ListInterface $themeCollection,
        PackageFactory $packageFactory
    ) {
        $this->collector = $collector;
        $themeCollection->clear()->resetConstraints();
        $this->themes = $themeCollection->getItems();
        $this->packageFactory = $packageFactory;
    }

    public function getPackage($path)
    {
        $this->collect();
        return isset($this->packages[$path]) ? $this->packages[$path] : null;
    }

    public function getPackages()
    {
        $this->collect();
        return $this->packages;
    }

    public function getThemeModel($areaCode, $themePath)
    {
        $theme = $this->getThemeByFullPath($areaCode . '/' . $themePath);
        if ($theme && !$theme->getThemePath()) {
            $theme->setThemePath($themePath);
        }
        return $theme;
    }

    public function getPackagesForDeployment(array $options)
    {
        $this->collect();
        $this->ensurePackagesForRequiredLocales($options);

        $toSkip = [];
        $toDeploy = [];
        foreach ($this->packages as $path => $package) {
            if ($this->checkPackageSkip($package, $options)) {
                $toSkip[$path] = $package;
                continue;
            } else {
                $toDeploy[$path] = $package;
            }
        }

        foreach ($toSkip as $path => $package) {
            if (!$this->isAncestorForDeployedPackages($package, $toDeploy)) {
                unset($this->packages[$path]);
            }
        }

        return $this->packages;
    }

    private function isAncestorForDeployedPackages(Package $excludedPackage, array $deployedPackages)
    {
        foreach ($deployedPackages as $deployedPackage) {
            $parents = $deployedPackage->getParentPackages();
            if (array_key_exists($excludedPackage->getPath(), $parents)) {
                return true;
            }
        }
        return false;
    }

    private function getThemeByFullPath($fullPath)
    {
        foreach ($this->themes as $theme) {
            if ($theme->getFullPath() === $fullPath) {
                return $theme;
            }
        }
        return null;
    }

    private function collect($recollect = false)
    {
        if (!$this->collected || $recollect) {
            $this->packages = $this->collector->collect();
            $this->collected = true;
        }
    }

    private function ensurePackagesForRequiredLocales(array $options)
    {
        $this->ensureRequiredLocales($options);

        $resultPackages = $this->packages;

        foreach ($this->themes as $theme) {
            $inheritedThemes = $theme->getInheritedThemes();
            foreach ($resultPackages as $package) {
                if ($package->getTheme() === Package::BASE_THEME) {
                    continue;
                }
                foreach ($inheritedThemes as $inheritedTheme) {
                    if ($package->getTheme() === $inheritedTheme->getThemePath()
                        && $package->getArea() === $inheritedTheme->getArea()
                    ) {
                        $this->ensurePackage([
                            'area' => $package->getArea(),
                            'theme' => $theme->getThemePath(),
                            'locale' => $package->getLocale(),
                            'isVirtual' => $package->getLocale() == Package::BASE_LOCALE
                        ]);
                    }
                }
            }
        }
    }

    private function ensureRequiredLocales(array $options)
    {
        if (empty($options[Options::LANGUAGE]) || $options[Options::LANGUAGE][0] === 'all') {
            $forcedLocales = [AppInterface::DISTRO_LOCALE_CODE];
        } else {
            $forcedLocales = $options[Options::LANGUAGE];
        }

        $resultPackages = $this->packages;
        foreach ($resultPackages as $package) {
            if ($package->getTheme() === Package::BASE_THEME) {
                continue;
            }
            foreach ($forcedLocales as $locale) {
                $this->ensurePackage([
                    'area' => $package->getArea(),
                    'theme' => $package->getTheme(),
                    'locale' => $locale
                ]);
            }
        }
    }

    private function checkPackageSkip(Package $package, array $options)
    {
        return !$this->canDeployArea($package, $options)
        || !$this->canDeployTheme($package, $options)
        || !$this->canDeployLocale($package, $options);
    }

    private function canDeployArea(Package $package, array $options)
    {
        $area = $package->getArea();

        if ($area == 'install') {
            return false;
        }
        if ($area == Package::BASE_AREA) {
            return true;
        }
        $exclude = $this->getOption(Options::EXCLUDE_AREA, $options);
        $include = $this->getOption(Options::AREA, $options);
        return $this->isIncluded($area, $include, $exclude);
    }

    private function canDeployTheme(Package $package, array $options)
    {
        $theme = $package->getTheme();

        if ($theme == Package::BASE_THEME) {
            return true;
        }
        $exclude = $this->getOption(Options::EXCLUDE_THEME, $options);
        $include = $this->getOption(Options::THEME, $options);
        return $this->isIncluded($theme, $include, $exclude);
    }

    private function canDeployLocale(Package $package, array $options)
    {
        $locale = $package->getLocale();
        if ($locale == Package::BASE_LOCALE) {
            return true;
        }
        $exclude = $this->getOption(Options::EXCLUDE_LANGUAGE, $options);
        $include = $this->getOption(Options::LANGUAGE, $options);
        return $this->isIncluded($locale, $include, $exclude);
    }

    private function isIncluded($entity, array $includedEntities, array $excludedEntities)
    {
        $result = true;
        if ($includedEntities[0] === 'all' && $excludedEntities[0] === 'none') {
            $result = true;
        } elseif ($excludedEntities[0] !== 'none') {
            $result = !in_array($entity, $excludedEntities);
        } elseif ($includedEntities[0] !== 'all') {
            $result = in_array($entity, $includedEntities);
        }
        return $result;
    }

    private function getOption($name, $options)
    {
        return isset($options[$name]) ? $options[$name] : null;
    }

    private function ensurePackage(array $params)
    {
        $packagePath = "{$params['area']}/{$params['theme']}/{$params['locale']}";
        if (!isset($this->packages[$packagePath])) {
            $this->packages[$packagePath] = $this->packageFactory->create($params);
        }
    }
}