devtoolboxuk\cerberus\CerberusService

Complexity

Total Complexity

11

Size/Duplication

Total Lines	74
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

72.72%

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__call()	0	7	1
A	toArray()	0	4	1
A	hasScore()	0	4	1
A	__construct()	0	4	1
A	resetHandlers()	0	7	1
A	pushHandler()	0	6	1
A	process()	0	14	3
A	getResult()	0	4	1
A	getScore()	0	4	1

<?php

namespace devtoolboxuk\cerberus;

use devtoolboxuk\cerberus\handlers\Handler;
use ReflectionClass;

class CerberusService extends AbstractCerberus implements CerberusInterface
{
    private static $instance = null;
    protected $handlers = [];
    protected $references = [];

    function __construct()

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

It is recommend to declare an explicit visibility for __construct.

    {
        $this->resetHandlers();
    }

    public function resetHandlers()
    {
        $this->references = [];
        $this->handlers = [];
        self::$instance = null;
        return $this;
    }

    public function __call($method, $arguments = [])
    {
        $handlers = new Handler($arguments);
        $handler = $handlers->build($method, $arguments);
        $this->pushHandler($handler);
        return $this;
    }

    public function pushHandler($handler)
    {
        array_unshift($this->handlers, $handler);
        $this->clearResults();
        return $this;
    }

    /**
     * @return array
     */
    public function toArray()
    {
        return $this->process()->toArray();
    }

    public function process()
    {
        foreach ($this->handlers as $handler) {
            array_unshift($this->references, ['name' => $handler->getName(), 'value' => $handler->getValue()]);
            $this->processWrappers($handler);
        }

        if (self::$instance === null) {
            $reflection = new ReflectionClass('devtoolboxuk\\cerberus\\Models\\CerberusModel');
            self::$instance = $reflection->newInstance($this->references, $this->score, $this->result);
        }

        return self::$instance;
    }

    public function hasScore()
    {
        return $this->process()->hasScore();
    }


    public function getResult()
    {
        return $this->process()->getResult();
    }

    public function getScore()
    {
        return $this->process()->getScore();
    }

}