Imanghafoori\LaravelMicroscope\ErrorReporters\ErrorPrinter

Complexity

Total Complexity

49

Size/Duplication

Total Lines	297
Duplicated Lines	15.15 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes

0

29 Methods

Rating	Name	Duplication	Size	Complexity
A	authConf()	0	4	1
A	badRelation()	0	6	1
A	view()	0	4	1
A	printFixation()	0	7	1
A	route()	11	11	2
A	doesNotExist()	0	4	1
A	routelessAction()	0	4	1
A	simplePendError()	11	11	2
A	wrongImport()	0	4	1
A	compactError()	11	11	2
A	routeDefinitionConflict()	0	36	4
A	wrongUsedClassError()	0	4	1
A	queryInBlade()	12	12	2
A	wrongMethodError()	0	4	1
A	yellow()	0	4	1
A	badNamespace()	0	11	2
A	print()	0	14	4
A	printHeader()	0	12	2
A	end()	0	5	1
A	printLink()	0	7	2
A	hasErrors()	0	8	1
A	logErrors()	0	16	3
A	possibleFixMsg()	0	7	2
A	wrongImportPossibleFixes()	0	5	1
A	getCount()	0	4	1
A	printTime()	0	4	2
A	thanks()	0	11	1
A	warnIncorrectNamespace()	0	13	3
A	ask()	0	8	2

<?php

namespace Imanghafoori\LaravelMicroscope\ErrorReporters;

use Imanghafoori\LaravelMicroscope\LaravelPaths\FilePath;
use Imanghafoori\LaravelMicroscope\LaravelPaths\LaravelPaths;

class ErrorPrinter
{
    public $errorsList = [
        'total' => 0,
    ];

    public $printer;

    public $logErrors = true;

    public $pended = [];

    public function view($absPath, $message, $lineNumber, $fileName)
    {
        $this->simplePendError($fileName.'.blade.php', $absPath, $lineNumber, 'view', \trim($message), ' does not exist');
    }

    public function printFixation($absPath, $wrongClass, $lineNumber, $correct)
    {
        $header = $wrongClass.'  <===  Did not exist';
        $msg = 'Auto-corrected to:   '.substr($correct[0], 0, 55);

        $this->simplePendError($msg, $absPath, $lineNumber, 'ns_replacement', $header);
    }

    public function route($path, $errorIt, $errorTxt, $absPath = null, $lineNumber = 0)

This method seems to be duplicated in your project.

    {
        if (LaravelPaths::isIgnored($absPath)) {
            return;
        }

        ($this->errorsList['route'][] = (new PendingError('route'))
            ->header($errorIt)
            ->errorData($errorTxt.$this->yellow($path))
            ->link($absPath, $lineNumber));
    }

    public function authConf()
    {
        $this->print('The model in the "config/auth.php" is not a valid class');
    }

    public function badRelation($absPath, $lineNumber, $relatedModel)
    {
        $header = 'Wrong model is passed in relation:';

        $this->doesNotExist($relatedModel, $absPath, $lineNumber, 'badRelation', $header);
    }

    public function doesNotExist($yellowText, $absPath, $lineNumber, $key, $header)
    {
        $this->simplePendError($yellowText, $absPath, $lineNumber, $key, $header, '   <==== does not exist');
    }

    public function routelessAction($absPath, $lineNumber, $msg)
    {
        $this->simplePendError($msg, $absPath, $lineNumber, 'routelessCtrl', 'No route is defined for controller action:');
    }

    public function simplePendError($yellowText, $absPath, $lineNumber, $key, $header, $rest = '')

This method seems to be duplicated in your project.

    {
        if (LaravelPaths::isIgnored($absPath)) {
            return;
        }

        ($this->errorsList[$key][] = (new PendingError($key))
            ->header($header)
            ->errorData($this->yellow($yellowText). $rest)
            ->link($absPath, $lineNumber));
    }

