Alchemy\RestBundle\Rest\Request\SortRequest

Complexity

Total Complexity

15

Size/Duplication

Total Lines	101
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	getSorts()	0	15	3
B	normalizeSorts()	0	16	6
A	extractSortProperty()	0	12	3
A	mapSortProperty()	0	8	2

<?php

namespace Alchemy\RestBundle\Rest\Request;

use Alchemy\Rest\Request\Sort;
use Alchemy\Rest\Request\SortOptions;

class SortRequest implements SortOptions
{
    /**
     * @var string|array
     */
    private $sorts;

    /**
     * @var string
     */
    private $property;

    /**
     * @var string
     */
    private $direction;

    /**
     * @param $sorts
     * @param string|null $property
     * @param string|null $direction
     */
    public function __construct($sorts, $property = null, $direction = null)
    {
        $this->sorts = $sorts;
        $this->property = $property;
        $this->direction = $direction;
    }

    /**
     * @param array $sortMap
     * @return array
     */
    public function getSorts(array $sortMap = array())
    {
        $sorts = array();

        foreach ($this->normalizeSorts($this->sorts) as $sort) {

The expression $this->normalizeSorts($this->sorts) of type array|string|null is not guaranteed to be traversable. How about adding an additional type check?

            $sort = $this->extractSortProperty($sort);
            $sort = $this->mapSortProperty($sortMap, $sort[0], $sort[1]);

            if ($sort) {
                $sorts[] = $sort;
            }
        }

        return $sorts;
    }

    /**
     * @return array|string|null
     */
    private function normalizeSorts($sorts)
    {
        if ($sorts === null && $this->property !== null && $this->direction !== null) {
            $sorts = array(array($this->property, $this->direction));
        }

        if (is_string($sorts)) {
            $sorts = explode(',', $sorts);
        }

        if ($sorts === null) {
            $sorts = array();
        }

        return $sorts;
    }

    /**
     * @param $sort
     * @return array
     */
    private function extractSortProperty($sort)
    {
        if (is_string($sort)) {
            $sort = explode(':', $sort);
        }

        if (count($sort) < 2) {
            $sort[1] = self::SORT_ASC;
        }

        return $sort;
    }

    /**
     * @param array $sortMap
     * @param $sort
     * @param $direction
     * @return Sort
     */
    private function mapSortProperty(array $sortMap, $sort, $direction)
    {
        if (isset($sortMap[$sort])) {
            $sort = $sortMap[$sort];
        }

        return new Sort($sort, $direction);
    }
}