SLLH\StyleCIBridge\ConfigBridge

Complexity

Total Complexity

46

Size/Duplication

Total Lines	273
Duplicated Lines	2.2 %

Coupling/Cohesion

Components	1
Dependencies	15

Importance

Changes	14
Bugs	2	Features	0

11 Methods

Rating	Name	Duplication	Size	Complexity
C	__construct()	0	38	14
B	create()	0	26	4
B	getFinder()	0	23	5
A	getLevel()	0	16	2
A	getFixers()	0	21	3
B	getRules()	0	23	4
A	getRisky()	0	4	1
A	getPresetFixers()	0	7	1
B	resolveAliases()	6	13	8
A	isFixerAvailable()	0	9	2
A	parseStyleCIConfig()	0	8	2

<?php

namespace SLLH\StyleCIBridge;

use Composer\Semver\Semver;
use SLLH\StyleCIBridge\Exception\LevelConfigException;
use SLLH\StyleCIBridge\StyleCI\Configuration;
use SLLH\StyleCIFixers\Fixers;
use Symfony\Component\Config\Definition\Processor;
use Symfony\Component\Console\Formatter\OutputFormatterStyle;
use Symfony\Component\Console\Output\ConsoleOutput;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\DependencyInjection\Container;
use Symfony\Component\Finder\Finder;
use Symfony\Component\Yaml\Yaml;
use Symfony\CS\Config\Config;
use Symfony\CS\Finder\DefaultFinder;
use Symfony\CS\Fixer;
use Symfony\CS\Fixer\Contrib\HeaderCommentFixer;
use Symfony\CS\FixerFactory;
use Symfony\CS\FixerInterface;

/**
 * @author Sullivan Senechal <soullivaneuh@gmail.com>
 */
final class ConfigBridge
{
    const CS_FIXER_MIN_VERSION = '1.6.1';

    /**
     * @var OutputInterface
     */
    private $output;

    /**
     * @var FixerFactory
     */
    private $fixerFactory = null;

    /**
     * @var string
     */
    private $styleCIConfigDir;

    /**
     * @var array|null
     */
    private $styleCIConfig = null;

    /**
     * @var string|array
     */
    private $finderDirs;

    /**
     * @param string|null       $styleCIConfigDir StyleCI config directory. Called script dir as default.
     * @param string|array|null $finderDirs       A directory path or an array of directories for Finder. Called script dir as default.

This line exceeds maximum limit of 120 characters; contains 135 characters

     */
    public function __construct($styleCIConfigDir = null, $finderDirs = null)
    {
        if (!Semver::satisfies(Fixer::VERSION, sprintf('>=%s', self::CS_FIXER_MIN_VERSION))) {
            throw new \RuntimeException(sprintf(
                'PHP-CS-Fixer v%s is not supported, please upgrade to v%s or higher.',
                Fixer::VERSION,
                self::CS_FIXER_MIN_VERSION
            ));
        }

        // Guess config files path if not specified.
        // getcwd function is not enough. See: https://github.com/Soullivaneuh/php-cs-fixer-styleci-bridge/issues/46
        if (null === $styleCIConfigDir || null === $finderDirs) {
            $dbt = version_compare(PHP_VERSION, '5.4.0', '>=') ? debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 2) : debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS);

This line exceeds maximum limit of 120 characters; contains 160 characters

            // Static call
            if (isset($dbt[1]['class']) && 'SLLH\StyleCIBridge\ConfigBridge' === $dbt[1]['class'] && 'create' === $dbt[1]['function']) {

This line exceeds maximum limit of 120 characters; contains 136 characters

                $configsPath = dirname($dbt[1]['file']);
            } elseif (isset($dbt[0]['class']) && 'SLLH\StyleCIBridge\ConfigBridge' === $dbt[0]['class'] && '__construct' === $dbt[0]['function']) { // Manual instance

This line exceeds maximum limit of 120 characters; contains 166 characters

                $configsPath = dirname($dbt[0]['file']);
            } else { // If no case found, fallback to not reliable getcwd method.
                $configsPath = getcwd();
            }

