Scabbia\Scanners\Scanners

Complexity

Total Complexity

37

Size/Duplication

Total Lines	185
Duplicated Lines	8.65 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes	1
Bugs	0	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	register()	0	6	2
A	processFolder()	0	11	2
A	processFile()	0	11	2
D	processTokenStream()	16	103	29
A	processClass()	0	8	2

<?php
/**
 * Scabbia2 Scanners Component
 * https://github.com/eserozvataf/scabbia2
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * @link        https://github.com/eserozvataf/scabbia2-scanners for the canonical source repository
 * @copyright   2010-2016 Eser Ozvataf. (http://eser.ozvataf.com/)
 * @license     http://www.apache.org/licenses/LICENSE-2.0 - Apache License, Version 2.0
 */

namespace Scabbia\Scanners;

use Scabbia\Helpers\FileSystem;
// use Scabbia\Scanners\ScannerInterface;
use LogicException;
use ReflectionClass;

/**
 * Scanners registry
 *
 * @package     Scabbia\Scanners
 * @author      Eser Ozvataf <eser@ozvataf.com>
 * @since       2.0.0
 */
class Scanners
{
    /** @type array      scanner classes */
    public $scanners = [];


    /**
     * Registers a scanner
     *
     * @param array|string   $uScanners    scanner instances
     *
     * @return void
     */
    public function register(...$uScanners)
    {
        foreach ($uScanners as $tScanner) {
            $this->scanners[] = $tScanner;
        }
    }

    /**
     * Scans all files in folders
     *
     * @param array|string  $uFolders          folders
     *
     * @return void
     */
    public function processFolder(...$uFolders)
    {
        foreach ($uFolders as $tFolder) {
            FileSystem::getFilesWalk(
                $tFolder,

It seems like $tFolder defined by $tFolder on line 57 can also be of type array; however, Scabbia\Helpers\FileSystem::getFilesWalk() does only seem to accept string, maybe add an additional type check?

                "*.php",
                true,
                [$this, "processFile"]
            );
        }
    }

    /**
     * Scans a file
     *
     * @param string      $uFile             file path
     *
     * @return void
     */
    public function processFile($uFile)
    {
        $tFileContents = FileSystem::read($uFile);

        foreach ($this->scanners as $tScanner) {
            $tScanner->processFile($uFile, $tFileContents);
        }

        $tTokenStream = TokenStream::fromString($tFileContents);

It seems like $tFileContents defined by \Scabbia\Helpers\FileSystem::read($uFile) on line 76 can also be of type false; however, Scabbia\Scanners\TokenStream::fromString() does only seem to accept string, did you maybe forget to handle an error condition?

        $this->processTokenStream($tTokenStream);
    }

    /**
     * Scans a token stream
     *
     * @param TokenStream $uTokenStream      extracted tokens wrapped with tokenstream
     *
     * @return void
     */
    public function processTokenStream(TokenStream $uTokenStream)
    {
        foreach ($this->scanners as $tScanner) {
            $tScanner->processTokenStream($uTokenStream);
        }

        $tBuffer = "";

        $tUses = [];
        $tLastNamespace = null;
        $tLastClass = null;
        $tLastClassDerivedFrom = null;
        $tExpectation = 0; // 1=namespace, 2=class

56% of this comment could be valid code. Did you maybe forget this after debugging?

        foreach ($uTokenStream as $tToken) {
            if ($tToken[0] === T_WHITESPACE) {
                continue;
            }

            if ($tExpectation === 0) {
                if ($tToken[0] === T_NAMESPACE) {
                    $tBuffer = "";
                    $tExpectation = 1;
                    continue;
                }

                if ($tToken[0] === T_CLASS) {
                    $tExpectation = 2;
                    continue;
                }

                if ($tToken[0] === T_USE) {
                    $tBuffer = "";
                    $tExpectation = 5;
                    continue;
                }
            } elseif ($tExpectation === 1) {

This code seems to be duplicated across your project.

                if ($tToken[0] === T_STRING || $tToken[0] === T_NS_SEPARATOR) {
                    $tBuffer .= $tToken[1];
                } else {
                    $tLastNamespace = $tBuffer;
                    $tExpectation = 0;
                }
            } elseif ($tExpectation === 2) {
                $tLastClass = "{$tLastNamespace}\\{$tToken[1]}";
                $tExpectation = 3;
            } elseif ($tExpectation === 3) {
                if ($tToken[0] === T_EXTENDS) {
                    $tBuffer = "";
                    $tExpectation = 4;
                    continue;
                }

                $tSkip = false;
                if ($tLastClassDerivedFrom !== null && !class_exists($tLastClassDerivedFrom)) {
                    $tSkip = true;

$tSkip is not used, you could remove the assignment.

                    throw new LogicException(sprintf(
                        "\"%s\" derived from \"%s\", but it could not be found.\n",
                        $tLastClass,
                        $tLastClassDerivedFrom
                    ));
                }

                if (!$tSkip && !isset($this->result[$tLastClass])) {

The property result does not exist. Did you maybe forget to declare it?

                    $this->processClass($tLastClass);
                }

                $tExpectation = 0;
            } elseif ($tExpectation === 4) {
                if ($tToken[0] === T_STRING || $tToken[0] === T_NS_SEPARATOR) {
                    $tBuffer .= $tToken[1];
                } else {
                    $tFound = false;

                    foreach ($tUses as $tUse) {
                        $tLength = strlen($tBuffer);
                        if (strlen($tUse) >= $tLength && substr($tUse, -$tLength) === $tBuffer) {
                            $tLastClassDerivedFrom = $tUse;
                            $tFound = true;
                            break;
                        }
                    }

                    if (!$tFound) {
                        if (strpos($tBuffer, "\\") !== false) {
                            $tLastClassDerivedFrom = $tBuffer;
                        } else {
                            $tLastClassDerivedFrom = "{$tLastNamespace}\\{$tBuffer}";
                        }
                    }

                    $tExpectation = 3;
                }
            } elseif ($tExpectation === 5) {

This code seems to be duplicated across your project.

                if ($tToken[0] === T_STRING || $tToken[0] === T_NS_SEPARATOR) {
                    $tBuffer .= $tToken[1];
                } else {
                    $tUses[] = $tBuffer;
                    $tExpectation = 0;
                }
            }
        }
    }

    /**
     * Processes classes using reflection
     *
     * @param string      $uClass            class name
     *
     * @return void
     */
    public function processClass($uClass)
    {
        $tReflection = new ReflectionClass($uClass);

        foreach ($this->scanners as $tScanner) {
            $tScanner->processClass($uClass, $tReflection);
        }
    }
}