TheCodingMachine\Discovery\AssetsBuilder

Complexity

Total Complexity

8

Size/Duplication

Total Lines	103
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	9

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	findAssetTypes()	0	16	1
B	buildAssetTypes()	0	24	5
A	getDiscoveryJson()	0	14	1

<?php


namespace TheCodingMachine\Discovery;

use Composer\Installer\InstallationManager;
use Composer\IO\IOInterface;
use Composer\Package\PackageInterface;
use Composer\Repository\RepositoryInterface;
use Symfony\Component\Filesystem\Filesystem;
use TheCodingMachine\Discovery\Utils\JsonException;

/**
 * Transforms discovery.json files into arrays of assets.
 */
class AssetsBuilder
{


    /**
     * @var InstallationManager
     */
    private $installationManager;
    /**
     * @var IOInterface
     */
    private $io;
    /**
     * @var string
     */
    private $rootDir;

    public function __construct(InstallationManager $installationManager, IOInterface $io, string $rootDir)
    {
        $this->installationManager = $installationManager;
        $this->io = $io;
        $this->rootDir = $rootDir;
    }

    /**
     * Find discovery.json files in the passed repository and builds an asset type.
     *
     * @param RepositoryInterface $repository
     * @return AssetType[]
     */
    public function findAssetTypes(RepositoryInterface $repository) : array
    {
        $unorderedPackagesList = $repository->getPackages();

        $orderedPackageList = PackagesOrderer::reorderPackages($unorderedPackagesList);

        $packages = array_filter($orderedPackageList, function (PackageInterface $package) {
            $installationManager = $this->installationManager;

            $packageInstallPath = $installationManager->getInstallPath($package);

            return file_exists($packageInstallPath.'/discovery.json');
        });

        return $this->buildAssetTypes($packages);
    }

    /**
     * Builds the AssetTypes that will be exported in the generated TheCodingMachine\Discovery class.
     *
     * @param PackageInterface[] $discoveryPackages
     *
     * @return AssetType[] An array of AssetType, indexed by asset type name.
     */
    public function buildAssetTypes(array $discoveryPackages) : array
    {
        /* @var $assetTypes AssetType[] */
        $assetTypes = [];

        foreach ($discoveryPackages as $package) {
            try {
                $assetOperationsByType = $this->getDiscoveryJson($package);
                // TODO display warnings if problem with discovery.json without crashing!

                foreach ($assetOperationsByType as $type => $assetOperations) {
                    $assetTypes[$type] = $assetTypes[$type] ?? new AssetType($type);

                    foreach ($assetOperations as $assetOperation) {
                        $assetTypes[$type]->addAssetOperation($assetOperation);
                    }
                }
            } catch (JsonException $exception) {
                $this->io->writeError($exception->getMessage());
            }
        }

        return $assetTypes;
    }

    /**
     * Returns the parsed JSON of the discovery.json file of a package.
     *
     * @param PackageInterface $package
     *
     * @return AssetOperation[][]
     *
     * @throws \TheCodingMachine\Discovery\Utils\JsonException
     */
    private function getDiscoveryJson(PackageInterface $package) : array
    {
        $packageInstallPath = $this->installationManager->getInstallPath($package);

        $fileSystem = new Filesystem();

        $packageDir = $fileSystem->makePathRelative($packageInstallPath, realpath($this->rootDir));

        $path = $packageInstallPath.'/discovery.json';

        $discoveryFileLoader = new DiscoveryFileLoader();

        return $discoveryFileLoader->loadDiscoveryFile(new \SplFileInfo($path), $package->getName(), $packageDir);
    }
}