Base::loadSchema() - Code Metrics - Inspection of "Add schema resolver (#37)" - swaggest/json-cli - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( 7add85...9336e3 )

by Viacheslav
created 2022-09-18 22:21 UTC
Base::loadSchema() B

↳ Parent: Base
Complexity

Conditions	10
Paths	12
Size

Total Lines	53
Code Lines	31
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	0
CRAP Score	110
Importance

Changes
Metric	Value
cc	10
eloc	31
nc	12
nop	2
dl	0
loc	53
ccs	0
cts	0
cp	0
crap	110
rs	7.6666
c	0
b	0
f	0
How to fix Long Method Complexity

<?php

namespace Swaggest\JsonCli;

use Swaggest\JsonCli\Json\LoadFile;
use Swaggest\JsonCli\JsonSchema\ResolverMux;
use Swaggest\JsonDiff\Exception;
use Swaggest\JsonSchema\Context;
use Swaggest\JsonSchema\RemoteRef\BasicFetcher;
use Swaggest\JsonSchema\RemoteRef\Preloaded;
use Swaggest\JsonSchema\Schema;
use Swaggest\PhpCodeBuilder\Markdown\TypeBuilder;
use Symfony\Component\Yaml\Yaml;
use Yaoi\Command;
use Yaoi\Io\Response;

abstract class Base extends Command
{
    use LoadFile;

    public $pretty;
    public $toYaml;
    public $toSerialized;
    public $output;
    public $schemaResolver;

    /**
     * @param Command\Definition $definition
     * @param \stdClass|static $options
     */
    static function setUpDefinition(Command\Definition $definition, $options)
    {
        $options->pretty = Command\Option::create()
            ->setDescription('Pretty-print result JSON');
        $options->output = Command\Option::create()->setType()
            ->setDescription('Path to output result, default STDOUT');
        $options->schemaResolver = Command\Option::create()->setType()
            ->setDescription('Path to schema resolver JSON file. Schema:');
        $tb = new TypeBuilder();
        $tb->getTypeString(SchemaResolver::schema()->exportSchema());
        $options->schemaResolver->description .= "\n" . trim(substr($tb->file, 77)); // Stripping header.


        $options->toYaml = Command\Option::create()->setDescription('Output in YAML format');
        $options->toSerialized = Command\Option::create()->setDescription('Output in PHP serialized format');
    }


    protected $out;

    /**
     * @param string $path
     * @return mixed
     * @throws ExitCode
     */
    protected function readData($path)
    {
        return self::readJsonOrYaml($path, $this->response);
    }

    /**
     * @param string $path
     * @param Response $response
     * @return mixed
     * @throws ExitCode
     */
    public static function readJsonOrYaml($path, $response)
    {
        $fileData = file_get_contents($path);
        if (!$fileData) {
            $response->error('Unable to read ' . $path);
            throw new ExitCode('', 1);
        }
        if (substr($path, -5) === '.yaml' || substr($path, -4) === '.yml') {
            $jsonData = Yaml::parse($fileData, Yaml::PARSE_OBJECT + Yaml::PARSE_OBJECT_FOR_MAP);
        } elseif (substr($path, -11) === '.serialized') {
            $jsonData = unserialize($fileData);
        } else {
            $jsonData = json_decode($fileData);
        }

        return $jsonData;
    }


    protected function postPerform()
    {
        $options = JSON_UNESCAPED_SLASHES + JSON_UNESCAPED_UNICODE;
        if ($this->pretty) {
            $options += JSON_PRETTY_PRINT;
        }

        if ($this->toYaml) {
            $result = Yaml::dump($this->out, 2, 2, Yaml::DUMP_OBJECT_AS_MAP);
        } elseif ($this->toSerialized) {
            $result = serialize($this->out);
        } else {
            $result = json_encode($this->out, $options);
        }

        if ($this->output) {
            file_put_contents($this->output, $result);
        } else {
            echo $result, "\n";
        }
    }


    /** @var string */
    public $schema;
    /** @var string[] */
    public $defPtr = ['#/definitions'];
    /** @var string[] */
    public $ptrInSchema;

    /**
     * @param Command\Definition $definition
     * @param static|mixed $options
     */
    protected static function setupGenOptions(Command\Definition $definition, $options)
    protected static function setupGenOptions(/** @scrutinizer ignore-unused */ Command\Definition $definition, $options)
    {
        $options->schema = Command\Option::create()

            ->setDescription('Path to JSON schema file, use `-` for STDIN')->setIsUnnamed()->setIsRequired();

        $options->ptrInSchema = Command\Option::create()->setType()->setIsVariadic()

            ->setDescription('JSON pointers to structure in root schema, default #');

        $options->defPtr = Command\Option::create()->setType()->setIsVariadic()

            ->setDescription('Definitions pointers to strip from symbol names, default #/definitions');

        $options->schemaResolver = Command\Option::create()->setType()
            ->setDescription('Path to schema resolver JSON file. Schema:');
        $tb = new TypeBuilder();
        $tb->getTypeString(SchemaResolver::schema()->exportSchema());
        $options->schemaResolver->description .= "\n" . trim(substr($tb->file, 77)); // Stripping header.

        static::setupLoadFileOptions($options);
    }

    /**
     * @param bool $skipRoot
     * @param string $baseName
     * @return \Swaggest\JsonSchema\SchemaContract
     * @throws Exception
     * @throws ExitCode
     * @throws \Swaggest\JsonSchema\Exception
     * @throws \Swaggest\JsonSchema\InvalidValue
     */
    protected function loadSchema(&$skipRoot, &$baseName)
    {
        if ($this->schema === '-') {
            $this->schema = 'php://stdin';
        }

        $resolver = new ResolverMux();
        $preloaded = new Preloaded();

        if ($this->schemaResolver !== null) {
            $data = file_get_contents($this->schemaResolver);
            if (empty($data)) {
                throw new ExitCode("empty or missing schema resolver file", 1);
            }
            $json = json_decode($data);
            if (empty($json)) {
                throw new ExitCode("invalid json in schema resolver file", 1);
            }

            $schemaResolver = SchemaResolver::import($json);

            foreach ($schemaResolver->schemaData as $url => $data) {
                $preloaded->setSchemaData($url, $data);
            }

            foreach ($schemaResolver->schemaFiles as $url => $file) {
                $preloaded->setSchemaFile($url, $file);
            }
        }

        $resolver->resolvers[] = $preloaded;

        $dataValue = $this->loadFile();
        $data = $dataValue;

        if (!empty($this->ptrInSchema)) {
            $baseName = basename($this->schema);
            $skipRoot = true;
            $preloaded->setSchemaData($baseName, $dataValue);
            $data = new \stdClass();

            foreach ($this->defPtr as $defPtr) {
                $this->defPtr[] = $baseName . $defPtr;
            }
            $this->defPtr[] = $baseName;

            foreach ($this->ptrInSchema as $i => $ptr) {
                $data->oneOf[$i] = (object)[Schema::PROP_REF => $baseName . $ptr];
            }
        }

        $resolver->resolvers[] = new BasicFetcher();
        return Schema::import($data, new Context($resolver));
    }
}
swaggest / json-cli

Push — master ( 7add85...9336e3 )

Base::loadSchema() B

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like
