SLLH\ComposerVersionsCheck\VersionsCheckPlugin

Complexity

Total Complexity

19

Size/Duplication

Total Lines	152
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	activate()	0	14	3
A	getSubscribedEvents()	0	11	1
A	command()	0	9	3
A	postUpdate()	0	8	3
A	resolveOptions()	0	23	5
A	checkVersions()	0	16	3
A	disable()	0	4	1

<?php

namespace SLLH\ComposerVersionsCheck;

use Composer\Composer;
use Composer\EventDispatcher\EventSubscriberInterface;
use Composer\IO\IOInterface;
use Composer\Package\RootPackageInterface;
use Composer\Plugin\CommandEvent;
use Composer\Plugin\PluginEvents;
use Composer\Plugin\PluginInterface;
use Composer\Repository\RepositoryManager;
use Composer\Script\Event;
use Composer\Script\ScriptEvents;

/**
 * @author Sullivan Senechal <soullivaneuh@gmail.com>
 */
final class VersionsCheckPlugin implements PluginInterface, EventSubscriberInterface
{
    /**
     * @var Composer
     */
    private $composer;

    /**
     * @var IOInterface
     */
    private $io;

    /**
     * @var VersionsCheck
     */
    private $versionsCheck;

    /**
     * @var bool
     */
    private $preferLowest;

    /**
     * @var array
     */
    private $options = array();

    /** @var boolean */
    private $disabled = false;
    
    /**
     * @var array
     */
    private $classes = array(
        "SLLH\ComposerVersionsCheck\VersionsCheckPlugin",
        "SLLH\ComposerVersionsCheck\VersionsCheck",
        "SLLH\ComposerVersionsCheck\OutdatedPackage"
    );

    /**
     * {@inheritdoc}
     */
    public function activate(Composer $composer, IOInterface $io)
    {
        // guard for self-update problem
        foreach ($this->classes as $class) {
            if (!class_exists($class)) {
                return $this->disable();
            }
        }

        $this->composer = $composer;
        $this->io = $io;
        $this->versionsCheck = new VersionsCheck();
        $this->options = $this->resolveOptions();

It seems like $this->resolveOptions() can be null. However, the property $options is declared as array. Maybe change the type of the property to array|null or add a type check?

    }

    /**
     * {@inheritdoc}
     */
    public static function getSubscribedEvents()
    {
        return array(
            PluginEvents::COMMAND => array(
                array('command'),
            ),
            ScriptEvents::POST_UPDATE_CMD => array(
                array('postUpdate', -100),
            ),
        );
    }

    /**
     * @param CommandEvent $event
     */
    public function command(CommandEvent $event)
    {
        if ($this->disabled) {
            return;
        }
        
        $input = $event->getInput();
        $this->preferLowest = $input->hasOption('prefer-lowest') && true === $input->getOption('prefer-lowest');
    }

    /**
     * @param Event $event
     */
    public function postUpdate(Event $event)

The parameter $event is not used and could be removed.

    {
        if ($this->disabled || true === $this->preferLowest) {
            return;
        }

        $this->checkVersions($this->composer->getRepositoryManager(), $this->composer->getPackage());
    }

    /**
     * Tries to get plugin options and resolves them.
     *
     * @return array
     */
    private function resolveOptions()
    {
        if ($this->disabled) {
            return;
        }

        $pluginConfig = $this->composer->getConfig()
            ? $this->composer->getConfig()->get('sllh-composer-versions-check')
            : null
        ;

        $options = array(
            'show-links' => false,
        );

        if (null === $pluginConfig) {
            return $options;
        }

        $options['show-links'] = isset($pluginConfig['show-links']) ? (bool) $pluginConfig['show-links'] : $options['show-links'];

        return $options;
    }

    /**
     * @param RepositoryManager    $repositoryManager
     * @param RootPackageInterface $rootPackage
     */
    private function checkVersions(RepositoryManager $repositoryManager, RootPackageInterface $rootPackage)
    {
        if ($this->disabled) {
            return;
        }
        
        foreach ($repositoryManager->getRepositories() as $repository) {
            $this->versionsCheck->checkPackages(
                $repository,

$repository of type object<Composer\Repository\RepositoryInterface> is not a sub-type of object<Composer\Repository\ArrayRepository>. It seems like you assume a concrete implementation of the interface Composer\Repository\RepositoryInterface to be always present.

                $repositoryManager->getLocalRepository(),
                $rootPackage
            );
        }

        $this->io->write($this->versionsCheck->getOutput($this->options['show-links']), false);
    }
    
    public function disable()
    {
        $this->disabled = true;
    }
}