Oliverde8\Component\RuleEngine\RuleApplier

Complexity

Total Complexity

17

Size/Duplication

Total Lines	131
Duplicated Lines	0 %

Test Coverage

Coverage

97.56%

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	2
D	apply()	0	31	10
B	applyRule()	0	28	4
A	registerRule()	0	3	1

<?php

namespace Oliverde8\Component\RuleEngine;

use Oliverde8\Component\RuleEngine\Exceptions\RuleException;
use Oliverde8\Component\RuleEngine\Exceptions\UnknownRuleException;
use Oliverde8\Component\RuleEngine\Rules\RuleInterface;
use Psr\Log\LoggerInterface;

/**
 * Class RuleApplier
 *
 * @author    de Cramer Oliver<oiverde8@gmail.com>
 * @copyright 2018 Oliverde8
 * @package Oliverde8\Component\RuleEngine\RuleApplier
 */
class RuleApplier
{
    /** @var LoggerInterface */
    protected $logger;

    /** @var RuleInterface[] */
    protected $rules;

    /** @var boolean When vali */
    protected $validate;

    /** @var array */
    protected $currentIdentity;

    /**
     * RuleApplier constructor.
     *
     * @param LoggerInterface $logger   Standard logger to use to log errors or debug information.
     * @param RuleInterface[] $rules    List of rules defined.
     * @param boolean         $validate When validation is active rules are validated and clear messages are displayed
     *                                  when a rule is not well coded. But performance is worsened.
     */
    public function __construct(LoggerInterface $logger, array $rules, $validate = false)
    {
        $this->logger = $logger;
        $this->validate = $validate;

        foreach ($rules as $rule) {
            $this->registerRule($rule);
        }
    }

    /**
     * Register a rule to the rule engine.
     *
     * @param RuleInterface $rule
     */
    public function registerRule(RuleInterface $rule)
    {
        $this->rules[$rule->getRuleCode()] = $rule;
    }


    /**
     * Apply rules to data.
     *
     * @param array|string $rowData         Data that is being trasformed.
     * @param array        $transformedData Transformed data at the current stage
     * @param array|string $rules           Rules to apply, if string is given the string is returned.
     * @param array        $options         Options to be used by the rules.
     * @param array        $identifier      Identity of the line rule is applied on to log & display.
     *
     * @return null|string
     * @throws UnknownRuleException
     * @throws RuleException
     */
    public function apply($rowData, $transformedData, $rules, $options = [], $identifier = [])
    {
        // There is no rule apply.
        if (!is_array($rules)) {
            return $rules;
        }

        if (!empty($identifier)) {
            $this->currentIdentity = $identifier;
        }

        foreach ($rules as $ruleData) {
            // There is no rule apply.
            if (!is_array($ruleData)) {
                return $ruleData;
            }

            foreach ($ruleData as $rule => $ruleOptions) {
                $value = $this->applyRule($rule, $ruleOptions, $rowData, $transformedData, $options);

It seems like $rowData can also be of type string; however, parameter $rowData of Oliverde8\Component\RuleEngine\RuleApplier::applyRule() does only seem to accept array, maybe add an additional type check?

                if (!empty($value) || $value === 0 || $value === "0") {
                    return $value;
                }
            }
        }

        if (!empty($this->currentIdentity)) {
            $this->logger->warning("Rules were not resolved for line.", $this->currentIdentity);
        }

        return "";
    }

    /**
     * Apply a rule to a data set.
     *
     * @param string $rule            Code of the rule to apply.
     * @param array  $ruleOptions     Options to use when applying the rule
     * @param array  $rowData         Row that needs conversion.
     * @param array  $transformedData Current state of the transformed rule.
     * @param array  $options         Other options.
     *
     * @throws RuleException
     *
     * @return null|string
     * @throws UnknownRuleException
     */
    protected function applyRule($rule, $ruleOptions, $rowData, $transformedData, $options)
    {
        if (!isset($this->rules[$rule])) {
            throw new UnknownRuleException("Rule '$rule' was not found!");
        }
        $ruleObject = $this->rules[$rule];

        $options = array_merge($options, $ruleOptions);

        if ($this->validate) {
            try {
                $ruleObject->validate($options);
            } catch (RuleException $ruleException) {
                $this->logger->error(
                    "An exception accured when executing rules!",
                    array_merge(
                        $this->currentIdentity,
                        ['message' => $ruleException->getMessage()]
                    )
                );
                throw $ruleException;
            }
        }

        $ruleObject->setApplier($this);
        $result = $ruleObject->apply($rowData, $transformedData, $options);

        return $result;
    }
}