jtd 0.1.1 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 38fab09375c0357e0c329bca34011de7f04eb7da7af137eea1c986534b47b2c5
-  data.tar.gz: b99fee5bda367e455c45b530ae828ed429d7b6fde00348c246d555139c42bab1
+  metadata.gz: 48c509443ff1c585b82b2dad7e6177cb427b1109fb5f4561b8d13f5aea367732
+  data.tar.gz: ed30da3978bda75cdac5a726ccaec03516035e7b352f3d3a923719c934ba227f
 SHA512:
-  metadata.gz: c0da77011abe60b2fdd3ee667c057a7218c8494342063202ff11489417fd04a2fe104126d0c5e96f984b95e0ed86453fdd3df24355e0efe372d6efe09d293941
-  data.tar.gz: 98c043d9b4bcd4943b5e11d8767f02125fb7754ec026d782210a937a0b0a60232e376d87e722f7b5045fe91965bda21eedd631b5877c77bd4b2830f90b822696
+  metadata.gz: 211758c89db305e4e6b1fdafdb27043f0cee0c233bd14e358eeef901a76d1c06a732404e4d13ff4e00220b23d4ee577ae10f17c61ac167ff38a5910e51002245
+  data.tar.gz: 90bde12a921a518fe982cfc9fce5b2dd2610b2165bd891e1c450ef2dbc4b6094d32107bdc0f40621168c09f3a11814360d9659c6ed20c28acce093f6fcc853a7

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    jtd (0.1.1)
+    jtd (0.1.6)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -1 +1,184 @@
 # jtd: JSON Validation for Ruby
