SchemaBuilder::setSkipProperties() - Code Metrics - Inspection of "Add support for if/then/else, fixes #5" - swaggest/php-code-builder - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — master (#6)

by Viacheslav
created 2018-12-13 14:44 UTC
SchemaBuilder::setSkipProperties() A

↳ Parent: SchemaBuilder
Complexity

Conditions	1
Paths	1
Size

Total Lines	4
Code Lines	2
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	3
CRAP Score	1
Importance

Changes
Metric	Value
cc	1
eloc	2
nc	1
nop	1
dl	0
loc	4
ccs	3
cts	3
cp	1
crap	1
rs	10
c	0
b	0
f	0
<?php

namespace Swaggest\PhpCodeBuilder\JsonSchema;


use Swaggest\CodeBuilder\PlaceholderString;
use Swaggest\JsonSchema\Constraint\Type;
use Swaggest\JsonSchema\Schema;
use Swaggest\JsonSchema\Structure\ClassStructure;
use Swaggest\JsonSchema\Structure\ObjectItem;
use Swaggest\PhpCodeBuilder\PhpClass;
use Swaggest\PhpCodeBuilder\PhpCode;
use Swaggest\PhpCodeBuilder\PhpConstant;
use Swaggest\PhpCodeBuilder\Types\ReferenceTypeOf;
use Swaggest\PhpCodeBuilder\Types\TypeOf;

class SchemaBuilder
{
    /** @var Schema */
    private $schema;
    /** @var string */
    private $varName;
    /** @var bool */
    private $createVarName;

    /** @var PhpBuilder */
    private $phpBuilder;
    /** @var string */
    private $path;

    /** @var PhpCode */
    private $result;

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

    /** @var PhpClass */
    private $saveEnumConstInClass;

    /**
     * SchemaBuilder constructor.
     * @param Schema $schema
     * @param string $varName
     * @param string $path
     * @param PhpBuilder $phpBuilder
     * @param bool $createVarName
     */
    public function __construct($schema, $varName, $path, PhpBuilder $phpBuilder, $createVarName = true)
    {
        $this->schema = $schema;
        $this->varName = $varName;
        $this->phpBuilder = $phpBuilder;
        $this->path = $path;
        $this->createVarName = $createVarName;
    }

    private function processType()
    {
        if ($this->schema->type !== null) {
            switch ($this->schema->type) {
                case Type::INTEGER:
                    $result = $this->createVarName
                        ? "{$this->varName} = ::schema::integer();"
                        : "{$this->varName}->type = ::schema::INTEGER;";
                    break;

                case Type::NUMBER:
                    $result = $this->createVarName
                        ? "{$this->varName} = ::schema::number();"
                        : "{$this->varName}->type = ::schema::NUMBER;";
                    break;

                case Type::BOOLEAN:
                    $result = $this->createVarName
                        ? "{$this->varName} = ::schema::boolean();"
                        : "{$this->varName}->type = ::schema::BOOLEAN;";
                    break;

                case Type::STRING:
                    $result = $this->createVarName
                        ? "{$this->varName} = ::schema::string();"
                        : "{$this->varName}->type = ::schema::STRING;";
                    break;

                case Type::ARR:
                    $result = $this->createVarName
                        ? "{$this->varName} = ::schema::arr();"
                        : "{$this->varName}->type = ::schema::_ARRAY;";
                    break;

                case Type::OBJECT:
                    return;

                case Type::NULL:
                    $result = $this->createVarName
                        ? "{$this->varName} = ::schema::null();"
                        : "{$this->varName}->type = ::schema::NULL;";
                    break;

                default:
                    $types = PhpCode::varExport($this->schema->type);
                    $result = $this->createVarName
                        ? "{$this->varName} = (new ::schema())->setType($types);"
                        : "{$this->varName}->type = $types;";
            }
        } else {
            if ($this->createVarName) {
                $result = "{$this->varName} = new ::schema();";
            }
        }

        if (isset($result)) {
            $this->result->addSnippet(
                new PlaceholderString($result . "\n", array('::schema' => new ReferenceTypeOf(Palette::schemaClass())))
                new PlaceholderString($result . "\n", array('::schema' => /** @scrutinizer ignore-deprecated */ new ReferenceTypeOf(Palette::schemaClass())))
            );
        }
    }

    private function processNamedClass()
    {
        if (!$this->skipProperties
            //&& $this->schema->type === Type::OBJECT

            && $this->schema->properties !== null
        ) {
            $class = $this->phpBuilder->getClass($this->schema, $this->path);
            if ($this->schema->id === 'http://json-schema.org/draft-04/schema#') {
                $this->result->addSnippet(
                    new PlaceholderString("{$this->varName} = ::class::schema();\n",
                        array('::class' => new TypeOf(Palette::schemaClass())))
                );
            } else {
                $this->result->addSnippet(
                    new PlaceholderString("{$this->varName} = ::class::schema();\n",
                        array('::class' => new TypeOf($class)))
                );
            }
            return true;
        }
        return false;
    }

    private function processRef()
    {
        if (!$this->skipProperties
            //&& $this->schema->type === Type::OBJECT

            && !$this->phpBuilder->minimizeRefs
            && $this->schema->getFromRefs()
        ) {
            $class = $this->phpBuilder->getClass($this->schema, $this->path);
            if ($this->schema->id === 'http://json-schema.org/draft-04/schema#') {
                $this->result->addSnippet(
                    new PlaceholderString("{$this->varName} = ::class::schema();\n",
                        array('::class' => new TypeOf(Palette::schemaClass())))
                );
            } else {
                $this->result->addSnippet(
                    new PlaceholderString("{$this->varName} = ::class::schema();\n",
                        array('::class' => new TypeOf($class)))
                );
            }
            return true;
        }
        return false;
    }


    /**
     * @throws Exception
     */
    private function processObject()
    {
        if ($this->schema->type === Type::OBJECT) {
            if (!$this->skipProperties) {
                $this->result->addSnippet(
                    new PlaceholderString("{$this->varName} = ::schema::object();\n",
                        array('::schema' => new TypeOf(Palette::schemaClass())))
                );
            } else {
                $this->result->addSnippet(
                    "{$this->varName}->type = 'object';\n"
                );
            }

        }


        if ($this->schema->additionalProperties !== null) {
            if ($this->schema->additionalProperties instanceof Schema) {
                $this->result->addSnippet(
                    $this->copyTo(new SchemaBuilder(
                        $this->schema->additionalProperties,
                        "{$this->varName}->additionalProperties",
                        $this->path . '->additionalProperties',
                        $this->phpBuilder
                    ))->build()
                );
            } else {
                $val = $this->schema->additionalProperties ? 'true' : 'false';
                $this->result->addSnippet(
                    "{$this->varName}->additionalProperties = $val;\n"
                );
            }
        }

        if ($this->schema->patternProperties !== null) {
            foreach ($this->schema->patternProperties as $pattern => $property) {
                $patternExp = var_export($pattern, true);
                $this->result->addSnippet(
                    $this->copyTo(new SchemaBuilder(
                        $property,
                        "\$patternProperty",
                        $this->path . '->patternProperties->{{$pattern}}',
                        $this->phpBuilder
                    ))->build()
                );
                $this->result->addSnippet("{$this->varName}->setPatternProperty({$patternExp}, \$patternProperty);\n");

            }
        }
    }

    /**
     * @throws Exception
     */
    private function processArray()
    {
        $schema = $this->schema;

        if (is_bool($schema->additionalItems)) {
            $val = $schema->additionalItems ? 'true' : 'false';
            $this->result->addSnippet(
                "{$this->varName}->additionalItems = $val;\n"
            );
        }

        $pathItems = 'items';
        if ($schema->items instanceof ClassStructure) { // todo better check for schema, `getJsonSchema` interface ?
            $items = array();
            $additionalItems = $schema->items;
            $pathItems = 'items';
        } elseif ($schema->items === null) { // items defaults to empty schema so everything is valid
            $items = array();
            $additionalItems = true;
        } else { // listed items
            $items = $schema->items;
            $additionalItems = $schema->additionalItems;
            $pathItems = 'additionalItems';
        }

        if ($items !== null || $additionalItems !== null) {

            if ($additionalItems instanceof ClassStructure) {
                $this->result->addSnippet(
                    $this->copyTo(new SchemaBuilder(
                        $additionalItems,
                        "{$this->varName}->{$pathItems}",
                        $this->path . '->' . $pathItems,
                        $this->phpBuilder
                    ))->build()
                );
            }
        }
    }

    private function processEnum()
    {
        if (!empty($this->schema->enum)) {
            $this->result->addSnippet(
                "{$this->varName}->enum = array(\n"
            );
            foreach ($this->schema->enum as $i => $enumItem) {
                if (isset($this->schema->{Schema::ENUM_NAMES_PROPERTY}[$i])) {
                    $name = PhpCode::makePhpConstantName($this->schema->{Schema::ENUM_NAMES_PROPERTY}[$i]);
                } else {
                    $name = PhpCode::makePhpConstantName($enumItem);
                }
                $value = var_export($enumItem, true);
                if ($this->saveEnumConstInClass !== null && is_scalar($enumItem) && !is_bool($enumItem)) {
                    $this->saveEnumConstInClass->addConstant(new PhpConstant($name, $enumItem));
                    $this->result->addSnippet(
                        "    self::$name,\n"
                    );
                } else {
                    $this->result->addSnippet(
                        "    $value,\n"
                    );
                }

            }
            $this->result->addSnippet(
                ");\n"
            );

        }
    }

    private $skip = [];

    public function skipProperty($name)
    {
        $this->skip[$name] = 1;
        return $this;
    }

    private function copyTo(SchemaBuilder $schemaBuilder)
    {
        $schemaBuilder->skip = $this->skip;
        $schemaBuilder->saveEnumConstInClass = $this->saveEnumConstInClass;
        return $schemaBuilder;
    }

    private function processOther()
    {
        static $skip = null;
        if ($skip === null) {
            $names = Schema::names();
            $skip = array(
                (string)$names->type => 1,
                '$ref' => 1,
                (string)$names->items => 1,
                (string)$names->additionalItems => 1,
                (string)$names->properties => 1,
                (string)$names->additionalProperties => 1,
                (string)$names->patternProperties => 1,
                (string)$names->allOf => 1, // @todo process
                (string)$names->anyOf => 1,
                (string)$names->oneOf => 1,
                (string)$names->not => 1,
                (string)$names->definitions => 1,
                (string)$names->enum => 1,
                (string)$names->if => 1,
                (string)$names->then => 1,
                (string)$names->else => 1,
                (string)$names->fromRef => 1,
                (string)$names->originPath => 1,
            );
        }
        $schemaData = Schema::export($this->schema);
        foreach ((array)$schemaData as $key => $value) {
            if (isset($skip[$key])) {
                continue;
            }
            if (isset($this->skip[$key])) {
                continue;
            }

            //$this->result->addSnippet('/* ' . print_r($value, 1) . '*/' . "\n");

            //echo "{$this->varName}->{$key}\n";
            if ($value instanceof ObjectItem) {
                //$value = $value->jsonSerialize();

                $export = 'new \stdClass()';
            } elseif ($value instanceof \stdClass) {
                $export = '(object)' . PhpCode::varExport((array)$value);
            } elseif (is_string($value)) {
                $export = '"' . str_replace(array('\\', "\n", "\r", "\t", '"'), array('\\\\', '\n', '\r', '\t', '\"'), $value) . '"';
            } else {
                $export = PhpCode::varExport($value);
            }

            $key = PhpCode::makePhpName($key);
            $this->result->addSnippet(
                "{$this->varName}->{$key} = " . $export . ";\n"
            );
        }
    }

    private function processLogic()
    {
        $names = Schema::names();
        foreach (array($names->not, $names->if, $names->then, $names->else) as $keyword) {
            if ($this->schema->$keyword !== null) {
                $this->result->addSnippet(
                    $this->copyTo(new SchemaBuilder(
                        $this->schema->$keyword,
                        "{$this->varName}->{$keyword}",
                        $this->path . '->' . $keyword,
                        $this->path . '->' . /** @scrutinizer ignore-type */ $keyword,
                        $this->phpBuilder
                    ))->build()
                );
            }

        }

        foreach (array($names->anyOf, $names->oneOf, $names->allOf) as $keyword) {
            if ($this->schema->$keyword !== null) {
                foreach ($this->schema->$keyword as $index => $schema) {
                    $this->result->addSnippet(
                        $this->copyTo(new SchemaBuilder(
                            $schema,
                            "{$this->varName}->{$keyword}[{$index}]",
                            $this->path . "->{$keyword}[{$index}]",
                            $this->phpBuilder
                        ))->build()
                    );
                }
            }
        }
    }

    /**
     * @return PhpCode
     * @throws Exception
     */
    public function build()
    {
        $this->result = new PhpCode();

        if ($this->processNamedClass()) {
            return $this->result;
        }

        if ($this->processRef()) {
            return $this->result;
        }

        $this->processType();
        $this->processObject();
        $this->processArray();
        $this->processLogic();
        $this->processEnum();
        $this->processOther();
        $this->processFromRef();

        return $this->result;

    }

    private function processFromRef()
    {
        if ($this->phpBuilder->minimizeRefs) {
            if ($fromRefs = $this->schema->getFromRefs()) {
                $fromRef = $fromRefs[count($fromRefs) - 1];
                $fromRef = $fromRefs[count(/** @scrutinizer ignore-type */ $fromRefs) - 1];
                $value = var_export($fromRef, 1);
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
$object = $a->getObject();
                $this->result->addSnippet("{$this->varName}->setFromRef($value);\n");
            }
            return;
        }
        if ($fromRefs = $this->schema->getFromRefs()) {
            foreach ($fromRefs as $fromRef) {

                $value = var_export($fromRef, 1);
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
$object = $a->getObject();
                $this->result->addSnippet("{$this->varName}->setFromRef($value);\n");
            }
        }
    }

    /**
     * @param boolean $skipProperties
     * @return $this
     */
    public function setSkipProperties($skipProperties)
    {
        $this->skipProperties = $skipProperties;
        return $this;
    }

    /**
     * @param PhpClass $saveEnumConstInClass
     * @return $this
     */
    public function setSaveEnumConstInClass($saveEnumConstInClass)
    {
        $this->saveEnumConstInClass = $saveEnumConstInClass;
        return $this;
    }


}
swaggest / php-code-builder

Pull Request — master (#6)

SchemaBuilder::setSkipProperties() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
