devtoolboxuk\cerberus\AbstractCerberus

Complexity

Total Complexity

22

Size/Duplication

Total Lines	120
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

73.58%

Importance

Changes

0

10 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	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;

    function __construct()

It is generally recommended to explicitly declare the visibility for methods.

It is recommend to declare an explicit visibility for __construct.

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


    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());
        }
    }

    private function getOption($name)
    {
        if (!$this->hasOption($name)) {
            return null;
        }

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

    private function hasOption($name)
    {
        return isset($this->options[$name]);
    }

    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;
    }

    /**
     * @param file|array $options
     * @return $this
     */
    public function setOptions($options = [])

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->yaml_loaded()) {

The method yaml_loaded() does not seem to exist on object<devtoolboxuk\cerberus\AbstractCerberus>.

                $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 also be of type object<devtoolboxuk\cerberus\file>. However, the property $options is declared as type array. Maybe add an additional type check?

    }

    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;
    }
}