hiqdev\assetpackagist\models\AssetPackage

Complexity

Total Complexity

37

Size/Duplication

Total Lines	219
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Test Coverage

Coverage

13.86%

Importance

Changes	6
Bugs	0	Features	0

22 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	11	3
A	checkType()	0	4	2
A	checkName()	0	4	1
A	getFullName()	0	4	1
A	buildFullName()	0	4	1
A	splitFullName()	0	7	1
A	getType()	0	4	1
A	getName()	0	4	1
A	getHash()	0	4	1
A	getCommonComposer()	0	8	2
A	setComposer()	0	4	1
A	getComposer()	0	8	2
A	getIO()	0	8	2
A	findOne()	0	7	1
A	load()	0	6	1
A	update()	0	7	1
B	prepareReleases()	0	31	6
A	prepareUid()	0	6	2
A	getReleases()	0	4	1
A	getRelease()	0	4	2
A	getSaved()	0	8	2
A	getStorage()	0	8	2

<?php

/*
 * Asset Packagist
 *
 * @link      https://github.com/hiqdev/asset-packagist
 * @package   asset-packagist
 * @license   BSD-3-Clause
 * @copyright Copyright (c) 2016, HiQDev (http://hiqdev.com/)
 */

namespace hiqdev\assetpackagist\models;

use Composer\Composer;
use Composer\Factory;
use Composer\IO\NullIO;
use Exception;
use Fxp\Composer\AssetPlugin\Repository\AssetVcsRepository;
use hiqdev\assetpackagist\registry\RegistryFactory;

class AssetPackage
{
    protected $_type;
    protected $_name;
    protected $_hash;
    protected $_releases = [];
    protected $_saved;

    /**
     * @var NullIO
     */
    protected $_io;
    /**
     * @var Composer
     */
    protected $_composer;
    /**
     * @var Storage
     */
    protected $_storage;
    /**
     * @var Composer
     */
    protected static $_commonComposer;

    public function __construct($type, $name)
    {
        if (!$this->checkType($type)) {
            throw new Exception('wrong type');
        }
        if (!$this->checkName($name)) {
            throw new Exception('wrong name');
        }
        $this->_type = $type;
        $this->_name = $name;
    }

    public function checkType($type)
    {
        return $type === 'bower' || $type === 'npm';
    }

    public function checkName($name)
    {
        return strlen($name) > 1;
    }

    public function getFullName()
    {
        return static::buildFullName($this->_type, $this->_name);
    }

    public static function buildFullName($type, $name)
    {
        return $type . '-asset/' . $name;
    }

    public static function splitFullName($full)
    {
        list($temp, $name) = explode('/', $full);
        list($type, $temp) = explode('-', $temp);

The assignment to $temp is unused. Consider omitting it like so list($first,,$third).

        return [$type, $name];
    }

    public function getType()
    {
        return $this->_type;
    }

    public function getName()
    {
        return $this->_name;
    }

    public function getHash()
    {
        return $this->_hash;
    }

    /**
     * @return Composer
     */
    public static function getCommonComposer()
    {
        if (static::$_commonComposer === null) {
            static::$_commonComposer = Factory::create(new NullIO());
        }

        return static::$_commonComposer;
    }

    public function setComposer($value)
    {
        $this->_composer = $value;
    }

    /**
     * @return Composer
     */
    public function getComposer()
    {
        if ($this->_composer === null) {
            $this->_composer = static::getCommonComposer();
        }

        return $this->_composer;
    }

    public function getIO()
    {
        if ($this->_io === null) {
            $this->_io = new NullIO();
        }

        return $this->_io;
    }

    /**
     * findOne.
     *
     * @param string $type
     * @param string $name
     * @return static|null
     */
    public static function findOne($type, $name)
    {
        $package = new static($type, $name);
        $package->load();

        return $package;
    }

    public function load()
    {
        $data = $this->getStorage()->readPackage($this);
        $this->_hash = $data['hash'];
        $this->_releases = $data['releases'];
    }

    public function update()
    {
        $registry = RegistryFactory::getRegistry($this->getType(), $this->getComposer()->getRepositoryManager());
        $repo = $registry->buildVcsRepository($this->getName());
        $this->_releases = $this->prepareReleases($repo);
        $this->_hash = $this->getStorage()->writePackage($this);
    }

    /**
     * @param AssetVcsRepository $repository
     * @return array
     */
    public function prepareReleases($repository)
    {
        $releases = [];
        foreach ($repository->getPackages() as $package) {
            $version = $package->getVersion();
            $release = [
                'uid'       => $this->prepareUid($version),
                'name'      => $this->getFullName(),
                'version'   => $version,
            ];
            if ($package->getDistUrl()) {
                $release['dist'] = [
                    'type'      => $package->getDistType(),
                    'url'       => $package->getDistUrl(),
                    'reference' => $package->getDistReference(),
                ];
            }
            if ($package->getSourceUrl()) {
                $release['source'] = [
                    'type'      => $package->getSourceType(),
                    'url'       => $package->getSourceUrl(),
                    'reference' => $package->getSourceReference(),
                ];
            }
            if ($release['dist'] || $release['source']) {
                $releases[$version] = $release;
            }
        }

        return $releases;
    }

    public function prepareUid($version)
    {
        $known = $this->getSaved()->getRelease($version);

        return isset($known['uid']) ? $known['uid'] : $this->getStorage()->getNextID();
    }

    public function getReleases()
    {
        return $this->_releases;
    }

    public function getRelease($version)
    {
        return isset($this->_releases[$version]) ? $this->_releases[$version] : [];
    }

    public function getSaved()
    {
        if ($this->_saved === null) {
            $this->_saved = static::findOne($this->getType(), $this->getName());
        }

        return $this->_saved;
    }

    public function getStorage()
    {
        if ($this->_storage === null) {
            $this->_storage = Storage::getInstance();
        }

        return $this->_storage;
    }
}