jddf 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7cc8ef91dfd4d35ae749703e5d5b18c15c0645e37bb6c459a63b154582815a5c
-  data.tar.gz: 19793c4423eb19de83ee3fc46100bdcb7d2eb86a492995e498df9b274362f262
+  metadata.gz: b488c9c91ad6f8eed43e3295b1a7bfbce20985d3aee9217eb2c9defc5f737e8c
+  data.tar.gz: 42676f592a08589204ccbb03aa68118714c60c10b0415a0a194cee9b65a7e228
 SHA512:
-  metadata.gz: dd744ebb3fdd5276e880026858bf34db51ce8a6b7a2c344f1b8d4d725724a38bed741dd16a96df5eb3afc496a0a7958382b365107ed22e7d3ce8dbc1b1b00817
-  data.tar.gz: 6fab08eedbc0091ed390ad1102afda5cd00ddc553f5d7fd2d8a5e31eb9776c75554f66c4ac5853e588fc30c00a23b5c853befb0c88c96ca68dcd1889823f013a
+  metadata.gz: c9a69812ceae8889294f9b6adc0848d14b7f66511145156af42a34fe7e9f1de5aa678b684372249d8cef6a643b48f4b7cc3c9b8a341f3d960bb449593785cf4c
+  data.tar.gz: 0e04a88ceac3add797277390fcffed2256229abef37f68cb0515291f85096ff9475a27c6372ec9c267c90976aabef96768cc550afa81e945ebffb8e5f3cc843b

data/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "jddf-spec"]
+	path = jddf-spec
+	url = git@github.com:jddf/spec.git

data/.rubocop.yml

@@ -0,0 +1,29 @@
+Metrics/AbcSize:
+  Enabled: false
+
+Metrics/MethodLength:
+  Enabled: false
+
+Metrics/CyclomaticComplexity:
+  Enabled: false
+
+Metrics/BlockLength:
+  Enabled: false
+
+Metrics/ModuleLength:
+  Enabled: false
+
+Metrics/PerceivedComplexity:
+  Enabled: false
+
+Lint/ShadowingOuterLocalVariable:
+  Enabled: false
+
+Metrics/ClassLength:
+  Enabled: false
+
+Metrics/BlockNesting:
+  Enabled: false
+
+Style/Next:
+  Enabled: false

data/Gemfile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 source "https://rubygems.org"
 
 git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }

data/Gemfile.lock

@@ -1,12 +1,18 @@
 PATH
   remote: .
   specs:
-    jddf (0.1.0)
+    jddf (0.2.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
+    ast (2.4.0)
     diff-lcs (1.3)
+    jaro_winkler (1.5.3)
+    parallel (1.18.0)
+    parser (2.6.5.0)
+      ast (~> 2.4.0)
+    rainbow (3.0.0)
     rake (10.5.0)
     rspec (3.8.0)
       rspec-core (~> 3.8.0)
@@ -21,6 +27,15 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.8.0)
     rspec-support (3.8.3)
+    rubocop (0.75.0)
+      jaro_winkler (~> 1.5.1)
+      parallel (~> 1.10)
+      parser (>= 2.6)
+      rainbow (>= 2.2.2, < 4.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 1.7)
+    ruby-progressbar (1.10.1)
+    unicode-display_width (1.6.0)
 
 PLATFORMS
   ruby
@@ -30,6 +45,7 @@ DEPENDENCIES
   jddf!
   rake (~> 10.0)
   rspec (~> 3.0)
+  rubocop (~> 0.75.0)
 
 BUNDLED WITH
    1.17.2

data/README.md

