ArrayTypeAdapter::isArrayObject() - Code Metrics - Inspection of "type adapter work" - tebru/gson-php - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — v0.7 ( 5c4e91...21297d )

by Nate
created 2019-10-17 18:18 UTC
ArrayTypeAdapter::isArrayObject() A

↳ Parent: Project
Complexity

Conditions	2
Paths	2
Size

Total Lines	7
Code Lines	3
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	4
CRAP Score	2
Importance

Changes
Metric	Value
eloc	3
c	0
b	0
f	0
dl	0
loc	7
ccs	4
cts	4
cp	1
rs	10
cc	2
nc	2
nop	1
crap	2
<?php
/*
 * Copyright (c) Nate Brunette.
 * Distributed under the MIT License (http://opensource.org/licenses/MIT)
 */

declare(strict_types=1);

namespace Tebru\Gson\TypeAdapter;

use LogicException;
use stdClass;
use Tebru\Gson\Exception\JsonSyntaxException;
use Tebru\Gson\Internal\TypeAdapterProvider;
use Tebru\Gson\ReaderContext;
use Tebru\Gson\TypeAdapter;
use Tebru\Gson\WriterContext;
use Tebru\PhpType\TypeToken;

/**
 * Class ArrayTypeAdapter
 *
 * @author Nate Brunette <[email protected]>
 */
class ArrayTypeAdapter extends TypeAdapter
{
    /**
     * @var TypeAdapterProvider
     */
    private $typeAdapterProvider;

    /**
     * @var TypeToken
     */
    private $keyType;

    /**
     * @var TypeAdapter
     */
    private $valueTypeAdapter;

    /**
     * @var int
     */
    private $numberOfGenerics;

    /**
     * A TypeAdapter cache keyed by raw type
     *
     * @var TypeAdapter[]
     */
    private $adapters = [];

    /**
     * Constructor
     *
     * @param TypeAdapterProvider $typeAdapterProvider
     * @param TypeToken $keyType
     * @param TypeAdapter $valueTypeAdapter
     * @param int $numberOfGenerics
     */
    public function __construct(
        TypeAdapterProvider $typeAdapterProvider,
        TypeToken $keyType,
        TypeAdapter $valueTypeAdapter,
        int $numberOfGenerics
    ) {
        $this->typeAdapterProvider = $typeAdapterProvider;
        $this->keyType = $keyType;
        $this->valueTypeAdapter = $valueTypeAdapter;
        $this->numberOfGenerics = $numberOfGenerics;
    }

    /**
     * Read the next value, convert it to its type and return it
     *
     * @param array|null $value
     * @param ReaderContext $context
     * @return array|null
     */
    public function read($value, ReaderContext $context): ?array
    {
        if ($value === null) {
            return null;
        }

        $result = [];

        if ($this->numberOfGenerics > 2) {
            throw new LogicException('Array may not have more than 2 generic types');
        }

        $arrayIsObject = $this->numberOfGenerics === 2 || is_string(key($value));
        $enableScalarAdapters = $context->enableScalarAdapters();

        foreach ($value as $key => $item) {
            if (!$enableScalarAdapters && is_scalar($item)) {
                $result[$arrayIsObject ? (string)$key : (int)$key] = $item;
                continue;
            }

            $itemValue = null;
            switch ($this->numberOfGenerics) {
                case 0:
                    if (!$arrayIsObject) {
                        $itemValue = $this->valueTypeAdapter->read($item, $context);
                        break;
                    }

                    if (is_array($item)) {
                        $itemValue = $this->read($item, $context);
                        break;
                    }

                    $type = TypeToken::createFromVariable($item);
                    $adapter = $this->adapters[$type->rawType] ?? $this->adapters[$type->rawType] = $this->typeAdapterProvider->getAdapter($type);
                    $itemValue = $adapter->read($item, $context);
                    break;
                case 1:
                    $itemValue = $this->valueTypeAdapter->read($item, $context);
                    break;
                case 2:
                    if (!$arrayIsObject) {
                        throw new LogicException('An array may only specify a generic type for the value');
                    }

                    if ($this->keyType->phpType !== TypeToken::STRING && $this->keyType->phpType !== TypeToken::INTEGER) {
                        throw new LogicException('Array keys must be strings or integers');
                    }

                    if (($this->keyType->phpType === TypeToken::INTEGER) && !ctype_digit($key)) {
                        throw new JsonSyntaxException('Expected integer, but found string for key');
                    }

                    $itemValue = $this->valueTypeAdapter->read($item, $context);
                    break;
            }

            $result[$arrayIsObject ? (string)$key : (int)$key] = $itemValue;
        }

        return $result;
    }

    /**
     * Write the value to the writer for the type
     *
     * @param array|stdClass|null $value
     * @param WriterContext $context
     * @return array|null
     */
    public function write($value, WriterContext $context): ?array
    {
        if ($value === null) {
            return null;
        }

        if ($this->numberOfGenerics > 2) {
            throw new LogicException('Array may not have more than 2 generic types');
        }

        $arrayIsObject = $this->numberOfGenerics === 2 || is_string(key($value));
        $arrayIsObject = $this->numberOfGenerics === 2 || is_string(key(/** @scrutinizer ignore-type */ $value));
        $enableScalarAdapters = $context->enableScalarAdapters();
        $result = [];

        foreach ($value as $key => $item) {
            if (!$enableScalarAdapters && is_scalar($item)) {
                $result[$arrayIsObject ? (string)$key : (int)$key] = $item;
                continue;
            }

            $itemValue = null;
            switch ($this->numberOfGenerics) {
                // no generics specified
                case 0:
                    if (is_array($item)) {
                        $itemValue = $this->write($item, $context);
                        break;
                    }

                    $type = TypeToken::createFromVariable($item);
                    $adapter = $this->adapters[$type->rawType] ?? $this->adapters[$type->rawType] = $this->typeAdapterProvider->getAdapter($type);
                    $itemValue = $adapter->write($item, $context);
                    break;
                // generic for value specified
                case 1:
                case 2:
                    $itemValue = $this->valueTypeAdapter->write($item, $context);
                    break;
            }

            $result[$arrayIsObject ? (string)$key : (int)$key] = $itemValue;
        }

        return $result;
    }
}

tebru / gson-php

Push — v0.7 ( 5c4e91...21297d )

ArrayTypeAdapter::isArrayObject() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
