AlecRabbit\StringList\StringList

Complexity

Total Complexity

11

Size/Duplication

Total Lines	89
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	include()	0	6	1
A	process()	0	4	1
A	exclude()	0	6	1
A	has()	0	4	2
A	diff()	0	4	1
A	includes()	0	4	2
A	notExcludes()	0	4	2

<?php
/**
 * Date: 11.11.18
 * Time: 15:22
 */

namespace AlecRabbit\StringList;

use AlecRabbit\StringList\Contracts\StringListInterface;

class StringList implements StringListInterface
{
    /** @var array */
    private $including = [];
    /** @var array */
    private $excluding = [];

    /**
     * StringList constructor.
     * @param null|array $including
     * @param null|array $excluding
     */
    public function __construct(?array $including = null, ?array $excluding = null)
    {
        $this->include(...$including ?? []);
        $this->exclude(...$excluding ?? []);
    }

    /**
     * {@inheritdoc}
     */
    public function include(string ...$including): StringListInterface
    {
        $this->including = $this->process($this->including, $including);
        $this->excluding = $this->diff($this->excluding, $this->including);

        return $this;
    }

    /**
     * @param array $first
     * @param array $second
     * @return array
     */
    private function process(array $first, array $second): array
    {
        return
            array_unique(array_merge($first, $second));
    }

    /**
     * @param array $first
     * @param array $second
     * @return array
     */
    private function diff(array $first, array $second): array
    {
        return
            array_diff($first, $second);
    }

    /**
     * {@inheritdoc}
     */
    public function exclude(string ...$excluding): StringListInterface
    {
        $this->excluding = $this->process($this->excluding, $excluding);
        $this->including = $this->diff($this->including, $this->excluding);

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function has(string $element): bool
    {
        return
            $this->includes($element) && $this->notExcludes($element);
    }

    /**
     * @param string $element
     * @return bool
     */
    private function includes(string $element): bool
    {
        return
            empty($this->including) || \in_array($element, $this->including, true);
    }

    /**
     * @param string $element
     * @return bool
     */
    private function notExcludes(string $element): bool
    {
        return
            empty($this->excluding) || !\in_array($element, $this->excluding, true);
    }
}