ReflectionTypeAdapter::write() - Code Metrics - Inspection of "initial" - tebru/gson-php - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — class-metadata-visitor ( 0a5a84...7b4c97 )

by Nate
created 2019-07-18 03:16 UTC
ReflectionTypeAdapter::write() F

↳ Parent: ReflectionTypeAdapter
Complexity

Conditions	22
Paths	1221
Size

Total Lines	79
Code Lines	47
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	22
eloc	47
c	1
b	0
f	0
nc	1221
nop	2
dl	0
loc	79
rs	0
How to fix Long Method Complexity

<?php
/*
 * Copyright (c) Nate Brunette.
 * Distributed under the MIT License (http://opensource.org/licenses/MIT)
 */

declare(strict_types=1);

namespace Tebru\Gson\Internal\TypeAdapter;

use Tebru\Gson\Annotation\ExclusionStrategy;
use Tebru\Gson\Annotation\JsonAdapter;
use Tebru\Gson\Exclusion\DeserializationExclusionDataAware;
use Tebru\Gson\Exclusion\PropertyDeserializationExclusionStrategy;
use Tebru\Gson\Exclusion\PropertySerializationExclusionStrategy;
use Tebru\Gson\Exclusion\SerializationExclusionDataAware;
use Tebru\Gson\Internal\ConstructorConstructor;
use Tebru\Gson\Internal\Data\Property;
use Tebru\Gson\Internal\DefaultClassMetadata;
use Tebru\Gson\Internal\DefaultDeserializationExclusionData;
use Tebru\Gson\Internal\DefaultSerializationExclusionData;
use Tebru\Gson\Internal\Excluder;
use Tebru\Gson\Internal\ObjectConstructor\CreateFromInstance;
use Tebru\Gson\Internal\ObjectConstructorAware;
use Tebru\Gson\Internal\ObjectConstructorAwareTrait;
use Tebru\Gson\Internal\TypeAdapterProvider;
use Tebru\Gson\JsonWritable;
use Tebru\Gson\Internal\Data\PropertyCollection;
use Tebru\Gson\JsonReadable;
use Tebru\Gson\Internal\ObjectConstructor;
use Tebru\Gson\JsonToken;
use Tebru\Gson\TypeAdapter;
use Tebru\PhpType\TypeToken;
use TypeError;

/**
 * Class ReflectionTypeAdapter
 *
 * Uses reflected class properties to read/write object
 *
 * @author Nate Brunette <[email protected]>
 */
final class ReflectionTypeAdapter extends TypeAdapter implements ObjectConstructorAware
{
    use ObjectConstructorAwareTrait;

    /**
     * @var ConstructorConstructor
     */
    private $constructorConstructor;

    /**
     * @var PropertyCollection
     */
    private $properties;

    /**
     * @var DefaultClassMetadata
     */
    private $classMetadata;

    /**
     * @var Excluder
     */
    private $excluder;

    /**
     * @var TypeAdapterProvider
     */
    private $typeAdapterProvider;

    /**
     * @var null|string
     */
    private $classVirtualProperty;

    /**
     * @var bool
     */
    private $skipSerialize;

    /**
     * @var bool
     */
    private $skipDeserialize;

    /**
     * @var bool
     */
    private $hasClassSerializationStrategies;

    /**
     * @var bool
     */
    private $hasPropertySerializationStrategies;

    /**
     * @var bool
     */
    private $hasClassDeserializationStrategies;

    /**
     * @var bool
     */
    private $hasPropertyDeserializationStrategies;

    /**
     * An memory cache of used type adapters
     *
     * @var TypeAdapter[]
     */
    private $adapters = [];

    /**
     * A memory cache of read properties
     *
     * @var Property[]
     */
    private $propertyCache = [];

