LegalThings\DataEnricher

Complexity

Total Complexity

25

Size/Duplication

Total Lines	170
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes	7
Bugs	1	Features	4

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	17	4
A	getSource()	0	4	1
B	applyTo()	0	22	6
B	findNodes()	0	17	7
A	hasProcessorProperty()	0	10	1
B	applyNodeResults()	0	10	5
A	process()	0	5	1

<?php

namespace LegalThings;

use LegalThings\DataEnricher\Node;
use LegalThings\DataEnricher\Processor;

/**
 * Enrich objects by processing special properties.
 */
class DataEnricher
{
    /**
     * Default processors
     * @var array
     */
    public static $defaultProcessors = [
        '<ifset>' => Processor\IfSet::class,
        '<ref>' => Processor\Reference::class,
        '<switch>' => Processor\SwitchChoose::class,
        '<src>' => Processor\Http::class,
        '<merge>' => Processor\Merge::class,
        '<jmespath>' => Processor\JmesPath::class,
        '<tpl>' => Processor\Mustache::class,
        '<transformation>' => Processor\Transform::class,
        
        // Deprecated
        '_ref' => Processor\Reference::class,
        '_switch' => Processor\SwitchChoose::class,
        '_src' => Processor\Http::class,
        '_merge' => Processor\Merge::class,
        '_jmespath' => Processor\JmesPath::class,
        '_tpl' => Processor\Mustache::class,
        '_transformation' => Processor\Transform::class
    ];
    
    
    /**
     * @var object
     */
    protected $source;
    
    /**
     * Processors, applied in specified order.
     * 
     * @var DataEnricher\Processor[]
     */
    public $processors;
    
    
    /**
     * Class constructor
     * 
     * @param object $source  Data source
     */
    public function __construct($source)
    {
        if (!is_object($source)) {
            throw new \Exception("Data enricher on works on an object, not on a " . gettype($source));
        }
        
        $this->source = $source;
        
        foreach (static::$defaultProcessors as $property => $processor) {
            if (is_string($processor)) {
                $class = $processor;

Equals sign not aligned with surrounding assignments; expected 5 spaces but found 1 space

                $processor = new $class($this, $property);
            }
            
            $this->processors[] = $processor;
        }
    }
    
    /**
     * Get the source object
     * 
     * @return object
     */
    public function getSource()
    {
        return $this->source;
    }
    
    
    /**
     * Invoke enricher 
     * 
     * @param array|object|string $target  Target or dot key path
     */
    public function applyTo($target)
    {
        if (is_string($target)) {
            $target = \DotKey::on($this->source)->get($target);
        }
        
        $nodes = $this->findNodes($target);

        foreach ($this->processors as $processor) {
            $processor->prepare($nodes);
        }
        
        foreach ($nodes as $node) {
            foreach ($this->processors as $processor) {
                if ($node->hasInstruction($processor)) {
                    $processor->applyToNode($node);
                }
            }
        }
        
        $this->applyNodeResults($target);
    }

    /**
     * Find nodes that have processing instructions
     * 
     * @param array|object $target
     * @return array
     */
    public function findNodes(&$target)
    {
        $nodes = [];
        
        foreach ($target as $key => &$value) {
            if (is_array($value) || (is_object($value) && !$value instanceof Node)) {
                $nodes = array_merge($nodes, $this->findNodes($value));
            }
            
            if ($value instanceof \stdClass && $this->hasProcessorProperty($value)) {
                $value = new Node($value);

Equals sign not aligned with surrounding assignments; expected 3 spaces but found 1 space

                $nodes[] = $value;
            }
        }
        
        return $nodes;
    }
    
    /**
     * Check if object has at leas one process property
     * 
     * @param \stdClass $value
     * @return boolean
     */
    protected function hasProcessorProperty($value)
    {
        $processorProps = array_map(function ($processor) {
            return $processor->getProperty();
        }, $this->processors);
        
        $valueProps = array_keys(get_object_vars($value));
        
        return count(array_intersect($valueProps, $processorProps)) > 0;
    }
    
    /**
     * Replace nodes with their results
     * 
     * @param array|object $target
     */
    public function applyNodeResults(&$target)
    {
        foreach ($target as &$value) {
            if ($value instanceof Node) {
                $value = $value->getResult();
            } elseif (is_array($value) || is_object($value)) {
                $this->applyNodeResults($value);
            }
        }
    }
    
    /**
     * Enrich object
     * 
     * @param object $subject
     */
    public static function process($subject)
    {
        $enrich = new static($subject);
        $enrich->applyTo($subject);
    }
}