BindsToContainer::providesCache() - Code Metrics - michael-rubel/laravel-auto-binder - Measure and Improve Code Quality continuously with Scrutinizer

BindsToContainer::providesCache() A
last analyzed 2024-03-12 20:48 UTC

↳ Parent: BindsToContainer

Complexity

Conditions	2
Paths	2

Size

Total Lines	9
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	5
CRAP Score	2

Importance

Changes

Metric	Value
cc	2
eloc	4
nc	2
nop	0
dl	0
loc	9
ccs	5
cts	5
cp	1
crap	2
rs	10
c	0
b	0
f	0

<?php

declare(strict_types=1);

namespace MichaelRubel\AutoBinder\Traits;

use Illuminate\Support\Facades\File;
use Illuminate\Support\LazyCollection;
use Illuminate\Support\Str;
use Psr\Container\ContainerExceptionInterface;
use Psr\Container\NotFoundExceptionInterface;
use Symfony\Component\Finder\SplFileInfo;

trait BindsToContainer
{
    private ?bool $providesCache = null;

    /**
     * Run the directory scanning & bind the results.
     *
     * @throws ContainerExceptionInterface
     * @throws NotFoundExceptionInterface
     */
    protected function scan(): void
    {
        $this->getFolderFiles()->each(
            fn (array $files, string $actualFolder) => LazyCollection::make($files)->each(
            fn (array $files, string $actualFolder) => LazyCollection::make(/** @scrutinizer ignore-type */ $files)->each(
                function (SplFileInfo $file) use ($actualFolder) {
                    $relativePath = $file->getRelativePathname();
                    $filenameWithoutExtension = $file->getFilenameWithoutExtension();
                    $filenameWithRelativePath = $this->prepareFilename($relativePath);

                    $interface = $this->interfaceFrom($filenameWithoutExtension);
                    $concrete = $this->concreteFrom($actualFolder, $filenameWithRelativePath);

                    if (! interface_exists($interface) || ! class_exists($concrete)) {
                        return;
                    }

                    $dependencies = collect($this->dependencies);

                    $concrete = match (true) {
                        $dependencies->has($interface) => $dependencies->get($interface),
                        $dependencies->has($concrete) => $dependencies->get($concrete),
                        default => $concrete,
                    };

                    if ($this->providesCache() && $this->cacheEnabled()) {
                    if ($this->providesCache() && $this->/** @scrutinizer ignore-call */ cacheEnabled()) {
                        $this->cacheBindingFor($interface, $concrete);
                               cacheBindingFor($interface, $concrete);
                    }

                    app()->{$this->bindingType}($interface, $concrete);
                }
            )
        );
    }

    /**
     * Get the folder files except for ignored ones.
     *
     * @return LazyCollection<string, array<SplFileInfo>>
     */
    protected function getFolderFiles(): LazyCollection
    {
        return LazyCollection::make(File::directories(base_path($this->basePath . DIRECTORY_SEPARATOR . $this->classFolder)))
        return LazyCollection::make(/** @scrutinizer ignore-type */ File::directories(base_path($this->basePath . DIRECTORY_SEPARATOR . $this->classFolder)))
            ->reject(fn (string $folder) => in_array(basename($folder), $this->excludesFolders))
            ->mapWithKeys(fn (string $folder) => [basename($folder) => File::allFiles($folder)]);
    }

    /**
     * Prepare the filename.
     */
    protected function prepareFilename(string $filename): string
    {
        return str($filename)
            ->replace('/', '\\')
            ->substr(0, strrpos($filename, '.') ?: null)
            ->value();
    }

    /**
     * Get the namespace from a given path.
     */
    protected function namespaceFrom(string $path): string
    {
        return str($path)
            ->replace('/', '\\')
            ->ucfirst()
            ->value();
    }

    /**
     * Get the concrete from filename.
     */
    protected function concreteFrom(string $folder, string $filenameWithRelativePath): string
    {
        return $this->classNamespace . '\\'
            . $this->classFolder . '\\'
            . $this->prepareActual($folder . '\\')
            . $this->prepareNamingFor($filenameWithRelativePath);
    }

    /**
     * Get the interface from filename.
     */
    protected function interfaceFrom(string $filenameWithoutExtension): string
    {
        $guessedInterface = $this->guessInterfaceBy($filenameWithoutExtension);

        return ! is_null($guessedInterface)
            ? $guessedInterface
            : $this->buildInterfaceBy($filenameWithoutExtension);
    }

    /**
     * Guess the interface with a given filename.
     */
    protected function guessInterfaceBy(string $filenameWithoutExtension): ?string
    {
        return ! Str::contains($this->interfaceNamespace, '\\')
            ? $this->buildInterfaceFromClassBy($filenameWithoutExtension)
            : null;
    }

    /**
     * Build the interface class-string.
     */
    protected function buildInterfaceBy(string $filename): string
    {
        return $this->interfaceNamespace . '\\'
            . $this->prepareNamingFor($filename)
            . $this->interfaceNaming;
    }

    /**
     * Build the interface class-string based on the class folder.
     */
    protected function buildInterfaceFromClassBy(string $filename): string
    {
        return $this->classNamespace . '\\'
            . $this->classFolder . '\\'
            . $this->interfaceNamespace . '\\'
            . $this->prepareNamingFor($filename)
            . $this->interfaceNaming;
    }

    /**
     * Cleans up filename to append the desired interface name.
     */
    protected function prepareNamingFor(string $filename): string
    {
        return Str::replace($this->interfaceNaming, '', $filename);
    }

    /**
     * prepares an actual folder.
     */
    protected function prepareActual(string $folder): string
    {
        return Str::replace(Str::plural($this->interfaceNaming) . '\\', '', $folder);
    }

    /**
     * Check if the class use `CachesBindings` trait.
     */
    protected function providesCache(): bool
    {
        if ($this->providesCache) {
            return true;
        }

        $uses = class_uses_recursive(static::class);

        return $this->providesCache = in_array(CachesBindings::class, $uses);
    }
}


michael-rubel / laravel-auto-binder

BindsToContainer::providesCache() A last analyzed 2024-03-12 20:48 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

BindsToContainer::providesCache() A
last analyzed 2024-03-12 20:48 UTC