NilPortugues\Api\Transformer\Transformer

Complexity

Total Complexity

49

Size/Duplication

Total Lines	372
Duplicated Lines	4.84 %

Coupling/Cohesion

Components	4
Dependencies	4

Importance

Changes	5
Bugs	0	Features	1

27 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
	serialize()	0	1	?
A	unserialize()	0	4	1
A	addMeta()	0	4	1
A	setMeta()	0	6	1
A	addHrefToLinks()	0	10	3
A	noMappingGuard()	0	8	3
A	recursiveSetKeysToUnderScore()	0	13	3
A	buildLinks()	0	14	1
A	getSelfUrl()	0	4	1
A	setSelfUrl()	0	6	1
A	getFirstUrl()	0	4	1
A	setFirstUrl()	0	4	1
A	getLastUrl()	0	4	1
A	setLastUrl()	0	4	1
A	getPrevUrl()	0	4	1
A	setPrevUrl()	0	4	1
A	getNextUrl()	0	4	1
A	setNextUrl()	0	4	1
B	getResponseAdditionalLinks()	0	22	6
A	formatScalarValues()	8	8	3
A	arrayToScalarValue()	0	8	2
A	loopScalarValues()	0	8	4
A	flattenObjectsWithSingleKeyScalars()	10	10	4
A	getMappings()	0	4	1
A	getMappingByAlias()	0	10	3
A	getMappingByClassName()	0	6	2

<?php

namespace NilPortugues\Api\Transformer;

use NilPortugues\Api\Mapping\Mapper;
use NilPortugues\Api\Mapping\Mapping;
use NilPortugues\Api\Transformer\Helpers\RecursiveFormatterHelper;
use NilPortugues\Serializer\Serializer;
use NilPortugues\Serializer\Strategy\StrategyInterface;

abstract class Transformer implements StrategyInterface
{
    const SELF_LINK = 'self';
    const FIRST_LINK = 'first';
    const LAST_LINK = 'last';
    const PREV_LINK = 'prev';
    const NEXT_LINK = 'next';
    const LINKS_HREF = 'href';
    const LINKS_KEY = 'links';

    /**
     * @var Mapping[]
     */
    protected $mappings = [];
    /**
     * @var string
     */
    protected $firstUrl = '';
    /**
     * @var string
     */
    protected $lastUrl = '';
    /**
     * @var string
     */
    protected $prevUrl = '';
    /**
     * @var string
     */
    protected $nextUrl = '';

    /**
     * @var string
     */
    protected $selfUrl = '';

    /**
     * @var array
     */
    protected $meta = [];

    /**
     * @param Mapper $mapper
     */
    public function __construct(Mapper $mapper)
    {
        $this->mappings = $mapper->getClassMap();
    }

    /**
     * Represents the provided $value as a serialized value in string format.
     *
     * @param mixed $value
     *
     * @return string
     */
    abstract public function serialize($value);

    /**
     * Unserialization will fail. This is a transformer.
     *
     * @param string $value
     *
     * @throws TransformerException
     *
     * @return array
     */
    public function unserialize($value)
    {
        throw new TransformerException(\sprintf('%s does not perform unserializations.', __CLASS__));
    }

    /**
     * @param string       $key
     * @param array|string $value
     */
    public function addMeta($key, $value)
    {
        $this->meta[$key] = $value;
    }

    /**
     * @param array $meta
     *
     * @return $this
     */
    public function setMeta(array $meta)
    {
        $this->meta = $meta;

        return $this;
    }

    /**
     * @param array $links
     *
     * @return array
     */
    protected function addHrefToLinks(array $links)
    {
        if (!empty($links)) {
            foreach ($links as &$link) {
                $link = [self::LINKS_HREF => $link];
            }
        }

        return $links;
    }

    /**
     * @throws TransformerException
     */
    protected function noMappingGuard()
    {
        if (empty($this->mappings) || !is_array($this->mappings)) {
            throw new TransformerException(
                'No mappings were found. Mappings are required by the transformer to work.'
            );
        }
    }

    /**
     * Changes all array keys to under_score format using recursion.
     *
     * @param array $array
     */
    protected function recursiveSetKeysToUnderScore(array &$array)
    {
        $newArray = [];
        foreach ($array as $key => &$value) {
            $underscoreKey = RecursiveFormatterHelper::camelCaseToUnderscore($key);
            $newArray[$underscoreKey] = $value;

            if (\is_array($value)) {
                $this->recursiveSetKeysToUnderScore($newArray[$underscoreKey]);
            }
        }
        $array = $newArray;
    }

    /**
     * @return array
     */
    protected function buildLinks()
    {
        $links = \array_filter(
            [
                self::SELF_LINK => $this->getSelfUrl(),
                self::FIRST_LINK => $this->getFirstUrl(),
                self::LAST_LINK => $this->getLastUrl(),
                self::PREV_LINK => $this->getPrevUrl(),
                self::NEXT_LINK => $this->getNextUrl(),
            ]
        );

        return $links;
    }

