Swaggest\JsonCli\BuildSchema::performAction()

Complexity

Conditions	20
Paths	164

Size

Total Lines	106
Code Lines	71

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

<?php
    public function performAction()
    {
        $schema = new Schema();

        if ($this->schema) {
            $schemaDataOrig = $this->readData($this->schema);
            $schemaData = $schemaDataOrig;

            $resolver = new ResolverMux();

            if (!empty($this->ptrInSchema)) {
                $baseName = basename($this->schema);
                $preloaded = new Preloaded();
                $preloaded->setSchemaData($baseName, $schemaData);
                $resolver->resolvers[] = $preloaded;
                $schemaData = (object)[Schema::PROP_REF => $baseName . $this->ptrInSchema];
            }

            $resolver->resolvers[] = new BasicFetcher();

            try {
                $schemaContract = Schema::import($schemaData, new Context($resolver));
                if ($schemaContract instanceof Schema) {
                    $schema = $schemaContract;
                }
            } catch (InvalidValue $e) {
                $this->response->error('Invalid schema');
                $this->response->addContent($e->getMessage());
                throw new ExitCode('', 1);
            } catch (\Exception $e) {
                $this->response->error('Failed to import schema:' . $e->getMessage());
                throw new ExitCode('', 1);
            }
        }

        $maker = new SchemaMaker($schema);
        $maker->options->useXNullable = $this->useXNullable;
        $maker->options->useNullable = $this->useNullable;
        $maker->options->defsPtr = $this->defsPtr;
        $maker->options->collectExamples = $this->collectExamples;
        $maker->options->heuristicRequired = $this->heuristicRequired;

        if ($this->jsonl) {
            $pathInData = [];
            if ($this->ptrInData) {
                $pathInData = JsonPointer::splitPath($this->ptrInData);
            }

            $handle = fopen($this->data, "r");
            if ($handle) {

$handle is of type resource, thus it always evaluated to false.

                while (($buffer = fgets($handle)) !== false) {
                    $item = json_decode($buffer);
                    // Tolerate and skip malformed JSON line.
                    if (null === $item) {
                        continue;
                    }
                    if ($this->ptrInData) {
                        $item = JsonPointer::get($item, $pathInData);
                    }
                    $maker->addInstanceValue($item);
                }
                if (!feof($handle)) {
                    echo "Error: unexpected fgets() fail\n";
                }
                fclose($handle);
            }
        } else {
            $data = $this->readData($this->data);
            $maker->addInstanceValue($data);

            if (!empty($this->additionalData)) {
                foreach ($this->additionalData as $path) {
                    $data = $this->readData($path);
                    $maker->addInstanceValue($data);
                }
            }
        }


        $s = Schema::export($schema);
        $this->out = $s;

        if ($this->ptrInSchema && isset($schemaDataOrig)) {
            $tmp = json_encode($schemaDataOrig);
            if ($tmp === false) {
                throw new ExitCode('Failed to encode JSON', 1);
            }
            $schemaDataResult = json_decode($tmp);

            $defs = JsonPointer::get($s, JsonPointer::splitPath(rtrim($this->defsPtr, '/')));
            foreach ($defs as $name => $def) {
                JsonPointer::add($schemaDataResult, JsonPointer::splitPath($this->defsPtr . $name), $def);
            }
            JsonPointer::remove($s, JsonPointer::splitPath(rtrim($this->defsPtr, '/')));
            JsonPointer::add($schemaDataResult, JsonPointer::splitPath($this->ptrInSchema), $s);

            $tmp = json_encode($schemaDataResult);
            if ($tmp === false) {
                throw new ExitCode('Failed to encode JSON', 1);
            }
            $schemaDataResult = json_decode($tmp);
            $diff = new JsonDiff($schemaDataOrig, $schemaDataResult, JsonDiff::REARRANGE_ARRAYS);
            $this->out = $diff->getRearranged();
        }

        $this->postPerform();
    }
}