BeyondCode\SelfDiagnosis\Checks\EnvVariablesExists

Complexity

Total Complexity

14

Size/Duplication

Total Lines	126
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

84.62%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	name()	0	4	1
A	message()	0	6	1
A	check()	0	28	5
A	getResult()	0	8	1
A	storeResult()	0	6	3
A	recursiveDirSearch()	0	21	3

<?php

namespace BeyondCode\SelfDiagnosis\Checks;

use Illuminate\Support\Arr;
use Illuminate\Support\Collection;
use RecursiveDirectoryIterator;
use RecursiveIteratorIterator;
use RegexIterator;

class EnvVariablesExists implements Check
{
    /**
     * The empty results of performed scan
     *
     * @var array
     */
    public $empty = 0;

    /**
     * The name of the check.
     *
     * @param array $config
     * @return string
     */
    public function name(array $config): string
    {
        return trans('self-diagnosis::checks.env_variables_exist.name');
    }

    /**
     * The error message to display in case the check does not pass.
     *
     * @param array $config
     * @return string
     */
    public function message(array $config): string
    {
        return trans('self-diagnosis::checks.env_variables_exist.message', [
            'empty' => $this->empty,
        ]);
    }

    /**
     * Directories to start recursive search for env()'s from
     * Defaults to config_path()
     *
     * @var string $dir
     */
    public $paths;

    /**
     * Perform the actual verification of this check.
     *
     * @param array $config
     * @return bool
     * @throws \Exception
     */
    public function check(array $config): bool
    {
        $this->paths = Collection::make(Arr::get($config, 'directories', []));

It seems like \Illuminate\Support\Collection::make(\Illuminate\Support\Arr::get($config, 'directories', array())) of type object<Illuminate\Support\Collection> is incompatible with the declared type string of property $paths.

        foreach ($this->paths as $path) {
            $files = $this->recursiveDirSearch($path,  '/.*?.php/');

            foreach ($files as $file) {
                preg_match_all(
                    '#env\((.*?)\)#',
                    str_replace(["\n", "\r"], '', file_get_contents($file)),
                    $values
                );

                if (is_array($values)) {
                    foreach ($values[1] as $value) {
                        $result = $this->getResult(
                            explode(',', str_replace(["'", '"', ' '], '', $value))
                        );

                        $this->storeResult($result);
                    }
                }
            }
        }

        return $this->empty === 0;
    }

    /**
     * Get result based on comma separated parsed env() parameters
     *
     * @param array $values
     * @return object
     */
    private function getResult(array $values)
    {
        return (object)[
            'envVar' => $values[0],
            'hasValue' => (bool)env($values[0]),
            'hasDefault' => isset($values[1]),
        ];
    }

    /**
     * Store result and optional runtime output
     *
     * @param $result
     */
    private function storeResult($result)
    {
        if (! $result->hasValue && ! $result->hasDefault) {
            $this->empty++;
        }
    }

    private function recursiveDirSearch(string $folder, string $pattern): array
    {
        if (! file_exists($folder)) {
            return [];
        }

        $files = new RegexIterator(
            new RecursiveIteratorIterator(
                new RecursiveDirectoryIterator($folder)
            ),
            $pattern, RegexIterator::GET_MATCH
        );

        $list = [];

        foreach($files as $file) {
            $list = array_merge($list, $file);
        }

        return $list;
    }
}