    /**
     * Constructor
     *
     * @param ConstructorConstructor $constructorConstructor
     * @param ObjectConstructor $objectConstructor
     * @param DefaultClassMetadata $classMetadata
     * @param Excluder $excluder
     * @param TypeAdapterProvider $typeAdapterProvider
     * @param null|string $classVirtualProperty
     */
    public function __construct(
        ConstructorConstructor $constructorConstructor,
        ObjectConstructor $objectConstructor,
        DefaultClassMetadata $classMetadata,
        Excluder $excluder,
        TypeAdapterProvider $typeAdapterProvider,
        ?string $classVirtualProperty
    ) {
        $this->constructorConstructor = $constructorConstructor;
        $this->objectConstructor = $objectConstructor;
        $this->classMetadata = $classMetadata;
        $this->excluder = $excluder;
        $this->typeAdapterProvider = $typeAdapterProvider;
        $this->classVirtualProperty = $classVirtualProperty;

        $this->properties = $classMetadata->getPropertyCollection();
        $this->skipSerialize = $classMetadata->skipSerialize();
        $this->skipDeserialize = $classMetadata->skipDeserialize();
        $this->hasClassSerializationStrategies = $this->excluder->hasClassSerializationStrategies();
        $this->hasPropertySerializationStrategies = $this->excluder->hasPropertySerializationStrategies();
        $this->hasClassDeserializationStrategies = $this->excluder->hasClassDeserializationStrategies();
        $this->hasPropertyDeserializationStrategies = $this->excluder->hasPropertyDeserializationStrategies();
    }
    /**
     * Read the next value, convert it to its type and return it
     *
     * @param JsonReadable $reader
     * @return object
     */
    public function read(JsonReadable $reader)
    {
        if ($this->skipDeserialize) {
            $reader->skipValue();
            return null;
        }

        if ($reader->peek() === JsonToken::NULL) {
            $reader->nextNull();
            return null;
        }

        $object = $this->objectConstructor->construct();
        $exclusionData = $this->hasClassDeserializationStrategies || $this->hasPropertyDeserializationStrategies
            ? new DefaultDeserializationExclusionData(clone $object, $reader)
            : null;

        if ($this->hasClassDeserializationStrategies && $exclusionData) {
            $this->excluder->applyClassDeserializationExclusionData($exclusionData);

            if ($this->excluder->excludeClassByDeserializationStrategy($this->classMetadata)) {
                $reader->skipValue();
                return null;
            }
        }

        if ($this->hasPropertyDeserializationStrategies && $exclusionData) {
            $this->excluder->applyPropertyDeserializationExclusionData($exclusionData);
        }

        $reader->beginObject();

        if ($this->classVirtualProperty !== null) {
            $reader->nextName();
            $reader->beginObject();
        }

        $usesExisting = $reader->getContext()->usesExistingObject();

        while ($reader->hasNext()) {
            $name = $reader->nextName();
            $property = $this->propertyCache[$name] ?? $this->propertyCache[$name] = $this->properties->getBySerializedName($name);

            if ($property === null) {
                $reader->skipValue();
                continue;
            }

            $exclusionAnnotation = $property->getAnnotation(ExclusionStrategy::class);
            if ($exclusionAnnotation !== null) {
                $type = TypeToken::create($exclusionAnnotation->getValue());
                if ($type->isA(PropertySerializationExclusionStrategy::class)) {
                    /** @var PropertyDeserializationExclusionStrategy $exclusionStrategy */
                    $exclusionStrategy = $this->constructorConstructor->get($type)->construct();
                    if ($exclusionStrategy instanceof DeserializationExclusionDataAware) {
                        $propertyExclusionData = new DefaultDeserializationExclusionData(clone $object, $reader);
                        $exclusionStrategy->setDeserializationExclusionData($propertyExclusionData);
                    }

                    if ($exclusionStrategy->skipDeserializingProperty($property)) {
                        $reader->skipValue();
                        continue;
                    }
                }
            }

            if (
                $property->skipDeserialize()
                || ($this->hasPropertyDeserializationStrategies && $this->excluder->excludePropertyByDeserializationStrategy($property))
            ) {
                $reader->skipValue();
                continue;
            }

            $realName = $property->getName();

            $adapter = $this->adapters[$realName] ?? null;
            if ($adapter === null) {
                /** @var JsonAdapter $jsonAdapterAnnotation */
                $jsonAdapterAnnotation = $property->getAnnotations()->get(JsonAdapter::class);
                $adapter = null === $jsonAdapterAnnotation
                    ? $this->typeAdapterProvider->getAdapter($property->getType())
                    : $this->typeAdapterProvider->getAdapterFromAnnotation(
                        $property->getType(),
                        $jsonAdapterAnnotation
                    );
                $this->adapters[$realName] = $adapter;
            }

            if ($adapter instanceof ObjectConstructorAware && $usesExisting) {
                try {
                    $nestedObject = $property->get($object);
                    $nestedObject = $property->get($object);
                } /** @noinspection BadExceptionsProcessingInspection */ catch (TypeError $error) {
                    // this may occur when attempting to get a nested object that doesn't exist and
                    // the method return is not nullable. The type error only occurs because we are
                    // may be calling the getter before data exists.
                    $nestedObject = null;
                }

                if ($nestedObject !== null) {
                    $adapter->setObjectConstructor(new CreateFromInstance($nestedObject));
                }
            }

            $property->set($object, $adapter->read($reader));
                       set($object, $adapter->read($reader));
        }
        $reader->endObject();

        if ($this->classVirtualProperty !== null) {
            $reader->endObject();
        }

        return $object;
    }

