Slince\Crm\RegistryManager

Complexity

Total Complexity

21

Size/Duplication

Total Lines	161
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Importance

Changes	1
Bugs	0	Features	0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	readRegistriesFromFile()	0	4	1
A	dumpRepositoriesToFile()	0	5	1
A	getRegistries()	0	4	1
A	addRegistry()	0	14	2
A	removeRegistry()	0	7	2
A	findRegistry()	0	9	3
A	useRegistry()	0	5	1
B	getCurrentRegistry()	0	19	5
A	makeUseRegistryCommand()	0	7	2
A	runSystemCommand()	0	8	2

<?php
/**
 * CRM library
 * @author Tao <taosikai@yeah.net>
 */
namespace Slince\Crm;

use Slince\Crm\Exception\InvalidArgumentException;
use Slince\Crm\Exception\RegistryNotExistsException;
use Slince\Crm\Exception\RuntimeException;

class RegistryManager
{
    /**
     * registry collection
     * @var RegistryCollection
     */
    protected $registries;

    public function __construct()
    {
        $this->registries = new RegistryCollection();
    }

    /**
     * Read repositories from file
     * @param $file
     */
    public function readRegistriesFromFile($file)
    {
        $this->registries = RegistryCollection::fromArray(Utils::readJsonFile($file));
    }

    /**
     * Dump all registries to file
     * @param $file
     */
    public function dumpRepositoriesToFile($file)
    {
        $registries = $this->registries->toArray();
        Utils::getFilesystem()->dumpFile($file, json_encode($registries, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES));
    }

    /**
     * @return RegistryCollection
     */
    public function getRegistries()
    {
        return $this->registries;
    }

    /**
     * Add one registry
     * @param string $name
     * @param string $url
     * @throws InvalidArgumentException
     * @return Registry
     */
    public function addRegistry($name, $url)
    {
        try {
            $this->findRegistry($name);
            throw new InvalidArgumentException(sprintf("Registry [%s] already exists", $name));
        } catch (RegistryNotExistsException $exception) {
            $registry = Registry::create([
                'name' => $name,
                'url' => $url
            ]);
            $this->registries->add($registry);
        }
        return $registry;
    }

    /**
     * Remove registry
     * @param string $name
     */
    public function removeRegistry($name)
    {
        try {
            $registry = $this->findRegistry($name);
            $this->registries->remove($registry);
        } catch (RegistryNotExistsException $exception) {}

Consider adding a comment why this CATCH block is empty.

    }

    /**
     * Find registry
     * @param $name
     * @return Registry
     * @throws RegistryNotExistsException
     */
    public function findRegistry($name)
    {
        foreach ($this->registries as $registry) {
            if (strcasecmp($name, $registry->getName()) == 0) {
                return $registry;
            }
        }
        throw new RegistryNotExistsException($name);
    }

    /**
     * Use Registry
     * @param Registry $registry
     * @param boolean $isCurrent
     * @return void
     * @codeCoverageIgnore
     */
    public function useRegistry(Registry $registry, $isCurrent = false)
    {
        $command = $this->makeUseRegistryCommand($registry, $isCurrent);
        $this->runSystemCommand($command);
    }

    /**
     * Get Current Registry
     * @param boolean $isCurrent
     * @throws RuntimeException
     * @return Registry
     * @codeCoverageIgnore
     */
    public function getCurrentRegistry($isCurrent = false)
    {
        $rawOutput = $this->runSystemCommand($isCurrent
            ? "composer config repo.packagist.org"
            : "composer config -g repo.packagist.org");
        $registryData = json_decode($rawOutput, true);
        if (json_last_error()) {
            throw new RuntimeException(sprintf("Can not find current registry, error: %s", json_last_error_msg()));
        }
        foreach ($this->registries as $registry) {
            if (strcasecmp($registry->getUrl(), $registryData['url']) == 0) {
                return $registry;
            }
        }
        return Registry::create([
            'url' => $registryData['url'],
            'name' => 'unknown'
        ]);
    }

    /**
     * Make change registry command string
     * @param Registry $registry
     * @param boolean $isCurrent
     * @return string
     * @codeCoverageIgnore
     */
    protected function makeUseRegistryCommand(Registry $registry, $isCurrent)
    {
        $command = $isCurrent
            ? "composer config repo.packagist composer %s"
            : "composer config -g repo.packagist composer %s";
        return sprintf($command, $registry->getUrl());
    }

    /**
     * Run command
     * @param string $command
     * @throws RuntimeException
     * @return string
     * @codeCoverageIgnore
     */
    protected function runSystemCommand($command)
    {
        $return = exec($command, $output, $returnVar);
        if ($returnVar !== 0) {
            throw new RuntimeException(sprintf('Execute the command "%s" failed, "composer" must be set for crm to run correctly', $command));
        }
        return $return;
    }
}