Addiks\RDMBundle\ValueResolver\ArrayValueResolver

Complexity

Total Complexity

13

Size/Duplication

Total Lines	88
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

100%

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
B	resolveValue()	0	24	3
B	revertValue()	0	32	5
A	assertValue()	0	15	4

<?php
/**
 * Copyright (C) 2018 Gerrit Addiks.
 * This package (including this file) was released under the terms of the GPL-3.0.
 * You should have received a copy of the GNU General Public License along with this program.
 * If not, see <http://www.gnu.org/licenses/> or send me a mail so i can send you a copy.
 *
 * @license GPL-3.0
 *
 * @author Gerrit Addiks <gerrit@addiks.de>
 */

namespace Addiks\RDMBundle\ValueResolver;

use Addiks\RDMBundle\ValueResolver\ValueResolverInterface;
use Addiks\RDMBundle\Mapping\MappingInterface;
use Addiks\RDMBundle\Mapping\ArrayMappingInterface;
use Addiks\RDMBundle\Exception\FailedRDMAssertionException;

final class ArrayValueResolver implements ValueResolverInterface
{

    /**
     * @var ValueResolverInterface
     */
    private $entryValueResolver;

    public function __construct(ValueResolverInterface $entryValueResolver)
    {
        $this->entryValueResolver = $entryValueResolver;
    }

    public function resolveValue(
        MappingInterface $arrayMapping,
        $entity,
        array $dataFromAdditionalColumns
    ) {
        /** @var null|array<mixed> $value */
        $value = null;

        if ($arrayMapping instanceof ArrayMappingInterface) {
            $value = array();

            foreach ($arrayMapping->getEntryMappings() as $key => $entryMapping) {
                /** @var MappingInterface $entryMapping */

                $value[$key] = $this->entryValueResolver->resolveValue(
                    $entryMapping,
                    $entity,
                    $dataFromAdditionalColumns
                );
            }
        }

        return $value;
    }

    public function revertValue(
        MappingInterface $arrayMapping,
        $entity,
        $valueFromEntityField
    ): array {
        /** @var array<string, string> $data */
        $data = array();

        if ($arrayMapping instanceof ArrayMappingInterface && is_array($valueFromEntityField)) {
            foreach ($arrayMapping->getEntryMappings() as $key => $entryMapping) {
                /** @var MappingInterface $entryMapping */

                /** @var mixed $valueFromEntry */
                $valueFromEntry = null;

                if (isset($valueFromEntityField[$key])) {
                    $valueFromEntry = $valueFromEntityField[$key];
                }

                $data = array_merge(
                    $data,
                    $this->entryValueResolver->revertValue(
                        $entryMapping,
                        $entity,
                        $valueFromEntry
                    )
                );
            }
        }

        return $data;
    }

    public function assertValue(
        MappingInterface $arrayMapping,
        $entity,
        array $dataFromAdditionalColumns,
        $actualValue
    ): void {
        if ($arrayMapping instanceof ArrayMappingInterface) {
            if (!is_array($actualValue) && !is_null($actualValue)) {
                throw FailedRDMAssertionException::expectedArray(
                    $actualValue,
                    $arrayMapping->describeOrigin()
                );
            }
        }
    }

}