LegalThings\DataEnricher\Node

Complexity

Total Complexity

18

Size/Duplication

Total Lines	130
Duplicated Lines	10.77 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

0%

Importance

Changes	4
Bugs	1	Features	2

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	12	3
B	applyNodeResults()	14	14	5
A	getResult()	0	11	2
A	setResult()	0	4	1
A	hasInstruction()	0	5	1
A	getInstruction()	0	16	3
A	apply()	0	14	3

<?php

namespace LegalThings\DataEnricher;

use LegalThings\DataEnricher\Processor;
use GuzzleHttp\Promise\PromiseInterface;

/**
 * An object with processing instructions
 */
class Node extends \stdClass
{
    /**
     * The processed data
     * @var mixed 
     */
    protected $i_result;

    /**
     * Class constructor
     * 
     * @param \stdClass $data
     */
    public function __construct(\stdClass $data)
    {
        $this->i_result = $data;
        
        foreach ($data as $key => $value) {

The expression $data of type object<stdClass> is not traversable.

            if ($key === 'i_result') {
                continue;
            }
            
            $this->$key = $value;
        }
    }

    
    /**
     * Replace nodes with their results
     * 
     * @param array|object $target
     */
    protected function applyNodeResults(&$target)

This method seems to be duplicated in your project.

    {
        if (!is_array($target) && !is_object($target)) {
            return;
        }
        
        foreach ($target as &$value) {
            if ($value instanceof self) {
                $value = $value->getResult();
            }
            
            $this->applyNodeResults($value);
        }
    }
    
    /**
     * Get the processed result
     * 
     * @return mixed
     */
    public function getResult()
    {
        if ($this->i_result instanceof PromiseInterface) {
            $result = $this->i_result->wait();
        } else {
            $result = $this->i_result;
        }
        
        $this->applyNodeResults($result);
        return $result;
    }
    
    /**
     * Set the result after processing
     * 
     * @param mixed $result
     */
    public function setResult($result)
    {
        $this->i_result = $result;
    }

    
    /**
     * Test if the node has an instruction for a processor
     * 
     * @param Processor $processor
     * @return boolean
     */
    public function hasInstruction(Processor $processor)
    {
        $prop = $processor->getProperty();
        return isset($this->$prop);
    }
    
    /**
     * Get an instruction for a processor
     * 
     * @param Processor $processor
     * @return mixed
     */
    public function getInstruction(Processor $processor)
    {
        $prop = $processor->getProperty();
        
        if (!isset($this->$prop)) {
            throw new \LogicException("Node doesn't have instruction property '$prop'");
        }
        
        $value = $this->$prop;
        
        if ($value instanceof self) {
            $value = $value->getResult();
        }
        
        return $value;
    }
    
    /**
     * Apply processing to this node
     * 
     * @param Processor $processor
     */
    public function apply(Processor $processor)
    {
        if (!$this->hasInstruction($processor)) {
            return;
        }
        
        if ($this->i_result instanceof PromiseInterface) {
            $this->i_result->then(function() use ($processor) {

Expected 1 space after FUNCTION keyword; 0 found

                $processor->applyToNode($this);
            });
        } else {
            $processor->applyToNode($this);
        }
    }
}