Sylius\Bundle\ThemeBundle\Asset\Installer\AssetsInstaller

Complexity

Total Complexity

27

Size/Duplication

Total Lines	253
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	10

Importance

Changes	8
Bugs	3	Features	1

10 Methods

Rating	Name	Duplication	Size	Complexity
A	installVanillaBundleAssets()	0	4	1
A	findAssetsPaths()	0	18	4
A	__construct()	0	13	1
A	installAssets()	0	13	2
B	installBundleAssets()	0	27	4
B	installThemedBundleAssets()	0	26	3
B	installAsset()	0	29	6
A	doInstallAsset()	0	9	2
A	doSymlinkAsset()	0	8	2
A	doCopyAsset()	0	11	2

<?php

/*
 * This file is part of the Sylius package.
 *
 * (c) Paweł Jędrzejewski
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Sylius\Bundle\ThemeBundle\Asset\Installer;

use Sylius\Bundle\ThemeBundle\Asset\PathResolverInterface;
use Sylius\Bundle\ThemeBundle\Model\ThemeInterface;
use Sylius\Bundle\ThemeBundle\Repository\ThemeRepositoryInterface;
use Sylius\Bundle\ThemeBundle\HierarchyProvider\ThemeHierarchyProviderInterface;
use Symfony\Component\Filesystem\Exception\IOException;
use Symfony\Component\Filesystem\Filesystem;
use Symfony\Component\Finder\Finder;
use Symfony\Component\Finder\SplFileInfo;
use Symfony\Component\HttpKernel\Bundle\BundleInterface;
use Symfony\Component\HttpKernel\KernelInterface;

/**
 * @author Kamil Kokot <kamil.kokot@lakion.com>
 */
class AssetsInstaller implements AssetsInstallerInterface
{
    /**
     * @var Filesystem
     */
    protected $filesystem;
    
    /**
     * @var KernelInterface
     */
    protected $kernel;
    
    /**
     * @var ThemeRepositoryInterface
     */
    protected $themeRepository;

    /**
     * @var ThemeHierarchyProviderInterface
     */
    protected $themeHierarchyProvider;

    /**
     * @var PathResolverInterface
     */
    protected $pathResolver;

    /**
     * @param Filesystem $filesystem
     * @param KernelInterface $kernel
     * @param ThemeRepositoryInterface $themeRepository
     * @param ThemeHierarchyProviderInterface $themeHierarchyProvider
     * @param PathResolverInterface $pathResolver
     */
    public function __construct(
        Filesystem $filesystem,
        KernelInterface $kernel,
        ThemeRepositoryInterface $themeRepository,
        ThemeHierarchyProviderInterface $themeHierarchyProvider,
        PathResolverInterface $pathResolver
    ) {
        $this->filesystem = $filesystem;
        $this->kernel = $kernel;
        $this->themeRepository = $themeRepository;
        $this->themeHierarchyProvider = $themeHierarchyProvider;
        $this->pathResolver = $pathResolver;
    }

    /**
     * {@inheritdoc}
     */
    public function installAssets($targetDir, $symlinkMask)
    {
        // Create the bundles directory otherwise symlink will fail.
        $targetDir = rtrim($targetDir, '/') . '/bundles/';
        $this->filesystem->mkdir($targetDir);

        $effectiveSymlinkMask = $symlinkMask;
        foreach ($this->kernel->getBundles() as $bundle) {
            $effectiveSymlinkMask = min($effectiveSymlinkMask, $this->installBundleAssets($bundle, $targetDir, $symlinkMask));
        }

        return $effectiveSymlinkMask;
    }

    /**
     * {@inheritdoc}
     */
    public function installBundleAssets(BundleInterface $bundle, $targetDir, $symlinkMask)
    {
        $targetDir .= preg_replace('/bundle$/', '', strtolower($bundle->getName()));

        $this->filesystem->remove($targetDir);

        $effectiveSymlinkMask = $symlinkMask;
        foreach ($this->findAssetsPaths($bundle) as $originDir) {
            $effectiveSymlinkMask = min(
                $effectiveSymlinkMask,
                $this->installVanillaBundleAssets($originDir, $targetDir, $symlinkMask)
            );
        }

        foreach ($this->themeRepository->findAll() as $theme) {
            $themes = $this->themeHierarchyProvider->getThemeHierarchy($theme);

            foreach ($this->findAssetsPaths($bundle, $themes) as $originDir) {
                $effectiveSymlinkMask = min(
                    $effectiveSymlinkMask,
                    $this->installThemedBundleAssets($theme, $originDir, $targetDir, $symlinkMask)
                );
            }
        }

        return $effectiveSymlinkMask;
    }

    /**
     * @param ThemeInterface $theme
     * @param string $originDir
     * @param string $targetDir
     * @param int $symlinkMask
     *
     * @return int
     */
    protected function installThemedBundleAssets(ThemeInterface $theme, $originDir, $targetDir, $symlinkMask)
    {
        $effectiveSymlinkMask = $symlinkMask;

        $finder = new Finder();
        $finder->sortByName()->ignoreDotFiles(false)->in($originDir);

        /** @var SplFileInfo[] $finder */
        foreach ($finder as $originFile) {
            $targetFile = $targetDir . '/' . $originFile->getRelativePathname();
            $targetFile = $this->pathResolver->resolve($targetFile, $theme);

            if (file_exists($targetFile)) {
                continue;
            }

            $this->filesystem->mkdir(dirname($targetFile));

            $effectiveSymlinkMask = min(
                $effectiveSymlinkMask,
                $this->installAsset($originFile->getPathname(), $targetFile, $symlinkMask)
            );
        }

        return $effectiveSymlinkMask;
    }

    /**
     * @param string $originDir
     * @param string $targetDir
     * @param int $symlinkMask
     *
     * @return int
     */
    protected function installVanillaBundleAssets($originDir, $targetDir, $symlinkMask)
    {
        return $this->installAsset($originDir, $targetDir, $symlinkMask);
    }

    /**
     * @param string $origin
     * @param string $target
     * @param int $symlinkMask
     *
     * @return int
     */
    protected function installAsset($origin, $target, $symlinkMask)
    {
        if (AssetsInstallerInterface::RELATIVE_SYMLINK === $symlinkMask) {
            try {
                $targetDirname = realpath(is_dir($target) ? $target : dirname($target));
                $relativeOrigin = rtrim($this->filesystem->makePathRelative($origin, $targetDirname), '/');

                $this->doInstallAsset($relativeOrigin, $target, true);

                return AssetsInstallerInterface::RELATIVE_SYMLINK;
            } catch (IOException $exception) {
                // Do nothing, trying to create non-relative symlinks later.
            }
        }

        if (AssetsInstallerInterface::HARD_COPY !== $symlinkMask) {
            try {
                $this->doInstallAsset($origin, $target, true);

                return AssetsInstallerInterface::SYMLINK;
            } catch (IOException $exception) {
                // Do nothing, hard copy later.
            }
        }

        $this->doInstallAsset($origin, $target, false);

        return AssetsInstallerInterface::HARD_COPY;
    }

    /**
     * @param string $origin
     * @param string $target
     * @param bool $symlink
     *
     * @throws IOException When failed to make symbolic link, if requested.
     */
    protected function doInstallAsset($origin, $target, $symlink)
    {
        if ($symlink) {
            $this->doSymlinkAsset($origin, $target);
            return;
        }

        $this->doCopyAsset($origin, $target);
    }

    /**
     * @param BundleInterface $bundle
     * @param ThemeInterface[] $themes
     *
     * @return array
     */
    protected function findAssetsPaths(BundleInterface $bundle, array $themes = [])
    {
        $sources = [];

        foreach ($themes as $theme) {
            $sourceDir = $theme->getPath() . '/' . $bundle->getName() . '/public';
            if (is_dir($sourceDir)) {
                $sources[] = $sourceDir;
            }
        }

        $sourceDir = $bundle->getPath() . '/Resources/public';
        if (is_dir($sourceDir)) {
            $sources[] = $sourceDir;
        }

        return $sources;
    }

    /**
     * @param string $origin
     * @param string $target
     *
     * @throws IOException If symbolic link is broken
     */
    private function doSymlinkAsset($origin, $target)
    {
        $this->filesystem->symlink($origin, $target);

        if (!file_exists($target)) {
            throw new IOException('Symbolic link is broken');
        }
    }

    /**
     * @param string $origin
     * @param string $target
     */
    private function doCopyAsset($origin, $target)
    {
        if (is_dir($origin)) {
            $this->filesystem->mkdir($target, 0777);
            $this->filesystem->mirror($origin, $target, Finder::create()->ignoreDotFiles(false)->in($origin));

            return;
        }

        $this->filesystem->copy($origin, $target);
    }
}