TypeHints\Unused\Analyzer\ViewAnalyzer

Complexity

Total Complexity

23

Size/Duplication

Total Lines	181
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	viewParser()	0	3	1
A	analyze()	0	7	1
A	actionParser()	0	7	2
A	getAllViews()	0	17	4
A	fetchUnusedViews()	0	12	1
A	delete()	0	11	3
A	getUnusedViews()	0	3	1
A	__construct()	0	3	1
A	generateViewTransformer()	0	3	1
A	fetchUsedViews()	0	5	1
A	closureParser()	0	3	1
A	getUsedViews()	0	5	1
A	retrieveViewCounts()	0	13	3
A	controllerParser()	0	3	1
A	parse()	0	5	1

<?php

namespace TypeHints\Unused\Analyzer;

use Illuminate\Filesystem\Filesystem;
use Illuminate\Routing\Route;
use Illuminate\Routing\Router;
use Illuminate\Support\Collection;
use Illuminate\Support\Str;
use TypeHints\Unused\Parser\Action\ClosureParser;
use TypeHints\Unused\Parser\Action\ControllerParser;
use TypeHints\Unused\Parser\Action\ParserActionInterface;
use TypeHints\Unused\Parser\ParserInterface;
use TypeHints\Unused\Parser\ViewParser;
use TypeHints\Unused\Transformers\ViewTransformer;

class ViewAnalyzer
{
    protected $router;

    protected $unusedViews = [];

    protected $usedViews = [];

    public function __construct(Router $router)
    {
        $this->router = $router;
    }

    public function analyze()
    {
        $this->usedViews = $this->fetchUsedViews();

        $this->unusedViews = $this->fetchUnusedViews();

        return $this;
    }

    public function delete(string $view)
    {
        $filesystem = new Filesystem();

        $view = str_replace('.', '/', $view);

        foreach (config('view.paths') as $path) {

The function config was not found. Maybe you did not declare it correctly or list all dependencies?

            $viewPath = $path.'/'.$view.'.blade.php';

            if ($filesystem->exists($viewPath)) {
                $filesystem->delete($viewPath);
            }
        }
    }

    protected function fetchUnusedViews()
    {
        $flattenUsedViews = collect($this->usedViews)->map(function ($viewTransformer) {
            return array_keys($viewTransformer->getViews());
        })
        ->flatten();

        $this->retrieveViewCounts($flattenUsedViews);

        return array_diff(
            $this->getAllViews(),
            $flattenUsedViews->unique()->toArray()
        );
    }

    protected function fetchUsedViews(): array
    {
        return array_map(function ($route) {
            return $this->generateViewTransformer($route);
        }, $this->router->getRoutes()->getRoutes());
    }

    /**
     * @param Route $route
     *
     * @return TypeHints\Unused\Transformers\ViewTransformer

The type TypeHints\Unused\Analyzer\TypeHints\Unused\Transformers\ViewTransformer was not found. Did you mean TypeHints\Unused\Transformers\ViewTransformer? If so, make sure to prefix the type with \.

     */
    protected function generateViewTransformer(Route $route): ViewTransformer
    {
        return new ViewTransformer($this->parse($route));

The expression return new TypeHints\Unused\Transformers\ViewTransformer($this->parse($route)) returns the type TypeHints\Unused\Transformers\ViewTransformer which is incompatible with the documented return type TypeHints\Unused\Analyzer\TypeHints\Unused\Transformers\ViewTransformer.

    }

    /**
     * @return array
     */
    protected function getAllViews(): array
    {
        $filesystem = new Filesystem();

        $views = [];

        foreach (config('view.paths') as $path) {

The function config was not found. Maybe you did not declare it correctly or list all dependencies?

            foreach ($filesystem->allFiles($path, true) as $file) {
                if (Str::startsWith($file->getRelativePath(), 'vendor')) {
                    break;
                }

                $views[] = str_replace('.blade.php', '', str_replace('/', '.', $file->getRelativePathname()));
            }
        }

        return $views;
    }

