ReenExe\CompareDataStructure\Comparator

Complexity

Total Complexity

43

Size/Duplication

Total Lines	208
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes	3
Bugs	0	Features	0

16 Methods

Rating	Name	Duplication	Size	Complexity
A	addCustom()	0	6	1
A	initialize()	0	6	1
A	check()	0	8	2
A	compare()	0	12	3
B	checkTypes()	0	23	6
A	diffType()	0	6	1
A	diffSet()	0	15	4
A	diffStructure()	0	17	4
A	diffArrayData()	0	12	3
B	diffValuesStructure()	0	19	7
A	assoc()	0	12	4
A	getType()	0	4	1
A	getStructureType()	0	13	2
A	createDiff()	0	4	1
A	processDiff()	0	6	1
A	instance()	0	6	2

<?php

namespace ReenExe\CompareDataStructure;

class Comparator
{
    private $custom = [];

    /**
     * @var array
     */
    private $temporaryCustom;

    /**
     * @var array
     */
    private $exists;

    public static function addCustom(array $custom)
    {
        $instance = self::instance();

        $instance->custom = $instance->custom + $custom;
    }

    private function initialize(array $temporaryCustom)
    {
        $this->temporaryCustom = $this->custom + $temporaryCustom;

        $this->exists = array_keys($this->temporaryCustom);
    }

    /**
     * @param $data
     * @param $structure
     * @param array $custom
     * @return StructureDiffInfo
     */
    public static function check($data, $structure, array $custom = [])
    {
        $instance = self::instance();

        $instance->initialize($custom);

        return $instance->compare($data, $structure) ?: StructureDiffInfo::createEqual();
    }

    private function compare($data, $structure)
    {
        if (is_string($structure)) {
            return $this->diffType($data, $structure);
        }

        if (is_array($structure)) {
            return $this->diffStructure($data, $structure);
        }

        return $this->createDiff('undefined:structure', StructureDiffInfo::CONFIG);
    }

    private function checkTypes($value, array $types)
    {
        /**
         * Возможно тут будет переопределение проверки
         * К примеру формата даты или длины
         */

        if (in_array($this->getType($value), $types)) return; /* success */

        if ($this->exists) {
            if ($intersect = array_intersect($types, $this->exists)) {
                foreach ($intersect as $key) {
                    $diff = $this->compare($value, $this->temporaryCustom[$key]);

                    if (empty($diff)) return; /* success */
                }

                return $this->processDiff($diff, "custom:type:$key");
            }
        }

        return $this->createDiff('var:type', StructureDiffInfo::TYPE);
    }

    private function diffType($data, $structure)
    {
        $needTypes = explode('|', $structure);

        return $this->checkTypes($data, $needTypes);
    }

    private function diffSet($data, $set)
    {
        $data = (array)$data;
        $set = (array)$set;

        if (array_diff($data, $set)) {
            return $this->createDiff('set:out', StructureDiffInfo::TYPE);
        }

        foreach ($data as $value) {
            if (in_array($value, $set, true)) continue;

            return $this->createDiff('var:type', StructureDiffInfo::TYPE);
        }
    }

    private function diffStructure($data, array $structure)
    {
        /**
         * structure `set`
         */
        if (isset($structure['set'])) {
            return $this->diffSet($data, $structure['set']);
        }

        if ($diff = $this->checkTypes($data, $this->getStructureType($structure))) {
            return $diff;
        }

        if (is_array($data)) {
            return $this->diffArrayData($data, $structure);
        }
    }

    private function diffArrayData(array $data, array $structure)
    {
        if (isset($structure['assoc'])) {
            return $this->assoc($structure['assoc'], $data);
        }

        if (isset($structure['values'])) {
            return $this->diffValuesStructure($data, $structure);
        }

        return $this->createDiff('structure:type', StructureDiffInfo::CONFIG);
    }

    private function diffValuesStructure(array $data, array $structure)
    {
        if (is_array($structure['values'])) {
            foreach ($data as $key => $subData) {
                if ($diff = $this->assoc($structure['values'], $subData)) {
                    return $this->processDiff($diff, "[$key]");
                }

            }
        } elseif (is_string($structure['values'])) {
            $needTypes = explode('|', $structure['values']);

            foreach ($data as $key => $subData) {
                if ($diff = $this->checkTypes($subData, $needTypes)) {
                    return $this->processDiff($diff, "[$key]");
                }
            }
        }
    }

    private function assoc(array $assoc, array $data)
    {
        foreach ($assoc as $key => $structure) {
            if (!array_key_exists($key, $data)) {
                return $this->createDiff($key, StructureDiffInfo::KEY);
            };

            if ($diff = $this->compare($data[$key], $structure)) {
                return $this->processDiff($diff, $key);
            }
        }
    }

    private function getType($value)
    {
        return strtolower(gettype($value));
    }

    private function getStructureType(array $structure)
    {
        $types = ['array'];

        if (isset($structure['type'])) {
            $types = array_merge(
                $types,
                explode('|', $structure['type'])
            );
        }

        return $types;
    }

    private function createDiff($key, $message)
    {
        return $this->processDiff(StructureDiffInfo::createDiff($message), $key);
    }

    private function processDiff(StructureDiffInfo $diff, $key)
    {
        $diff->addPath($key);

        return $diff;
    }

    /**
     * @return Comparator
     */
    private static function instance()
    {
        static $self;

        return $self ?: $self = new self;
    }
}