            $this->styleCIConfigDir = $styleCIConfigDir ?: $configsPath;
            $this->finderDirs = $finderDirs ?: $configsPath;
        }

        $this->output = new ConsoleOutput();
        $this->output->getFormatter()->setStyle('warning', new OutputFormatterStyle('black', 'yellow'));
        // PHP-CS-Fixer 1.x BC
        if (class_exists('Symfony\CS\FixerFactory')) {
            $this->fixerFactory = FixerFactory::create();
            $this->fixerFactory->registerBuiltInFixers();
        }

        $this->parseStyleCIConfig();
    }

    /**
     * @param string       $styleCIConfigDir

Should the type for parameter $styleCIConfigDir not be string|null?

     * @param string|array $finderDirs       A directory path or an array of directories for Finder

Should the type for parameter $finderDirs not be string|array|null? Also, consider making the array more specific, something like array<String>, or String[].

     *
     * @return Config
     */
    public static function create($styleCIConfigDir = null, $finderDirs = null)
    {
        $bridge = new static($styleCIConfigDir, $finderDirs);

        $config = Config::create();

        // PHP-CS-Fixer 1.x BC
        if (method_exists($config, 'level')) {
            $config->level(FixerInterface::NONE_LEVEL);
        }

        if (method_exists($config, 'setRules')) {
            $config->setRules($bridge->getRules());

The method setRules() does not seem to exist on object<Symfony\CS\Config\Config>.

        } else { // PHP-CS-Fixer 1.x BC
            $config->fixers($bridge->getFixers());
        }

        // PHP-CS-Fixer 1.x BC
        if (method_exists($config, 'setRiskyAllowed')) {
            $config->setRiskyAllowed($bridge->getRisky());

The method setRiskyAllowed() does not seem to exist on object<Symfony\CS\Config\Config>.

        }

        return $config
            ->finder($bridge->getFinder())
        ;
    }

    /**
     * @return Finder
     */
    public function getFinder()
    {
        $finder = DefaultFinder::create()->in($this->finderDirs);
        if (isset($this->styleCIConfig['finder'])) {
            $finderConfig = $this->styleCIConfig['finder'];
            foreach ($finderConfig as $key => $values) {
                $finderMethod = Container::camelize($key);
                foreach ($values as $value) {
                    if (method_exists($finder, $finderMethod)) {
                        $finder->$finderMethod($value);
                    } else {
                        $this->output->writeln(sprintf(
                            '<warning>Can not apply "%s" finder option with PHP-CS-Fixer v%s. You fixer config may be erroneous. Consider upgrading to fix it.</warning>',

This line exceeds maximum limit of 120 characters; contains 170 characters

                            str_replace('_', '-', $key),
                            Fixer::VERSION
                        ));
                    }
                }
            }
        }

        return $finder;
    }

    /**
     * @return int
     *
     * @deprecated since 1.1, to be removed in 2.0
     */
    public function getLevel()
    {
        @trigger_error('The '.__METHOD__.' method is deprecated since version 1.1 and will be removed in 2.0.', E_USER_DEPRECATED);

It seems like you do not handle an error condition here. This can introduce security issues, and is generally not recommended.

This line exceeds maximum limit of 120 characters; contains 131 characters

        $preset = $this->styleCIConfig['preset'];
        $validPresets = array(
            'psr1'    => FixerInterface::PSR1_LEVEL,
            'psr2'    => FixerInterface::PSR1_LEVEL,
            'symfony' => FixerInterface::SYMFONY_LEVEL,
        );
        if (!in_array($preset, array_keys($validPresets))) {
            throw new LevelConfigException(sprintf('Invalid preset "%s". Must be one of "%s".', $preset, implode('", "', array_keys($validPresets))));

The class SLLH\StyleCIBridge\Exception\LevelConfigException has been deprecated with message: since 1.1, will be removed in 2.0

This line exceeds maximum limit of 120 characters; contains 150 characters

        }

        return $validPresets[$preset];
    }

    /**
     * @return string[]
     */
    public function getFixers()
    {
        $presetFixers = $this->resolveAliases($this->getPresetFixers());
        $enabledFixers = $this->resolveAliases($this->styleCIConfig['enabled']);
        $disabledFixers = $this->resolveAliases($this->styleCIConfig['disabled']);

        $fixers = array_merge(
            $enabledFixers,
            array_map(function ($disabledFixer) {
                return '-'.$disabledFixer;
            }, $disabledFixers),
            array_diff($presetFixers, $disabledFixers) // Remove disabled fixers from preset
        );

        // PHP-CS-Fixer 1.x BC
        if (method_exists('Symfony\CS\Fixer\Contrib\HeaderCommentFixer', 'getHeader') && HeaderCommentFixer::getHeader()) {

This line exceeds maximum limit of 120 characters; contains 123 characters

            array_push($fixers, 'header_comment');
        }

        return $fixers;
    }

    /**
     * Returns fixers converted to rules for PHP-CS-Fixer 2.x.
     *
     * @return array
     */
    public function getRules()
    {
        $fixers = $this->getFixers();

        $rules = array();
        foreach ($fixers as $fixer) {
            if ('-' === $fixer[0]) {
                $name = substr($fixer, 1);
                $enabled = false;
            } else {
                $name = $fixer;
                $enabled = true;
            }

            if ($this->isFixerAvailable($name)) {
                $rules[$name] = $enabled;
            } else {
                $this->output->writeln(sprintf('<warning>Fixer "%s" does not exist, skipping.</warning>', $name));
            }
        }

        return $rules;
    }

    /**
     * @return bool
     */
    public function getRisky()

function getRisky() does not seem to conform to the naming convention (^(?:is|has|should|may|supports)).

    {
        return $this->styleCIConfig['risky'];
    }

    /**
     * @return string[]
     */
    private function getPresetFixers()
    {
        $preset = $this->styleCIConfig['preset'];
        $validPresets = Fixers::getPresets();

        return $validPresets[$preset];
    }

    /**
     * Adds both aliases and real fixers if set. PHP-CS-Fixer would not take care if not existing.
     * Better compatibility between PHP-CS-Fixer 1.x and 2.x.
     *
     * @param string[] $fixers
     *
     * @return string[]
     */
    private function resolveAliases(array $fixers)
    {
        foreach (Fixers::$aliases as $alias => $name) {
            if (in_array($alias, $fixers, true) && !in_array($name, $fixers, true) && $this->isFixerAvailable($name)) {

This code seems to be duplicated across your project.

                array_push($fixers, $name);
            }
            if (in_array($name, $fixers, true) && !in_array($alias, $fixers, true) && $this->isFixerAvailable($alias)) {

This code seems to be duplicated across your project.

                array_push($fixers, $alias);
            }
        }

        return $fixers;
    }

    /**
     * @param string $name
     *
     * @return bool
     */
    private function isFixerAvailable($name)
    {
        // PHP-CS-Fixer 1.x BC
        if (null === $this->fixerFactory) {
            return true;
        }

        return $this->fixerFactory->hasRule($name);
    }

    private function parseStyleCIConfig()
    {
        if (null === $this->styleCIConfig) {
            $config = Yaml::parse(file_get_contents(sprintf('%s/.styleci.yml', $this->styleCIConfigDir)));
            $processor = new Processor();
            $this->styleCIConfig = $processor->processConfiguration(new Configuration(), array('styleci' => $config));
        }
    }
}