MichaelRubel\EnhancedContainer\Core\BindingBuilder

Complexity

Total Complexity

13

Size/Duplication

Total Lines	160
Duplicated Lines	0 %

Importance

Changes	6
Bugs	0	Features	0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	__call()	0	6	1
A	singleton()	0	3	1
A	scoped()	0	3	1
A	to()	0	5	1
A	itself()	0	3	1
A	contextual()	0	5	1
A	for()	0	5	1
A	resolve()	0	8	1
A	extend()	0	5	1
A	method()	0	11	3

<?php

declare(strict_types=1);

namespace MichaelRubel\EnhancedContainer\Core;

use MichaelRubel\EnhancedContainer\Bind;
use MichaelRubel\EnhancedContainer\Traits\HelpsProxies;

class BindingBuilder implements Bind
{
    use HelpsProxies;

    /**
     * @var \Closure|string|array
     */
    private \Closure|string|array $contextualImplementation;

    /**
     * BindingBuilder constructor.
     *
     * @param object|string $abstract
     */
    public function __construct(
        private object | string $abstract
    ) {
        $this->abstract = $this->convertToNamespace($this->abstract);
    }

    /**
     * Method binding.
     *
     * @param string|null  $method
     * @param \Closure|null $override
     *
     * @return $this|null
     */
    public function method(string $method = null, \Closure $override = null): self|null

The type MichaelRubel\EnhancedContainer\Core\null was not found. Maybe you did not declare it correctly or list all dependencies?

    {
        // try to resolve implementation
        // for actual abstract type
        $this->resolve();

        if (is_null($method) || is_null($override)) {
            return $this;
        }

        return $this->{$method}($override);
    }

    /**
     * Basic "bind".
     *
     * @param \Closure|string|null $concrete
     * @param bool                 $shared
     *
     * @return $this
     */
    public function to(\Closure|string $concrete = null, bool $shared = false): self
    {
        app()->bind($this->abstract, $concrete, $shared);

It seems like $this->abstract can also be of type object; however, parameter $abstract of Illuminate\Container\Container::bind() does only seem to accept string, maybe add an additional type check?

        return $this;
    }

    /**
     * Basic "bind", binds itself.
     *
     * @return void
     */
    public function itself(): void
    {
        app()->bind($this->abstract);

It seems like $this->abstract can also be of type object; however, parameter $abstract of Illuminate\Container\Container::bind() does only seem to accept string, maybe add an additional type check?

    }

    /**
     * Singleton.
     *
     * @param \Closure|string|null $concrete
     *
     * @return void
     */
    public function singleton(\Closure|string $concrete = null): void
    {
        app()->singleton($this->abstract, $concrete);

It seems like $this->abstract can also be of type object; however, parameter $abstract of Illuminate\Container\Container::singleton() does only seem to accept string, maybe add an additional type check?

    }

    /**
     * Scoped instance.
     *
     * @param \Closure|string|null $concrete
     *
     * @return void
     */
    public function scoped(\Closure|string $concrete = null): void
    {
        app()->scoped($this->abstract, $concrete);

It seems like $this->abstract can also be of type object; however, parameter $abstract of Illuminate\Container\Container::scoped() does only seem to accept string, maybe add an additional type check?

    }

    /**
     * Enables contextual binding.
     *
     * @return $this
     */
    public function contextual(\Closure|string|array $implementation): self
    {
        $this->contextualImplementation = $implementation;

        return $this;
    }

    /**
     * Contextual binding.
     *
     * @param array|string $concrete
     *
     * @return void
     */
    public function for(array|string $concrete): void
    {
        app()->when($concrete)
             ->needs($this->abstract)

It seems like $this->abstract can also be of type object; however, parameter $abstract of Illuminate\Container\ContextualBindingBuilder::needs() does only seem to accept string, maybe add an additional type check?

             ->give($this->contextualImplementation);
    }

    /**
     * Extend the abstract type.
     *
     * @param \Closure $closure
     *
     * @return BindingBuilder
     */
    public function extend(\Closure $closure): self
    {
        app()->extend($this->abstract, $closure);

It seems like $this->abstract can also be of type object; however, parameter $abstract of Illuminate\Container\Container::extend() does only seem to accept string, maybe add an additional type check?

        return $this;
    }

    /**
     * Try to resolve an abstract.
     *
     * @return mixed
     */
    public function resolve(): mixed
    {
        return rescue(
            fn () => $this->abstract = $this->convertToNamespace(
                resolve($this->abstract)

It seems like $this->abstract can also be of type object; however, parameter $name of resolve() does only seem to accept string, maybe add an additional type check?

            ),
            null,
            false
        );
    }

    /**
     * Bind the method to the container.
     *
     * @param string $method
     * @param array  $parameters
     *
     * @return void
     */
    public function __call(string $method, array $parameters): void
    {
        app()->bindMethod([
            $this->abstract,
            $method,
        ], current($parameters));
    }
}