Ktomk\Pipelines\Value\StepExpression

Complexity

Total Complexity

26

Size/Duplication

Total Lines	175
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	1

11 Methods

Rating	Name	Duplication	Size	Complexity
A	createFromString()	0	3	1
A	validate()	0	9	2
A	__construct()	0	3	1
A	getSegments()	0	3	1
A	resolveCountable()	0	3	1
A	resolveSegmentFunctor()	0	4	1
A	resolveSegmentCount()	0	18	4
A	parseSegment()	0	21	6
A	parseSegments()	0	18	4
A	verifyValueCount()	0	7	2
A	resolveCount()	0	9	3

<?php

/* this file is part of pipelines */

namespace Ktomk\Pipelines\Value;

use Ktomk\Pipelines\Lib;

/**
 * Class StepExpression
 *
 * @package Ktomk\Pipelines\Value
 */
class StepExpression
{
    /**
     * @var array 1-3, -5, 1-
     */
    private $segments;

    /**
     * @param string $expression
     *
     * @return StepExpression
     */
    public static function createFromString($expression)
    {
        return new self(self::parseSegments($expression));
    }

    /**
     * Is a step expression syntactically valid?
     *
     * @param string $expression
     *
     * @return bool
     */
    public static function validate($expression)
    {
        try {
            self::parseSegments($expression);
        } catch (\InvalidArgumentException $ex) {
            return false;
        }

        return true;
    }

    public static function resolveSegmentCount($segment, $count)
    {
        $pos = strpos($segment, '-');
        list($from, $to) = explode('-', $segment, 2) + array('', '');

        if (false === $pos) {
            return array(self::verifyValueCount((int)Lib::emptyCoalesce($from, $to), $count));
        }

        if (empty($to)) {
            return range(self::verifyValueCount($from, $count), $count);
        }

        if (empty($from)) {
            return range(self::verifyValueCount(1, $count), self::verifyValueCount($to, $count));
        }

        return range(self::verifyValueCount($from, $count), self::verifyValueCount($to, $count));
    }

    /**
     * StepExpression constructor.
     *
     * @param array $segments
     */
    public function __construct(array $segments)
    {
        $this->segments = $segments;
    }

    /**
     * @return array
     */
    public function getSegments()
    {
        return $this->segments;
    }

    /**
     * @param mixed $countable
     *
     * @return mixed
     */
    public function resolveCountable($countable)
    {
        return $this->resolveCount(count($countable));
    }

    /**
     * @param int $count
     */
    public function resolveCount($count)
    {
        if (0 === $count || !is_int($count)) {
            throw new \InvalidArgumentException('Count is zero');
        }

        $range = Lib::merge(array_map(self::resolveSegmentFunctor($count), $this->segments));

        return call_user_func_array('array_merge', $range);
    }

    /**
     * @param $buffer
     *
     * @return array|string[]
     */
    private static function parseSegments($buffer)
    {
        $normalized = preg_replace(array('~\s+~', '~(\d+)\s+(-)~', '~(-)\s+(\d+)+~'), array(' ', '\\1\\2', '\\1\\2'), $buffer);
        if (empty($normalized)) {
            throw new \InvalidArgumentException(sprintf('No steps: "%s"', $buffer));
        }

        $result = preg_split('~\s*(?:,|\s)\s*~', $normalized, 64, PREG_SPLIT_NO_EMPTY);
        if (empty($result)) {
            throw new \InvalidArgumentException(sprintf('No steps: "%s"', $buffer));
        }

        $array = array();
        foreach ($result as $segmentBuffer) {
            $array[] = self::parseSegment($segmentBuffer);
        }

        return $array;
    }

    /**
     * Parse (better: normalize) segment
     *
     * @param string $buffer
     *
     * @return string
     */
    private static function parseSegment($buffer)
    {
        $segment = preg_replace('~\s+~', '', $buffer);
        if (null === $segment) {
            // @codeCoverageIgnoreStart
            throw new \InvalidArgumentException(sprintf('Can not parse step segment for "%s"', $buffer));
            // @codeCoverageIgnoreEnd
        }

        $result = preg_match('~^(?:(?:[1-9]\d*)?-(?:[1-9]\d*)?|(?:[1-9]\d*))$~', $segment);
        if (false === $result || 0 === $result || '-' === $segment) {
            if ($buffer !== $segment) {
                // @codeCoverageIgnoreStart
                throw new \InvalidArgumentException(sprintf('Can not parse step segment for "%s" (from "%s")', $segment, $buffer));
                // @codeCoverageIgnoreEnd
            }

            throw new \InvalidArgumentException(sprintf('Can not parse step segment for "%s"', $segment));
        }

        return $segment;
    }

    /**
     * @param int $count
     */
    private static function resolveSegmentFunctor($count)
    {
        return function ($segment) use ($count) {
            return StepExpression::resolveSegmentCount($segment, $count);
        };
    }

    /**
     * @param int $value
     * @param int $count
     *
     * @return int
     */
    private static function verifyValueCount($value, $count)
    {
        if ($value > $count) {
            throw new \InvalidArgumentException(sprintf('%d is out of range (%d)', $value, $count));
        }

        return $value;
    }
}