Symplify\PHP7_CodeSniffer\Report\ErrorDataCollector

Complexity

Total Complexity

17

Size/Duplication

Total Lines	124
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

95.65%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	getErrorCount()	0	4	1
A	getFixableErrorCount()	0	4	1
A	getUnfixableErrorCount()	0	4	1
A	getErrorMessages()	0	4	1
A	getUnfixableErrorMessages()	0	12	3
A	addErrorMessage()	0	21	2
A	getSniffFullCode()	0	10	2
A	applyDataToMessage()	0	8	2
A	filterUnfixableErrorMessagesForFile()	0	13	3

<?php

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

namespace Symplify\PHP7_CodeSniffer\Report;

use Symplify\PHP7_CodeSniffer\EventDispatcher\CurrentListenerSniffCodeProvider;
use Symplify\PHP7_CodeSniffer\File\File;

final class ErrorDataCollector
{
    /**
     * @var int
     */
    private $errorCount = 0;

    /**
     * @var int
     */
    private $fixableErrorCount = 0;

    /**
     * @var array[]
     */
    private $errorMessages = [];

    /**
     * @var CurrentListenerSniffCodeProvider
     */
    private $currentListenerSniffCodeProvider;

    /**
     * @var ErrorMessageSorter
     */
    private $errorMessageSorter;

    public function __construct(
        CurrentListenerSniffCodeProvider $currentListenerSniffCodeProvider,
        ErrorMessageSorter $errorMessageSorter
    ) {
        $this->currentListenerSniffCodeProvider = $currentListenerSniffCodeProvider;
        $this->errorMessageSorter = $errorMessageSorter;
    }

    public function getErrorCount() : int
    {
        return $this->errorCount;
    }

    public function getFixableErrorCount() : int
    {
        return $this->fixableErrorCount;
    }

    public function getUnfixableErrorCount() : int
    {
        return $this->errorCount - $this->fixableErrorCount;
    }

    public function getErrorMessages() : array
    {
        return $this->errorMessageSorter->sortByFileAndLine($this->errorMessages);
    }

    public function getUnfixableErrorMessages() : array
    {
        $unfixableErrorMessages = [];
        foreach ($this->getErrorMessages() as $file => $errorMessagesForFile) {
            $unfixableErrorMessagesForFile = $this->filterUnfixableErrorMessagesForFile($errorMessagesForFile);
            if (count($unfixableErrorMessagesForFile)) {
                $unfixableErrorMessages[$file] = $unfixableErrorMessagesForFile;
            }
        }

        return $unfixableErrorMessages;
    }

    public function addErrorMessage(
        string $filePath,
        string $message,
        int $line,
        string $sniffCode,
        array $data = [],
        bool $isFixable = false
    ) {
        $this->errorCount++;

        if ($isFixable) {
            $this->fixableErrorCount++;
        }

        $this->errorMessages[$filePath][] = [
            'line' => $line,
            'message' => $this->applyDataToMessage($message, $data),
            'sniffCode' => $this->getSniffFullCode($sniffCode),
            'isFixable'  => $isFixable
        ];
    }

    private function getSniffFullCode(string $sniffCode) : string
    {
        $parts = explode('.', $sniffCode);
        if ($parts[0] !== $sniffCode) {
            return $sniffCode;
        }

        $listenerSniffCode = $this->currentListenerSniffCodeProvider->getCurrentListenerSniffCode();
        return $listenerSniffCode.'.'.$sniffCode;
    }

    private function applyDataToMessage(string $message, array $data) : string
    {
        if (count($data)) {
            $message = vsprintf($message, $data);
        }

        return $message;
    }

    private function filterUnfixableErrorMessagesForFile(array $errorMessagesForFile) : array
    {
        $unfixableErrorMessages = [];
        foreach ($errorMessagesForFile as $errorMessage) {
            if ($errorMessage['isFixable']) {
                continue;
            }

            $unfixableErrorMessages[] = $errorMessage;
        }

        return $unfixableErrorMessages;
    }
}