Schema::in() - Code Metrics - Inspection of "applying default values, refactoring schema proces..." - swaggest/php-json-schema - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Pull Request — master (#19)

by Viacheslav
created 2018-02-14 10:32 UTC
Schema::in() C

↳ Parent: Schema
Complexity

Conditions	8
Paths	49
Size

Total Lines	32
Code Lines	18
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	17
CRAP Score	8
Importance

Changes
Metric	Value
dl	0
loc	32
ccs	17
cts	17
cp	1
rs	5.3846
c	0
b	0
f	0
cc	8
eloc	18
nc	49
nop	2
crap	8
<?php

namespace Swaggest\JsonSchema;


use PhpLang\ScopeExit;
use Swaggest\JsonDiff\JsonDiff;
use Swaggest\JsonSchema\Constraint\Content;
use Swaggest\JsonSchema\Constraint\Format;
use Swaggest\JsonSchema\Constraint\Properties;
use Swaggest\JsonSchema\Constraint\Type;
use Swaggest\JsonSchema\Constraint\UniqueItems;
use Swaggest\JsonSchema\Exception\ArrayException;
use Swaggest\JsonSchema\Exception\ConstException;
use Swaggest\JsonSchema\Exception\EnumException;
use Swaggest\JsonSchema\Exception\LogicException;
use Swaggest\JsonSchema\Exception\NumericException;
use Swaggest\JsonSchema\Exception\ObjectException;
use Swaggest\JsonSchema\Exception\StringException;
use Swaggest\JsonSchema\Exception\TypeException;
use Swaggest\JsonSchema\Meta\Meta;
use Swaggest\JsonSchema\Meta\MetaHolder;
use Swaggest\JsonSchema\Structure\ClassStructure;
use Swaggest\JsonSchema\Structure\Egg;
use Swaggest\JsonSchema\Structure\ObjectItem;
use Swaggest\JsonSchema\Structure\ObjectItemContract;

/**
 * Class Schema
 * @package Swaggest\JsonSchema
 */
class Schema extends JsonSchema implements MetaHolder
{
    const CONST_PROPERTY = 'const';

    const DEFAULT_MAPPING = 'default';

    const VERSION_AUTO = 'a';
    const VERSION_DRAFT_04 = 4;
    const VERSION_DRAFT_06 = 6;
    const VERSION_DRAFT_07 = 7;

    const REF = '$ref';
    const ID = '$id';
    const ID_D4 = 'id';

    // Object
    /** @var Properties|Schema[]|Schema */
    public $properties;
    /** @var Schema|bool */
    public $additionalProperties;
    /** @var Schema[] */
    public $patternProperties;
    /** @var string[][]|Schema[]|\stdClass */
    public $dependencies;

    // Array
    /** @var null|Schema|Schema[] */
    public $items;
    /** @var null|Schema|bool */
    public $additionalItems;

    /** @var Schema[] */
    public $allOf;
    /** @var Schema */
    public $not;
    /** @var Schema[] */
    public $anyOf;
    /** @var Schema[] */
    public $oneOf;

    /** @var Schema */
    public $if;
    /** @var Schema */
    public $then;
    /** @var Schema */
    public $else;


    public $objectItemClass;
    private $useObjectAsArray = false;

    private $__dataToProperty = array();
    private $__propertyToData = array();

    private $__booleanSchema;

    public function addPropertyMapping($dataName, $propertyName, $mapping = self::DEFAULT_MAPPING)
    {
        $this->__dataToProperty[$mapping][$dataName] = $propertyName;
        $this->__propertyToData[$mapping][$propertyName] = $dataName;
        return $this;
    }

    /**
     * @param mixed $data
     * @param Context|null $options
     * @return static|JsonSchema
     * @throws Exception
     * @throws InvalidValue
     * @throws \Exception
     */
    public static function import($data, Context $options = null)
    {
        if (null === $options) {
            $options = new Context();
        }

        //$options->applyDefaults = false; // todo check infinite recursion on items, additionalProperties, etc...


        if (isset($options->schemasCache) && is_object($data)) {
            if ($options->schemasCache->contains($data)) {
                return $options->schemasCache->offsetGet($data);
            } else {
                $schema = parent::import($data, $options);
                $options->schemasCache->attach($data, $schema);
                return $schema;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
            }
        }

        // string $data is expected to be $ref uri
        if (is_string($data)) {
            $data = (object)array(self::REF => $data);
        }

        $data = self::unboolSchema($data);
        if ($data instanceof Schema) {
            return $data;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
        }

        return parent::import($data, $options);
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
    }

    /**
     * @param mixed $data
     * @param Context|null $options
     * @return array|mixed|null|object|\stdClass
     * @throws Exception
     * @throws InvalidValue
     * @throws \Exception
     */
    public function in($data, Context $options = null)
    {
        if (null !== $this->__booleanSchema) {
            if ($this->__booleanSchema) {
                return $data;
            } elseif (empty($options->skipValidation)) {
                $this->fail(new InvalidValue('Denied by false schema'), '#');
            }
        }

        if ($options === null) {
            $options = new Context();
        }

        $options->import = true;

        if ($options->refResolver === null) {
            $options->refResolver = new RefResolver($data);
        } else {
            $options->refResolver->setRootData($data);
        }

        if ($options->remoteRefProvider) {
            $options->refResolver->setRemoteRefProvider($options->remoteRefProvider);
        }

        if ($options->import) {
            $options->refResolver->preProcessReferences($data, $options);
        }

        return $this->process($data, $options, '#');
    }


    /**
     * @param mixed $data
     * @param Context|null $options
     * @return array|mixed|null|object|\stdClass
     * @throws InvalidValue
     * @throws \Exception
     */
    public function out($data, Context $options = null)
    {
        if ($options === null) {
            $options = new Context();
        }

        $options->circularReferences = new \SplObjectStorage();
        $options->import = false;
        return $this->process($data, $options);
    }

    /**
     * @param mixed $data
     * @param Context $options
     * @param string $path
     * @throws InvalidValue
     * @throws \Exception
     */
    private function processType($data, Context $options, $path = '#')
    {
        if ($options->tolerateStrings && is_string($data)) {
            $valid = Type::readString($this->type, $data);
        } else {
            $valid = Type::isValid($this->type, $data, $options->version);
        }
        if (!$valid) {
            $this->fail(new TypeException(ucfirst(
                    implode(', ', is_array($this->type) ? $this->type : array($this->type))
                    . ' expected, ' . json_encode($data) . ' received')
            ), $path);
        }
    }

    /**
     * @param mixed $data
     * @param string $path
     * @throws InvalidValue
     * @throws \Exception
     */
    private function processEnum($data, $path = '#')
    {
        $enumOk = false;
        foreach ($this->enum as $item) {
            if ($item === $data) { // todo support complex structures here
                $enumOk = true;
                break;
            }
        }
        if (!$enumOk) {
            $this->fail(new EnumException('Enum failed'), $path);
        }
    }

    /**
     * @param mixed $data
     * @param string $path
     * @throws InvalidValue
     * @throws \Swaggest\JsonDiff\Exception
     */
    private function processConst($data, $path)
    {
        if ($this->const !== $data) {
            if ((is_object($this->const) && is_object($data))
                || (is_array($this->const) && is_array($data))) {
                $diff = new JsonDiff($this->const, $data,
                    JsonDiff::STOP_ON_DIFF);
                if ($diff->getDiffCnt() != 0) {
                    $this->fail(new ConstException('Const failed'), $path);
                }
            } else {
                $this->fail(new ConstException('Const failed'), $path);
            }
        }
    }

    /**
     * @param mixed $data
     * @param Context $options
     * @param string $path
     * @throws InvalidValue
     * @throws \Exception
     * @throws \Swaggest\JsonDiff\Exception
     */
    private function processNot($data, Context $options, $path)
    {
        $exception = false;
        try {
            self::unboolSchema($this->not)->process($data, $options, $path . '->not');
        } catch (InvalidValue $exception) {
            // Expected exception
        }
        if ($exception === false) {
            $this->fail(new LogicException('Failed due to logical constraint: not'), $path);
        }
    }

    /**
     * @param string $data
     * @param string $path
     * @throws InvalidValue
     */
    private function processString($data, $path)
    {
        if ($this->minLength !== null) {
            if (mb_strlen($data, 'UTF-8') < $this->minLength) {
                $this->fail(new StringException('String is too short', StringException::TOO_SHORT), $path);
            }
        }
        if ($this->maxLength !== null) {
            if (mb_strlen($data, 'UTF-8') > $this->maxLength) {
                $this->fail(new StringException('String is too long', StringException::TOO_LONG), $path);
            }
        }
        if ($this->pattern !== null) {
            if (0 === preg_match(Helper::toPregPattern($this->pattern), $data)) {
                $this->fail(new StringException(json_encode($data) . ' does not match to '
                    . $this->pattern, StringException::PATTERN_MISMATCH), $path);
            }
        }
        if ($this->format !== null) {
            $validationError = Format::validationError($this->format, $data);
            if ($validationError !== null) {
                if ($this->format === "uri" && substr($path, -3) === ':id') {
if (rand(1, 6) > 3) {
//print "Check failed";
} else {
    print "Check succeeded";
}
                } else {
                    $this->fail(new StringException($validationError), $path);
                }
            }
        }
    }

    /**
     * @param float|int $data
     * @param string $path
     * @throws InvalidValue
     */
    private function processNumeric($data, $path)
    {
        if ($this->multipleOf !== null) {
            $div = $data / $this->multipleOf;
            if ($div != (int)$div) {
                $this->fail(new NumericException($data . ' is not multiple of ' . $this->multipleOf, NumericException::MULTIPLE_OF), $path);
            }
        }

        if ($this->exclusiveMaximum !== null && !is_bool($this->exclusiveMaximum)) {
            if ($data >= $this->exclusiveMaximum) {
                $this->fail(new NumericException(
                    'Value less or equal than ' . $this->exclusiveMaximum . ' expected, ' . $data . ' received',
                    NumericException::MAXIMUM), $path);
            }
        }

        if ($this->exclusiveMinimum !== null && !is_bool($this->exclusiveMinimum)) {
            if ($data <= $this->exclusiveMinimum) {
                $this->fail(new NumericException(
                    'Value more or equal than ' . $this->exclusiveMinimum . ' expected, ' . $data . ' received',
                    NumericException::MINIMUM), $path);
            }
        }

        if ($this->maximum !== null) {
            if ($this->exclusiveMaximum === true) {
                if ($data >= $this->maximum) {
                    $this->fail(new NumericException(
                        'Value less or equal than ' . $this->maximum . ' expected, ' . $data . ' received',
                        NumericException::MAXIMUM), $path);
                }
            } else {
                if ($data > $this->maximum) {
                    $this->fail(new NumericException(
                        'Value less than ' . $this->minimum . ' expected, ' . $data . ' received',
                        NumericException::MAXIMUM), $path);
                }
            }
        }

        if ($this->minimum !== null) {
            if ($this->exclusiveMinimum === true) {
                if ($data <= $this->minimum) {
                    $this->fail(new NumericException(
                        'Value more or equal than ' . $this->minimum . ' expected, ' . $data . ' received',
                        NumericException::MINIMUM), $path);
                }
            } else {
                if ($data < $this->minimum) {
                    $this->fail(new NumericException(
                        'Value more than ' . $this->minimum . ' expected, ' . $data . ' received',
                        NumericException::MINIMUM), $path);
                }
            }
        }
    }

    /**
     * @param mixed $data
     * @param Context $options
     * @param string $path
     * @return array|mixed|null|object|\stdClass
     * @throws InvalidValue
     * @throws \Exception
     * @throws \Swaggest\JsonDiff\Exception
     */
    private function processOneOf($data, Context $options, $path)
    {
        $successes = 0;
        $failures = '';
        $skipValidation = false;
        if ($options->skipValidation) {
            $skipValidation = true;
            $options->skipValidation = false;
        }

        $result = $data;
        foreach ($this->oneOf as $index => $item) {
            try {
                $result = self::unboolSchema($item)->process($data, $options, $path . '->oneOf:' . $index);
                $successes++;
                if ($successes > 1 || $options->skipValidation) {
                    break;
                }
            } catch (InvalidValue $exception) {
                $failures .= ' ' . $index . ': ' . Helper::padLines(' ', $exception->getMessage()) . "\n";
                // Expected exception
            }
        }
        if ($skipValidation) {
            $options->skipValidation = true;
            if ($successes === 0) {
                $result = self::unboolSchema($this->oneOf[0])->process($data, $options, $path . '->oneOf:' . 0);
            }
        }

        if (!$options->skipValidation) {
            if ($successes === 0) {
                $this->fail(new LogicException('Failed due to logical constraint: no valid results for oneOf {' . "\n" . substr($failures, 0, -1) . "\n}"), $path);
            } elseif ($successes > 1) {
                $this->fail(new LogicException('Failed due to logical constraint: '
                    . $successes . '/' . count($this->oneOf) . ' valid results for oneOf'), $path);
            }
        }
        return $result;
    }

    /**
     * @param mixed $data
     * @param Context $options
     * @param string $path
     * @return array|mixed|null|object|\stdClass
     * @throws InvalidValue
     * @throws \Exception
     * @throws \Swaggest\JsonDiff\Exception
     */
    private function processAnyOf($data, Context $options, $path)
    {
        $successes = 0;
        $failures = '';
        $result = $data;
        foreach ($this->anyOf as $index => $item) {
            try {
                $result = self::unboolSchema($item)->process($data, $options, $path . '->anyOf:' . $index);
                $successes++;
                if ($successes) {
                    break;
                }
            } catch (InvalidValue $exception) {
                $failures .= ' ' . $index . ': ' . $exception->getMessage() . "\n";
                // Expected exception
            }
        }
        if (!$successes && !$options->skipValidation) {
            $this->fail(new LogicException('Failed due to logical constraint: no valid results for anyOf {' . "\n" . substr(Helper::padLines(' ', $failures), 0, -1) . "\n}"), $path);
        }
        return $result;
    }

    /**
     * @param mixed $data
     * @param Context $options
     * @param string $path
     * @return array|mixed|null|object|\stdClass
     * @throws InvalidValue
     * @throws \Exception
     * @throws \Swaggest\JsonDiff\Exception
     */
    private function processAllOf($data, Context $options, $path)
    {
        $result = $data;
        foreach ($this->allOf as $index => $item) {
            $result = self::unboolSchema($item)->process($data, $options, $path . '->allOf' . $index);
        }
        return $result;
    }

    /**
     * @param mixed $data
     * @param Context $options
     * @param string $path
     * @return array|mixed|null|object|\stdClass
     * @throws InvalidValue
     * @throws \Exception
     * @throws \Swaggest\JsonDiff\Exception
     */
    private function processIf($data, Context $options, $path)
    {
        $valid = true;
        try {
            self::unboolSchema($this->if)->process($data, $options, $path . '->if');
        } catch (InvalidValue $exception) {
            $valid = false;
        }
        if ($valid) {
            if ($this->then !== null) {
                return self::unboolSchema($this->then)->process($data, $options, $path . '->then');
            }
        } else {
            if ($this->else !== null) {
                return self::unboolSchema($this->else)->process($data, $options, $path . '->else');
            }
        }
        return null;
    }

    /**
     * @param \stdClass $data
     * @param Context $options
     * @param string $path
     * @throws InvalidValue
     */
    private function processObjectRequired($data, Context $options, $path)
    {
        if (isset($this->__dataToProperty[$options->mapping])) {
            if ($options->import) {
                foreach ($this->required as $item) {
                    if (isset($this->__propertyToData[$options->mapping][$item])) {
                        $item = $this->__propertyToData[$options->mapping][$item];
                    }
                    if (!property_exists($data, $item)) {
                        $this->fail(new ObjectException('Required property missing: ' . $item, ObjectException::REQUIRED), $path);
                    }
                }
            } else {
                foreach ($this->required as $item) {
                    if (isset($this->__dataToProperty[$options->mapping][$item])) {
                        $item = $this->__dataToProperty[$options->mapping][$item];
                    }
                    if (!property_exists($data, $item)) {
                        $this->fail(new ObjectException('Required property missing: ' . $item, ObjectException::REQUIRED), $path);
                    }
                }
            }

        } else {
            foreach ($this->required as $item) {
                if (!property_exists($data, $item)) {
                    $this->fail(new ObjectException('Required property missing: ' . $item, ObjectException::REQUIRED), $path);
                }
            }
        }
    }

    /**
     * @param \stdClass $data
     * @param Context $options
     * @param string $path
     * @param ObjectItemContract|null $result
     * @return array|null|ClassStructure|ObjectItemContract
     * @throws InvalidValue
     * @throws \Exception
     * @throws \Swaggest\JsonDiff\Exception
     */
    private function processObject($data, Context $options, $path, $result = null)
    {
        $import = $options->import;

        if (!$options->skipValidation && $this->required !== null) {
            $this->processObjectRequired($data, $options, $path);
        }

        if ($import) {
            if (!$options->validateOnly) {

                if ($this->useObjectAsArray) {
                    $result = array();
                } elseif (!$result instanceof ObjectItemContract) {
                    //$result = $this->makeObjectItem($options);

                    //* todo check performance impact
                    if (null === $this->objectItemClass) {
                        $result = new ObjectItem();
                    } else {
                        $className = $this->objectItemClass;
                        if ($options->objectItemClassMapping !== null) {
                            if (isset($options->objectItemClassMapping[$className])) {
                                $className = $options->objectItemClassMapping[$className];
                            }
                        }
                        $result = new $className;
                    }
                    //*/


                    if ($result instanceof ClassStructure) {
                        if ($result->__validateOnSet) {
                            $result->__validateOnSet = false;
                            /** @noinspection PhpUnusedLocalVariableInspection */
                            /* todo check performance impact

                            $validateOnSetHandler = new ScopeExit(function () use ($result) {
                                $result->__validateOnSet = true;
                            });
                            //*/
                        }
                    }

                    //* todo check performance impact
                    if ($result instanceof ObjectItemContract) {
                        $result->setDocumentPath($path);
                    }
                    //*/
                }
            }
        }

        // @todo better check for schema id

        if ($import
            && isset($data->{Schema::ID_D4})
            && ($options->version === Schema::VERSION_DRAFT_04 || $options->version === Schema::VERSION_AUTO)
            && is_string($data->{Schema::ID_D4}) /*&& (!isset($this->properties['id']))/* && $this->isMetaSchema($data)*/) {

            $id = $data->{Schema::ID_D4};
            $refResolver = $options->refResolver;
            $parentScope = $refResolver->updateResolutionScope($id);
            /** @noinspection PhpUnusedLocalVariableInspection */
            $defer = new ScopeExit(function () use ($parentScope, $refResolver) {
                $refResolver->setResolutionScope($parentScope);
            });
        }

        if ($import
            && isset($data->{self::ID})
            && ($options->version >= Schema::VERSION_DRAFT_06 || $options->version === Schema::VERSION_AUTO)
            && is_string($data->{self::ID}) /*&& (!isset($this->properties['id']))/* && $this->isMetaSchema($data)*/) {

            $id = $data->{self::ID};
            $refResolver = $options->refResolver;
            $parentScope = $refResolver->updateResolutionScope($id);
            /** @noinspection PhpUnusedLocalVariableInspection */
            $defer = new ScopeExit(function () use ($parentScope, $refResolver) {
                $refResolver->setResolutionScope($parentScope);
            });
        }

        if ($import) {
            try {
                while (
                    isset($data->{self::REF})
                    && is_string($data->{self::REF})
                    && !isset($this->properties[self::REF])
                ) {
                    $refString = $data->{self::REF};

                    // todo check performance impact
                    if ($refString === 'http://json-schema.org/draft-04/schema#'
                        || $refString === 'http://json-schema.org/draft-06/schema#'
                        || $refString === 'http://json-schema.org/draft-07/schema#') {
                        return Schema::schema();
                    }

                    // TODO consider process # by reference here ?
                    $refResolver = $options->refResolver;
                    $preRefScope = $refResolver->getResolutionScope();
                    /** @noinspection PhpUnusedLocalVariableInspection */
                    $deferRefScope = new ScopeExit(function () use ($preRefScope, $refResolver) {
                        $refResolver->setResolutionScope($preRefScope);
                    });

                    $ref = $refResolver->resolveReference($refString);
                    $data = self::unboolSchemaData($ref->getData());
                    //$data = $ref->getData();

                    if (!$options->validateOnly) {
                        if ($ref->isImported()) {
                            $refResult = $ref->getImported();
                            return $refResult;
                        }
                        if ($result instanceof ObjectItemContract) {
                            $result->setFromRef($refString);
                        }
                        $ref->setImported($result);
                        $refResult = $this->process($data, $options, $path . '->ref:' . $refString, $result);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
                        $ref->setImported($refResult);
                        return $refResult;
                    } else {
                        $this->process($data, $options, $path . '->ref:' . $refString);
                    }
                }
            } catch (InvalidValue $exception) {
                $this->fail($exception, $path);
            }
        }

        /** @var Schema[]|null $properties */
        $properties = null;

        $nestedProperties = null;
        if ($this->properties !== null) {
            $properties = $this->properties->toArray(); // todo call directly
            if ($this->properties instanceof Properties) {
                $nestedProperties = $this->properties->nestedProperties;
            } else {
                $nestedProperties = array();
            }
        }

        $array = array();
        if (!empty($this->__dataToProperty[$options->mapping])) { // todo skip on $options->validateOnly
            foreach ((array)$data as $key => $value) {
                if ($import) {
                    if (isset($this->__dataToProperty[$options->mapping][$key])) {
                        $key = $this->__dataToProperty[$options->mapping][$key];
                    }
                } else {
                    if (isset($this->__propertyToData[$options->mapping][$key])) {
                        $key = $this->__propertyToData[$options->mapping][$key];
                    }
                }
                $array[$key] = $value;
            }
        } else {
            $array = (array)$data;
        }

        if (!$options->skipValidation) {
            if ($this->minProperties !== null && count($array) < $this->minProperties) {
                $this->fail(new ObjectException("Not enough properties", ObjectException::TOO_FEW), $path);
            }
            if ($this->maxProperties !== null && count($array) > $this->maxProperties) {
                $this->fail(new ObjectException("Too many properties", ObjectException::TOO_MANY), $path);
            }
            if ($this->propertyNames !== null) {
                $propertyNames = self::unboolSchema($this->propertyNames);
                foreach ($array as $key => $tmp) {
                    $propertyNames->process($key, $options, $path . '->propertyNames:' . $key);
                }
            }
        }

        $defaultApplied = array();
        if ($import
            && !$options->validateOnly
            && $options->applyDefaults
            && $properties !== null
            && $this->objectItemClass !== 'Swaggest\JsonSchema\Schema' // todo replace literal
        ) {
            foreach ($properties as $key => $property) {
                if (isset($property->default)) {
                    if (isset($this->__dataToProperty[$options->mapping][$key])) {
                        $key = $this->__dataToProperty[$options->mapping][$key];
                    }
                    if (!array_key_exists($key, $array)) {
                        $defaultApplied[$key] = true;
                        $array[$key] = $property->default;
                    }
                }
            }
        }

        foreach ($array as $key => $value) {
            if ($key === '' && PHP_VERSION_ID < 71000) {
                $this->fail(new InvalidValue('Empty property name'), $path);
            }

            $found = false;

            if (!$options->skipValidation && !empty($this->dependencies)) {
                $deps = $this->dependencies;
                if (isset($deps->$key)) {
                    $dependencies = $deps->$key;
                    $dependencies = self::unboolSchema($dependencies);
                    if ($dependencies instanceof Schema) {
                        $dependencies->process($data, $options, $path . '->dependencies:' . $key);
                    } else {
                        foreach ($dependencies as $item) {
                            if (!property_exists($data, $item)) {
                                $this->fail(new ObjectException('Dependency property missing: ' . $item,
                                    ObjectException::DEPENDENCY_MISSING), $path);
                            }
                        }
                    }
                }
            }

            $propertyFound = false;
            if (isset($properties[$key])) {
                /** @var Schema[] $properties */
                $prop = self::unboolSchema($properties[$key]);
                $propertyFound = true;
                $found = true;
                if ($prop instanceof Schema) {
                    $value = $prop->process(
                        $value,
                        isset($defaultApplied[$key]) ? $options->withSkipValidation() : $options,
                        $path . '->properties:' . $key
                    );
                }
            }

            /** @var Egg[] $nestedEggs */
            $nestedEggs = null;
            if (isset($nestedProperties[$key])) {
                $found = true;
                $nestedEggs = $nestedProperties[$key];
                // todo iterate all nested props?
                $value = self::unboolSchema($nestedEggs[0]->propertySchema)->process($value, $options, $path . '->nestedProperties:' . $key);
            }

            if ($this->patternProperties !== null) {
                foreach ($this->patternProperties as $pattern => $propertySchema) {
                    if (preg_match(Helper::toPregPattern($pattern), $key)) {
                        $found = true;
                        $value = self::unboolSchema($propertySchema)->process($value, $options,
                            $path . '->patternProperties[' . $pattern . ']:' . $key);
                        if (!$options->validateOnly && $import) {
                            $result->addPatternPropertyName($pattern, $key);
                        }
                        //break; // todo manage multiple import data properly (pattern accessor)
                    }
                }
            }
            if (!$found && $this->additionalProperties !== null) {
                if (!$options->skipValidation && $this->additionalProperties === false) {
                    $this->fail(new ObjectException('Additional properties not allowed'), $path . ':' . $key);
                }

                if ($this->additionalProperties instanceof Schema) {
                    $value = $this->additionalProperties->process($value, $options, $path . '->additionalProperties:' . $key);
                }

                if ($import && !$this->useObjectAsArray && !$options->validateOnly) {
                    $result->addAdditionalPropertyName($key);
                }
            }

            if (!$options->validateOnly && $nestedEggs && $import) {
                foreach ($nestedEggs as $nestedEgg) {
                    $result->setNestedProperty($key, $value, $nestedEgg);
                }
                if ($propertyFound) {
                    $result->$key = $value;
                }
            } else {
                if ($this->useObjectAsArray && $import) {
                    $result[$key] = $value;
                } else {
                    if ($found || !$import) {
                        $result->$key = $value;
                    } elseif (!isset($result->$key)) {
                        $result->$key = $value;
                    }
                }
            }
        }

        return $result;
    }

    /**
     * @param array $data
     * @param Context $options
     * @param string $path
     * @param array $result
     * @return mixed
     * @throws InvalidValue
     * @throws \Exception
     * @throws \Swaggest\JsonDiff\Exception
     */
    private function processArray($data, Context $options, $path, $result)
    {
        $count = count($data);
        if (!$options->skipValidation) {
            if ($this->minItems !== null && $count < $this->minItems) {
                $this->fail(new ArrayException("Not enough items in array"), $path);
            }

            if ($this->maxItems !== null && $count > $this->maxItems) {
                $this->fail(new ArrayException("Too many items in array"), $path);
            }
        }

        $pathItems = 'items';
        $this->items = self::unboolSchema($this->items);
        if ($this->items instanceof Schema) {
            $items = array();
            $additionalItems = $this->items;
        } elseif ($this->items === null) { // items defaults to empty schema so everything is valid
            $items = array();
            $additionalItems = true;
        } else { // listed items
            $items = $this->items;
            $additionalItems = $this->additionalItems;
            $pathItems = 'additionalItems';
        }

        /**
         * @var Schema|Schema[] $items
         * @var null|bool|Schema $additionalItems
         */
        $itemsLen = is_array($items) ? count($items) : 0;
        $index = 0;
        foreach ($result as $key => $value) {
            if ($index < $itemsLen) {
                $itemSchema = self::unboolSchema($items[$index]);
                $result[$key] = $itemSchema->process($value, $options, $path . '->items:' . $index);
            } else {
                if ($additionalItems instanceof Schema) {
                    $result[$key] = $additionalItems->process($value, $options, $path . '->' . $pathItems
                        . '[' . $index . ']');
                } elseif (!$options->skipValidation && $additionalItems === false) {
                    $this->fail(new ArrayException('Unexpected array item'), $path);
                }
            }
            ++$index;
        }

        if (!$options->skipValidation && $this->uniqueItems) {
            if (!UniqueItems::isValid($data)) {
                $this->fail(new ArrayException('Array is not unique'), $path);
            }
        }

        if (!$options->skipValidation && $this->contains !== null) {
            /** @var Schema|bool $contains */
            $contains = $this->contains;
            if ($contains === false) {
                $this->fail(new ArrayException('Contains is false'), $path);
            }
            if ($count === 0) {
                $this->fail(new ArrayException('Empty array fails contains constraint'), $path);
            }
            if ($contains === true) {
                $contains = self::unboolSchema($contains);
            }
            $containsOk = false;
            foreach ($data as $key => $item) {
                try {
                    $contains->process($item, $options, $path . '->' . $key);
                    $containsOk = true;
                    break;
                } catch (InvalidValue $exception) {

                }
            }
            if (!$containsOk) {
                $this->fail(new ArrayException('Array fails contains constraint'), $path);
            }
        }
        return $result;
    }

    /**
     * @param mixed|string $data
     * @param Context $options
     * @param string $path
     * @return bool|mixed|string
     * @throws InvalidValue
     */
    private function processContent($data, Context $options, $path)
    {
        try {
            if ($options->unpackContentMediaType) {
                return Content::process($options, $this->contentEncoding, $this->contentMediaType, $data, $options->import);
            } else {
                Content::process($options, $this->contentEncoding, $this->contentMediaType, $data, true);
            }
        } catch (InvalidValue $exception) {
            $this->fail($exception, $path);
        }
        return $data;
    }

    /**
     * @param mixed $data
     * @param Context $options
     * @param string $path
     * @param null $result
     * @return array|mixed|null|object|\stdClass
     * @throws InvalidValue
     * @throws \Exception
     * @throws \Swaggest\JsonDiff\Exception
     */
    public function process($data, Context $options, $path = '#', $result = null)
    {

        $import = $options->import;
        //$pathTrace = explode('->', $path);


        if (!$import && $data instanceof ObjectItemContract) {
            $result = new \stdClass();
            if ($options->circularReferences->contains($data)) {
                /** @noinspection PhpIllegalArrayKeyTypeInspection */
                $path = $options->circularReferences[$data];
                // @todo $path is not a valid json pointer $ref
                $result->{self::REF} = $path;
                return $result;
//                return $options->circularReferences[$data];

            }
            $options->circularReferences->attach($data, $path);
            //$options->circularReferences->attach($data, $result);


            $data = $data->jsonSerialize();
        }
        if (!$import && is_array($data) && $this->useObjectAsArray) {
            $data = (object)$data;
        }

        if (null !== $options->dataPreProcessor) {
            $data = $options->dataPreProcessor->process($data, $this, $import);
        }

        if ($result === null) {
            $result = $data;
        }

        if ($options->skipValidation) {
            goto skipValidation;
        }

        if ($this->type !== null) {
            $this->processType($data, $options, $path);
        }

        if ($this->enum !== null) {
            $this->processEnum($data, $path);
        }

        if (array_key_exists(self::CONST_PROPERTY, $this->__arrayOfData)) {
            $this->processConst($data, $path);
        }

        if ($this->not !== null) {
            $this->processNot($data, $options, $path);
        }

        if (is_string($data)) {
            $this->processString($data, $path);
        }

        if (is_int($data) || is_float($data)) {
            $this->processNumeric($data, $path);
        }

        if ($this->if !== null) {
            $result = $this->processIf($data, $options, $path);
        }

        skipValidation:

        if ($this->oneOf !== null) {
            $result = $this->processOneOf($data, $options, $path);
        }

        if ($this->anyOf !== null) {
            $result = $this->processAnyOf($data, $options, $path);
        }

        if ($this->allOf !== null) {
            $result = $this->processAllOf($data, $options, $path);
        }

        if ($data instanceof \stdClass) {
            $result = $this->processObject($data, $options, $path, $result);
        }

        if (is_array($data)) {
            $result = $this->processArray($data, $options, $path, $result);
        }

        if ($this->contentEncoding !== null || $this->contentMediaType !== null) {
            $result = $this->processContent($data, $options, $path);
        }

        return $result;
    }

    /**
     * @param boolean $useObjectAsArray
     * @return Schema
     */
    public function setUseObjectAsArray($useObjectAsArray)
    {
        $this->useObjectAsArray = $useObjectAsArray;
        return $this;
    }

    /**
     * @param InvalidValue $exception
     * @param string $path
     * @throws InvalidValue
     */
    private function fail(InvalidValue $exception, $path)
    {
        if ($path !== '#') {
            $exception->addPath($path);
        }
        throw $exception;
    }

    public static function integer()
    {
        $schema = new static();
        $schema->type = Type::INTEGER;
        return $schema;
    }

    public static function number()
    {
        $schema = new static();
        $schema->type = Type::NUMBER;
        return $schema;
    }

    public static function string()
    {
        $schema = new static();
        $schema->type = Type::STRING;
        return $schema;
    }

    public static function boolean()
    {
        $schema = new static();
        $schema->type = Type::BOOLEAN;
        return $schema;
    }

    public static function object()
    {
        $schema = new static();
        $schema->type = Type::OBJECT;
        return $schema;
    }

    public static function arr()
    {
        $schema = new static();
        $schema->type = Type::ARR;
        return $schema;
    }

    public static function null()
    {
        $schema = new static();
        $schema->type = Type::NULL;
        return $schema;
    }


    /**
     * @param Properties $properties
     * @return Schema
     */
    public function setProperties($properties)
    {
        $this->properties = $properties;
        return $this;
    }

    /**
     * @param string $name
     * @param Schema $schema
     * @return $this
     */
    public function setProperty($name, $schema)
    {
        if (null === $this->properties) {
            $this->properties = new Properties();
        }
        $this->properties->__set($name, $schema);
        return $this;
    }

    /** @var Meta[] */
    private $metaItems = array();

    public function addMeta(Meta $meta)
    {
        $this->metaItems[get_class($meta)] = $meta;
        return $this;
    }

    public function getMeta($className)
    {
        if (isset($this->metaItems[$className])) {
            return $this->metaItems[$className];
        }
        return null;
    }

    /**
     * @param Context $options
     * @return ObjectItemContract
     */
    public function makeObjectItem(Context $options = null)
    {
        if (null === $this->objectItemClass) {
            return new ObjectItem();
        } else {
            $className = $this->objectItemClass;
            if ($options !== null) {
                if (isset($options->objectItemClassMapping[$className])) {
                    $className = $options->objectItemClassMapping[$className];
                }
            }
            return new $className;
        }
    }

    /**
     * @param mixed $schema
     * @return mixed|Schema
     */
    private static function unboolSchema($schema)
    {
        static $trueSchema;
        static $falseSchema;

        if (null === $trueSchema) {
            $trueSchema = new Schema();
            $trueSchema->__booleanSchema = true;
            $falseSchema = new Schema();
            $falseSchema->not = $trueSchema;
            $falseSchema->__booleanSchema = false;
        }

        if ($schema === true) {
            return $trueSchema;
        } elseif ($schema === false) {
            return $falseSchema;
        } else {
            return $schema;
        }
    }

    /**
     * @param mixed $data
     * @return \stdClass
     */
    private static function unboolSchemaData($data)
    {
        static $trueSchema;
        static $falseSchema;

        if (null === $trueSchema) {
            $trueSchema = new \stdClass();
            $falseSchema = new \stdClass();
            $falseSchema->not = $trueSchema;
        }

        if ($data === true) {
            return $trueSchema;
        } elseif ($data === false) {
            return $falseSchema;
        } else {
            return $data;
        }
    }

}

1			<?php
2
3			namespace Swaggest\JsonSchema;
4
5
6			use PhpLang\ScopeExit;
7			use Swaggest\JsonDiff\JsonDiff;
8			use Swaggest\JsonSchema\Constraint\Content;
9			use Swaggest\JsonSchema\Constraint\Format;
10			use Swaggest\JsonSchema\Constraint\Properties;
11			use Swaggest\JsonSchema\Constraint\Type;
12			use Swaggest\JsonSchema\Constraint\UniqueItems;
13			use Swaggest\JsonSchema\Exception\ArrayException;
14			use Swaggest\JsonSchema\Exception\ConstException;
15			use Swaggest\JsonSchema\Exception\EnumException;
16			use Swaggest\JsonSchema\Exception\LogicException;
17			use Swaggest\JsonSchema\Exception\NumericException;
18			use Swaggest\JsonSchema\Exception\ObjectException;
19			use Swaggest\JsonSchema\Exception\StringException;
20			use Swaggest\JsonSchema\Exception\TypeException;
21			use Swaggest\JsonSchema\Meta\Meta;
22			use Swaggest\JsonSchema\Meta\MetaHolder;
23			use Swaggest\JsonSchema\Structure\ClassStructure;
24			use Swaggest\JsonSchema\Structure\Egg;
25			use Swaggest\JsonSchema\Structure\ObjectItem;
26			use Swaggest\JsonSchema\Structure\ObjectItemContract;
27
28			/**
29			* Class Schema
30			* @package Swaggest\JsonSchema
31			*/
32			class Schema extends JsonSchema implements MetaHolder
33			{
34			const CONST_PROPERTY = 'const';
35
36			const DEFAULT_MAPPING = 'default';
37
38			const VERSION_AUTO = 'a';
39			const VERSION_DRAFT_04 = 4;
40			const VERSION_DRAFT_06 = 6;
swaggest / php-json-schema

Pull Request — master (#19)

Schema::in() C

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
