Flugg\Responder\Transformers\TransformerResolver

Complexity

Total Complexity

19

Size/Duplication

Total Lines	123
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	bind()	0	6	2
A	resolve()	0	12	4
A	resolveFromData()	0	10	3
B	resolveTransformable()	0	12	5
A	resolveTransformer()	0	8	2
A	makeClosureTransformer()	0	6	2

<?php

namespace Flugg\Responder\Transformers;

use Flugg\Responder\Contracts\Transformers\TransformerResolver as TransformerResolverContract;
use Flugg\Responder\Contracts\Transformable;
use Flugg\Responder\Exceptions\InvalidTransformerException;
use Illuminate\Contracts\Container\Container;
use Illuminate\Contracts\Support\Arrayable;

/**
 * This class is responsible for resolving transformers.
 *
 * @package flugger/laravel-responder
 * @author  Alexander Tømmerås <flugged@gmail.com>
 * @license The MIT License
 */
class TransformerResolver implements TransformerResolverContract
{
    /**
     * An IoC container, used to resolve transformers.
     *
     * @var \Illuminate\Contracts\Container\Container
     */
    protected $container;

    /**
     * Transformable to transformer mappings.
     *
     * @var array
     */
    protected $bindings = [];

    /**
     * Construct the resolver class.
     *
     * @param \Illuminate\Contracts\Container\Container $container
     */
    public function __construct(Container $container)
    {
        $this->container = $container;
    }

    /**
     * Register a transformable to transformer binding.
     *
     * @param  string|array    $transformable
     * @param  string|callback $transformer
     * @return void
     */
    public function bind($transformable, $transformer)
    {
        $this->bindings = array_merge($this->bindings, is_array($transformable) ? $transformable : [
            $transformable => $transformer,
        ]);
    }

    /**
     * Resolve a transformer.
     *
     * @param  \Flugg\Responder\Transformers\Transformer|string|callable $transformer
     * @return \Flugg\Responder\Transformers\Transformer|callable
     * @throws \Flugg\Responder\Exceptions\InvalidTransformerException
     */
    public function resolve($transformer)
    {
        if (is_string($transformer)) {
            return $this->container->make($transformer);
        }

        if (! is_callable($transformer) && ! $transformer instanceof Transformer) {
            throw new InvalidTransformerException;
        }

        return $transformer;
    }

    /**
     * Resolve a transformer from the given data.
     *
     * @param  mixed $data
     * @return \Flugg\Responder\Transformers\Transformer|callable|null
     */
    public function resolveFromData($data)
    {
        if ($transformable = $this->resolveTransformable($data)) {

$transformable is not used, you could remove the assignment.

            if ($transformer = $this->resolveTransformer()) {

The call to resolveTransformer() misses a required argument $transformable.

                return $this->resolve($transformer);

$transformer is of type object<Flugg\Responder\Contracts\Transformable>, but the function expects a callable.

            }
        }

        return $this->makeClosureTransformer();
    }

    /**
     * Resolve a transformable from the transformation data.
     *
     * @param  mixed $data
     * @return \Flugg\Responder\Contracts\Transformable|null
     */
    protected function resolveTransformable($data)
    {
        if (is_iterable($data)) {
            foreach ($data as $item) {
                if ($item instanceof Transformable) {
                    return $item;
                }
            }
        }

        return $data instanceof Transformable ? $data : null;
    }

    /**
     * Resolve a transformer from the transformable.
     *
     * @param  \Flugg\Responder\Contracts\Transformable $transformable
     * @return \Flugg\Responder\Contracts\Transformable|null
     */
    protected function resolveTransformer(Transformable $transformable)
    {
        if (key_exists($this->bindings, get_class($transformable))) {
            return $this->bindings[get_class($transformable)];
        }

        return $transformable->transformer();

The expression $transformable->transformer(); of type callable|null adds the type callable to the return on line 126 which is incompatible with the return type documented by Flugg\Responder\Transformers\TransformerResolver::resolveTransformer of type Flugg\Responder\Contracts\Transformable|null.

    }

    /**
     * Make a simple closure transformer.
     *
     * @return callable
     */
    protected function makeClosureTransformer(): callable
    {
        return function ($data) {
            return $data instanceof Arrayable ? $data->toArray() : $data;
        };
    }
}