+
+[![Gem](https://img.shields.io/gem/v/jtd)](https://rubygems.org/gems/jtd)
+
+`jtd` is a Ruby implementation of [JSON Type Definition][jtd], a schema language
+for JSON. `jtd` primarily gives you two things:
+
+1. Validating input data against JSON Typedef schemas.
+2. A Ruby representation of JSON Typedef schemas.
+
+With this package, you can add JSON Typedef-powered validation to your
+application, or you can build your own tooling on top of JSON Type Definition.
+
+## Installation
+
+You can install this package with `gem`:
+
+```bash
+gem install jtd
+```
+
+## Documentation
+
+Detailed API documentation is available online at:
+
+https://rubydoc.info/gems/jtd/JTD
+
+For more high-level documentation about JSON Typedef in general, or JSON Typedef
+in combination with Python in particular, see:
+
+* [The JSON Typedef Website][jtd]
+* ["Validating JSON in Ruby with JSON Typedef"][jtd-ruby-validation]
+
+## Basic Usage
+
+> For a more detailed tutorial and guidance on how to integrate `jtd` in your
+> application, see ["Validating JSON in Ruby with JSON
+> Typedef"][jtd-ruby-validation] in the JSON Typedef docs.
+
+Here's an example of how you can use this package to validate JSON data against
+a JSON Typedef schema:
+
+```ruby
+require 'jtd'
+
+schema = JTD::Schema.from_hash({
+  'properties' => {
+    'name' => { 'type' => 'string' },
+    'age' => { 'type' => 'uint32' },
+    'phones' => {
+      'elements' => {
+        'type' => 'string'
+      }
+    }
+  }
+})
+
+# JTD::validate returns an array of validation errors. If there were no problems
+# with the input, it returns an empty array.
+
+# Outputs: []
+p JTD::validate(schema, {
+  'name' => 'John Doe',
+  'age' => 43,
+  'phones' => ['+44 1234567', '+44 2345678'],
+})
+
+# This next input has three problems with it:
+#
+# 1. It's missing "name", which is a required property.
+# 2. "age" is a string, but it should be an integer.
+# 3. "phones[1]" is a number, but it should be a string.
+#
+# Each of those errors corresponds to one of the errors returned by validate.
+
+# Outputs:
+#
+# [
+#   #<struct JTD::ValidationError
+#     instance_path=[],
+#     schema_path=["properties", "name"]
+#   >,
+#   #<struct JTD::ValidationError
+#     instance_path=["age"],
+#     schema_path=["properties", "age", "type"]
+#   >,
+#   #<struct JTD::ValidationError
+#     instance_path=["phones", "1"],
+#     schema_path=["properties", "phones", "elements", "type"]
+#   >
+# ]
+p JTD::validate(schema, {
+  'age' => '43',
+  'phones' => ['+44 1234567', 442345678],
+})
+```
+
+## Advanced Usage: Limiting Errors Returned
+
+By default, `JTD::validate` returns every error it finds. If you just care about
+whether there are any errors at all, or if you can't show more than some number
+of errors, then you can get better performance out of `JTD::validate` using the
+`max_errors` option.
+
+For example, taking the same example from before, but limiting it to 1 error, we
+get:
+
+```python
+# Outputs:
+#
+# [#<struct JTD::ValidationError instance_path=[], schema_path=["properties", "name"]>]
+options = JTD::ValidationOptions.new(max_errors: 1)
+p JTD::validate(schema, {
+  'age' => '43',
+  'phones' => ['+44 1234567', 442345678],
+}, options)
+```
+
+## Advanced Usage: Handling Untrusted Schemas
+
+If you want to run `jtd` against a schema that you don't trust, then you should:
+
+1. Ensure the schema is well-formed, using the `#verify` method on
+   `JTD::Schema`. That will check things like making sure all `ref`s have
+   corresponding definitions.
+
+2. Call `JTD::validate` with the `max_depth` option. JSON Typedef lets you write
+   recursive schemas -- if you're evaluating against untrusted schemas, you
+   might go into an infinite loop when evaluating against a malicious input,
+   such as this one:
+
+   ```json
+   {
+     "ref": "loop",
+     "definitions": {
+       "loop": {
+         "ref": "loop"
+       }
+     }
+   }
+   ```
+
+   The `max_depth` option tells `JTD::validate` how many `ref`s to follow
+   recursively before giving up and raising `JTD::MaxDepthExceededError`.
+
+Here's an example of how you can use `jtd` to evaluate data against an untrusted
+schema:
+
+```ruby
+require 'jtd'
+
+# validate_untrusted returns true if `data` satisfies `schema`, and false if it
+# does not. Throws an error if `schema` is invalid, or if validation goes in an
+# infinite loop.
+def validate_untrusted(schema, data)
+  schema.verify()
+
+  # You should tune max_depth to be high enough that most legitimate schemas
+  # evaluate without errors, but low enough that an attacker cannot cause a
+  # denial of service attack.
+  options = JTD::ValidationOptions.new(max_depth: 32)
+  JTD::validate(schema, data, options).empty?
+end
+
+# Returns true
+validate_untrusted(JTD::Schema.from_hash({ 'type' => 'string' }), 'foo')
+
+# Returns false
+validate_untrusted(JTD::Schema.from_hash({ 'type' => 'string' }), nil)
+
+# Raises ArgumentError (invalid type: nonsense)
+validate_untrusted(JTD::Schema.from_hash({ 'type' => 'nonsense' }), 'foo')
+
+# Raises JTD::MaxDepthExceededError (max depth exceeded during JTD::validate)
+validate_untrusted(JTD::Schema.from_hash({
+  'definitions' => {
+    'loop' => { 'ref' => 'loop' },
+  },
+  'ref' => 'loop',
+}), nil)
+```
+
+[jtd]: https://jsontypedef.com
+[jtd-ruby-validation]: https://jsontypedef.com/docs/ruby/validation

data/lib/jtd.rb

@@ -1,6 +1,7 @@
-require "jtd/version"
+require 'jtd/schema'
+require 'jtd/validate'
+require 'jtd/version'
 
+# JTD is an implementation of JSON Type Definition validation for Ruby.
 module JTD
-  class Error < StandardError; end
-  # Your code goes here...
 end

data/lib/jtd/schema.rb

@@ -0,0 +1,291 @@
+module JTD
+  # Represents a JSON Type Definition schema.
+  class Schema
+    attr_accessor *%i[
+      metadata
+      nullable
+      definitions
+      ref
+      type
+      enum
+      elements
+      properties
+      optional_properties
+      additional_properties
+      values
+      discriminator
+      mapping
+    ]
+
+    # Constructs a Schema from a Hash like the kind produced by JSON#parse.
+    #
+    # In other words, #from_hash is meant to be used to convert some parsed JSON
+    # into a Schema.
+    #
+    # If hash isn't a Hash or contains keys that are illegal for JSON Type
+    # Definition, then #from_hash will raise a TypeError.
+    #
+    # If the properties of hash are not of the correct type for a JSON Type
+    # Definition schema (for example, if the "elements" property of hash is
+    # non-nil, but not a hash), then #from_hash may raise a NoMethodError.
+    def self.from_hash(hash)
+      # Raising this error early makes for a much clearer error for the
+      # relatively common case of something that was expected to be an object
+      # (Hash), but was something else instead.
+      raise TypeError.new("expected hash, got: #{hash}") unless hash.is_a?(Hash)
+
+      illegal_keywords = hash.keys - KEYWORDS
+      unless illegal_keywords.empty?
+        raise TypeError.new("illegal schema keywords: #{illegal_keywords}")
+      end
+
+      s = Schema.new
+
+      if hash['metadata']
+        s.metadata = hash['metadata']
+      end
+
+      unless hash['nullable'].nil?
+        s.nullable = hash['nullable']
+      end
+
+      if hash['definitions']
+        s.definitions = Hash[hash['definitions'].map { |k, v| [k, from_hash(v) ]}]
+      end
+
+      s.ref = hash['ref']
+      s.type = hash['type']
+      s.enum = hash['enum']
+
+      if hash['elements']
+        s.elements = from_hash(hash['elements'])
+      end
+
+      if hash['properties']
+        s.properties = Hash[hash['properties'].map { |k, v| [k, from_hash(v) ]}]
+      end
+
+      if hash['optionalProperties']
+        s.optional_properties = Hash[hash['optionalProperties'].map { |k, v| [k, from_hash(v) ]}]
+      end
+
+      unless hash['additionalProperties'].nil?
+        s.additional_properties = hash['additionalProperties']
+      end
+
+      if hash['values']
+        s.values = from_hash(hash['values'])
+      end
+
+      s.discriminator = hash['discriminator']
+
+      if hash['mapping']
+        s.mapping = Hash[hash['mapping'].map { |k, v| [k, from_hash(v) ]}]
+      end
+
+      s
+    end
+
+    # Raises a TypeError or ArgumentError if the Schema is not correct according
+    # to the JSON Type Definition specification.
+    #
+    # See the JSON Type Definition specification for more details, but a high
+    # level #verify checks such things as:
+    #
+    # 1. Making sure each of the attributes of the Schema are of the right type,
+    # 2. The Schema uses a valid combination of JSON Type Definition keywords,
+    # 3. The Schema isn't ambiguous or unsatisfiable.
+    # 4. The Schema doesn't make references to nonexistent definitions.
+    #
+    # If root is specified, then that root is assumed to contain the schema
+    # being verified. By default, the Schema is considered its own root, which
+    # is usually the desired behavior.
+    def verify(root = self)
+      self.check_type('metadata', [Hash])
+      self.check_type('nullable', [TrueClass, FalseClass])
+      self.check_type('definitions', [Hash])
+      self.check_type('ref', [String])
+      self.check_type('type', [String])
+      self.check_type('enum', [Array])
+      self.check_type('elements', [Schema])
+      self.check_type('properties', [Hash])
+      self.check_type('optional_properties', [Hash])
+      self.check_type('additional_properties', [TrueClass, FalseClass])
+      self.check_type('values', [Schema])
+      self.check_type('discriminator', [String])
+      self.check_type('mapping', [Hash])
+
+      form_signature = [
+        !!ref,
+        !!type,
+        !!enum,
+        !!elements,
+        !!properties,
+        !!optional_properties,
+        !!additional_properties,
+        !!values,
+        !!discriminator,
+        !!mapping,
+      ]
+
+      unless VALID_FORMS.include?(form_signature)
+        raise ArgumentError.new("invalid schema form: #{self}")
+      end
+
+      if root != self && definitions && definitions.any?
+        raise ArgumentError.new("non-root definitions: #{definitions}")
+      end
+
+      if ref
+        if !root.definitions || !root.definitions.key?(ref)
+          raise ArgumentError.new("ref to non-existent definition: #{ref}")
+        end
+      end
+
+      if type && !TYPES.include?(type)
+        raise ArgumentError.new("invalid type: #{type}")
+      end
+
+      if enum
+        if enum.empty?
+          raise ArgumentError.new("enum must not be empty: #{self}")
+        end
+
+        if enum.any? { |v| !v.is_a?(String) }
+          raise ArgumentError.new("enum must contain only strings: #{enum}")
+        end
+
+        if enum.size != enum.uniq.size
+          raise ArgumentError.new("enum must not contain duplicates: #{enum}")
+        end
+      end
+
+      if properties && optional_properties
+        shared_keys = properties.keys & optional_properties.keys
+        if shared_keys.any?
+          raise ArgumentError.new("properties and optional_properties share keys: #{shared_keys}")
+        end
+      end
+
+      if mapping
+        mapping.values.each do |s|
+          if s.form != :properties
+            raise ArgumentError.new("mapping values must be of properties form: #{s}")
+          end
+
+          if s.nullable
+            raise ArgumentError.new("mapping values must not be nullable: #{s}")
+          end
+
+          contains_discriminator = ArgumentError.new("mapping values must not contain discriminator (#{discriminator}): #{s}")
+
+          if s.properties && s.properties.key?(discriminator)
+            raise contains_discriminator
+          end
+
+          if s.optional_properties && s.optional_properties.key?(discriminator)
+            raise contains_discriminator
+          end
+        end
+      end
+
+      definitions.values.each { |s| s.verify(root) } if definitions
+      elements.verify(root) if elements
+      properties.values.each { |s| s.verify(root) } if properties
+      optional_properties.values.each { |s| s.verify(root) } if optional_properties
+      values.verify(root) if values
+      mapping.values.each { |s| s.verify(root) } if mapping
+
+      self
+    end
+
+    # Returns the form that the schema takes on.
+    #
+    # The return value will be one of :empty, :ref:, :type, :enum, :elements,
+    # :properties, :values, or :discriminator.
+    #
+    # If the schema is not well-formed, i.e. calling #verify on it raises an
+    # error, then the return value of #form is not well-defined.
+    def form
+      return :ref if ref
+      return :type if type
+      return :enum if enum
+      return :elements if elements
+      return :properties if properties || optional_properties
+      return :values if values
+      return :discriminator if discriminator
+
+      :empty
+    end
+
+    private
+
+    KEYWORDS = %w[
+      metadata
+      nullable
+      definitions
+      ref
+      type
+      enum
+      elements
+      properties
+      optionalProperties
+      additionalProperties
+      values
+      discriminator
+      mapping
+    ]
+
+    private_constant :KEYWORDS
+
+    TYPES = %w[
+      boolean
+      int8
+      uint8
+      int16
+      uint16
+      int32
+      uint32
+      float32
+      float64
+      string
+      timestamp
+    ]
+
+    private_constant :TYPES
+
+    VALID_FORMS = [
+      # Empty form
+      [false, false, false, false, false, false, false, false, false, false],
+      # Ref form
+      [true, false, false, false, false, false, false, false, false, false],
+      # Type form
+      [false, true, false, false, false, false, false, false, false, false],
+      # Enum form
+      [false, false, true, false, false, false, false, false, false, false],
+      # Elements form
+      [false, false, false, true, false, false, false, false, false, false],
+      # Properties form -- properties or optional properties or both, and
+      # never additional properties on its own
+      [false, false, false, false, true, false, false, false, false, false],
+      [false, false, false, false, false, true, false, false, false, false],
+      [false, false, false, false, true, true, false, false, false, false],
+      [false, false, false, false, true, false, true, false, false, false],
+      [false, false, false, false, false, true, true, false, false, false],
+      [false, false, false, false, true, true, true, false, false, false],
+      # Values form
+      [false, false, false, false, false, false, false, true, false, false],
+      # Discriminator form
+      [false, false, false, false, false, false, false, false, true, true],
+    ]
+
+    private_constant :VALID_FORMS
+
+    def check_type(key, classes)
+      val = self.send(key)
+      unless val.nil? || classes.include?(val.class)
+        raise TypeError.new("#{key} must be one of #{classes}, got: #{val}")
+      end
+    end
+  end
+end

data/lib/jtd/validate.rb

@@ -0,0 +1,363 @@
+require 'time'
+
+module JTD
+  # Validates +instance+ against +schema+ according to the JSON Type Definition
+  # specification.
+  #
+  # Returns a list of ValidationError. If there are no validation errors, then
+  # the returned list will be empty.
+  #
+  # By default, all errors are returned, and an unlimited number of references
+  # will be followed. If you are running #validate against schemas that may
+  # return a lot of errors, or which may contain circular references, then this
+  # can cause performance issues or stack overflows.
+  #
+  # To mitigate this risk, consider using +options+, which must be an instance
+  # of ValidationOptions, to limit the number of errors returned or references
+  # followed.
+  #
+  # If ValidationOptions#max_depth is reached, then #validate will raise a
+  # MaxDepthExceededError.
+  #
+  # The return value of #validate is not well-defined if the schema is not
+  # valid, i.e. Schema#verify raises an error.
+  def self.validate(schema, instance, options = ValidationOptions.new)
+    state = ValidationState.new
+    state.options = options
+    state.root_schema = schema
+    state.instance_tokens = []
+    state.schema_tokens = [[]]
+    state.errors = []
+
+    begin
+      validate_with_state(state, schema, instance)
+    rescue MaxErrorsReachedError
+      # This is just a dummy error to immediately stop validation. We swallow
+      # the error here, and return the abridged set of errors.
+    end
+
+    state.errors
+  end
+
+  # Options you can pass to JTD::validate.
+  class ValidationOptions
+    # The maximum number of references to follow before aborting validation. You
+    # can use this to prevent a stack overflow when validating schemas that
+    # potentially have infinite loops, such as this one:
+    #
+    #   {
+    #     "definitions": {
+    #       "loop": { "ref": "loop" }
+    #     },
+    #     "ref": "loop"
+    #   }
+    #
+    # The default value for +max_depth+ is 0, which indicates that no max depth
+    # should be imposed at all.
+    attr_accessor :max_depth
+
+    # The maximum number of errors to return. You can use this to have
+    # JTD::validate have better performance if you don't have any use for errors
+    # beyond a certain count.
+    #
+    # For instance, if all you care about is whether or not there are any
+    # validation errors at all, you can set +max_errors+ to 1. If you're
+    # presenting validation errors in an interface that can't show more than 5
+    # errors, set +max_errors+ to 5.
+    #
+    # The default value for +max_errors+ is 0, which indicates that all errors
+    # will be returned.
+    attr_accessor :max_errors
+
+    # Construct a new set of ValidationOptions with the given +max_depth+ and
+    # +max_errors+.
+    #
+    # See the documentation for +max_depth+ and +max_errors+ for what their
+    # default values of 0 mean.
+    def initialize(max_depth: 0, max_errors: 0)
+      @max_depth = max_depth
+      @max_errors = max_errors
+    end
+  end
+
+  # Represents a single JSON Type Definition validation error.
+  #
+  # ValidationError does not extend StandardError; it is not a Ruby exception.
+  # It is a plain old Ruby object.
+  #
+  # Every ValidationError has two attributes:
+  #
+  # * +instance_path+ is an array of strings. It represents the path to the part
+  #   of the +instance+ passed to JTD::validate that was rejected.
+  #
+  # * +schema_path+ is an array of strings. It represents the path to the part
+  #   of the +schema+ passed to JTD::validate that rejected the instance at
+  #   +instance_path+.
+  class ValidationError < Struct.new(:instance_path, :schema_path)
+
+    # Constructs a new ValidationError from the standard JSON representation of
+    # a validation error in JSON Type Definition.
+    def self.from_hash(hash)
+      instance_path = hash['instancePath']
+      schema_path = hash['schemaPath']
+
+      ValidationError.new(instance_path, schema_path)
+    end
+  end
+
+  # Error raised from JTD::validate if the number of references followed exceeds
+  # ValidationOptions#max_depth.
+  class MaxDepthExceededError < StandardError
+    # Constructs a new MaxDepthExceededError.
+    def initialize(msg = 'max depth exceeded during JTD::validate')
+      super
+    end
+  end
+
+  private
+
+  class ValidationState # :nodoc:
+    attr_accessor :options, :root_schema, :instance_tokens, :schema_tokens, :errors
+
+    def push_instance_token(token)
+      instance_tokens << token
+    end
+
+    def pop_instance_token
+      instance_tokens.pop
+    end
+
+    def push_schema_token(token)
+      schema_tokens.last << token
+    end
+
+    def pop_schema_token
+      schema_tokens.last.pop
+    end
+
+    def push_error
+      errors << ValidationError.new(instance_tokens.clone, schema_tokens.last.clone)
+
+      raise MaxErrorsReachedError.new if errors.size == options.max_errors
+    end
+  end
+
+  private_constant :ValidationState
+
+  class MaxErrorsReachedError < StandardError # :nodoc:
+  end
+
+  private_constant :MaxErrorsReachedError
+
+  def self.validate_with_state(state, schema, instance, parent_tag = nil)
+    return if schema.nullable && instance.nil?
+
+    case schema.form
+    when :ref
+      state.schema_tokens << ['definitions', schema.ref]
+      raise MaxDepthExceededError.new if state.schema_tokens.length == state.options.max_depth
+
+      validate_with_state(state, state.root_schema.definitions[schema.ref], instance)
+      state.schema_tokens.pop
+
+    when :type
+      state.push_schema_token('type')
+
+      case schema.type
+      when 'boolean'
+        state.push_error unless instance == true || instance == false
+      when 'float32', 'float64'
+        state.push_error unless instance.is_a?(Numeric)
+      when 'int8'
+        validate_int(state, instance, -128, 127)
+      when 'uint8'
+        validate_int(state, instance, 0, 255)
+      when 'int16'
+        validate_int(state, instance, -32_768, 32_767)
+      when 'uint16'
+        validate_int(state, instance, 0, 65_535)
+      when 'int32'
+        validate_int(state, instance, -2_147_483_648, 2_147_483_647)
+      when 'uint32'
+        validate_int(state, instance, 0, 4_294_967_295)
+      when 'string'
+        state.push_error unless instance.is_a?(String)
+      when 'timestamp'
+        begin
+          DateTime.rfc3339(instance)
+        rescue TypeError, ArgumentError
+          state.push_error
+        end
+      end
+
+      state.pop_schema_token
+
+    when :enum
+      state.push_schema_token('enum')
+      state.push_error unless schema.enum.include?(instance)
+      state.pop_schema_token
+
+    when :elements
+      state.push_schema_token('elements')
+
+      if instance.is_a?(Array)
+        instance.each_with_index do |sub_instance, index|
+          state.push_instance_token(index.to_s)
+          validate_with_state(state, schema.elements, sub_instance)
+          state.pop_instance_token
+        end
+      else
+        state.push_error
+      end
+
+      state.pop_schema_token
+
+    when :properties
+      # The properties form is a little weird. The JSON Typedef spec always
+      # works out so that the schema path points to a part of the schema that
+      # really exists, and there's no guarantee that a schema of the properties
+      # form has the properties keyword.
+      #
+      # To deal with this, we handle the "instance isn't even an object" case
+      # separately.
+      unless instance.is_a?(Hash)
+        if schema.properties
+          state.push_schema_token('properties')
+        else
+          state.push_schema_token('optionalProperties')
+        end
+
+        state.push_error
+        state.pop_schema_token
+
+        return
+      end
+
+      # Check the required properties.
+      if schema.properties
+        state.push_schema_token('properties')
+
+        schema.properties.each do |property, sub_schema|
+          state.push_schema_token(property)
+
+          if instance.key?(property)
+            state.push_instance_token(property)
+            validate_with_state(state, sub_schema, instance[property])
+            state.pop_instance_token
+          else
+            state.push_error
+          end
+
+          state.pop_schema_token
+        end
+
+        state.pop_schema_token
+      end
+
+      # Check the optional properties. This is almost identical to the previous
+      # case, except we don't raise an error if the property isn't present on
+      # the instance.
+      if schema.optional_properties
+        state.push_schema_token('optionalProperties')
+
+        schema.optional_properties.each do |property, sub_schema|
+          state.push_schema_token(property)
+
+          if instance.key?(property)
+            state.push_instance_token(property)
+            validate_with_state(state, sub_schema, instance[property])
+            state.pop_instance_token
+          end
+
+          state.pop_schema_token
+        end
+
+        state.pop_schema_token
+      end
+
+      # Check for unallowed additional properties.
+      unless schema.additional_properties
+        properties = (schema.properties || {}).keys
+        optional_properties = (schema.optional_properties || {}).keys
+        parent_tags = [parent_tag]
+
+        additional_keys = instance.keys - properties - optional_properties - parent_tags
+        additional_keys.each do |property|
+          state.push_instance_token(property)
+          state.push_error
+          state.pop_instance_token
+        end
+      end
+
+    when :values
+      state.push_schema_token('values')
+
+      if instance.is_a?(Hash)
+        instance.each do |property, sub_instance|
+          state.push_instance_token(property)
+          validate_with_state(state, schema.values, sub_instance)
+          state.pop_instance_token
+        end
+      else
+        state.push_error
+      end
+
+      state.pop_schema_token
+
+    when :discriminator
+      unless instance.is_a?(Hash)
+        state.push_schema_token('discriminator')
+        state.push_error
+        state.pop_schema_token
+
+        return
+      end
+
+      unless instance.key?(schema.discriminator)
+        state.push_schema_token('discriminator')
+        state.push_error
+        state.pop_schema_token
+
+        return
+      end
+
+      unless instance[schema.discriminator].is_a?(String)
+        state.push_schema_token('discriminator')
+        state.push_instance_token(schema.discriminator)
+        state.push_error
+        state.pop_instance_token
+        state.pop_schema_token
+
+        return
+      end
+
+      unless schema.mapping.key?(instance[schema.discriminator])
+        state.push_schema_token('mapping')
+        state.push_instance_token(schema.discriminator)
+        state.push_error
+        state.pop_instance_token
+        state.pop_schema_token
+
+        return
+      end
+
+      sub_schema = schema.mapping[instance[schema.discriminator]]
+
+      state.push_schema_token('mapping')
+      state.push_schema_token(instance[schema.discriminator])
+      validate_with_state(state, sub_schema, instance, schema.discriminator)
+      state.pop_schema_token
+      state.pop_schema_token
+    end
+  end
+
+  def self.validate_int(state, instance, min, max)
+    if instance.is_a?(Numeric)
+      if instance.modulo(1).nonzero? || instance < min || instance > max
+        state.push_error
+      end
+    else
+      state.push_error
+    end
+  end
+end

data/lib/jtd/version.rb

@@ -1,3 +1,4 @@
 module JTD
-  VERSION = "0.1.1"
+  # The version of the +jtd+ gem you are using.
+  VERSION = '0.1.6'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jtd
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.6
 platform: ruby
 authors:
 - Ulysse Carion
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-09-18 00:00:00.000000000 Z
+date: 2020-09-21 00:00:00.000000000 Z
 dependencies: []
 description: 
 email:
@@ -32,6 +32,8 @@ files:
 - bin/setup
 - jtd.gemspec
 - lib/jtd.rb
+- lib/jtd/schema.rb
+- lib/jtd/validate.rb
 - lib/jtd/version.rb
 homepage: https://github.com/jsontypedef/json-typedef-ruby
 licenses: