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

Completed
Push — v0.7 ( 7c9b41...5c4e91 )

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

↳ Parent: ArrayTypeAdapter
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;

    /**
     * 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;
        }

        $array = [];

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

        $arrayIsObject = $this->isArrayObject($value);
        $enableScalarAdapters = $context->enableScalarAdapters();

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

            $itemValue = null;
            switch ($this->numberOfGenerics) {
                case 0:
switch ($expr) {
case "A":
    doSomething(); //right
    break;
case "B":

    doSomethingElse(); //wrong
    break;

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

                    // By now we know that we're deserializing a json object to an array.
                    // If there is a nested object, continue deserializing to an array,
                    // otherwise guess the type using the wildcard
                    $type = is_array($item)
                        ? TypeToken::create(TypeToken::HASH)
                        : TypeToken::create(TypeToken::WILDCARD);

                    $adapter = $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;
            }

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

        return $array;
    }

    /**
     * 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->isArrayObject($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:
                    $adapter = $this->typeAdapterProvider->getAdapter(TypeToken::createFromVariable($item));
                    $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;
    }

    /**
     * Returns true if the array is acting like an object
     * @param array|stdClass $array
     * @return bool
     */
    private function isArrayObject($array): bool
    {
        if ($this->numberOfGenerics === 2) {
            return true;
        }

        return is_string(key($array));
        return is_string(key(/** @scrutinizer ignore-type */ $array));
    }
}

tebru / gson-php

Push — v0.7 ( 7c9b41...5c4e91 )

ArrayTypeAdapter::isArrayObject() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
