Tebru\Gson\ArrayTypeAdapter::read()

Complexity

Conditions	17
Paths	16

Size

Total Lines	85
Code Lines	49

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	45
CRAP Score	17

Importance

Changes

0

<?php
    public function read(JsonReadable $reader): ?array
    {
        $token = $reader->peek();
        if ($token === JsonToken::NULL) {
            $reader->nextNull();
            return null;
        }

        $array = [];

        if ($this->numberOfGenerics > 2) {
            throw new LogicException(\sprintf('Array may not have more than 2 generic types at "%s"', $reader->getPath()));
        }

        switch ($token) {
            case JsonToken::BEGIN_OBJECT:
                $reader->beginObject();

                while ($reader->hasNext()) {
                    $name = $reader->nextName();

                    switch ($this->numberOfGenerics) {
                        // no generics specified
                        case 0:
                            // 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 = $reader->peek() === JsonToken::BEGIN_OBJECT
                                ? TypeToken::create(TypeToken::HASH)
                                : TypeToken::create(TypeToken::WILDCARD);

                            $adapter = $this->typeAdapterProvider->getAdapter($type);
                            $array[$name] = $adapter->read($reader);
                            break;
                        // generic for value specified
                        case 1:
                            $array[$name] = $this->valueTypeAdapter->read($reader);
                            break;
                        // generic for key and value specified
                        case 2:
                            if (!$this->keyType->isString() && !$this->keyType->isInteger()) {
                                throw new LogicException(\sprintf('Array keys must be strings or integers at "%s"', $reader->getPath()));
                            }

                            if ($this->keyType->isInteger()) {
                                if (!\ctype_digit($name)) {
                                    throw new JsonSyntaxException(\sprintf('Expected integer, but found string for key at "%s"', $reader->getPath()));
                                }

                                $name = (int)$name;
                            }

                            $array[$name] = $this->valueTypeAdapter->read($reader);

                            break;
                    }
                }

                $reader->endObject();

                break;
            case JsonToken::BEGIN_ARRAY:
                $reader->beginArray();

                while ($reader->hasNext()) {
                    switch ($this->numberOfGenerics) {
                        // no generics specified
                        case 0:
                        case 1:
                            $array[] = $this->valueTypeAdapter->read($reader);

                            break;
                        default:
                            throw new LogicException(\sprintf('An array may only specify a generic type for the value at "%s"', $reader->getPath()));
                    }
                }

                $reader->endArray();

                break;
            default:
                throw new JsonSyntaxException(\sprintf('Could not parse json, expected array or object but found "%s" at "%s"', $token, $reader->getPath()));
        }

        return $array;
    }