hiqdev\assetpackagist\models\AssetPackage

Complexity

Total Complexity

42

Size/Duplication

Total Lines	267
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	9

Test Coverage

Coverage

88.24%

Importance

Changes	8
Bugs	0	Features	2

26 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	13	3
A	checkType()	0	4	2
A	checkName()	0	4	1
A	getFullName()	0	4	1
A	buildFullName()	0	4	1
A	getRegistry()	0	7	2
A	splitFullName()	0	7	1
A	getType()	0	4	1
A	getName()	0	4	1
A	getHash()	0	4	1
A	getCommonComposer()	0	13	2
A	setComposer()	0	4	1
A	getComposer()	0	8	2
A	getIO()	0	8	2
A	findOne()	0	7	1
A	load()	0	9	2
A	update()	0	6	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	4	1
A	getUpdateTime()	0	4	1
A	canBeUpdated()	0	4	1
A	canAutoUpdate()	0	4	1

<?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\components\Storage;
use hiqdev\assetpackagist\registry\BowerRegistry;
use hiqdev\assetpackagist\registry\NpmRegistry;
use hiqdev\assetpackagist\registry\RegistryFactory;
use Yii;
use yii\base\Object;

class AssetPackage extends Object
{
    protected $_type;
    protected $_name;
    protected $_hash;
    protected $_releases = [];
    protected $_saved;
    /**
     * @var AssetVcsRepository|BowerRegistry|NpmRegistry
     */
    protected $_registry;

    /**
     * @var integer UNIX Epoch timestamp of the latest package update
     */
    protected $_updateTime;

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

    public function __construct($type, $name, $config = [])
    {
        parent::__construct($config);

        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 getRegistry() {
        if ($this->_registry === null) {
            $this->_registry = RegistryFactory::getRegistry($this->getType(), $this->getComposer()->getRepositoryManager());

It seems like \hiqdev\assetpackagist\registry\RegistryFactory::getRegistry($this->getType(), $this->getComposer()->getRepositoryManager()) of type object<Fxp\Composer\AssetPlugin\Repository\AbstractAssetsRepository> is incompatible with the declared type object<Fxp\Composer\AssetPlugin\Repository\AssetVcsRepository>|object<hiqdev\assetpackagist\registry\BowerRegistry>|object<hiqdev\assetpackagist\registry\NpmRegistry> of property $_registry.

        }

        return $this->_registry;
    }

    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,) = explode('-', $temp);

        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 = (new Factory)->createComposer(
                new NullIO(),
                Yii::getAlias('@composer/composer.json'),

It seems like \Yii::getAlias('@composer/composer.json') targeting yii\BaseYii::getAlias() can also be of type boolean; however, Composer\Factory::createComposer() does only seem to accept array|string|null, maybe add an additional type check?

                false,
                Yii::getAlias('@composer')
            );
        }

        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);
        if ($data !== null) {
            $this->_hash = $data['hash'];
            $this->_releases = $data['releases'];
            $this->_updateTime = $data['updateTime'];
        }
    }

    public function update()
    {
        $repo = $this->getRegistry()->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;
    }

    /**
     * @return Storage
     */
    public function getStorage()
    {
        return Yii::$app->get('packageStorage');
    }

    /**
     * Returns the latest update time (UNIX Epoch)
     * @return int|null
     */
    public function getUpdateTime()
    {
        return $this->_updateTime;
    }

    /**
     * Package can be updated not more often than once in 10 min
     * @return bool
     */
    public function canBeUpdated()
    {
        return time() - $this->getUpdateTime() > 60*10; // 10 min
    }

    /**
     * Whether tha package should be auth-updated (if it is older than 1 day)
     * @return bool
     */
    public function canAutoUpdate()
    {
        return time() - $this->getUpdateTime() > 60*60*24; // 1 day
    }
}