RulerZ\Target\Operators\Definitions

Complexity

Total Complexity

16

Size/Duplication

Total Lines	150
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	mergeWith()	0	7	1
A	hasOperator()	0	4	1
A	defineOperators()	0	6	2
A	defineOperator()	0	5	1
A	getOperator()	0	8	2
A	getOperators()	0	4	1
A	getInlineOperator()	0	8	2
A	hasInlineOperator()	0	4	1
A	defineInlineOperators()	0	6	2
A	defineInlineOperator()	0	5	1
A	getInlineOperators()	0	4	1

<?php

declare(strict_types=1);

namespace RulerZ\Target\Operators;

use RulerZ\Exception\OperatorNotFoundException;

class Definitions
{
    /**
     * List of operators.
     *
     * @var array
     */
    private $operators = [];

    /**
     * List of inline-able operators.
     *
     * @var array
     */
    private $inlineOperators = [];

    public function __construct(array $operators = [], array $inlineOperators = [])
    {
        $this->defineOperators($operators);
        $this->defineInlineOperators($inlineOperators);
    }

    public function mergeWith(self $other): self
    {
        return new static(
            array_merge($this->operators, $other->operators),
            array_merge($this->inlineOperators, $other->inlineOperators)
        );
    }

    /**
     * Tells if an operator exists.
     *
     * @param string $operator The operator's name.
     */
    public function hasOperator(string $operator): bool
    {
        return isset($this->operators[$operator]);
    }

    /**
     * Define operators.
     *
     * @param array<callable> $operators A list of operators to add, each one being a collable.
     */
    public function defineOperators(array $operators): void
    {
        foreach ($operators as $name => $callable) {
            $this->defineOperator($name, $callable);
        }
    }

    /**
     * Define an operator.
     *
     * @param string   $operator    The operator's name.
     * @param callable $transformer Callable.
     */
    public function defineOperator(string $operator, callable $transformer): void
    {
        unset($this->inlineOperators[$operator]);
        $this->operators[$operator] = $transformer;
    }

    /**
     * Get an operator.
     *
     * @param string $operator The operator's name.
     *
     * @throws OperatorNotFoundException
     */
    protected function getOperator(string $operator): callable
    {
        if (!$this->hasOperator($operator)) {
            throw new OperatorNotFoundException($operator, sprintf('Operator "%s" does not exist.', $operator));
        }

        return $this->operators[$operator];
    }

    /**
     * Get the operators list.
     *
     * @return array<callable>
     */
    public function getOperators(): array
    {
        return $this->operators;
    }

    /**
     * Gets an inline-able operator.
     *
     * @param string $operator The operator's name.
     *
     * @throws OperatorNotFoundException
     */
    public function getInlineOperator(string $operator): callable
    {
        if (!$this->hasInlineOperator($operator)) {
            throw new OperatorNotFoundException($operator, sprintf('Inline operator "%s" does not exist.', $operator));
        }

        return $this->inlineOperators[$operator];
    }

    /**
     * Tells if an inline-able operator exists.
     *
     * @param string $operator The operator's name.
     */
    public function hasInlineOperator(string $operator): bool
    {
        return isset($this->inlineOperators[$operator]);
    }

    /**
     * Add inline operators.
     *
     * @param array<callable> $operators A list of inline operators to add.
     */
    public function defineInlineOperators(array $operators): void
    {
        foreach ($operators as $name => $callable) {
            $this->defineInlineOperator($name, $callable);
        }
    }

    /**
     * Set an inline-able operator.
     *
     * @param string   $operator    The operator's name.
     * @param callable $transformer Callable.
     */
    public function defineInlineOperator(string $operator, callable $transformer)
    {
        unset($this->operators[$operator]);
        $this->inlineOperators[$operator] = $transformer;
    }

    /**
     * Get the inline operators list.
     *
     * @return array<callable>
     */
    public function getInlineOperators(): array
    {
        return $this->inlineOperators;
    }
}