Flugg\Responder\Resources\ResourceFactory

Complexity

Total Complexity

12

Size/Duplication

Total Lines	99
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

100%

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	make()	0	12	4
A	resolveTransformer()	0	8	2
A	instatiateResource()	0	10	3
A	shouldCreateCollection()	0	8	2

<?php

namespace Flugg\Responder\Resources;

use Flugg\Responder\Contracts\Resources\ResourceFactory as ResourceFactoryContract;
use Flugg\Responder\Contracts\Transformers\TransformerResolver;
use Illuminate\Support\Arr;
use League\Fractal\Resource\Collection as CollectionResource;
use League\Fractal\Resource\Item as ItemResource;
use League\Fractal\Resource\NullResource;
use League\Fractal\Resource\ResourceInterface;
use Traversable;

/**
 * This class is responsible for making Fractal resources from a variety of data types.
 *
 * @package flugger/laravel-responder
 * @author  Alexander Tømmerås <flugged@gmail.com>
 * @license The MIT License
 */
class ResourceFactory implements ResourceFactoryContract
{
    /**
     * A service class, used to normalize data.
     *
     * @var \Flugg\Responder\DataNormalizer
     */
    protected $normalizer;

    /**
     * A manager class, used to manage transformers.
     *
     * @var \Flugg\Responder\Contracts\Transformers\TransformerResolver
     */
    protected $transformerResolver;

    /**
     * Construct the factory class.
     *
     * @param \Flugg\Responder\Resources\DataNormalizer                   $normalizer
     * @param \Flugg\Responder\Contracts\Transformers\TransformerResolver $transformerResolver
     */
    public function __construct(DataNormalizer $normalizer, TransformerResolver $transformerResolver)
    {
        $this->normalizer = $normalizer;

It seems like $normalizer of type object<Flugg\Responder\Resources\DataNormalizer> is incompatible with the declared type object<Flugg\Responder\DataNormalizer> of property $normalizer.

        $this->transformerResolver = $transformerResolver;
    }

    /**
     * Make resource from the given data.
     *
     * @param  mixed                                                          $data
     * @param  \Flugg\Responder\Transformers\Transformer|string|callable|null $transformer
     * @param  string|null                                                    $resourceKey
     * @return \League\Fractal\Resource\ResourceInterface
     */
    public function make($data = null, $transformer = null, string $resourceKey = null): ResourceInterface
    {
        if ($data instanceof ResourceInterface) {
            return $data->setTransformer($this->resolveTransformer($data->getData(), $transformer ?: $data->getTransformer()));

It seems like $this->resolveTransformer($data->getData(), $transformer ?: $data->getTransformer()) targeting Flugg\Responder\Resources\ResourceFactory::resolveTransformer() can also be of type null; however, League\Fractal\Resource\ResourceInterface::setTransformer() does only seem to accept callable, maybe add an additional type check?

        } elseif (is_null($data = $this->normalizer->normalize($data))) {
            return $this->instatiateResource($data);
        }

        $transformer = $this->resolveTransformer($data, $transformer);

        return $this->instatiateResource($data, $transformer, $resourceKey);
    }

    /**
     * Resolve a transformer.
     *
     * @param  mixed                                                          $data
     * @param  \Flugg\Responder\Transformers\Transformer|string|callable|null $transformer
     * @return \Flugg\Responder\Transformers\Transformer|callable

Should the return type not be callable|null?

     */
    protected function resolveTransformer($data, $transformer)
    {
        if (isset($transformer)) {
            return $this->transformerResolver->resolve($transformer);
        }

        return $this->transformerResolver->resolveFromData($data);
    }

    /**
     * Instatiate a new resource instance.
     *
     * @param  mixed                                                   $data
     * @param  \Flugg\Responder\Transformers\Transformer|callable|null $transformer
     * @param  string|null                                             $resourceKey
     * @return \League\Fractal\Resource\ResourceInterface
     */
    protected function instatiateResource($data, $transformer = null, string $resourceKey = null): ResourceInterface
    {
        if (is_null($data)) {
            return new NullResource;
        } elseif ($this->shouldCreateCollection($data)) {
            return new CollectionResource($data, $transformer, $resourceKey);
        }

        return new ItemResource($data, $transformer, $resourceKey);
    }

    /**
     * Indicates if the data belongs to a collection resource.
     *
     * @param  mixed $data
     * @return bool
     */
    protected function shouldCreateCollection($data): bool
    {
        if (is_array($data)) {
            return ! is_scalar(Arr::first($data));
        }

        return $data instanceof Traversable;
    }
}