    /**
     * @param Route $route
     *
     * @return TypeHints\Unused\Parser\ViewParser

The type TypeHints\Unused\Analyzer\TypeHints\Unused\Parser\ViewParser was not found. Did you mean TypeHints\Unused\Parser\ViewParser? If so, make sure to prefix the type with \.

     */
    protected function parse(Route $route): ViewParser
    {
        return $this->viewParser(

The expression return $this->viewParser($this->actionParser($route))->parse() returns the type TypeHints\Unused\Parser\ViewParser which is incompatible with the documented return type TypeHints\Unused\Analyzer\TypeHints\Unused\Parser\ViewParser.

            $this->actionParser($route)
        )->parse();
    }

    /**
     * @param Route $route
     *
     * @return TypeHints\Unused\Parser\Action\ParserActionInterface

The type TypeHints\Unused\Analyzer\TypeHints\Unused\Parser\Action\ParserActionInterface was not found. Did you mean TypeHints\Unused\Parser\Action\ParserActionInterface? If so, make sure to prefix the type with \.

     */
    protected function actionParser(Route $route): ParserActionInterface
    {
        if (array_key_exists('controller', $route->getAction())) {

It seems like $route->getAction() can also be of type null; however, parameter $search of array_key_exists() does only seem to accept array, maybe add an additional type check?

            return $this->controllerParser($route)->parse();

The expression return $this->controllerParser($route)->parse() returns the type TypeHints\Unused\Parser\Action\ControllerParser which is incompatible with the documented return type TypeHints\Unused\Analyzer\TypeHints\Unused\Parser\Action\ParserActionInterface.

        }

        return $this->closureParser($route)->parse();

The expression return $this->closureParser($route)->parse() returns the type TypeHints\Unused\Parser\Action\ClosureParser which is incompatible with the documented return type TypeHints\Unused\Analyzer\TypeHints\Unused\Parser\Action\ParserActionInterface.

    }

    /**
     * @param Route $route
     *
     * @return TypeHints\Unused\Parser\Action\ParserActionInterface
     */
    protected function controllerParser(Route $route): ParserActionInterface
    {
        return new ControllerParser($route);

The expression return new TypeHints\Unused\Parser\Action\ControllerParser($route) returns the type TypeHints\Unused\Parser\Action\ControllerParser which is incompatible with the documented return type TypeHints\Unused\Analyzer\TypeHints\Unused\Parser\Action\ParserActionInterface.

    }

    /**
     * @param Route $route
     *
     * @return TypeHints\Unused\Parser\Action\ParserActionInterface
     */
    protected function closureParser(Route $route): ParserActionInterface
    {
        return new ClosureParser($route);

The expression return new TypeHints\Unused\Parser\Action\ClosureParser($route) returns the type TypeHints\Unused\Parser\Action\ClosureParser which is incompatible with the documented return type TypeHints\Unused\Analyzer\TypeHints\Unused\Parser\Action\ParserActionInterface.

    }

    /**
     * @param ParserActionInterface $content
     *
     * @return TypeHints\Unused\Parser\ParserInterface

The type TypeHints\Unused\Analyzer\TypeHints\Unused\Parser\ParserInterface was not found. Did you mean TypeHints\Unused\Parser\ParserInterface? If so, make sure to prefix the type with \.

     */
    protected function viewParser(ParserActionInterface $content): ParserInterface
    {
        return new ViewParser($content);

The expression return new TypeHints\Unused\Parser\ViewParser($content) returns the type TypeHints\Unused\Parser\ViewParser which is incompatible with the documented return type TypeHints\Unused\Analyzer\TypeHints\Unused\Parser\ParserInterface.

    }

    /**
     * @return array
     */
    public function getUnusedViews(): array
    {
        return array_values($this->unusedViews);
    }

    /**
     * @return array
     */
    public function getUsedViews(): array
    {
        return array_map(function ($usedView) {
            return $usedView->transform();
        }, $this->usedViews);
    }

    /**
     * @param $usedViews
     */
    public function retrieveViewCounts(Collection $usedViews): void
    {
        $usedViewCountValues = array_count_values($usedViews->toArray());

        collect($this->usedViews)->map(function ($viewTransformer) use ($usedViewCountValues) {
            $views = array_keys($viewTransformer->getViews());

            if (!$views) {

The expression $views of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

                return;
            }

            foreach ($views as $view) {
                $viewTransformer->setViewCount($view, $usedViewCountValues[$view]);
            }
        });
    }
}