Symplify\PHP7_CodeSniffer\Php7CodeSniffer

Complexity

Total Complexity

15

Size/Duplication

Total Lines	135
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	9

Test Coverage

Coverage

56.89%

Importance

Changes	7
Bugs	0	Features	2

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	13	1
A	runCommand()	0	12	1
A	registerSniffs()	0	11	1
A	runForSource()	0	14	3
A	processFile()	0	9	2
A	processFileWithFixer()	0	16	1
A	setupRequirements()	0	5	1
A	ensureLineEndingsAreDetected()	0	4	1
A	setupVerbosityToMakeLegacyCodeRun()	0	6	2
A	ensureSniffsAreRegistered()	0	9	2

<?php

/*
 * This file is part of Symplify
 * Copyright (c) 2016 Tomas Votruba (http://tomasvotruba.cz).
 */

namespace Symplify\PHP7_CodeSniffer;

use Symplify\PHP7_CodeSniffer\EventDispatcher\Event\CheckFileTokenEvent;
use Symplify\PHP7_CodeSniffer\EventDispatcher\SniffDispatcher;
use Symplify\PHP7_CodeSniffer\Exception\AnySniffMissingException;
use Symplify\PHP7_CodeSniffer\File\File;
use Symplify\PHP7_CodeSniffer\File\Provider\FilesProvider;
use Symplify\PHP7_CodeSniffer\Sniff\SniffFactory;
use Symplify\PHP7_CodeSniffer\Sniff\SniffClassesResolver;

final class Php7CodeSniffer
{
    /**
     * @var SniffDispatcher
     */
    private $sniffDispatcher;

    /**
     * @var FilesProvider
     */
    private $filesProvider;

    /**
     * @var SniffClassesResolver
     */
    private $sniffClassesResolver;

    /**
     * @var SniffFactory
     */
    private $sniffFactory;

    public function __construct(
        SniffDispatcher $sniffDispatcher,
        FilesProvider $sourceFilesProvider,
        SniffClassesResolver $sniffProvider,
        SniffFactory $sniffFactory
    ) {
        $this->sniffDispatcher = $sniffDispatcher;
        $this->filesProvider = $sourceFilesProvider;
        $this->sniffClassesResolver = $sniffProvider;
        $this->sniffFactory = $sniffFactory;

        $this->setupRequirements();
    }

    public function runCommand(Php7CodeSnifferCommand $command)
    {
        $this->registerSniffs(
            $command->getStandards(),
            $command->getSniffs(),
            $command->getExcludedSniffs()
        );

        $this->ensureSniffsAreRegistered();

        $this->runForSource($command->getSource(), $command->isFixer());
    }

    private function registerSniffs(array $standards, array $extraSniffs, array $excludedSniffs)
    {
        $sniffClasses = $this->sniffClassesResolver->resolveFromStandardsAndSniffs(
            $standards,
            $extraSniffs,
            $excludedSniffs
        );

        $sniffs = $this->sniffFactory->createFromSniffClassNames($sniffClasses);
        $this->sniffDispatcher->addSniffListeners($sniffs);
    }

    private function runForSource(array $source, bool $isFixer)
    {
        $files = $this->filesProvider->getFilesForSource($source, $isFixer);

        foreach ($files as $file) {
            if ($isFixer) {
                $this->processFileWithFixer($file);
            } else {
                $this->processFile($file);
            }

            $file->cleanUp(); // todo: check performance influence
        }
    }

    private function processFile(File $file)
    {
        foreach ($file->getTokens() as $stackPointer => $token) {
            $this->sniffDispatcher->dispatch(
                $token['code'],
                new CheckFileTokenEvent($file, $stackPointer)
            );
        }
    }

    private function processFileWithFixer(File $file)
    {
        // 1. puts tokens into fixer
        $file->fixer->startFile($file);

        // 2. run all Sniff fixers
        $this->processFile($file);

        // 3. load changes to tokens
        $file->fixer->endChangeset();

        // 4. content has changed, save it!
        $newContent = $file->fixer->getContents();

        file_put_contents($file->getFilename(), $newContent);
    }

    private function setupRequirements()
    {
        $this->ensureLineEndingsAreDetected();
        $this->setupVerbosityToMakeLegacyCodeRun();
    }

    /**
     * Ensure this option is enabled or else line endings will not always
     * be detected properly for files created on a Mac with the /r line ending.
     */
    private function ensureLineEndingsAreDetected()
    {
        ini_set('auto_detect_line_endings', true);
    }

    private function setupVerbosityToMakeLegacyCodeRun()
    {
        if (!defined('PHP_CODESNIFFER_VERBOSITY')) {
            define('PHP_CODESNIFFER_VERBOSITY', 0);
        }
    }

    private function ensureSniffsAreRegistered()
    {
        $listeners = $this->sniffDispatcher->getListeners();
        if ($listeners === []) {
            throw new AnySniffMissingException(
                'You need to specify some sniffs with "--standards=..." or "--sniffs=...".'
            );
        }
    }
}