devtoolboxuk\cerberus\AbstractCerberus

Complexity

Total Complexity

23

Size/Duplication

Total Lines	148
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

70.9%

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	processWrappers()	0	11	2
A	getOption()	0	8	2
A	hasOption()	0	4	1
A	addResult()	0	8	2
A	addScore()	0	5	1
A	clearResults()	0	6	1
A	getOptions()	0	4	1
A	isYamlLoaded()	0	4	1
A	setOptions()	0	23	5
A	arrayMergeRecursiveDistinct()	0	15	6

<?php

namespace devtoolboxuk\cerberus;

use devtoolboxuk\soteria\SoteriaService;

abstract class AbstractCerberus
{

    protected $options = [];
    protected $results = [];
    protected $result = [];
    protected $score = 0;
    protected $soteria;

    public function __construct()
    {
        $this->soteria = new SoteriaService();
        $this->setOptions();
    }

    /**
     * @param $handler
     */
    protected function processWrappers($handler)
    {
        $options = $this->getOption('Detection');

        foreach ($handler->getWrappers() as $wrapper) {

Blank line found at start of control structure

            $wrapper->setOptions($handler->getValue(), $options['Rules']);
            $wrapper->process();
            $this->addResult($wrapper->getScore(), $wrapper->getResult());
        }
    }

    /**
     * @param $name
     * @return mixed|null
     */
    private function getOption($name)
    {
        if (!$this->hasOption($name)) {
            return null;
        }

        return $this->options[$name];
    }

    /**
     * @param $name
     * @return bool
     */
    private function hasOption($name)
    {
        return isset($this->options[$name]);
    }

    /**
     * @param $score
     * @param $result
     * @return $this
     */
    protected function addResult($score, $result)
    {
        if (is_array($result)) {
            $this->addScore($score);
            $this->result = array_merge($this->result, $result);
        }
        return $this;
    }

    /**
     * @param $score
     * @return $this
     */
    private function addScore($score)
    {
        $this->score += $score;
        return $this;
    }


    protected function clearResults()
    {
        $this->results = [];
        $this->result = [];
        $this->score = 0;
    }

    /**
     * @return array
     */
    protected function getOptions()
    {
        return $this->options;
    }

    /**
     * @return bool
     */
    private function isYamlLoaded()
    {
        return extension_loaded('yaml');
    }

    /**
     * @param null $options
     */
    public function setOptions($options = null)

The variable $basic_options is not named in camelCase.

    {

        $baseOptions = new BaseOptions();
        $basic_options = $baseOptions->getOptions();

        if (is_array($options)) {
            $options = $this->arrayMergeRecursiveDistinct($basic_options, $options);
        } else {

The method setOptions uses an else expression. Else is never necessary and you can simplify the code to work without else.

            if ($this->isYamlLoaded()) {
                $this->soteria->sanitise()->disinfect($options, 'url');
                if ($this->soteria->sanitise()->result()->isValid()) {
                    $options = $this->arrayMergeRecursiveDistinct($basic_options, yaml_parse_file($options));
                } else {

The method setOptions uses an else expression. Else is never necessary and you can simplify the code to work without else.

                    if (file_exists($options)) {
                        $options = $this->arrayMergeRecursiveDistinct($basic_options, yaml_parse_file($options));
                    }
                }
            }
        }

        $this->options = $options;

It seems like $options can be null. However, the property $options is declared as array. Maybe change the type of the property to array|null or add a type check?

    }

    /**
     * @param array $merged
     * @param array $array2
     * @return array
     */
    private function arrayMergeRecursiveDistinct($merged = [], $array2 = [])

This operation has 10 execution paths which exceeds the configured maximum of 10.

    {
        if (empty($array2)) {
            return $merged;
        }

        foreach ($array2 as $key => &$value) {
            if (is_array($value) && isset($merged[$key]) && is_array($merged[$key])) {
                $merged[$key] = $this->arrayMergeRecursiveDistinct($merged[$key], $value);
            } else {

The method arrayMergeRecursiveDistinct uses an else expression. Else is never necessary and you can simplify the code to work without else.

                $merged[$key] = $value;
            }
        }
        return $merged;
    }
}