devtoolboxuk\cerberus\Wrappers\Wrapper

Complexity

Total Complexity

33

Size/Duplication

Total Lines	186
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

72.62%

Importance

Changes

0

27 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	pushResult()	0	4	1
A	getResult()	0	4	1
A	hasRealScore()	0	4	1
A	setOptions()	0	6	1
A	sanitizeReference()	0	4	1
A	getReference()	0	4	1
A	setReference()	0	5	1
A	inParams()	0	7	2
A	getParams()	0	4	1
A	setParams()	0	5	1
A	getRuleOption()	0	8	2
A	hasRuleOption()	0	4	1
A	initWrapper()	0	5	1
A	setRules()	0	8	1
A	getOption()	0	8	2
A	hasOption()	0	4	1
A	getName()	0	4	1
A	setName()	0	5	1
A	setRealScore()	0	4	1
A	setActive()	0	4	1
A	getActive()	0	4	1
A	getScore()	0	8	2
A	setScore()	0	4	1
A	hasScore()	0	4	1
A	getRealScore()	0	8	2
A	setResult()	0	10	2

<?php

namespace devtoolboxuk\cerberus\Wrappers;

use devtoolboxuk\soteria\SoteriaService;

abstract class Wrapper
{

    private $options = [];
    private $results = null;
    private $score = 0;
    private $realScore = 0;
    private $params = [];
    private $name;
    private $active;
    private $reference;

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

    function pushResult($result)

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

It is recommend to declare an explicit visibility for pushResult.

    {
        array_unshift($this->results, $result);
    }

    function getResult()

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

It is recommend to declare an explicit visibility for getResult.

    {
        return $this->results;
    }

    public function getRealScore()
    {
        if (!$this->hasRealScore()) {
            return 0;
        }

        return $this->realScore;
    }

    private function hasRealScore()
    {
        return isset($this->realScore);
    }

    function setOptions($reference, $options = [])

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

It is recommend to declare an explicit visibility for setOptions.

    {
        $this->reference = $reference;
        $this->options = $options;
        return $this;
    }

    function sanitizeReference()

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

It is recommend to declare an explicit visibility for sanitizeReference.

    {
        return str_replace(" ", "", strip_tags(trim($this->getReference())));
    }


    function getReference()

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

It is recommend to declare an explicit visibility for getReference.

    {
        return $this->reference;
    }

    protected function setReference($reference)
    {
        $this->reference = $reference;
        return $this;
    }

    public function inParams($name)
    {
        if (in_array($name, $this->getParams())) {
            return true;
        }
        return false;
    }

    protected function getParams()
    {
        return $this->params;
    }

    protected function setParams($params)
    {
        $this->params = explode("|", $params);
        return $this;
    }

    public function getRuleOption($name, $score)
    {
        if (!$this->hasRuleOption($name)) {
            return $score;
        }

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

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

    protected function initWrapper($name)
    {
        $this->setName($name);
        $this->setRules();
    }

    function setRules()

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

It is recommend to declare an explicit visibility for setRules.

    {
        $this->options = $this->getOption($this->getName());

        $this->setRealScore($this->getOption('score'));
        $this->setActive($this->getOption('active'));
        $this->setParams($this->getOption('params'));
    }

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

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

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

    function getName()

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

It is recommend to declare an explicit visibility for getName.

    {
        return $this->name;
    }

    protected function setName($name)
    {
        $this->name = $name;
        return $this;
    }

    private function setRealScore($score)
    {
        $this->realScore = $score;
    }

    private function setActive($active)
    {
        $this->active = $active;
    }

    protected function setResult()
    {
        if ($this->getActive()) {
            $this->results[$this->getName()] = $this->getScore();
            $this->score = $this->getScore();
        } else {

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

            $this->score = 0;
        }
        return $this;
    }

    private function getActive()
    {
        return $this->active;
    }

    public function getScore()
    {
        if (!$this->hasScore()) {
            return 0;
        }

        return $this->score;
    }

    protected function setScore($score)
    {
        $this->score = $score;
    }

    private function hasScore()
    {
        return isset($this->score);
    }

}