    public function wrongImport($absPath, $class, $lineNumber)
    {
        $this->doesNotExist("use $class;", $absPath, $lineNumber, 'wrongImport', 'Wrong import:');
    }

    public function compactError($path, $lineNumber, $absent, $key, $header)

This method seems to be duplicated in your project.

    {
        if (LaravelPaths::isIgnored($path)) {
            return;
        }

        ($this->errorsList[$key][] = (new PendingError($key))
            ->header($header)
            ->errorData($this->yellow(\implode(', ', array_keys($absent))).' does not exist')
            ->link($path, $lineNumber));
    }

    public function routeDefinitionConflict($route1, $route2, $info)
    {
        if (LaravelPaths::isIgnored($info[0]['file'] ?? 'unknown')) {
            return;
        }

        $key = 'routeDefinitionConflict';
        $routeName = $route1->getName();
        if ($routeName) {
            $routeName = $this->yellow($routeName);
            $msg = 'Route name: '.$routeName;
        } else {
            $routeUri = $route1->uri();
            $routeUri = $this->yellow($routeUri);
            $msg = 'Route uri: '.$routeUri;
        }

        $msg .= "\n".' at '.($info[0]['file'] ?? 'unknown').':'.($info[0]['line'] ?? 2);
        $msg .= "\n".' is overridden by ';

        $routeName = $route2->getName();
        if ($routeName) {
            $routeName = $this->yellow($routeName);
            $msg .= 'route name: '.$routeName;
        } else {
            $msg .= 'an other route with same uri.';
        }

        $msg .= "\n".' at '.($info[1]['file'] ?? ' ').':'.$info[1]['line']."\n";

        $methods = \implode(',', $route1->methods());

        $this->errorsList[$key][$methods] = (new PendingError($key))
            ->header('Route with uri: '.$this->yellow($methods.': /'.$route1->uri()).' is overridden.')
            ->errorData($msg);
    }

    public function wrongUsedClassError($absPath, $class, $lineNumber)
    {
        $this->doesNotExist($class, $absPath, $lineNumber, 'wrongUsedClassError', 'Class does not exist:');
    }

    public function queryInBlade($absPath, $class, $lineNumber)

This method seems to be duplicated in your project.

    {
        if (LaravelPaths::isIgnored($absPath)) {
            return;
        }

        $key = 'queryInBlade';
        ($this->errorsList[$key][] = (new PendingError($key))
            ->header('Query in blade file: ')
            ->errorData($this->yellow($class).'  <=== DB query in blade file')
            ->link($absPath, $lineNumber));
    }

    public function wrongMethodError($absPath, $class, $lineNumber)
    {
        $this->doesNotExist($class, $absPath, $lineNumber, 'wrongMethodError', 'Method does not exist:');
    }

    public function yellow($msg)
    {
        return "<fg=yellow>$msg</>";
    }

    public function badNamespace($absPath, $correctNamespace, $incorrectNamespace, $lineNumber = 4)
    {
        if (LaravelPaths::isIgnored($absPath)) {
            return;
        }

        ($this->errorsList['badNamespace'][] = (new PendingError('badNamespace'))
            ->header('Incorrect namespace: '.$this->yellow("namespace $incorrectNamespace;"))
            ->errorData('  namespace fixed to:  '.$this->yellow("namespace $correctNamespace;"))
            ->link($absPath, $lineNumber));
    }

    public function print($msg, $path = '|  ', $len = null)
    {
        ! $len && $len = PendingError::$maxLength + 1;
        $msgLen = strlen($msg);
        if (strpos($msg, 'yellow')) {
            $msgLen = $msgLen - 14;
        }
        $len = $len - $msgLen;
        if ($len < 0) {
            $len = 0;
        }

        $this->printer->writeln($path.$msg.str_repeat(' ', $len).'|');
    }

