Flugg\Responder\Transformers\Concerns\HasRelationships

Complexity

Total Complexity

6

Size/Duplication

Total Lines	83
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

20%

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	allRelationsAllowed()	0	4	1
A	getRelations()	0	6	1
A	getDefaultRelations()	0	10	2
A	extractDefaultRelations()	0	10	1
A	makeEagerLoadCallback()	0	6	1

<?php

namespace Flugg\Responder\Transformers\Concerns;

use Closure;

/**
 * A trait to be used by a transformer to handle relations
 *
 * @package flugger/laravel-responder
 * @author  Alexander Tømmerås <flugged@gmail.com>
 * @license The MIT License
 */
trait HasRelationships
{
    /**
     * List of available relations.
     *
     * @var string[]
     */
    protected $relations = ['*'];

    /**
     * A list of autoloaded default relations.
     *
     * @var array
     */
    protected $load = [];

    /**
     * Indicates if the transformer has whitelisted all relations.
     *
     * @return bool
     */
    public function allRelationsAllowed(): bool
    {
        return $this->relations == ['*'];
    }

    /**
     * Get a list of whitelisted relations.
     *
     * @return string[]
     */
    public function getRelations(): array
    {
        return array_filter($this->relations, function ($relation) {
            return $relation !== '*';
        });
    }

    /**
     * Get a list of default relations.
     *
     * @return string[]
     */
    public function getDefaultRelations(): array
    {
        return collect($this->load)->keys()->mapWithKeys(function ($relation) {
            if (method_exists($this, $method = 'load' . ucfirst($relation))) {
                return [$relation => $this->makeEagerLoadCallback($method)];
            }

            return $relation;
        });
    }

    /**
     * Extract a deep list of default relations, recursively.
     *
     * @return string[]
     */
    public function extractDefaultRelations(): array
    {
        return collect($this->getDefaultRelations())->merge($this->load->map(function ($transformer, $relation) {
            return collect($this->resolveTransformer($transformer)->extractDefaultRelations())

It seems like resolveTransformer() must be provided by classes using this trait. How about adding it as abstract method to this trait?

                ->keys()
                ->map(function ($nestedRelation) use ($relation) {
                    return "$relation.$nestedRelation";

As per coding-style, please use concatenation or sprintf for the variable $relation instead of interpolation.

As per coding-style, please use concatenation or sprintf for the variable $nestedRelation instead of interpolation.

                });
        }))->all();
    }

    /**
     * Extract a deep list of default relations, recursively.
     *
     * @param  string $method
     * @return \Closure
     */
    public function makeEagerLoadCallback(string $method): Closure
    {
        return function ($query) use ($method) {
            return $this->$method($query);
        };
    }
}