MichaelRubel\EnhancedContainer\Core\BindingBuilder

Complexity

Total Complexity

18

Size/Duplication

Total Lines	196
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	8
Bugs	0	Features	1

13 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	3	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	extend()	0	5	1
A	method()	0	11	3
A	instance()	0	5	1
A	resolve()	0	8	1
A	__call()	0	6	1
A	wrapToClosure()	0	9	4

<?php

declare(strict_types=1);

namespace MichaelRubel\EnhancedContainer\Core;

use MichaelRubel\EnhancedContainer\Binding;
use MichaelRubel\EnhancedContainer\Traits\HelpsProxies;

class BindingBuilder implements Binding
{
    use HelpsProxies;

The trait MichaelRubel\EnhancedContainer\Traits\HelpsProxies requires some properties which are not provided by MichaelRubel\EnhancedContainer\Core\BindingBuilder: $contextual, $map

    /**
     * @var string
     */
    private string $abstract;

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

    /**
     * BindingBuilder constructor.
     *
     * @param object|string $abstract
     */
    public function __construct(object | string $abstract)
    {
        $this->abstract = $this->convertToNamespace($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
    {
        // 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 object|string|null $concrete
     * @param bool               $shared
     *
     * @return $this
     */
    public function to(object|string $concrete = null, bool $shared = false): self
    {
        app()->bind($this->abstract, $this->wrapToClosure($concrete), $shared);

        return $this;
    }

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

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

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

    /**
     * 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)
             ->give($this->contextualImplementation);
    }

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

        return $this;
    }

    /**
     * Register an existing instance as shared in the container.
     *
     * @param mixed $instance
     *
     * @return BindingBuilder
     */
    public function instance(mixed $instance): self
    {
        app()->instance($this->abstract, $instance);

        return $this;
    }

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

    /**
     * Wrap an object to the closure if the type of the object differs.
     *
     * @param object|string|null $concrete
     *
     * @return \Closure|string|null
     */
    public function wrapToClosure(object|string|null $concrete): \Closure|string|null
    {
        if (! is_null($concrete)
            && ! is_string($concrete)
            && ! $concrete instanceof \Closure) {
            return fn () => $concrete;
        }

        return $concrete;
    }

    /**
     * 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));
    }
}