MichaelRubel\AutoBinder\Traits\AutoBindsToContainer

Complexity

Total Complexity

10

Size/Duplication

Total Lines	120
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	2
Bugs	0	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	run()	0	12	1
A	getFolderFiles()	0	9	2
A	prepareFilename()	0	5	1
A	guessInterfaceWith()	0	14	2
A	namespaceFrom()	0	5	1
A	interfaceFrom()	0	12	2
A	concreteFrom()	0	3	1

<?php

declare(strict_types=1);

namespace MichaelRubel\AutoBinder\Traits;

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
use Symfony\Component\Finder\SplFileInfo;

trait AutoBindsToContainer
{
    /**
     * Run the folders scanning & bind the results.
     *
     * @return void
     */
    protected function run(): void
    {
        collect($this->getFolderFiles())

$this->getFolderFiles() of type Symfony\Component\Finder\SplFileInfo[]|array is incompatible with the type Illuminate\Contracts\Support\Arrayable expected by parameter $value of collect().

            ->each(function (SplFileInfo $file) {
                $relativePath             = $file->getRelativePathname();
                $filenameWithoutExtension = $file->getFilenameWithoutExtension();
                $filenameWithRelativePath = $this->prepareFilename($relativePath);

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

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

    /**
     * Get the folder files.
     *
     * @return array
     */
    protected function getFolderFiles(): array
    {
        $filesystem = app('files');

        $folder = base_path($this->basePath . DIRECTORY_SEPARATOR . $this->classFolder);

        return $filesystem->isDirectory($folder)
            ? $filesystem->allFiles($folder)
            : [];
    }

    /**
     * Prepare the filename.
     *
     * @param string $filename
     *
     * @return string
     */
    protected function prepareFilename(string $filename): string
    {
        return (string) Str::of($filename)
            ->replace('/', '\\')
            ->substr(0, (int) strrpos($filename, '.'));
    }

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

    /**
     * Get the interface from filename.
     *
     * @param string $filenameWithoutExtension
     *
     * @return string
     */
    protected function interfaceFrom(string $filenameWithoutExtension): string
    {
        $interface = $this->guessInterfaceWith($filenameWithoutExtension);

        if (is_null($interface)) {
            return $this->interfaceNamespace
                . '\\'
                . $filenameWithoutExtension
                . ($this->interfacePostfix);
        }

        return $interface;
    }

    /**
     * Guess the interface with a given filename.
     *
     * @param string $filenameWithoutExtension
     *
     * @return string|null
     */
    protected function guessInterfaceWith(string $filenameWithoutExtension): ?string
    {
        if (! Str::contains($this->interfaceNamespace, '\\')) {
            return $this->classNamespace
                . '\\'
                . $this->classFolder
                . '\\'
                . $this->interfaceNamespace
                . '\\'
                . $filenameWithoutExtension
                . ($this->interfacePostfix);
        }

        return null;
    }

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