LegalThings\DataEnricher\Node

Complexity

Total Complexity

23

Size/Duplication

Total Lines	146
Duplicated Lines	17.12 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

39.66%

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	getResult()	0	15	3
A	setResult()	0	4	1
A	hasInstruction()	0	5	1
A	__construct()	0	12	3
B	applyNodeResults()	11	11	5
A	getInstruction()	0	10	2
B	resolve()	14	14	5
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 ($target instanceof self) {
            $target = $target->getResult();
            $this->applyNodeResults($target);
        } elseif (is_array($target) || is_object($target)) {
            foreach ($target as &$value) {         
                $this->applyNodeResults($value);
            }
        }
    }
    
    /**
     * Get the processed result
     * 
     * @return mixed
     */
    public function getResult()
    {
        if ($this->i_result instanceof PromiseInterface) {
            $this->i_result->wait();
            
            if ($this->i_result instanceof PromiseInterface) {
                throw new \LogicException("Promise result not replaced with data");
            }
        }

        $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'");
        }
        
        return $this->resolve($this->$prop);
    }

    /**
     * Resolve nodes within the value
     * 
     * @param mixed $value
     * @return mixed
     */
    protected function resolve($value)

This method seems to be duplicated in your project.

    {
        while ($value instanceof self) {
            $value = $value->getResult();
        }
        
        if (is_array($value) || is_object($value)) {
            foreach ($value as &$item) {
                $item = $this->resolve($item);
            }
        }
        
        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);
        }
    }
}