jtd 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 38fab09375c0357e0c329bca34011de7f04eb7da7af137eea1c986534b47b2c5
-  data.tar.gz: b99fee5bda367e455c45b530ae828ed429d7b6fde00348c246d555139c42bab1
+  metadata.gz: f28bef81d86fe4efad4f6e1398ce5b1d7d462de7e99590297b14a7a92bf2b40d
+  data.tar.gz: 8f25271a45816681d57d13dcb1cd8436cfc93d5a16aeadfa7a1946b199bc489f
 SHA512:
-  metadata.gz: c0da77011abe60b2fdd3ee667c057a7218c8494342063202ff11489417fd04a2fe104126d0c5e96f984b95e0ed86453fdd3df24355e0efe372d6efe09d293941
-  data.tar.gz: 98c043d9b4bcd4943b5e11d8767f02125fb7754ec026d782210a937a0b0a60232e376d87e722f7b5045fe91965bda21eedd631b5877c77bd4b2830f90b822696
+  metadata.gz: 0bcc179000832d0d22833fec826df648f1b40d2cbc8610d138a479144260fedae3c507a28aa986ef9392be6a777f871607bf27bb99bbaee8486ca6f5538d7e55
+  data.tar.gz: 8749c6e7e26072097069e4977b7b817210a2f70815f4a6706d728ae4b629169429856eaa0c24ec11dcee171e196b4effcc1ce2185c9ae028eb6da24a2d5df9d6

data/Gemfile.lock

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

data/lib/jtd.rb

@@ -1,6 +1,6 @@
-require "jtd/version"
+require 'jtd/schema'
+require 'jtd/validate'
+require 'jtd/version'
 
 module JTD
-  class Error < StandardError; end
-  # Your code goes here...
 end

data/lib/jtd/schema.rb

@@ -0,0 +1,258 @@
+module JTD
+  class Schema
+    attr_accessor *%i[
+      metadata
+      nullable
+      definitions
+      ref
+      type
+      enum
+      elements
+      properties
+      optional_properties
+      additional_properties
+      values
+      discriminator
+      mapping
+    ]
+
+    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
+
+    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
+
+    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,293 @@
+require 'time'
+
+module JTD
+  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
+
+  class ValidationOptions
+    attr_accessor :max_depth, :max_errors
+
+    def initialize(max_depth: 0, max_errors: 0)
+      @max_depth = max_depth
+      @max_errors = max_errors
+    end
+  end
+
+  class ValidationError < Struct.new(:instance_path, :schema_path)
+    def self.from_hash(hash)
+      instance_path = hash['instancePath']
+      schema_path = hash['schemaPath']
+
+      ValidationError.new(instance_path, schema_path)
+    end
+  end
+
+  class MaxDepthExceededError < StandardError
+    def initialize(msg = 'max depth exceeded during JTD::validate')
+      super
+    end
+  end
+
+  private
+
+  class ValidationState
+    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
+  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]
+      p state.schema_tokens.length, state.options, state.options.max_depth
+      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,3 @@
 module JTD
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jtd
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Ulysse Carion
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-09-18 00:00:00.000000000 Z
+date: 2020-09-19 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: