PeekAndPoke\Component\Slumber\Data\Journal\DomainModel\RecordableHistory

Complexity

Total Complexity

48

Size/Duplication

Total Lines	250
Duplicated Lines	30.8 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

0%

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	fromInitialAndFinalAndDiffs()	0	7	1
A	__construct()	0	4	1
B	getCompactionRate()	0	19	5
A	getInitialRecord()	8	8	4
A	getFinalRecord()	8	8	4
A	getRecords()	0	4	1
A	getDiffs()	0	8	2
B	calculateDiffs()	0	32	6
A	calculateDiff()	0	12	1
D	diffRecursiveFromBeforeToAfter()	29	29	9
D	diffRecursiveFromAfterToBefore()	32	32	9
B	convertToString()	0	19	5

<?php

namespace PeekAndPoke\Component\Slumber\Data\Journal\DomainModel;

/**
 * @author Karsten J. Gerber <kontakt@karsten-gerber.de>
 */
class RecordableHistory
{
    /** @var Record[] */
    private $records;
    /** @var RecordDiff[] */
    private $diffs;

    /**
     * @param Record       $initial
     * @param Record       $final
     * @param RecordDiff[] $diffs
     *
     * @return RecordableHistory
     */
    public static function fromInitialAndFinalAndDiffs(Record $initial, Record $final, $diffs)
    {
        $ret        = new RecordableHistory([$initial, $final]);
        $ret->diffs = $diffs;

        return $ret;
    }

    /**
     * @param Record[] $records
     */
    public function __construct($records)
    {
        $this->records = $records;
    }

    /**
     * @return float
     */
    public function getCompactionRate()
    {
        $compacted    = 0;
        $notCompacted = 0;

        foreach ($this->records as $record) {
            if ($record->getIsCompacted() === false || $record->getCompactedHistory() === null) {
                $notCompacted++;
            } else {
                $compacted += count($record->getCompactedHistory()->getDiffs());
            }
        }

        if ($compacted + $notCompacted === 0) {
            return 0;
        }

        return $compacted / ($compacted + $notCompacted);
    }

    /**
     * @return Record
     */
    public function getInitialRecord()

This method seems to be duplicated in your project.

    {
        $record = count($this->records) > 0 ? $this->records[0] : new NullRecord();

        return $record->getIsCompacted() && $record->getCompactedHistory() !== null
            ? $record->getCompactedHistory()->getInitialRecord()
            : $record;
    }

    /**
     * @return Record
     */
    public function getFinalRecord()

This method seems to be duplicated in your project.

    {
        $record = count($this->records) > 0 ? $this->records[count($this->records) - 1] : new NullRecord();

        return $record->getIsCompacted() && $record->getCompactedHistory() !== null
            ? $record->getCompactedHistory()->getFinalRecord()
            : $record;
    }

    /**
     * {@inheritdoc}
     */
    public function getRecords()
    {
        return $this->records;
    }

    /**
     * @return RecordDiff[]
     */
    public function getDiffs()
    {
        if ($this->diffs === null) {
            $this->calculateDiffs();
        }

        return $this->diffs;
    }

    protected function calculateDiffs()
    {
        $this->diffs = [];

        $previous = new NullRecord();

        foreach ($this->records as $current) {

            if ($current->getIsCompacted() === false) {
                $diff = $this->calculateDiff($previous, $current);

                if ($diff->getChangesCount() > 0) {

                    $this->diffs[] = $diff;
                }

                $previous = $current;

            } else {

                $history = $current->getCompactedHistory();

                if ($history) {
                    foreach ($history->getDiffs() as $diff) {
                        $this->diffs[] = $diff;
                    }
                }

                $previous = $history->getFinalRecord();
            }
        }
    }

    /**
     * @param Record $before
     * @param Record $after
     *
     * @return RecordDiff
     */
    protected function calculateDiff(Record $before, Record $after)
    {
        $diff = new RecordDiff($after->getChangeDate(), $after->getChangedBy());

        $beforeData = (array) $before->getRecordData();
        $afterData  = (array) $after->getRecordData();

        $this->diffRecursiveFromBeforeToAfter($diff, '', $beforeData, $afterData);
        $this->diffRecursiveFromAfterToBefore($diff, '', $beforeData, $afterData);

        return $diff;
    }

    /**
     * @param RecordDiff $diff
     * @param string     $pathInArray
     * @param mixed[]    $before
     * @param mixed[]    $after
     */
    private function diffRecursiveFromBeforeToAfter(RecordDiff $diff, $pathInArray, $before, $after)

This method seems to be duplicated in your project.

    {
        if (! is_array($before) && ! $before instanceof \Traversable) {

            $beforeValue = $this->convertToString($before);
            $afterValue  = $this->convertToString($after);

            if ($beforeValue !== $afterValue) {
                $diff->addChange(new RecordDiffEntry($pathInArray, $beforeValue, $afterValue));
            }
        } else {

            foreach ($before as $key => $beforeValue) {

                $afterValue = null;

                if ((is_array($after) || $after instanceof \ArrayAccess) && isset($after[$key])) {
                    $afterValue = $after[$key];
                }

                $this->diffRecursiveFromBeforeToAfter(
                    $diff,
                    empty($pathInArray) ? $key : $pathInArray . '.' . $key,
                    $beforeValue,
                    $afterValue
                );
            }
        }
    }

    /**
     * @param RecordDiff $diff
     * @param string     $pathInArray
     * @param array      $before
     * @param array      $after
     */
    private function diffRecursiveFromAfterToBefore(RecordDiff $diff, $pathInArray, $before, $after)

This method seems to be duplicated in your project.

    {
        if (! is_array($after) && ! $after instanceof \Traversable) {

            $beforeValue = $this->convertToString($before);
            $afterValue  = $this->convertToString($after);

            if ($beforeValue !== $afterValue) {
                $diff->addChange(new RecordDiffEntry($pathInArray, $beforeValue, $afterValue));
            }
        } else {

            // first compare from before to after
            foreach ($after as $key => $afterValue) {

                $beforeValue = null;

                if ((is_array($before) || $before instanceof \ArrayAccess) && isset($before[$key])) {
                    $beforeValue = $before[$key];
                }

                $processedKeys[] = $key;

$processedKeys was never initialized. Although not strictly required by PHP, it is generally a good practice to add $processedKeys = array(); before regardless.

                $this->diffRecursiveFromAfterToBefore(
                    $diff,
                    empty($pathInArray) ? $key : $pathInArray . '.' . $key,
                    $beforeValue,
                    $afterValue
                );
            }
        }
    }

    /**
     * @param        $value
     * @param string $fallback
     *
     * @return string
     */
    private function convertToString($value, $fallback = 'N/A')
    {
        try {
            if (is_array($value)) {
                $str = json_encode($value, JSON_PRETTY_PRINT);
            } elseif ($value instanceof \MongoDate) {
                $date = (new \DateTime())->setTimestamp($value->sec);
                $str  = $date->format('c');
            } elseif ($value instanceof \DateTime) {
                $str = $value->format('c');
            } else {
                $str = (string) $value;
            }
        } catch (\Exception $e) {
            $str = $fallback;
        }

        return $str;
    }
}