    /**
     * Write the value to the writer for the type
     *
     * @param JsonWritable $writer
     * @param object $value
     * @return void
     */
    public function write(JsonWritable $writer, $value): void
    {
        if ($this->skipSerialize || $value === null) {
            $writer->writeNull();
            return;
        }

        $exclusionData = $this->hasClassSerializationStrategies || $this->hasPropertySerializationStrategies
            ? new DefaultSerializationExclusionData($value, $writer)
            : null;

        if ($this->hasClassSerializationStrategies && $exclusionData) {
            $this->excluder->applyClassSerializationExclusionData($exclusionData);

            if ($this->excluder->excludeClassBySerializationStrategy($this->classMetadata)) {
                $writer->writeNull();
                return;
            }
        }

        if ($this->hasPropertySerializationStrategies && $exclusionData) {
            $this->excluder->applyPropertySerializationExclusionData($exclusionData);
        }

        $writer->beginObject();

        if ($this->classVirtualProperty !== null) {
            $writer->name($this->classVirtualProperty);
            $writer->beginObject();
        }

        /** @var Property $property */
        foreach ($this->properties as $property) {
            $realName = $property->getName();
            $writer->name($property->getSerializedName());

            $exclusionAnnotation = $property->getAnnotation(ExclusionStrategy::class);
            if ($exclusionAnnotation !== null) {
                $type = TypeToken::create($exclusionAnnotation->getValue());
                if ($type->isA(PropertySerializationExclusionStrategy::class)) {
                    /** @var PropertySerializationExclusionStrategy $exclusionStrategy */
                    $exclusionStrategy = $this->constructorConstructor->get($type)->construct();
                    if ($exclusionStrategy instanceof SerializationExclusionDataAware) {
                        $propertyExclusionData = new DefaultSerializationExclusionData($value, $writer);
                        $exclusionStrategy->setSerializationExclusionData($propertyExclusionData);
                    }

                    if ($exclusionStrategy->skipSerializingProperty($property)) {
                        $writer->writeNull();
                        continue;
                    }
                }
            }

            if (
                $property->skipSerialize()
                || ($this->hasPropertySerializationStrategies && $this->excluder->excludePropertyBySerializationStrategy($property))
            ) {
                $writer->writeNull();

                continue;
            }

            $adapter = $this->adapters[$realName] ?? null;
            if ($adapter === null) {
                /** @var JsonAdapter $jsonAdapterAnnotation */
                $jsonAdapterAnnotation = $property->getAnnotations()->get(JsonAdapter::class);
                $adapter = null === $jsonAdapterAnnotation
                    ? $this->typeAdapterProvider->getAdapter($property->getType())
                    : $this->typeAdapterProvider->getAdapterFromAnnotation($property->getType(), $jsonAdapterAnnotation);
                $this->adapters[$realName] = $adapter;
            }
            $adapter->write($writer, $property->get($value));
        }

        $writer->endObject();

        if ($this->classVirtualProperty !== null) {
            $writer->endObject();
        }
    }
}

tebru / gson-php

Push — class-metadata-visitor ( 0a5a84...7b4c97 )

ReflectionTypeAdapter::write() F

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like