    /**
     * @return string
     */
    public function getSelfUrl()
    {
        return $this->selfUrl;
    }

    /**
     * @param string $selfUrl
     *
     * @return $this
     */
    public function setSelfUrl($selfUrl)
    {
        $this->selfUrl = $selfUrl;

        return $this;
    }

    /**
     * @return string
     */
    public function getFirstUrl()
    {
        return $this->firstUrl;
    }

    /**
     * @param string $firstUrl
     *
     * @throws \InvalidArgumentException
     */
    public function setFirstUrl($firstUrl)
    {
        $this->firstUrl = (string) $firstUrl;
    }

    /**
     * @return string
     */
    public function getLastUrl()
    {
        return $this->lastUrl;
    }

    /**
     * @param string $lastUrl
     *
     * @throws \InvalidArgumentException
     */
    public function setLastUrl($lastUrl)
    {
        $this->lastUrl = (string) $lastUrl;
    }

    /**
     * @return string
     */
    public function getPrevUrl()
    {
        return $this->prevUrl;
    }

    /**
     * @param string $prevUrl
     *
     * @throws \InvalidArgumentException
     */
    public function setPrevUrl($prevUrl)
    {
        $this->prevUrl = (string) $prevUrl;
    }

    /**
     * @return string
     */
    public function getNextUrl()
    {
        return $this->nextUrl;
    }

    /**
     * @param string $nextUrl
     *
     * @throws \InvalidArgumentException
     */
    public function setNextUrl($nextUrl)
    {
        $this->nextUrl = (string) $nextUrl;
    }

    /**
     * @param array  $copy
     * @param string $type
     *
     * @return array
     */
    protected function getResponseAdditionalLinks(array $copy, $type)
    {
        if (\is_scalar($type) && !empty($this->mappings[$type])) {
            $otherUrls = $this->mappings[$type]->getUrls();
            list($idValues, $idProperties) = RecursiveFormatterHelper::getIdPropertyAndValues(
                $this->mappings,
                $copy,
                $type
            );

            $replacedUrls = \str_replace($idProperties, $idValues, $otherUrls);
            foreach ($replacedUrls as $key => $value) {
                if ($otherUrls[$key] === $value && false !== strpos($value, '{')) {
                    unset($replacedUrls[$key]);
                }
            }

            return $replacedUrls;
        }

        return [];
    }

    /**
     * Replaces the Serializer array structure representing scalar values to the actual scalar value using recursion.
     *
     * @param array $array
     */
    protected static function formatScalarValues(array &$array)

This method seems to be duplicated in your project.

    {
        $array = self::arrayToScalarValue($array);

        if (\is_array($array) && !array_key_exists(Serializer::SCALAR_VALUE, $array)) {
            self::loopScalarValues($array, 'formatScalarValues');
        }
    }

    /**
     * @param array $array
     *
     * @return array
     */
    protected static function arrayToScalarValue(array &$array)
    {
        if (\array_key_exists(Serializer::SCALAR_VALUE, $array)) {
            $array = $array[Serializer::SCALAR_VALUE];
        }

        return $array;
    }

    /**
     * @param array  $array
     * @param string $method
     */
    protected static function loopScalarValues(array &$array, $method)
    {
        foreach ($array as $propertyName => &$value) {
            if (\is_array($value) && self::LINKS_KEY !== $propertyName) {
                self::$method($value);
            }
        }
    }

    /**
     * Simplifies the data structure by removing an array level if data is scalar and has one element in array.
     *
     * @param array $array
     */
    protected static function flattenObjectsWithSingleKeyScalars(array &$array)

This method seems to be duplicated in your project.

    {
        if (1 === \count($array) && \is_scalar(\end($array))) {
            $array = \array_pop($array);
        }

        if (\is_array($array)) {
            self::loopScalarValues($array, 'flattenObjectsWithSingleKeyScalars');
        }
    }

    /**
     * @return \NilPortugues\Api\Mapping\Mapping[]
     */
    public function getMappings()
    {
        return $this->mappings;
    }

    /**
     * @param string $alias
     *
     * @return Mapping|null
     */
    public function getMappingByAlias($alias)
    {
        foreach ($this->mappings as $mapping) {
            if (0 === strcasecmp($alias, $mapping->getClassAlias())) {
                return $mapping;
            }
        }

        return;
    }

    /**
     * @param string $className
     *
     * @return Mapping|null
     */
    public function getMappingByClassName($className)
    {
        $className = ltrim($className, '\\');

        return (!empty($this->mappings[$className])) ? $this->mappings[$className] : null;
    }
}