KleijnWeb\PhpApi\Descriptions\Description\Schema\SchemaFactory

Complexity

Total Complexity

32

Size/Duplication

Total Lines	163
Duplicated Lines	6.13 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
F	create()	10	82	24
B	resolveTypes()	0	30	6
A	setClassNameResolver()	0	4	1
A	getTypeNameFromRefId()	0	4	1

<?php declare(strict_types=1);
/*
 * This file is part of the KleijnWeb\PhpApi\Descriptions package.
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace KleijnWeb\PhpApi\Descriptions\Description\Schema;

use KleijnWeb\PhpApi\Descriptions\Description\ComplexType;
use KleijnWeb\PhpApi\Descriptions\Hydrator\ClassNameResolver;

/**
 * @author John Kleijn <john@kleijnweb.nl>
 */
class SchemaFactory
{
    /**
     * @var array
     */
    private $schemas = [];

    /**
     * @var ComplexType[]
     */
    private $complexTypes = [];

    /**
     * @var ObjectSchema[]
     */
    private $typedSchemas = [];

    /**
     * @var array
     */
    private $definitions = [];

    /**
     * @var ClassNameResolver
     */
    private $classNameResolver;

    /**
     * @param \stdClass|null $definition
     * @param string|null    $name
     *
     * @return Schema
     */
    public function create(\stdClass $definition = null, string $name = null): Schema
    {
        if (!$definition) {
            $definition       = (object)[];
            $definition->type = Schema::TYPE_ANY;
        }
        if (!isset($definition->type)) {
            $definition = clone $definition;
            if (isset($definition->allOf)) {
                foreach ($definition->allOf as $nested) {
                    if (isset($nested->type)) {
                        $definition->type = $nested->type;
                    }
                }
            }
            if (!isset($definition->type)) {
                $definition->type = Schema::TYPE_STRING;
            }
        }
        if (isset($definition->properties)) {
            $definition->type = 'object';
        }

        $index = var_export($definition, true);

        if (!isset($this->schemas[$index])) {
            if ($definition->type == Schema::TYPE_OBJECT) {
                $propertySchemas = (object)[];

                if (isset($definition->properties)) {

This code seems to be duplicated across your project.

                    foreach ($definition->properties as $attributeName => $propertyDefinition) {
                        $propertySchemas->$attributeName = $this->create($propertyDefinition);
                    }
                }

                if (isset($definition->allOf)) {
                    foreach ($definition->allOf as $nested) {
                        if (isset($nested->{'x-ref-id'})) {
                            continue;
                        }
                        if (isset($nested->properties)) {

This code seems to be duplicated across your project.

                            foreach ($nested->properties as $attributeName => $propertyDefinition) {
                                $propertySchemas->$attributeName = $this->create($propertyDefinition);
                            }
                        }
                    }
                    unset($definition->type);
                }

                if ($name === null && isset($definition->{'x-ref-id'})) {
                    $name = $this->getTypeNameFromRefId($definition);
                }

                $schema = new ObjectSchema($definition, $propertySchemas, null, $name);

                if (null !== $name) {
                    if (isset($this->typedSchemas[$name])) {
                        $a = var_export($schema, true);

$a is not used, you could remove the assignment.

                        $b = var_export($this->typedSchemas[$name], true);

$b is not used, you could remove the assignment.

                        $a2 = var_export($definition, true);

$a2 is not used, you could remove the assignment.

                        $b2 = var_export($this->typedSchemas[$name]->getDefinition(), true);

$b2 is not used, you could remove the assignment.

                        throw new \InvalidArgumentException("Type '$name' already exists");
                    }
                    $this->typedSchemas[$name] = $schema;
                }

            } elseif ($definition->type == Schema::TYPE_ARRAY) {
                $itemsSchema = isset($definition->items) ? $this->create($definition->items) : null;
                $schema      = new ArraySchema($definition, $itemsSchema);
            } elseif ($definition->type == Schema::TYPE_ANY) {
                $schema = new AnySchema($definition);
            } else {
                $schema = new ScalarSchema($definition);
            }

            $this->schemas[$index] = $schema;

            return $schema;
        }

        return $this->schemas[$index];
    }

    /**
     * @return ComplexType[]
     */
    public function resolveTypes(): array
    {
        foreach ($this->typedSchemas as $name => $schema) {
            $schema->setComplexType(new ComplexType(
                $name,
                $schema,
                $this->classNameResolver->resolve($name)
            ));
        }

        foreach ($this->typedSchemas as $name => $schema) {
            $definition = $schema->getDefinition();

            if (isset($definition->allOf)) {
                foreach ($definition->allOf as $partial) {
                    if (isset($partial->{'x-ref-id'})) {
                        $this->typedSchemas[$schema->getXType()]
                            ->getComplexType()
                            ->addParent(
                                $this->typedSchemas[$this->getTypeNameFromRefId($partial)]->getComplexType()

It seems like $this->typedSchemas[$this->getTypeNameFromRefId($partial)]->getComplexType() can be null; however, addParent() does not accept null, maybe add an additional type check?

                            );
                    }
                }
            }
        }

        return array_map(function(ObjectSchema $schema){
            return $schema->getComplexType();
        }, $this->typedSchemas);
    }

    /**
     * @param ClassNameResolver $classNameResolver
     */
    public function setClassNameResolver(ClassNameResolver $classNameResolver)
    {
        $this->classNameResolver = $classNameResolver;
    }

    private function getTypeNameFromRefId(\stdClass $definition)
    {
        return substr($definition->{'x-ref-id'}, strrpos($definition->{'x-ref-id'}, '/') + 1);
    }
}