@@ -1,39 +1,106 @@
-# Jddf
+# jddf-ruby [![Gem Version][badge]][rubygems]
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/jddf`. To experiment with that code, run `bin/console` for an interactive prompt.
+> Documentation on rubydoc.info: https://www.rubydoc.info/github/jddf/jddf-ruby
 
-TODO: Delete this and the text above, and describe your gem
+This gem is a Ruby implementation of [JSON Data Definition Format][jddf], a
+schema language for JSON. You can use this gem to:
 
-## Installation
+1. Validate input data against a schema,
+2. Get a list of validation errors from that input data, or
+3. Build your own tooling on top of JSON Data Definition Format
 
-Add this line to your application's Gemfile:
+[jddf]: https://jddf.io
+[badge]: https://badge.fury.io/rb/jddf.svg
+[rubygems]: https://rubygems.org/gems/jddf
 
-```ruby
-gem 'jddf'
-```
+## Installing
 
-And then execute:
+You can install this gem by running:
 
-    $ bundle
+```bash
+gem install jddf
+```
 
-Or install it yourself as:
+Or if you're using Bundler:
 
-    $ gem install jddf
+```ruby
+gem 'jddf'
+```
 
 ## Usage
 
-TODO: Write usage instructions here
+The two most important classes offered by the `JDDF` module are:
 
-## Development
+* `Schema`, which represents a JDDF schema,
+* `Validator`, which can validate a `Schema` against any parsed JSON data, and
+* `ValidationError`, which represents a single validation problem with the
+  input. `Validator#validate` returns an array of these.
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+Here's a working example:
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
-
-## Contributing
-
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/jddf.
-
-## License
-
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+```ruby
+require 'jddf'
+
+# In this example, we're passing in a Hash directly into Schema#from_json, but
+# this type of Hash is exactly what JSON#parse returns.
+schema = JDDF::Schema.from_json({
+  'properties' => {
+    'name' => { 'type' => 'string' },
+    'age' => { 'type' => 'uint32' },
+    'phones' => {
+      'elements' => { 'type' => 'string' }
+    }
+  }
+})
+
+# Like before, in order to keep things simple we're construct raw Ruby values
+# here. But you can also get this sort of data by parsing JSON using the
+# standard library's JSON#parse.
+#
+# This input data is perfect. It satisfies all the schema requirements.
+input_ok = {
+  'name' => 'John Doe',
+  'age' => 43,
+  'phones' => [
+    '+44 1234567',
+    '+44 2345678'
+  ]
+}
+
+# This input data has problems. "name" is missing, "age" has the wrong type,
+# and "phones[1]" has the wrong type.
+input_bad = {
+  'age' => '43',
+  'phones' => [
+    '+44 1234567',
+    442345678
+  ]
+}
+
+# Validator can validate schemas against inputs. Validator#validate returns an
+# array of ValidationError.
+#
+# These ValidationError instances are portable -- every implementation of JDDF,
+# across every language, returns the same errors.
+validator = JDDF::Validator.new
+result_ok = validator.validate(schema, input_ok)
+result_bad = validator.validate(schema, input_bad)
+
+p result_ok.size  # 0
+p result_bad.size # 3
+
+# This error indicates that "name" is missing.
+#
+# #<struct JDDF::ValidationError instance_path=[], schema_path=["properties", "name"]
+p result_bad[0]
+
+# This error indicates that "age" has the wrong type.
+#
+# #<struct JDDF::ValidationError instance_path=["age"], schema_path=["properties", "age", "type"]>
+p result_bad[1]
+
+# This error indicates that "phones[1]" has the wrong type.
+#
+# #<struct JDDF::ValidationError instance_path=["phones", "1"], schema_path=["properties", "phones", "elements", "type"]>
+p result_bad[2]
+```

data/bin/bundle

