Flipbox\Transform\Helpers\TransformerHelper

Complexity

Total Complexity

21

Size/Duplication

Total Lines	112
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

8.33%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	isTransformer()	0	5	3
A	isTransformerClass()	0	4	2
A	resolve()	0	12	3
A	normalizeIncludes()	0	4	1
A	inInclude()	0	4	1
C	normalizeIncludesInternal()	0	32	8
A	findInArray()	0	9	3

<?php

/**
 * @author    Flipbox Factory
 * @copyright Copyright (c) 2017, Flipbox Digital
 * @link      https://github.com/flipbox/transform/releases/latest
 * @license   https://github.com/flipbox/transform/blob/master/LICENSE
 */

namespace Flipbox\Transform\Helpers;

use Closure;
use Flipbox\Transform\Transformers\TransformerInterface;

/**
 * @author Flipbox Factory <hello@flipboxfactory.com>
 * @since 1.0.0
 */
class TransformerHelper
{
    /**
     * @param $transformer
     * @return bool
     */
    public static function isTransformer($transformer): bool
    {
        return (is_object($transformer) && ($transformer instanceof Closure)) ||
            $transformer instanceof TransformerInterface;
    }

    /**
     * @param $transformer
     * @return bool
     */
    public static function isTransformerClass($transformer): bool
    {
        return is_string($transformer) && is_subclass_of($transformer, TransformerInterface::class);
    }

    /**
     * @param $transformer
     * @return null|callable|TransformerInterface
     */
    public static function resolve($transformer)
    {
        if (static::isTransformer($transformer)) {
            return $transformer;
        }

        if (static::isTransformerClass($transformer)) {
            return new $transformer();
        }

        return null;
    }

    /**
     * @param TransformerInterface $transformer
     * @return array
     */
    public static function normalizeIncludes(TransformerInterface $transformer): array
    {
        return self::normalizeIncludesInternal($transformer->getIncludes());
    }

    /**
     * @param TransformerInterface $transformer
     * @param string $key
     * @return bool
     */
    public static function inInclude(TransformerInterface $transformer, string $key): bool
    {
        return self::findInArray(static::normalizeIncludes($transformer), $key) !== null;
    }

    /**
     * @param array $includes
     * @return array
     */
    private static function normalizeIncludesInternal(array $includes)
    {
        foreach ($includes as $k => $v) {

            if (is_string($v) && ($pos = strrpos($v, '.')) !== false) {
                $v = [substr($v, 0, $pos) => [substr($v, $pos + 1)]];
            }

            // normalize sub-includes
            $v = is_array($v) ? static::normalizeIncludesInternal($v) : $v;

Since normalizeIncludesInternal() is declared private, calling it with static will lead to errors in possible sub-classes. You can either use self, or increase the visibility of normalizeIncludesInternal() to at least protected.

            if (is_numeric($k)) {
                unset($includes[$k]);

                if (is_array($v)) {
                    $k = key($v);
                    $v = reset($v);
                } else {
                    $k = $v;
                }
            }

            $includes[$k] = $v;

            if (($pos = strrpos($k, '.')) !== false) {
                $includes[substr($k, 0, $pos)] = [substr($k, $pos + 1) => $includes[$k]];
                unset($includes[$k]);
            }
        }

        return $includes;
    }

    /**
     * Retrieves the value of an array element or object property with the given key or property name.
     *
     * @param $array
     * @param $key
     * @param null $default
     * @return mixed|null
     */
    private static function findInArray(array $array, string $key, $default = null)
    {
        if (($pos = strrpos($key, '.')) !== false) {
            $array = static::findInArray($array, substr($key, 0, $pos), $default);

Since findInArray() is declared private, calling it with static will lead to errors in possible sub-classes. You can either use self, or increase the visibility of findInArray() to at least protected.

            $key = substr($key, $pos + 1);
        }

        return array_key_exists($key, $array) ? $array[$key] : $default;
    }
}