    public function printHeader($msg)
    {
        $number = ++$this->errorsList['total'];
        ($number < 10) && $number = " $number";

        $number = '<fg=yellow>'.$number.' </>';
        $path = "| $number";

        PendingError::$maxLength = max(PendingError::$maxLength, strlen($msg));
        $this->print('');
        $this->print($msg, $path, PendingError::$maxLength - 1);
    }

    public function end()
    {
        $this->print('');
        $this->printer->writeln('|'.str_repeat('*', 3 + PendingError::$maxLength).'|  ');
    }

    public function printLink($path, $lineNumber = 4)
    {
        if ($path) {
            $relativePath = FilePath::normalize(\trim(\str_replace(base_path(), '', $path), '\\/'));
            $this->print('at <fg=green>'.$relativePath.'</>'.':<fg=green>'.$lineNumber.'</>', '', PendingError::$maxLength + 30);
        }
    }

    /**
     * Checks for errors for the run command.
     *
     * @return int
     */
    public function hasErrors()
    {
        $errorsCollection = collect($this->errorsList);

        return $errorsCollection->flatten()->filter(function ($action) {
            return $action instanceof PendingError;
        })->count();
    }

    public function logErrors()
    {
        collect($this->errorsList)->except('total')->flatten()->each(function ($error) {
            if ($error instanceof PendingError) {
                $this->printHeader($error->getHeader());
                $this->print($error->getErrorData());
                $this->printLink($error->getLinkPath(), $error->getLinkLineNumber());
                $this->end();
            }
        });

        foreach ($this->pended as $pend) {
            $this->print($pend);
            $this->end();
        }
    }

    private static function possibleFixMsg($pieces)
    {
        $fixes = \implode("\n - ", $pieces);
        $fixes && $fixes = "\n Possible fixes:\n - ".$fixes;

        return $fixes;
    }

    public function wrongImportPossibleFixes($absPath, $class, $line, $fixes)
    {
        $fixes = self::possibleFixMsg($fixes);
        $this->wrongUsedClassError($absPath, $class.'   <===  \(-_-)/  '.$fixes, $line);
    }

    public function getCount($key)
    {
        return \count($this->errorsList[$key] ?? []);
    }

    public function printTime()
    {
        $this->logErrors && $this->printer->writeln('time: '.round(microtime(true) - microscope_start, 3).' (sec)', 2);
    }

    public static function thanks($command)
    {
        $command->line(PHP_EOL.'<fg=blue>|-------------------------------------------------|</>');
        $command->line('<fg=blue>|-----------     Star Me On Github     -----------|</>');
        $command->line('<fg=blue>|-------------------------------------------------|</>');
        $command->line('<fg=blue>|  Hey man, if you have found microscope useful   |</>');
        $command->line('<fg=blue>|  Please consider giving it an star on github.   |</>');
        $command->line('<fg=blue>|  \(^_^)/    Regards, Iman Ghafoori    \(^_^)/   |</>');
        $command->line('<fg=blue>|-------------------------------------------------|</>');
        $command->line('https://github.com/imanghafoori1/microscope');
    }

    public static function warnIncorrectNamespace($currentNamespace, $relativePath, $class)
    {
        /**
         * @var $p ErrorPrinter
         */
        $p = app(ErrorPrinter::class);
        $msg = 'Incorrect namespace: '.$p->yellow("namespace $currentNamespace;");
        PendingError::$maxLength = max(PendingError::$maxLength, strlen($msg));
        $p->end();
        $currentNamespace && $p->printHeader('Incorrect namespace: '.$p->yellow("namespace $currentNamespace;"));
        ! $currentNamespace && $p->printHeader('Namespace Not Found: '.$class);
        $p->printLink($relativePath, 3);
    }

    public static function ask($command, $correctNamespace)
    {
        if ($command->option('force')) {
            return true;
        }

        return $command->getOutput()->confirm('Do you want to change it to: '.$correctNamespace, true);
    }
}