HydeStan

Complexity

Total Complexity

19

Size/Duplication

Total Lines	123
Duplicated Lines	0 %

Importance

Changes	19
Bugs	1	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__destruct()	0	10	1
A	run()	0	29	5
A	__construct()	0	6	1
A	getFileContents()	0	3	1
A	getFiles()	0	13	2
A	hasErrors()	0	3	1
A	analysers()	0	4	1
A	addActionsMessage()	0	5	1
A	analyseFile()	0	17	5
A	getErrors()	0	3	1

<?php

declare(strict_types=1);

/**
 * @internal
 */
class HydeStan
{
    const VERSION = '0.0.0-dev';

    protected array $files;
    protected array $errors = [];
    protected int $scannedLines = 0;
    protected Console $console;
    protected static array $warnings = [];

    public function __construct(protected bool $debug = false)
    {
        $this->console = new Console();

        $this->console->info(sprintf('HydeStan v%s is running!', self::VERSION));
        $this->console->newline();
    }

    public function __destruct()
    {
        $this->console->newline();
        $this->console->info(sprintf('HydeStan has exited after scanning %s total lines in %s files.',
            number_format($this->scannedLines),
            number_format(count($this->files)))
        );

        // Forward warnings to GitHub Actions
        $this->console->line(sprintf("\n%s", implode("\n", self::$warnings)));
    }

    public function run(): void
    {
        $time = microtime(true);

        $this->files = $this->getFiles();

        foreach ($this->files as $file) {
            if ($this->debug) {
                $this->console->debug('Analysing file: '.$file);
            }

            $this->analyseFile($file, $this->getFileContents($file));
        }

        $endTime = microtime(true) - $time;
        $this->console->info(sprintf('HydeStan has finished in %s seconds (%sms) using %s KB RAM',
            number_format($endTime, 2),
            number_format($endTime * 1000, 2),
            number_format(memory_get_peak_usage(true) / 1024, 2))
        );

        if ($this->hasErrors()) {
            $this->console->error(sprintf('HydeStan has found %s errors!', count($this->errors)));

            foreach ($this->errors as $error) {
                $this->console->warn($error);
            }
        } else {
            $this->console->info('HydeStan has found no errors!');
        }
    }

    public function getErrors(): array
    {
        return $this->errors;
    }

    private function getFiles(): array
    {
        $files = [];

        $directory = new RecursiveDirectoryIterator(BASE_PATH.'/src');
        $iterator = new RecursiveIteratorIterator($directory);
        $regex = new RegexIterator($iterator, '/^.+\.php$/i', RecursiveRegexIterator::GET_MATCH);

        foreach ($regex as $file) {
            $files[] = substr($file[0], strlen(BASE_PATH) + 1);
        }

        return $files;
    }

    private function analyseFile(string $file, string $contents): void
    {
        foreach ($this->analysers() as $analyser) {
            if ($this->debug) {
                $this->console->debugComment('Running  '.$analyser::class);
            }

            $result = $analyser->run($file, $contents);
            foreach ($result as $error) {
                if ($this->debug) {
                    $this->console->debugComment('Adding error: '.$error);
                }
                $this->errors[] = $error;
            }
        }

        $this->scannedLines += substr_count($contents, "\n");
    }

    private function getFileContents(string $file): string
    {
        return file_get_contents(BASE_PATH.'/'.$file);
    }

    private function analysers(): array
    {
        return [
            new NoFixMeAnalyser(),
        ];
    }

    public function hasErrors(): bool
    {
        return count($this->errors) > 0;
    }

    public static function addActionsMessage(string $level, string $file, int $lineNumber, string $title, string $message): void
    {
        // https://docs.github.com/en/actions/using-workflows/workflow-commands-for-github-actions#setting-a-warning-message
        // $template = '::warning file={name},line={line},endLine={endLine},title={title}::{message}';
        self::$warnings[] = sprintf("::$level file=%s,line=%s,endLine=%s,title=%s::%s", 'packages/framework/'.str_replace('\\', '/', $file), $lineNumber, $lineNumber, $title, $message);
    }
}

class NoFixMeAnalyser
{
    public function run(string $file, string $contents): array
    {
        $errors = [];

        $searches = [
            'fixme',
            'fix me',
            'fix-me',
        ];

        $contents = strtolower($contents);

        foreach ($searches as $search) {
            if (str_contains($contents, $search)) {
                // Get line number of marker by counting new \n tags before it
                $stringBeforeMarker = substr($contents, 0, strpos($contents, $search));
                $lineNumber = substr_count($stringBeforeMarker, "\n") + 1;

                $errors[] = "Found $search in $file on line $lineNumber";

                HydeStan::addActionsMessage('warning', $file, $lineNumber, 'HydeStan: NoFixMeError', 'This line has been marked as needing fixing. Please fix it before merging.');

                // Todo we might want to check for more errors after the first marker
            }
        }

        return $errors;
    }
}