PhpBuilder::makeClass() - Code Metrics - swaggest/php-code-builder - Measure and Improve Code Quality continuously with Scrutinizer

PhpBuilder::makeClass() F
last analyzed 2025-02-15 16:15 UTC

↳ Parent: PhpBuilder

Complexity

Conditions	28
Paths	3073

Size

Total Lines	157
Code Lines	101

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	73
CRAP Score	29.0378

Importance

Changes	4
Bugs	0	Features	0

Metric	Value
cc	28
eloc	101
c	4
b	0
f	0
nc	3073
nop	2
dl	0
loc	157
ccs	73
cts	82
cp	0.8902
crap	29.0378
rs	0

How to fix Long Method Complexity

<?php

namespace Swaggest\PhpCodeBuilder\JsonSchema;

use Swaggest\CodeBuilder\AbstractTemplate;
use Swaggest\CodeBuilder\PlaceholderString;
use Swaggest\JsonSchema\Context;
use Swaggest\JsonSchema\JsonSchema;
use Swaggest\JsonSchema\Schema;
use Swaggest\JsonSchema\SchemaContract;
use Swaggest\JsonSchema\SchemaExporter;
use Swaggest\PhpCodeBuilder\Exception;
.
|-- OtherDir
|   |-- Bar.php
|   `-- Foo.php
`-- SomeDir
    `-- Foo.php
use Swaggest\PhpCodeBuilder\PhpAnyType;
use Swaggest\PhpCodeBuilder\PhpClass;
use Swaggest\PhpCodeBuilder\PhpClassProperty;
use Swaggest\PhpCodeBuilder\PhpCode;
use Swaggest\PhpCodeBuilder\PhpConstant;
use Swaggest\PhpCodeBuilder\PhpDoc;
use Swaggest\PhpCodeBuilder\PhpFlags;
use Swaggest\PhpCodeBuilder\PhpFunction;
use Swaggest\PhpCodeBuilder\PhpNamedVar;
use Swaggest\PhpCodeBuilder\PhpStdType;
use Swaggest\PhpCodeBuilder\Property\AdditionalPropertiesGetter;
use Swaggest\PhpCodeBuilder\Property\AdditionalPropertySetter;
use Swaggest\PhpCodeBuilder\Property\Getter;
use Swaggest\PhpCodeBuilder\Property\PatternPropertiesGetter;
use Swaggest\PhpCodeBuilder\Property\PatternPropertySetter;
use Swaggest\PhpCodeBuilder\Property\Setter;
use Swaggest\PhpCodeBuilder\Types\TypeOf;

class PhpBuilder
{
    const IMPORT_METHOD_PHPDOC_ID = '::import';

    const SCHEMA = 'schema';
    const ORIGIN = 'origin';
    const PROPERTY_NAME = 'property_name';
    const IMPORT_TYPE = 'import_type';

    /** @var \SplObjectStorage */
    private $generatedClasses;

    public function __construct()
    {
        $this->generatedClasses = new \SplObjectStorage();
    }

    public $buildGetters = false;
    public $buildSetters = false;
    public $makeEnumConstants = false;
    public $skipSchemaDescriptions = false;

    /**
     * Use title/description where available instead of keyword in names
     * @var bool
     */
    public $namesFromDescriptions = false;

    /**
     * Squish multiple $ref, a PHP class for each $ref will be created if false
     * @var bool
     */
    public $minimizeRefs = true;

    /** @var PhpBuilderClassHook */
    public $classCreatedHook;

    /** @var PhpBuilderClassHook */
    public $classPreparedHook;

    /**
     * Use default values to initialize properties
     * @var bool
     */
    public $declarePropertyDefaults = false;

    /**
     * Build setter and getter methods for additional properties
     * on a boolean true value for `additionalProperties`.
     * @var bool
     */
    public $buildAdditionalPropertyMethodsOnTrue = false;

    /**
     * @param SchemaContract $schema
     * @param string $path
     * @return PhpAnyType
     * @throws \Swaggest\PhpCodeBuilder\JsonSchema\Exception
     * @throws Exception
     */
    public function getType($schema, $path = '#')
    {
        if (!$schema instanceof Schema) {
            throw new Exception('Could not find Schema instance in SchemaContract: ' . get_class($schema));
        }
        $typeBuilder = new TypeBuilder($schema, $path, $this);
        return $typeBuilder->build();
    }


    /**
     * @param Schema $schema
     * @param string $path
     * @return PhpClass
     * @throws Exception
     * @throws \Swaggest\PhpCodeBuilder\JsonSchema\Exception
     */
    public function getClass($schema, $path)
    {
        if ($this->generatedClasses->contains($schema)) {
            return $this->generatedClasses[$schema]->class;
        } else {
            return $this->makeClass($schema, $path)->class;
        }
    }

    /**
     * @param Schema $schema
     * @param string $path
     * @return GeneratedClass
     * @throws Exception
     * @throws \Swaggest\PhpCodeBuilder\JsonSchema\Exception
     */
    private function makeClass($schema, $path)
    {
        if (empty($path)) {
            throw new Exception('Empty path');
        }
        $generatedClass = new GeneratedClass();
        $generatedClass->schema = $schema;

        $class = new PhpClass();
        if ($fromRefs = $schema->getFromRefs()) {
            $path = $fromRefs[count($fromRefs) - 1];
        }

        $class->setName(PhpCode::makePhpClassName($path));
        if ($this->classCreatedHook !== null) {
            $this->classCreatedHook->process($class, $path, $schema);
        }
        if (is_null($class->getExtends())) {
            $class->setExtends(Palette::classStructureClass());
        }

        $setupProperties = new PhpFunction('setUpProperties');
        $setupProperties
            ->setVisibility(PhpFlags::VIS_PUBLIC)
            ->setIsStatic(true);
        $setupProperties
            ->addArgument(new PhpNamedVar('properties', Palette::propertiesOrStaticClass()))
            ->addArgument(new PhpNamedVar('ownerSchema', Palette::schemaClass()));

        $body = new PhpCode();

        $class->addMeta($schema, self::SCHEMA);
        $class->addMethod($setupProperties);

        $generatedClass->class = $class;
        $generatedClass->path = $path;

        $this->generatedClasses->attach($schema, $generatedClass);
        if (null !== $this->dynamicIterator) {
            $this->dynamicIterator->push($generatedClass);
        }

        if ($schema->properties) {
            $phpNames = array();
            /**
             * @var string $name
             * @var Schema $property
             */
            foreach ($schema->properties as $name => $property) {
                $propertyName = PhpCode::makePhpName($name);

                $i = 2;
                $basePropertyName = $propertyName;
                while (isset($phpNames[$propertyName])) {
                    $propertyName = $basePropertyName . $i;
                    $i++;
                }
                $phpNames[$propertyName] = true;

                $schemaBuilder = new SchemaBuilder($property, '$properties->' . $propertyName, $path . '->' . $name, $this);
                if ($this->skipSchemaDescriptions) {
                    $schemaBuilder->skipProperty(JsonSchema::names()->description);
                }
                if ($this->makeEnumConstants) {
                    $schemaBuilder->setSaveEnumConstInClass($class);
                }
                $propertyType = $this->getType($property, $path . '->' . $name);
                $phpProperty = new PhpClassProperty($propertyName, $propertyType);
                $phpProperty->addMeta($property, self::SCHEMA);
                $phpProperty->addMeta($name, self::PROPERTY_NAME);

                if (!is_null($property->default) && $this->declarePropertyDefaults) {
                    $phpProperty->setDefault($property->default);
                }

                if ($this->schemaIsNullable($property)) {
                    $phpProperty->setIsMagical(true);
                }

                if ($property->description) {
                    $phpProperty->setDescription($property->description);
                }
                $class->addProperty($phpProperty);
                if ($this->buildGetters) {
                    $class->addMethod(new Getter($phpProperty));
                }
                if ($this->buildSetters) {
                    $class->addMethod(new Setter($phpProperty, true));
                }
                $body->addSnippet(
                    $schemaBuilder->build()
                );
                if ($propertyName != $name) {
                    $body->addSnippet('$ownerSchema->addPropertyMapping(' . var_export($name, true) . ', self::names()->'
                        . $propertyName . ");\n");
                }
            }
        }

        $additionalPropertiesType = null;
        $buildAdditionalPropertiesMethods = false;
        if ($schema->additionalProperties instanceof Schema) {
            $additionalPropertiesType = $this->getType($schema->additionalProperties);
            $buildAdditionalPropertiesMethods = true;
        } elseif ($this->buildAdditionalPropertyMethodsOnTrue && $schema->additionalProperties === true) {
            $additionalPropertiesType = PhpStdType::mixed();
            $buildAdditionalPropertiesMethods = true;
        }

        if ($buildAdditionalPropertiesMethods) {
            $class->addMethod(new AdditionalPropertiesGetter($additionalPropertiesType));
            $class->addMethod(new AdditionalPropertySetter($additionalPropertiesType));
        }

        if ($schema->patternProperties !== null) {
            foreach ($schema->patternProperties as $pattern => $patternProperty) {
                if ($patternProperty instanceof Schema) {
                    $const = new PhpConstant(PhpCode::makePhpConstantName($pattern . '_PROPERTY_PATTERN'), $pattern);
                    $class->addConstant($const);

                    $class->addMethod(new PatternPropertiesGetter($const, $this->getType($patternProperty)));
                    $class->addMethod(new PatternPropertySetter($const, $this->getType($patternProperty)));
                }
            }
        }

        $schemaBuilder = new SchemaBuilder($schema, '$ownerSchema', $path, $this, false);
        if ($this->skipSchemaDescriptions) {
            $schemaBuilder->skipProperty(JsonSchema::names()->description);
        }
        $schemaBuilder->setSkipProperties(true);
        $body->addSnippet($schemaBuilder->build());

        $setupProperties->setBody($body);

        $phpDoc = $class->getPhpDoc();
        $type = $this->getType($schema, $path);
        if (!$type instanceof PhpClass) {

            $class->addMeta($type, self::IMPORT_TYPE);
            $phpDoc->add(
                PhpDoc::TAG_METHOD,
                new PlaceholderString(
                    'static :type import($data, :context $options = null)',
                    array(
                        ':type' => new TypeOf($type, true),
                        ':context' => new TypeOf(PhpClass::byFQN(Context::class))
                    )
                ),
                self::IMPORT_METHOD_PHPDOC_ID
            );
        }

        if ($this->classPreparedHook !== null) {
            $this->classPreparedHook->process($class, $path, $schema);
        }

        return $generatedClass;
    }

    /** @var DynamicIterator */
    private $dynamicIterator;

    /**
     * @return GeneratedClass[]|DynamicIterator
     */
    public function getGeneratedClasses()
    {
        $result = array();
        foreach ($this->generatedClasses as $schema) {
            $result[] = $this->generatedClasses[$schema];
        }
        $iterator = new DynamicIterator($result);
        $this->dynamicIterator = $iterator;
        return $iterator;
    }

    /**
     * @param AbstractTemplate $template
     * @return null|Schema
     */
    public static function getSchemaMeta(AbstractTemplate $template)
    {
        return $template->getMeta(self::SCHEMA);
    }

    /**
     * Returns true if null is allowed by schema.
     *
     * @param Schema $property
     * @return bool
     */
    private function schemaIsNullable($property)
    {
        if (!empty($property->enum) && !in_array(null, $property->enum)) {
            return false;
        }

        if ($property->const !== null) {
            return false;
        }

        if (!empty($property->anyOf)) {
            $nullable = false;
            foreach ($property->anyOf as $item) {
                if ($item instanceof Schema) {
                    if ($this->schemaIsNullable($item)) {
                        $nullable = true;
                        break;
                    }
                }
            }
            if (!$nullable) {
                return false;
            }
        }

        if (!empty($property->oneOf)) {
            $nullable = false;
            foreach ($property->oneOf as $item) {
                if ($item instanceof Schema) {
                    if ($this->schemaIsNullable($item)) {
                        $nullable = true;
                        break;
                    }
                }
            }
            if (!$nullable) {
                return false;
            }
        }

        if (!empty($property->allOf)) {
            foreach ($property->allOf as $item) {
                if ($item instanceof Schema) {
                    if (!$this->schemaIsNullable($item)) {
                        return false;
                    }
                }
            }
        }

        if (
            $property->type === null
            || $property->type === Schema::NULL
            || (is_array($property->type) && in_array(Schema::NULL, $property->type))
        ) {
            return true;
        }

        return false;
    }
}


class DynamicIterator implements \Iterator, \ArrayAccess
{
    private $rows;
    private $current;
    private $key;
    private $valid;

    public function push($item)
    {
        $this->rows[] = $item;
        return $this;
    }

    /**
     * DynamicIterator constructor.
     * @param array $rows
     */
    public function __construct($rows = array())
    {
        $this->rows = $rows;
    }


    #[\ReturnTypeWillChange]
    public function current()
    {
        return $this->current;
    }

    #[\ReturnTypeWillChange]
    public function next()
    {
        if (empty($this->rows)) {
            $this->valid = false;
            return;
        }
        $this->current = array_shift($this->rows);
        $this->valid = true;
        ++$this->key;
    }

    #[\ReturnTypeWillChange]
    public function key()
    {
        return $this->key;
    }

    #[\ReturnTypeWillChange]
    public function valid()
    {
        return $this->valid;
    }

    #[\ReturnTypeWillChange]
    public function rewind()
    {
        $this->next();
    }

    #[\ReturnTypeWillChange]
    public function offsetExists($offset)
    {
        return array_key_exists($offset, $this->rows);
    }

    #[\ReturnTypeWillChange]
    public function offsetGet($offset)
    {
        return $this->rows[$offset];
    }

    #[\ReturnTypeWillChange]
    public function offsetSet($offset, $value)
    {
        $this->rows[$offset] = $value;
    }

    #[\ReturnTypeWillChange]
    public function offsetUnset($offset)
    {
        unset($this->rows[$offset]);
    }


}

1		<?php
2
3		namespace Swaggest\PhpCodeBuilder\JsonSchema;
4
5		use Swaggest\CodeBuilder\AbstractTemplate;
6		use Swaggest\CodeBuilder\PlaceholderString;
7		use Swaggest\JsonSchema\Context;
8		use Swaggest\JsonSchema\JsonSchema;
9		use Swaggest\JsonSchema\Schema;
10		use Swaggest\JsonSchema\SchemaContract;
11		use Swaggest\JsonSchema\SchemaExporter;
12		use Swaggest\PhpCodeBuilder\Exception;
		0 ignored issues – show Bug introduced 2018-05-15 10:38 UTC by Report Bug Copy Issue Report This use statement conflicts with another class in this namespace, `Swaggest\PhpCodeBuilder\JsonSchema\Exception`. Consider defining an alias. Let?s assume that you have a directory layout like this: . \|-- OtherDir \| \|-- Bar.php \| `-- Foo.php `-- SomeDir `-- Foo.php and let?s assume the following content of `Bar.php`: // Bar.php namespace OtherDir; use SomeDir\Foo; // This now conflicts the class OtherDir\Foo If both files `OtherDir/Foo.php` and `SomeDir/Foo.php` are loaded in the same runtime, you will see a PHP error such as the following: PHP Fatal error: Cannot use SomeDir\Foo as Foo because the name is already in use in OtherDir/Foo.php However, as `OtherDir/Foo.php` does not necessarily have to be loaded and the error is only triggered if it is loaded before `OtherDir/Bar.php`, this problem might go unnoticed for a while. In order to prevent this error from surfacing, you must import the namespace with a different alias: // Bar.php namespace OtherDir; use SomeDir\Foo as SomeDirFoo; // There is no conflict anymore. Loading history...
13		use Swaggest\PhpCodeBuilder\PhpAnyType;
14		use Swaggest\PhpCodeBuilder\PhpClass;
15		use Swaggest\PhpCodeBuilder\PhpClassProperty;
16		use Swaggest\PhpCodeBuilder\PhpCode;
17		use Swaggest\PhpCodeBuilder\PhpConstant;
18		use Swaggest\PhpCodeBuilder\PhpDoc;
19		use Swaggest\PhpCodeBuilder\PhpFlags;
20		use Swaggest\PhpCodeBuilder\PhpFunction;
21		use Swaggest\PhpCodeBuilder\PhpNamedVar;
22		use Swaggest\PhpCodeBuilder\PhpStdType;
23		use Swaggest\PhpCodeBuilder\Property\AdditionalPropertiesGetter;
24		use Swaggest\PhpCodeBuilder\Property\AdditionalPropertySetter;
25		use Swaggest\PhpCodeBuilder\Property\Getter;
26		use Swaggest\PhpCodeBuilder\Property\PatternPropertiesGetter;
27		use Swaggest\PhpCodeBuilder\Property\PatternPropertySetter;
28		use Swaggest\PhpCodeBuilder\Property\Setter;
29		use Swaggest\PhpCodeBuilder\Types\TypeOf;
30
31		class PhpBuilder
32		{
33		const IMPORT_METHOD_PHPDOC_ID = '::import';
34
35		const SCHEMA = 'schema';
36		const ORIGIN = 'origin';
37		const PROPERTY_NAME = 'property_name';
38		const IMPORT_TYPE = 'import_type';
39
40		/** @var \SplObjectStorage */
41		private $generatedClasses;
42
43	12	public function __construct()
44		{
45	12	$this->generatedClasses = new \SplObjectStorage();
46	12	}
47
48		public $buildGetters = false;
49		public $buildSetters = false;
50		public $makeEnumConstants = false;
51		public $skipSchemaDescriptions = false;
52
53		/**
54		* Use title/description where available instead of keyword in names
55		* @var bool
56		*/
57		public $namesFromDescriptions = false;
58
59		/**
60		* Squish multiple $ref, a PHP class for each $ref will be created if false
61		* @var bool
62		*/
63		public $minimizeRefs = true;
64
65		/** @var PhpBuilderClassHook */
66		public $classCreatedHook;
67
68		/** @var PhpBuilderClassHook */
69		public $classPreparedHook;
70
71	12	/**
72		* Use default values to initialize properties
73	12	* @var bool
74	12	*/
75		public $declarePropertyDefaults = false;
76
77		/**
78		* Build setter and getter methods for additional properties
79		* on a boolean true value for `additionalProperties`.
80		* @var bool
81		*/
82		public $buildAdditionalPropertyMethodsOnTrue = false;
83
84		/**
85	11	* @param SchemaContract $schema
86		* @param string $path
87	11	* @return PhpAnyType
88	10	* @throws \Swaggest\PhpCodeBuilder\JsonSchema\Exception
89		* @throws Exception
90	11	*/
91		public function getType($schema, $path = '#')
92		{
93		if (!$schema instanceof Schema) {
94		throw new Exception('Could not find Schema instance in SchemaContract: ' . get_class($schema));
95		}
96		$typeBuilder = new TypeBuilder($schema, $path, $this);
97		return $typeBuilder->build();
98		}
99
100
101	11	/**
102		* @param Schema $schema
103	11	* @param string $path
104		* @return PhpClass
105		* @throws Exception
106	11	* @throws \Swaggest\PhpCodeBuilder\JsonSchema\Exception
107	11	*/
108		public function getClass($schema, $path)
109	11	{
110	11	if ($this->generatedClasses->contains($schema)) {
111	3	return $this->generatedClasses[$schema]->class;
112		} else {
113		return $this->makeClass($schema, $path)->class;
114	11	}
115	11	}
116	4
117		/**
118	11	* @param Schema $schema
119		* @param string $path
120	11	* @return GeneratedClass
121		* @throws Exception
122	11	* @throws \Swaggest\PhpCodeBuilder\JsonSchema\Exception
123	11	*/
124		private function makeClass($schema, $path)
125	11	{
126	11	if (empty($path)) {
127		throw new Exception('Empty path');
128	11	}
129		$generatedClass = new GeneratedClass();
130	11	$generatedClass->schema = $schema;
131	11
132		$class = new PhpClass();
133	11	if ($fromRefs = $schema->getFromRefs()) {
134	11	$path = $fromRefs[count($fromRefs) - 1];
135		}
136	11
137	11	$class->setName(PhpCode::makePhpClassName($path));
138		if ($this->classCreatedHook !== null) {
139		$this->classCreatedHook->process($class, $path, $schema);
140		}
141	11	if (is_null($class->getExtends())) {
142	10	$class->setExtends(Palette::classStructureClass());
143	10	}
144	10
145		$setupProperties = new PhpFunction('setUpProperties');
146	10	$setupProperties
147	10	->setVisibility(PhpFlags::VIS_PUBLIC)
148	10	->setIsStatic(true);
149	10	$setupProperties
150		->addArgument(new PhpNamedVar('properties', Palette::propertiesOrStaticClass()))
151	10	->addArgument(new PhpNamedVar('ownerSchema', Palette::schemaClass()));
152	10
153		$body = new PhpCode();
154
155	10	$class->addMeta($schema, self::SCHEMA);
156	4	$class->addMethod($setupProperties);
157
158	10	$generatedClass->class = $class;
159	10	$generatedClass->path = $path;
160	10
161	10	$this->generatedClasses->attach($schema, $generatedClass);
162	2	if (null !== $this->dynamicIterator) {
163		$this->dynamicIterator->push($generatedClass);
164	10	}
165	10
166		if ($schema->properties) {
167		$phpNames = array();
168	10	/**
169	5	* @var string $name
170		* @var Schema $property
171	10	*/
172	10	foreach ($schema->properties as $name => $property) {
173		$propertyName = PhpCode::makePhpName($name);
174	10
175	3	$i = 2;
176	3	$basePropertyName = $propertyName;
177		while (isset($phpNames[$propertyName])) {
178		$propertyName = $basePropertyName . $i;
179		$i++;
180		}
181	11	$phpNames[$propertyName] = true;
182	2
183	2	$schemaBuilder = new SchemaBuilder($property, '$properties->' . $propertyName, $path . '->' . $name, $this);
184		if ($this->skipSchemaDescriptions) {
185		$schemaBuilder->skipProperty(JsonSchema::names()->description);
186	11	}
187	4	if ($this->makeEnumConstants) {
188	4	$schemaBuilder->setSaveEnumConstInClass($class);
189	4	}
190		$propertyType = $this->getType($property, $path . '->' . $name);
191	4	$phpProperty = new PhpClassProperty($propertyName, $propertyType);
192	4	$phpProperty->addMeta($property, self::SCHEMA);
193		$phpProperty->addMeta($name, self::PROPERTY_NAME);
194
195		if (!is_null($property->default) && $this->declarePropertyDefaults) {
196	11	$phpProperty->setDefault($property->default);
197	11	}
198
199		if ($this->schemaIsNullable($property)) {
200	11	$phpProperty->setIsMagical(true);
201	11	}
202
203	11	if ($property->description) {
204		$phpProperty->setDescription($property->description);
205	11	}
206	11	$class->addProperty($phpProperty);
207	11	if ($this->buildGetters) {
208	7	$class->addMethod(new Getter($phpProperty));
209	7	}
210	7	if ($this->buildSetters) {
211	7	$class->addMethod(new Setter($phpProperty, true));
212		}
213	7	$body->addSnippet(
214	7	$schemaBuilder->build()
215		);
216		if ($propertyName != $name) {
217	7	$body->addSnippet('$ownerSchema->addPropertyMapping(' . var_export($name, true) . ', self::names()->'
218		. $propertyName . ");\n");
219		}
220		}
221	11	}
222	2
223		$additionalPropertiesType = null;
224		$buildAdditionalPropertiesMethods = false;
225	11	if ($schema->additionalProperties instanceof Schema) {
226		$additionalPropertiesType = $this->getType($schema->additionalProperties);
227		$buildAdditionalPropertiesMethods = true;
228		} elseif ($this->buildAdditionalPropertyMethodsOnTrue && $schema->additionalProperties === true) {
229		$additionalPropertiesType = PhpStdType::mixed();
230		$buildAdditionalPropertiesMethods = true;
231		}
232
233		if ($buildAdditionalPropertiesMethods) {
234	7	$class->addMethod(new AdditionalPropertiesGetter($additionalPropertiesType));
235		$class->addMethod(new AdditionalPropertySetter($additionalPropertiesType));
236	7	}
237	7
238	7	if ($schema->patternProperties !== null) {
239		foreach ($schema->patternProperties as $pattern => $patternProperty) {
240	7	if ($patternProperty instanceof Schema) {
241	7	$const = new PhpConstant(PhpCode::makePhpConstantName($pattern . '_PROPERTY_PATTERN'), $pattern);
242	7	$class->addConstant($const);
243
244		$class->addMethod(new PatternPropertiesGetter($const, $this->getType($patternProperty)));
245		$class->addMethod(new PatternPropertySetter($const, $this->getType($patternProperty)));
246		}
247		}
248		}
249
250		$schemaBuilder = new SchemaBuilder($schema, '$ownerSchema', $path, $this, false);
251		if ($this->skipSchemaDescriptions) {
252		$schemaBuilder->skipProperty(JsonSchema::names()->description);
253		}
254		$schemaBuilder->setSkipProperties(true);
255		$body->addSnippet($schemaBuilder->build());
256
257		$setupProperties->setBody($body);
258
259		$phpDoc = $class->getPhpDoc();
260		$type = $this->getType($schema, $path);
261		if (!$type instanceof PhpClass) {
		0 ignored issues – show introduced 2019-08-21 16:36 UTC by Report Bug Copy Issue Report `$type` is never a sub-type of `Swaggest\PhpCodeBuilder\PhpClass`. Loading history...
262		$class->addMeta($type, self::IMPORT_TYPE);
263		$phpDoc->add(
264		PhpDoc::TAG_METHOD,
265		new PlaceholderString(
266		'static :type import($data, :context $options = null)',
267		array(
268		':type' => new TypeOf($type, true),
269		':context' => new TypeOf(PhpClass::byFQN(Context::class))
270		)
271		),
272		self::IMPORT_METHOD_PHPDOC_ID
273	7	);
274		}
275	7
276	7	if ($this->classPreparedHook !== null) {
277		$this->classPreparedHook->process($class, $path, $schema);
278		}
279	7
280		return $generatedClass;
281	7	}
282
283		/** @var DynamicIterator */
284	7	private $dynamicIterator;
285
286	7	/**
287	7	* @return GeneratedClass[]\|DynamicIterator
288	7	*/
289		public function getGeneratedClasses()
290	7	{
291	7	$result = array();
292	7	foreach ($this->generatedClasses as $schema) {
293	7	$result[] = $this->generatedClasses[$schema];
294		}
295		$iterator = new DynamicIterator($result);
296		$this->dynamicIterator = $iterator;
297		return $iterator;
298		}
299
300	7	/**
301		* @param AbstractTemplate $template
302	7	* @return null\|Schema
303		*/
304		public static function getSchemaMeta(AbstractTemplate $template)
305	7	{
306		return $template->getMeta(self::SCHEMA);
307	7	}
308	7
309		/**
310		* Returns true if null is allowed by schema.
311		*
312		* @param Schema $property
313		* @return bool
314		*/
315		private function schemaIsNullable($property)
316		{
317		if (!empty($property->enum) && !in_array(null, $property->enum)) {
318		return false;
319		}
320
321		if ($property->const !== null) {
322		return false;
323		}
324
325		if (!empty($property->anyOf)) {
326		$nullable = false;
327		foreach ($property->anyOf as $item) {
328		if ($item instanceof Schema) {
329		if ($this->schemaIsNullable($item)) {
330		$nullable = true;
331		break;
332		}
333		}
334		}
335		if (!$nullable) {
336		return false;
337		}
338		}
339
340		if (!empty($property->oneOf)) {
341		$nullable = false;
342		foreach ($property->oneOf as $item) {
343		if ($item instanceof Schema) {
344		if ($this->schemaIsNullable($item)) {
345		$nullable = true;
346		break;
347		}
348		}
349		}
350		if (!$nullable) {
351		return false;
352		}
353		}
354
355		if (!empty($property->allOf)) {
356		foreach ($property->allOf as $item) {
357		if ($item instanceof Schema) {
358		if (!$this->schemaIsNullable($item)) {
359		return false;
360		}
361		}
362		}
363		}
364
365		if (
366		$property->type === null
367		\|\| $property->type === Schema::NULL
368		\|\| (is_array($property->type) && in_array(Schema::NULL, $property->type))
369		) {
370		return true;
371		}
372
373		return false;
374		}
375		}
376
377
378		class DynamicIterator implements \Iterator, \ArrayAccess
379		{
380		private $rows;
381		private $current;
382		private $key;
383		private $valid;
384
385		public function push($item)
386		{
387		$this->rows[] = $item;
388		return $this;
389		}
390
391		/**
392		* DynamicIterator constructor.
393		* @param array $rows
394		*/
395		public function __construct($rows = array())
396		{
397		$this->rows = $rows;
398		}
399
400
401		#[\ReturnTypeWillChange]
402		public function current()
403		{
404		return $this->current;
405		}
406
407		#[\ReturnTypeWillChange]
408		public function next()
409		{
410		if (empty($this->rows)) {
411		$this->valid = false;
412		return;
413		}
414		$this->current = array_shift($this->rows);
415		$this->valid = true;
416		++$this->key;
417		}
418
419		#[\ReturnTypeWillChange]
420		public function key()
421		{
422		return $this->key;
423		}
424
425		#[\ReturnTypeWillChange]
426		public function valid()
427		{
428		return $this->valid;
429		}
430
431		#[\ReturnTypeWillChange]
432		public function rewind()
433		{
434		$this->next();
435		}
436
437		#[\ReturnTypeWillChange]
438		public function offsetExists($offset)
439		{
440		return array_key_exists($offset, $this->rows);
441		}
442
443		#[\ReturnTypeWillChange]
444		public function offsetGet($offset)
445		{
446		return $this->rows[$offset];
447		}
448
449		#[\ReturnTypeWillChange]
450		public function offsetSet($offset, $value)
451		{
452		$this->rows[$offset] = $value;
453		}
454
455		#[\ReturnTypeWillChange]
456		public function offsetUnset($offset)
457		{
458		unset($this->rows[$offset]);
459		}
460
461
462		}

swaggest / php-code-builder

PhpBuilder::makeClass() F last analyzed 2025-02-15 16:15 UTC

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like

PhpBuilder::makeClass() F
last analyzed 2025-02-15 16:15 UTC