Translation\Bundle\Catalogue\Operation\ReplaceOperation

Complexity

Total Complexity

33

Size/Duplication

Total Lines	139
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

88.89%

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
C	processDomain()	0	61	14
A	getMetadata()	0	9	2
B	mergeMetadata()	0	22	7
B	doMergeMetadata()	0	23	8
A	isArrayAssociative()	0	8	2

<?php

/*
 * This file is part of the PHP Translation package.
 *
 * (c) PHP Translation team <tobias.nyholm@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Translation\Bundle\Catalogue\Operation;

use Symfony\Component\Translation\Catalogue\AbstractOperation;
use Symfony\Component\Translation\MessageCatalogueInterface;
use Symfony\Component\Translation\MetadataAwareInterface;

/**
 * This will merge and replace all values in $target with values from $source.
 * It is the equivalent of running array_merge($target, $source). When in conflict,
 * always take values from $source.
 *
 * This operation is metadata aware. It will do the same recursive merge on metadata.
 *
 * all = source ∪ target = {x: x ∈ source ∨ x ∈ target}
 * new = all ∖ target = {x: x ∈ source ∧ x ∉ target}
 * obsolete = target ∖ all = {x: x ∈ target ∧ x ∉ source}
 *
 * @author Tobias Nyholm <tobias.nyholm@gmail.com>
 */
final class ReplaceOperation extends AbstractOperation
{
    protected function processDomain($domain)
    {
        $this->messages[$domain] = [
            'all' => [],
            'new' => [],
            'obsolete' => [],
        ];
        if (defined(sprintf('%s::INTL_DOMAIN_SUFFIX', MessageCatalogueInterface::class))) {
            $intlDomain = $domain.MessageCatalogueInterface::INTL_DOMAIN_SUFFIX;
        } else {
            $intlDomain = $domain;
        }

        foreach ($this->source->all($domain) as $id => $message) {
            $messageDomain = $this->source->defines($id, $intlDomain) ? $intlDomain : $domain;
            $this->messages[$domain]['all'][$id] = $message;
            $this->result->add([$id => $message], $messageDomain);

            if (!$this->target->has($id, $domain)) {
                // No merge required
                $this->messages[$domain]['new'][$id] = $message;
                $resultMeta = $this->getMetadata($this->source, $messageDomain, $id);
            } else {
                // Merge required
                $resultMeta = null;

$resultMeta is not used, you could remove the assignment.

                $sourceMeta = $this->getMetadata($this->source, $messageDomain, $id);
                $targetMeta = $this->getMetadata($this->target, $this->target->defines($id, $intlDomain) ? $intlDomain : $domain, $id);
                if (is_array($sourceMeta) && is_array($targetMeta)) {
                    // We can only merge meta if both is an array
                    $resultMeta = $this->mergeMetadata($sourceMeta, $targetMeta);
                } elseif (!empty($sourceMeta)) {
                    $resultMeta = $sourceMeta;
                } else {
                    // Assert: true === empty($sourceMeta);
                    $resultMeta = $targetMeta;
                }
            }

            if (!empty($resultMeta)) {
                $this->result->setMetadata($id, $resultMeta, $messageDomain);
            }
        }

        foreach ($this->target->all($domain) as $id => $message) {
            if ($this->result->has($id, $domain)) {
                // We've already merged this
                // That message was in source
                continue;
            }

            $messageDomain = $this->target->defines($id, $intlDomain) ? $intlDomain : $domain;
            $this->messages[$domain]['all'][$id] = $message;
            $this->messages[$domain]['obsolete'][$id] = $message;
            $this->result->add([$id => $message], $messageDomain);

            $resultMeta = $this->getMetadata($this->target, $messageDomain, $id);
            if (!empty($resultMeta)) {
                $this->result->setMetadata($id, $resultMeta, $messageDomain);
            }
        }
    }

    /**
     * @return array|null|string|mixed Can return anything..
     */
    private function getMetadata(MessageCatalogueInterface $catalogue, string $domain, string $key = '')
    {
        if (!$this->target instanceof MetadataAwareInterface) {
            return [];
        }

        /* @var MetadataAwareInterface $catalogue */
        return $catalogue->getMetadata($key, $domain);
    }

    /**
     * @param array|null $source
     * @param array|null $target
     *
     * @return array
     */
    private function mergeMetadata($source, $target)
    {
        if (empty($source) && empty($target)) {
            return [];
        }

        if (empty($source)) {
            return $target;
        }

        if (empty($target)) {
            return $source;
        }

        if (!is_array($source) || !is_array($target)) {
            return $source;
        }

        $result = $this->doMergeMetadata($source, $target);

        return $result;
    }

    private function doMergeMetadata(array $source, array $target)
    {
        $isTargetArrayAssociative = $this->isArrayAssociative($target);
        foreach ($target as $key => $value) {
            if ($isTargetArrayAssociative) {
                if (isset($source[$key]) && $source[$key] !== $value) {
                    if (is_array($source[$key]) && is_array($value)) {
                        // If both arrays, do recursive call
                        $source[$key] = $this->doMergeMetadata($source[$key], $value);
                    }
                    // Else, use value form $source
                } else {
                    // Add new value
                    $source[$key] = $value;
                }
                // if sequential
            } elseif (!in_array($value, $source)) {
                $source[] = $value;
            }
        }

        return $source;
    }

    public function isArrayAssociative(array $arr)
    {
        if ([] === $arr) {
            return false;
        }

        return array_keys($arr) !== range(0, count($arr) - 1);
    }
}