schema-validator 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 35da5c079158aa63d96d214b3ae9178236ffeba8
+  data.tar.gz: 5deffeb8218a0c223536dce3214362b41c668ed5
+SHA512:
+  metadata.gz: 6605965706c35485ffb5da9774151e68a4d7616eba9cd100da244f8f17349bdb9cf041dea688d648e4576704b0f700a59f1011b7351815c8390744cd104bf92e
+  data.tar.gz: 61967ced8167906dd409ca9131df95e5317b260956f80a4beded6b40231c64ac9626a44300fd78226e8f9e13b8b91ad0297148c7c4c040e11a4215610144cd5b

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2017 Lars Lockefeer
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,42 @@
+# SchemaValidator
+
+A simple CLI wrapper around [Rx](http://rx.codesimply.com) for all your schema validation needs.
+
+## Usage
+
+```
+Usage: runner [options]
+    -s, --schema SCHEMA              The schema to validate against
+    -f, --file FILE                  The file to validate
+    -m META_SCHEMATA,                A file containing meta schema definitions
+        --meta-schemata
+```
+
+Example: validate `validatable.json` against the schema defined in `schema.json`, using the meta schemas from `meta_schemata.json`:
+
+```
+./schema-validator -s schema.json -f validatable.json -m meta_schemata.json
+```
+
+## Installation
+
+Clone this repository and run:
+
+```
+gem build schema-validator.gemspec
+gem install schema-validator-{version}.gem
+```
+
+Or add the following to your Gemfile:
+
+```
+gem 'schema-validator', :git => 'https://github.com/larslockefeer/schema-validator.git', :submodules => true
+```
+
+## Acknowledgements
+
+Under the hood, this gem uses [Rx](http://rx.codesimply.com) as the actual schema validation implementation.
+
+## Author
+
+* Lars Lockefeer ([@larslockefeer](https://twitter.com/larslockefeer))

data/bin/schema-validator

@@ -0,0 +1,82 @@
+#!/usr/bin/env ruby
+
+require 'json'
+require 'optparse'
+require 'ostruct'
+require_relative '../lib/rx/ruby/Rx.rb'
+require 'yaml'
+
+# A utility to parse JSON or YAML
+def parse_json_or_yaml(file)
+  begin
+    JSON.parse(file)
+  rescue Exception => e
+    YAML.load(file)
+  end
+end
+
+options = OpenStruct.new
+OptionParser.new do |opt|
+  opt.on('-s', '--schema SCHEMA', 'The schema to validate against.') { |o| options.schema = o }
+  opt.on('-f', '--file FILE', 'The file to validate.') { |o| options.validatable = o }
+  opt.on('-m', '--meta-schemata META_SCHEMATA', 'A file containing meta schema definitions.') { |o| options.meta_schemata = o }
+end.parse!
+
+unless options.schema && options.validatable
+  puts "Please provide a schema and a file to validate."
+  puts "Run me with the -h flag to see usage instructions."
+  exit
+end
+
+if options.meta_schemata
+  meta_schemata_file = File.open(options.meta_schemata).read
+  meta_schemata = parse_json_or_yaml(meta_schemata_file)
+else
+  meta_schemata = []
+end
+
+schema_file = File.open(options.schema).read
+schema = parse_json_or_yaml(schema_file)
+
+file = File.open(options.validatable).read
+validatable = parse_json_or_yaml(file)
+
+rx = Rx.new({ :load_core => true })
+
+# Step 1: Learn the meta schemata
+unless meta_schemata.empty?
+  puts "Learning meta schemata"
+end
+meta_schemata.each do |meta_schema|
+  begin
+    rx.learn_type(meta_schema['uri'], meta_schema['schema'])
+    puts "  ✅  Learned meta scheme #{meta_schema['uri']}"
+  rescue Exception => e
+    puts "  ❌  An error occured learning meta scheme #{meta_schema['uri']}"
+    puts "      #{e.message}"
+    exit
+  end
+end
+
+# Step 2: Load the schema that we are going to validate against
+puts "Loading schema to validate against"
+begin
+  schema = rx.make_schema(schema)
+  puts "  ✅  Schema loaded successfully"
+rescue Exception => e
+  puts "  ❌  An error occured loading the schema"
+  puts "      #{e.message}"
+  exit
+end
+
+# Step 3: Validate our file against the schema
+puts "Validating"
+if schema then
+  begin  
+    schema.check!(validatable)
+    puts "  ✅  File is according to schema."
+  rescue Exception => e
+    puts "  ❌  An error occured validating the file against the schema"
+    puts "      #{e.message}"
+  end
+end

data/lib/rx/ruby/Rx.rb

@@ -0,0 +1,658 @@
+
+class Rx
+  def self.schema(schema)
+    Rx.new(:load_core => true).make_schema(schema)
+  end
+
+  def initialize(opt={})
+    @type_registry = {}
+    @prefix = {
+      ''      => 'tag:codesimply.com,2008:rx/core/',
+      '.meta' => 'tag:codesimply.com,2008:rx/meta/',
+    }
+
+    if opt[:load_core] then
+      Type::Core.core_types.each { |t| register_type(t) }
+    end
+  end
+
+  def register_type(type)
+    uri = type.uri
+
+    if @type_registry.has_key?(uri) then
+      raise Rx::Exception.new(
+        "attempted to register already-known type #{uri}"
+      )
+    end
+
+    @type_registry[ uri ] = type
+  end
+
+  def learn_type(uri, schema)
+    if @type_registry.has_key?(uri) then
+      raise Rx::Exception.new(
+        "attempted to learn type for already-registered uri #{uri}"
+      )
+    end
+
+    # make sure schema is valid
+    # should this be in a begin/rescue?
+    make_schema(schema)
+
+    @type_registry[ uri ] = { 'schema' => schema }
+  end
+
+  def expand_uri(name)
+    if name.match(/\A\w+:/) then; return name; end;
+
+    match = name.match(/\A\/(.*?)\/(.+)\z/)
+    if ! match then
+      raise Rx::Exception.new("couldn't understand Rx type name: #{name}")
+    end
+
+    if ! @prefix.has_key?(match[1]) then
+      raise Rx::Exception.new("unknown prefix '#{match[1]}' in name 'name'")
+    end
+
+    return @prefix[ match[1] ] + match[2]
+  end
+
+  def add_prefix(name, base)
+    if @prefix.has_key?(name) then
+      throw Rx::Exception.new("the prefix '#{name}' is already registered")
+    end
+
+    @prefix[name] = base
+  end
+
+  def make_schema(schema)
+    schema = { 'type' => schema } if schema.instance_of?(String)
+
+    if not (schema.instance_of?(Hash) and schema['type']) then
+      raise Rx::Exception.new('invalid type')
+    end
+
+    uri = expand_uri(schema['type'])
+
+    if ! @type_registry.has_key?(uri) then
+      raise Rx::Exception.new('unknown type')
+    end
+
+    type_class = @type_registry[uri]
+
+    if type_class.instance_of?(Hash) then
+      if schema.keys != [ 'type' ] then
+        raise Rx::Exception.new('composed type does not take check arguments')
+      end
+      return make_schema(type_class['schema'])
+    else
+      return type_class.new(schema, self)
+    end
+  end
+
+  class Helper; end;
+  class Helper::Range
+
+    def initialize(arg)
+      @range = { }
+
+      arg.each_pair { |key,value|
+        if not ['min', 'max', 'min-ex', 'max-ex'].index(key) then
+          raise Rx::Exception.new("illegal argument for Rx::Helper::Range")
+        end
+
+        @range[ key ] = value
+      }
+    end
+
+    def check(value)
+      return false if ! @range['min'   ].nil? and value <  @range['min'   ]
+      return false if ! @range['min-ex'].nil? and value <= @range['min-ex']
+      return false if ! @range['max-ex'].nil? and value >= @range['max-ex']
+      return false if ! @range['max'   ].nil? and value >  @range['max'   ]
+      return true
+    end
+  end
+
+  class Exception < StandardError
+  end
+
+  class ValidationError < StandardError
+    attr_accessor :path
+
+    def initialize(message, path)
+      @message = message
+      @path = path
+    end
+
+    def path
+      @path ||= ""
+    end
+
+    def message
+      "#{@message} (#{@path})"
+    end
+
+    def inspect
+      "#{@message} (#{@path})"
+    end
+
+    def to_s
+      inspect
+    end
+  end
+
+  class Type
+    def initialize(param, rx)
+      assert_valid_params(param)
+    end
+
+    def uri; self.class.uri; end
+
+    def assert_valid_params(param)
+      param.each_key { |k|
+        unless self.allowed_param?(k) then
+          raise Rx::Exception.new("unknown parameter #{k} for #{uri}")
+        end
+      }
+    end
+
+    module NoParams
+      def initialize(param, rx)
+        return if param.keys.length == 0
+        return if param.keys == [ 'type' ]
+
+        raise Rx::Exception.new('this type is not parameterized')
+      end
+    end
+
+    class Type::Core < Type
+      class << self
+        def uri
+          return 'tag:codesimply.com,2008:rx/core/' + subname
+        end
+      end
+
+      def check(value)
+        begin
+          check!(value)
+          true
+        rescue ValidationError
+          false
+        end
+      end
+
+      class All < Type::Core
+        @@allowed_param = { 'of' => true, 'type' => true }
+        def allowed_param?(p); return @@allowed_param[p]; end
+
+        def initialize(param, rx)
+          super
+
+          if ! param.has_key?('of') then
+            raise Rx::Exception.new("no 'of' parameter provided for #{uri}")
+          end
+
+          if param['of'].length == 0 then
+            raise Rx::Exception.new("no schemata provided for 'of' in #{uri}")
+          end
+
+          @alts = [ ]
+          param['of'].each { |alt| @alts.push(rx.make_schema(alt)) }
+        end
+
+        class << self; def subname; return 'all'; end; end
+
+        def check!(value)
+          @alts.each do |alt|
+            begin
+              alt.check!(value)
+            rescue ValidationError => e
+              e.path = "/all" + e.path
+              raise e
+            end
+          end
+          return true
+        end
+      end
+
+      class Any < Type::Core
+        @@allowed_param = { 'of' => true, 'type' => true }
+        def allowed_param?(p); return @@allowed_param[p]; end
+
+        def initialize(param, rx)
+          super
+
+          if param['of'] then
+            if param['of'].length == 0 then
+              raise Rx::Exception.new(
+                                      "no alternatives provided for 'of' in #{uri}"
+                                      )
+            end
+
+            @alts = [ ]
+            param['of'].each { |alt| @alts.push(rx.make_schema(alt)) }
+          end
+        end
+
+        class << self; def subname; return 'any'; end; end
+
+        def check!(value)
+          return true unless @alts
+
+          @alts.each do |alt|
+            begin
+              return true if alt.check!(value)
+            rescue ValidationError
+            end
+          end
+
+          raise ValidationError.new("expected one to match", "/any")
+        end
+      end
+
+      class Arr < Type::Core
+        class << self; def subname; return 'arr'; end; end
+
+        @@allowed_param = { 'contents' => true, 'length' => true, 'type' => true }
+        def allowed_param?(p); return @@allowed_param[p]; end
+
+        def initialize(param, rx)
+          super
+
+          unless param['contents'] then
+            raise Rx::Exception.new("no contents schema given for #{uri}")
+          end
+
+          @contents_schema = rx.make_schema( param['contents'] )
+
+          if param['length'] then
+            @length_range = Rx::Helper::Range.new( param['length'] )
+          end
+        end
+
+        def check!(value)
+          unless value.instance_of?(Array)
+            raise ValidationError.new("expected array got #{value.class}", "/arr")
+          end
+
+          if @length_range
+            unless @length_range.check(value.length)
+              raise ValidationError.new("expected array with #{@length_range} elements, got #{value.length}", "/arr")
+            end
+          end
+
+          if @contents_schema then
+            value.each do |v|
+              begin
+                @contents_schema.check!(v)
+              rescue ValidationError => e
+                e.path = "/arr" + e.path
+                raise e
+              end
+            end
+          end
+
+          return true
+        end
+      end
+
+      class Bool < Type::Core
+        class << self; def subname; return 'bool'; end; end
+
+        include Type::NoParams
+
+        def check!(value)
+          unless value.instance_of?(TrueClass) or value.instance_of?(FalseClass)
+            raise ValidationError.new("expected bool got #{value.inspect}", "/bool")
+          end
+          true
+        end
+      end
+
+      class Fail < Type::Core
+        class << self; def subname; return 'fail'; end; end
+        include Type::NoParams
+        def check(value); return false; end
+        def check!(value); raise ValidationError.new("explicit fail", "/fail"); end
+      end
+
+      #
+      # Added by dan - 81030
+      class Date < Type::Core
+        class << self; def subname; return 'date'; end; end
+
+        include Type::NoParams
+
+        def check!(value)
+          unless value.instance_of?(::Date)
+            raise ValidationError("expected Date got #{value.inspect}", "/date")
+          end
+          true
+        end
+      end
+
+      class Def < Type::Core
+        class << self; def subname; return 'def'; end; end
+        include Type::NoParams
+        def check!(value); raise ValidationError.new("def failed", "/def") unless ! value.nil?; end
+      end
+
+      class Map < Type::Core
+        class << self; def subname; return 'map'; end; end
+        @@allowed_param = { 'values' => true, 'type' => true }
+        def allowed_param?(p); return @@allowed_param[p]; end
+
+        def initialize(param, rx)
+          super
+
+          unless param['values'] then
+            raise Rx::Exception.new("no values schema given for #{uri}")
+          end
+
+          @value_schema = rx.make_schema(param['values'])
+        end
+
+        def check!(value)
+          unless value.instance_of?(Hash) or value.class.to_s == "HashWithIndifferentAccess"
+            raise ValidationError.new("expected map got #{value.inspect}", "/map")
+          end
+
+          if @value_schema
+            value.each_value do |v|
+              begin
+                @value_schema.check!(v)
+              rescue ValidationError => e
+                e.path = "/map" + e.path
+                raise e
+              end
+            end
+          end
+
+          return true
+        end
+      end
+
+      class Nil < Type::Core
+        class << self; def subname; return 'nil'; end; end
+        include Type::NoParams
+        def check!(value); raise ValidationError.new("expected nil got #{value.inspect}", "/nil") unless value.nil?; true; end
+      end
+
+      class Num < Type::Core
+        class << self; def subname; return 'num'; end; end
+        @@allowed_param = { 'range' => true, 'type' => true, 'value' => true }
+        def allowed_param?(p); return @@allowed_param[p]; end
+
+        def initialize(param, rx)
+          super
+
+          if param.has_key?('value') then
+            if ! param['value'].kind_of?(Numeric) then
+              raise Rx::Exception.new("invalid value parameter for #{uri}")
+            end
+
+            @value = param['value']
+          end
+
+          if param['range'] then
+            @value_range = Rx::Helper::Range.new( param['range'] )
+          end
+        end
+
+        def check!(value)
+          if not value.kind_of?(Numeric)
+            raise ValidationError.new("expected Numeric got #{value.inspect}", "/#{self.class.subname}")
+          end
+          if @value_range and not @value_range.check(value)
+            raise ValidationError.new("expected Numeric in range #{@value_range} got #{value.inspect}", "/#{self.class.subname}")
+          end
+          if @value and value != @value
+            raise ValidationError.new("expected Numeric to equal #{@value} got #{value.inspect}", "/#{self.class.subname}")
+          end
+          true
+        end
+      end
+
+      class Int < Type::Core::Num
+        class << self; def subname; return 'int'; end; end
+
+        def initialize(param, rx)
+          super
+
+          if @value and @value % 1 != 0 then
+            raise Rx::Exception.new("invalid value parameter for #{uri}")
+          end
+        end
+
+        def check!(value)
+          super
+          unless value % 1 == 0
+            raise ValidationError.new("expected Integer got #{value.inspect}", "/int")
+          end
+          return true
+        end
+      end
+
+      class One < Type::Core
+        class << self; def subname; return 'one'; end; end
+        include Type::NoParams
+
+        def check!(value)
+          unless [ Numeric, String, TrueClass, FalseClass ].any? { |cls| value.kind_of?(cls) }
+            raise ValidationError.new("expected One got #{value.inspect}", "/one")
+          end
+        end
+      end
+
+      class Rec < Type::Core
+        class << self; def subname; return 'rec'; end; end
+        @@allowed_param = {
+          'type' => true,
+          'rest' => true,
+          'required' => true,
+          'optional' => true,
+        }
+
+        def allowed_param?(p); return @@allowed_param[p]; end
+
+        def initialize(param, rx)
+          super
+
+          @field = { }
+
+          @rest_schema = rx.make_schema(param['rest']) if param['rest']
+
+          [ 'optional', 'required' ].each { |type|
+            next unless param[type]
+            param[type].keys.each { |field|
+              if @field[field] then
+                raise Rx::Exception.new("#{field} in both required and optional")
+              end
+
+              @field[field] = {
+                :required => (type == 'required'),
+                :schema   => rx.make_schema(param[type][field]),
+              }
+            }
+          }
+        end
+
+        def check!(value)
+          unless value.instance_of?(Hash) or value.class.to_s == "HashWithIndifferentAccess"
+            raise ValidationError.new("expected Hash got #{value.class}", "/rec")
+          end
+
+          rest = [ ]
+
+          value.each do |field, field_value|
+            unless @field[field] then
+              rest.push(field)
+              next
+            end
+
+            begin
+              @field[field][:schema].check!(field_value)
+            rescue ValidationError => e
+              e.path = "/rec:'#{field}'"
+              raise e
+            end
+          end
+
+          @field.select { |k,v| @field[k][:required] }.each do |pair|
+            unless value.has_key?(pair[0])
+              raise ValidationError.new("expected Hash to have key: '#{pair[0]}', only had #{value.keys.inspect}", "/rec")
+            end
+          end
+
+          if rest.length > 0 then
+            unless @rest_schema
+              raise ValidationError.new("Hash had extra keys: #{rest.inspect}", "/rec")
+            end
+            rest_hash = { }
+            rest.each { |field| rest_hash[field] = value[field] }
+            begin
+              @rest_schema.check!(rest_hash)
+            rescue ValidationError => e
+              e.path = "/rec"
+              raise e
+            end
+          end
+
+          return true
+        end
+      end
+
+      class Seq < Type::Core
+        class << self; def subname; return 'seq'; end; end
+        @@allowed_param = { 'tail' => true, 'contents' => true, 'type' => true }
+        def allowed_param?(p); return @@allowed_param[p]; end
+
+        def initialize(param, rx)
+          super
+
+          unless param['contents'] and param['contents'].kind_of?(Array) then
+            raise Rx::Exception.new("missing or invalid contents for #{uri}")
+          end
+
+          @content_schemata = param['contents'].map { |s| rx.make_schema(s) }
+
+          if param['tail'] then
+            @tail_schema = rx.make_schema(param['tail'])
+          end
+        end
+
+        def check!(value)
+          unless value.instance_of?(Array)
+            raise ValidationError.new("expected Array got #{value.inspect}", "/seq")
+          end
+          if value.length < @content_schemata.length
+            raise ValidationError.new("expected Array to have at least #{@content_schemata.length} elements, had #{value.length}", "/seq")
+          end
+          @content_schemata.each_index { |i|
+            begin
+              @content_schemata[i].check!(value[i])
+            rescue ValidationError => e
+              e.path = "/seq" + e.path
+              raise e
+            end
+          }
+
+          if value.length > @content_schemata.length then
+            unless @tail_schema
+              raise ValidationError.new("expected tail_schema", "/seq")
+            end
+            begin
+              @tail_schema.check!(value[
+                                        @content_schemata.length,
+                                        value.length - @content_schemata.length
+                                       ])
+            rescue ValidationError => e
+              e.path = "/seq" + e.path
+              raise e
+            end
+          end
+
+          return true
+        end
+      end
+
+      class Str < Type::Core
+        class << self; def subname; return 'str'; end; end
+        @@allowed_param = { 'type' => true, 'value' => true, 'length' => true }
+        def allowed_param?(p); return @@allowed_param[p]; end
+
+        def initialize(param, rx)
+          super
+
+          if param['length'] then
+            @length_range = Rx::Helper::Range.new( param['length'] )
+          end
+
+          if param.has_key?('value') then
+            if ! param['value'].instance_of?(String) then
+              raise Rx::Exception.new("invalid value parameter for #{uri}")
+            end
+
+            @value = param['value']
+          end
+        end
+
+        def check!(value)
+          unless value.instance_of?(String)
+            raise ValidationError.new("expected String got #{value.inspect}", "/str")
+          end
+
+          if @length_range
+            unless @length_range.check(value.length)
+              raise ValidationError.new("expected string with #{@length_range} characters, got #{value.length}", "/str")
+            end
+          end
+
+          if @value and value != @value
+            raise ValidationError.new("expected #{@value.inspect} got #{value.inspect}", "/str")
+          end
+          return true
+        end
+      end
+
+      #
+      # Added by dan - 81106
+      class Time < Type::Core
+        class << self; def subname; return 'time'; end; end
+
+        include Type::NoParams
+
+        def check!(value)
+          unless value.instance_of?(::Time)
+            raise ValidationError.new("expected Time got #{value.inspect}", "/time")
+          end
+          true
+        end
+      end
+
+      class << self
+        def core_types
+          return [
+                  Type::Core::All,
+                  Type::Core::Any,
+                  Type::Core::Arr,
+                  Type::Core::Bool,
+                  Type::Core::Date,
+                  Type::Core::Def,
+                  Type::Core::Fail,
+                  Type::Core::Int,
+                  Type::Core::Map,
+                  Type::Core::Nil,
+                  Type::Core::Num,
+                  Type::Core::One,
+                  Type::Core::Rec,
+                  Type::Core::Seq,
+                  Type::Core::Str,
+                  Type::Core::Time
+                 ]
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,49 @@
+--- !ruby/object:Gem::Specification
+name: schema-validator
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Lars Lockefeer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-10-27 00:00:00.000000000 Z
+dependencies: []
+description: "\n  A JSON schema validation tool.\n  "
+email:
+- lars.lockefeer@teampicnic.com
+executables:
+- schema-validator
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- bin/schema-validator
+- lib/rx/ruby/Rx.rb
+homepage: https://github.com/larslockefeer/schema-validator
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib/rx/ruby
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: A JSON schema validation tool.
+test_files: []