@@ -0,0 +1,105 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'bundle' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "rubygems"
+
+m = Module.new do
+    module_function
+
+  def invoked_as_script?
+    File.expand_path($0) == File.expand_path(__FILE__)
+  end
+
+  def env_var_version
+    ENV["BUNDLER_VERSION"]
+  end
+
+  def cli_arg_version
+    return unless invoked_as_script? # don't want to hijack other binstubs
+    return unless "update".start_with?(ARGV.first || " ") # must be running `bundle update`
+    bundler_version = nil
+    update_index = nil
+    ARGV.each_with_index do |a, i|
+      if update_index && update_index.succ == i && a =~ Gem::Version::ANCHORED_VERSION_PATTERN
+        bundler_version = a
+      end
+      next unless a =~ /\A--bundler(?:[= ](#{Gem::Version::VERSION_PATTERN}))?\z/
+      bundler_version = $1 || ">= 0.a"
+      update_index = i
+    end
+    bundler_version
+  end
+
+  def gemfile
+    gemfile = ENV["BUNDLE_GEMFILE"]
+    return gemfile if gemfile && !gemfile.empty?
+
+    File.expand_path("../../Gemfile", __FILE__)
+  end
+
+  def lockfile
+    lockfile =
+      case File.basename(gemfile)
+      when "gems.rb" then gemfile.sub(/\.rb$/, gemfile)
+      else "#{gemfile}.lock"
+      end
+    File.expand_path(lockfile)
+  end
+
+  def lockfile_version
+    return unless File.file?(lockfile)
+    lockfile_contents = File.read(lockfile)
+    return unless lockfile_contents =~ /\n\nBUNDLED WITH\n\s{2,}(#{Gem::Version::VERSION_PATTERN})\n/
+    Regexp.last_match(1)
+  end
+
+  def bundler_version
+    @bundler_version ||= begin
+      env_var_version || cli_arg_version ||
+        lockfile_version || "#{Gem::Requirement.default}.a"
+    end
+  end
+
+  def load_bundler!
+    ENV["BUNDLE_GEMFILE"] ||= gemfile
+
+    # must dup string for RG < 1.8 compatibility
+    activate_bundler(bundler_version.dup)
+  end
+
+  def activate_bundler(bundler_version)
+    if Gem::Version.correct?(bundler_version) && Gem::Version.new(bundler_version).release < Gem::Version.new("2.0")
+      bundler_version = "< 2"
+    end
+    gem_error = activation_error_handling do
+      gem "bundler", bundler_version
+    end
+    return if gem_error.nil?
+    require_error = activation_error_handling do
+      require "bundler/version"
+    end
+    return if require_error.nil? && Gem::Requirement.new(bundler_version).satisfied_by?(Gem::Version.new(Bundler::VERSION))
+    warn "Activating bundler (#{bundler_version}) failed:\n#{gem_error.message}\n\nTo install the version of bundler this project requires, run `gem install bundler -v '#{bundler_version}'`"
+    exit 42
+  end
+
+  def activation_error_handling
+    yield
+    nil
+  rescue StandardError, LoadError => e
+    e
+  end
+end
+
+m.load_bundler!
+
+if m.invoked_as_script?
+  load Gem.bin_path("bundler", "bundle")
+end

data/bin/htmldiff

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'htmldiff' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+bundle_binstub = File.expand_path("../bundle", __FILE__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 300) =~ /This file was generated by Bundler/
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("diff-lcs", "htmldiff")

data/bin/ldiff

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'ldiff' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+bundle_binstub = File.expand_path("../bundle", __FILE__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 300) =~ /This file was generated by Bundler/
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("diff-lcs", "ldiff")

data/bin/rake

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'rake' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+bundle_binstub = File.expand_path("../bundle", __FILE__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 300) =~ /This file was generated by Bundler/
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("rake", "rake")

data/bin/rspec

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'rspec' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+bundle_binstub = File.expand_path("../bundle", __FILE__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 300) =~ /This file was generated by Bundler/
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("rspec-core", "rspec")

data/bin/rubocop

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'rubocop' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+bundle_binstub = File.expand_path("../bundle", __FILE__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 300) =~ /This file was generated by Bundler/
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("rubocop", "rubocop")

data/bin/ruby-parse

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'ruby-parse' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+bundle_binstub = File.expand_path("../bundle", __FILE__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 300) =~ /This file was generated by Bundler/
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("parser", "ruby-parse")

data/bin/ruby-rewrite

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'ruby-rewrite' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+bundle_binstub = File.expand_path("../bundle", __FILE__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 300) =~ /This file was generated by Bundler/
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("parser", "ruby-rewrite")

data/jddf.gemspec

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 
 lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
@@ -5,7 +6,7 @@ require "jddf/version"
 
 Gem::Specification.new do |spec|
   spec.name          = "jddf"
-  spec.version       = Jddf::VERSION
+  spec.version       = JDDF::VERSION
   spec.authors       = ["Ulysse Carion"]
   spec.email         = ["ulysse@segment.com"]
 
@@ -25,4 +26,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.17"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "rubocop", "~> 0.75.0"
 end

data/lib/jddf.rb

@@ -1,6 +1,9 @@
-require "jddf/version"
+# frozen_string_literal: true
 
-module Jddf
-  class Error < StandardError; end
-  # Your code goes here...
+require 'jddf/schema'
+require 'jddf/validator'
+require 'jddf/version'
+
+# JDDF asdf
+module JDDF
 end

data/lib/jddf/schema.rb

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+
+module JDDF
+  SCHEMA_KEYWORDS = %i[
+    definitions
+    ref
+    type
+    enum
+    elements
+    properties
+    optional_properties
+    additional_properties
+    values
+    discriminator
+  ].freeze
+
+  DISCRIMINATOR_KEYWORDS = %i[
+    tag
+    mapping
+  ].freeze
+
+  TYPES = %i[
+    boolean
+    int8
+    uint8
+    int16
+    uint16
+    int32
+    uint32
+    float32
+    float64
+    string
+    timestamp
+  ].freeze
+
+  Schema = Struct.new(*SCHEMA_KEYWORDS) do
+    def self.from_json(hash)
+      raise TypeError.new, 'hash must be a Hash' unless hash.is_a?(Hash)
+
+      schema = Schema.new
+
+      if hash.include?('definitions')
+        unless hash['definitions'].is_a?(Hash)
+          raise TypeError, 'definitions not Hash'
+        end
+
+        schema.definitions = hash['definitions'].map do |key, schema|
+          [key, from_json(schema)]
+        end.to_h
+      end
+
+      if hash.include?('ref')
+        raise TypeError, 'ref not String' unless hash['ref'].is_a?(String)
+
+        schema.ref = hash['ref']
+      end
+
+      if hash.include?('type')
+        raise TypeError, 'type not String' unless hash['type'].is_a?(String)
+
+        unless TYPES.map(&:to_s).include?(hash['type'])
+          raise TypeError, "type not in #{TYPES}"
+        end
+
+        schema.type = hash['type'].to_sym
+      end
+
+      if hash.include?('enum')
+        raise TypeError, 'enum not Array' unless hash['enum'].is_a?(Array)
+        raise ArgumentError, 'enum is empty array' if hash['enum'].empty?
+
+        hash['enum'].each do |value|
+          raise TypeError, 'enum element not String' unless value.is_a?(String)
+        end
+
+        schema.enum = hash['enum'].to_set
+
+        if schema.enum.size != hash['enum'].size
+          raise ArgumentError, 'enum contains duplicates'
+        end
+      end
+
+      if hash.include?('elements')
+        raise TypeError, 'elements not Hash' unless hash['elements'].is_a?(Hash)
+
+        schema.elements = from_json(hash['elements'])
+      end
+
+      if hash.include?('properties')
+        unless hash['properties'].is_a?(Hash)
+          raise TypeError, 'properties not Hash'
+        end
+
+        schema.properties = hash['properties'].map do |key, schema|
+          [key, from_json(schema)]
+        end.to_h
+      end
+
+      if hash.include?('optionalProperties')
+        unless hash['optionalProperties'].is_a?(Hash)
+          raise TypeError, 'optionalProperties not Hash'
+        end
+
+        optional_properties = hash['optionalProperties'].map do |key, schema|
+          [key, from_json(schema)]
+        end.to_h
+
+        schema.optional_properties = optional_properties
+      end
+
+      if hash.include?('additionalProperties')
+        unless [true, false].include?(hash['additionalProperties'])
+          raise TypeError, 'additionalProperties not boolean'
+        end
+
+        schema.additional_properties = hash['additionalProperties']
+      end
+
+      if hash.include?('values')
+        raise TypeError, 'values not Hash' unless hash['values'].is_a?(Hash)
+
+        schema.values = from_json(hash['values'])
+      end
+
+      if hash.include?('discriminator')
+        unless hash['discriminator'].is_a?(Hash)
+          raise TypeError, 'discriminator not Hash'
+        end
+
+        schema.discriminator = Discriminator.from_json(hash['discriminator'])
+      end
+
+      schema
+    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
+
+    def verify(root = self)
+      empty = true
+
+      if ref
+        empty = false
+
+        unless root.definitions&.keys&.include?(ref)
+          raise ArgumentError, 'reference to non-existent definition'
+        end
+      end
+
+      if type
+        raise ArgumentError, 'invalid form' unless empty
+
+        empty = false
+      end
+
+      if enum
+        raise ArgumentError, 'invalid form' unless empty
+
+        empty = false
+      end
+
+      if elements
+        raise ArgumentError, 'invalid form' unless empty
+
+        empty = false
+
+        elements.verify(root)
+      end
+
+      if properties || optional_properties
+        raise ArgumentError, 'invalid form' unless empty
+
+        empty = false
+
+        properties&.values&.each { |schema| schema.verify(root) }
+        optional_properties&.values&.each { |schema| schema.verify(root) }
+      end
+
+      if values
+        raise ArgumentError, 'invalid form' unless empty
+
+        empty = false
+
+        values.verify(root)
+      end
+
+      if properties && optional_properties
+        unless (properties.keys & optional_properties.keys).empty?
+          raise ArgumentError, 'properties and optional_properties share key'
+        end
+      end
+
+      if discriminator
+        raise ArgumentError, 'invalid form' unless empty
+
+        discriminator.mapping.values.each do |schema|
+          schema.verify(root)
+
+          unless schema.form == :properties
+            raise ArgumentError, 'mapping value not of properties form'
+          end
+
+          if schema&.properties&.include?(discriminator.tag) ||
+             schema&.optional_properties&.include?(discriminator.tag)
+            raise ArgumentError, 'tag appears in mapping properties'
+          end
+        end
+      end
+
+      self
+    end
+  end
+
+  Discriminator = Struct.new(*DISCRIMINATOR_KEYWORDS) do
+    def self.from_json(hash)
+      raise TypeError, 'tag not String' unless hash['tag'].is_a?(String)
+      raise TypeError, 'mapping not Hash' unless hash['mapping'].is_a?(Hash)
+
+      mapping = hash['mapping'].map do |key, schema|
+        [key, Schema.from_json(schema)]
+      end.to_h
+
+      Discriminator.new(hash['tag'], mapping)
+    end
+  end
+end

data/lib/jddf/validator.rb

@@ -0,0 +1,272 @@
+# frozen_string_literal: true
+
+require 'time'
+
+module JDDF
+  # ValidationError
+  ValidationError = Struct.new(:instance_path, :schema_path)
+
+  # MaxDepthExceededError
+  class MaxDepthExceededError < StandardError
+    def initialize(msg = 'max depth exceeded while validating')
+      super
+    end
+  end
+
+  # Validator
+  class Validator
+    # MaxErrorsError
+    class MaxErrorsError < StandardError
+    end
+
+    private_constant :MaxErrorsError
+
+    # VM
+    class VM
+      attr_accessor :max_depth
+      attr_accessor :max_errors
+      attr_accessor :root_schema
+      attr_accessor :instance_tokens
+      attr_accessor :schema_tokens
+      attr_accessor :errors
+
+      def validate(schema, instance, parent_tag = nil)
+        case schema.form
+        when :ref
+          raise MaxDepthExceededError if schema_tokens.size == max_depth
+
+          schema_tokens << ['definitions', schema.ref]
+          validate(root_schema.definitions[schema.ref], instance)
+          schema_tokens.pop
+        when :type
+          push_schema_token('type')
+
+          case schema.type
+          when :boolean
+            push_error if instance != true && instance != false
+          when :float32, :float64
+            push_error unless instance.is_a?(Numeric)
+          when :int8
+            validate_int(instance, -128, 127)
+          when :uint8
+            validate_int(instance, 0, 255)
+          when :int16
+            validate_int(instance, -32_768, 32_767)
+          when :uint16
+            validate_int(instance, 0, 65_535)
+          when :int32
+            validate_int(instance, -2_147_483_648, 2_147_483_647)
+          when :uint32
+            validate_int(instance, 0, 4_294_967_295)
+          when :string
+            push_error unless instance.is_a?(String)
+          when :timestamp
+            begin
+              DateTime.rfc3339(instance)
+            rescue TypeError, ArgumentError
+              push_error
+            end
+          end
+
+          pop_schema_token
+        when :enum
+          push_schema_token('enum')
+          push_error unless schema.enum.include?(instance)
+          pop_schema_token
+        when :elements
+          push_schema_token('elements')
+
+          if instance.is_a?(Array)
+            instance.each_with_index do |sub_instance, index|
+              push_instance_token(index.to_s)
+              validate(schema.elements, sub_instance)
+              pop_instance_token
+            end
+          else
+            push_error
+          end
+
+          pop_schema_token
+        when :properties
+          if instance.is_a?(Hash)
+            if schema.properties
+              push_schema_token('properties')
+
+              schema.properties.each do |key, sub_schema|
+                push_schema_token(key)
+
+                if instance.include?(key)
+                  push_instance_token(key)
+                  validate(sub_schema, instance[key])
+                  pop_instance_token
+                else
+                  push_error
+                end
+
+                pop_schema_token
+              end
+
+              pop_schema_token
+            end
+
+            if schema.optional_properties
+              push_schema_token('optionalProperties')
+
+              schema.optional_properties.each do |key, sub_schema|
+                push_schema_token(key)
+
+                if instance.include?(key)
+                  push_instance_token(key)
+                  validate(sub_schema, instance[key])
+                  pop_instance_token
+                end
+
+                pop_schema_token
+              end
+
+              pop_schema_token
+            end
+
+            unless schema.additional_properties
+              instance.keys.each do |key|
+                in_properties =
+                  schema.properties&.include?(key)
+                in_optional_properties =
+                  schema.optional_properties&.include?(key)
+                is_parent_tag = parent_tag == key
+
+                unless in_properties || in_optional_properties || is_parent_tag
+                  push_instance_token(key)
+                  push_error
+                  pop_instance_token
+                end
+              end
+            end
+          else
+            if schema.properties.nil?
+              push_schema_token('optionalProperties')
+            else
+              push_schema_token('properties')
+            end
+
+            push_error
+            pop_schema_token
+          end
+        when :values
+          push_schema_token('values')
+
+          if instance.is_a?(Hash)
+            instance.each do |key, value|
+              push_instance_token(key)
+              validate(schema.values, value)
+              pop_instance_token
+            end
+          else
+            push_error
+          end
+
+          pop_schema_token
+        when :discriminator
+          push_schema_token('discriminator')
+
+          if instance.is_a?(Hash)
+            if instance.include?(schema.discriminator.tag)
+              tag_value = instance[schema.discriminator.tag]
+
+              if tag_value.is_a?(String)
+                push_schema_token('mapping')
+
+                if schema.discriminator.mapping.include?(tag_value)
+                  sub_schema = schema.discriminator.mapping[tag_value]
+
+                  push_schema_token(tag_value)
+                  validate(sub_schema, instance, schema.discriminator.tag)
+                  pop_schema_token
+                else
+                  push_instance_token(schema.discriminator.tag)
+                  push_error
+                  pop_instance_token
+                end
+
+                pop_schema_token
+              else
+                push_instance_token(schema.discriminator.tag)
+                push_schema_token('tag')
+                push_error
+                pop_schema_token
+                pop_instance_token
+              end
+            else
+              push_schema_token('tag')
+              push_error
+              pop_schema_token
+            end
+          else
+            push_error
+          end
+
+          pop_schema_token
+        end
+      end
+
+      def validate_int(instance, min, max)
+        if instance.is_a?(Numeric)
+          if instance.modulo(1).nonzero? || instance < min || instance > max
+            push_error
+          end
+        else
+          push_error
+        end
+      end
+
+      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
+        error = ValidationError.new
+        error.instance_path = instance_tokens.clone
+        error.schema_path = schema_tokens.last.clone
+
+        errors << error
+
+        raise MaxErrorsError if errors.size == max_errors
+      end
+    end
+
+    private_constant :VM
+
+    attr_accessor :max_depth
+    attr_accessor :max_errors
+
+    def validate(schema, instance)
+      vm = VM.new
+      vm.max_depth = max_depth
+      vm.max_errors = max_errors
+      vm.root_schema = schema
+      vm.instance_tokens = []
+      vm.schema_tokens = [[]]
+      vm.errors = []
+
+      begin
+        vm.validate(schema, instance)
+      rescue MaxErrorsError # rubocop:disable Lint/HandleExceptions
+        # There is nothing to do here. MaxErrorsError is just a circuit-breaker.
+      end
+
+      vm.errors
+    end
+  end
+end

data/lib/jddf/version.rb

@@ -1,3 +1,5 @@
-module Jddf
-  VERSION = "0.1.0"
+# frozen_string_literal: true
+
+module JDDF
+  VERSION = '0.2.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jddf
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Ulysse Carion
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-10-07 00:00:00.000000000 Z
+date: 2019-10-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.75.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.75.0
 description: 
 email:
 - ulysse@segment.com
@@ -60,17 +74,28 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".gitmodules"
 - ".rspec"
-- ".travis.yml"
+- ".rubocop.yml"
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
 - README.md
 - Rakefile
+- bin/bundle
 - bin/console
+- bin/htmldiff
+- bin/ldiff
+- bin/rake
+- bin/rspec
+- bin/rubocop
+- bin/ruby-parse
+- bin/ruby-rewrite
 - bin/setup
 - jddf.gemspec
 - lib/jddf.rb
+- lib/jddf/schema.rb
+- lib/jddf/validator.rb
 - lib/jddf/version.rb
 homepage: https://github.com/jddf/jddf-ruby
 licenses:

data/.travis.yml

@@ -1,7 +0,0 @@
----
-sudo: false
-language: ruby
-cache: bundler
-rvm:
-  - 2.6.5
-before_install: gem install bundler -v 1.17.2