jschema 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4564a821e55e9336df4d64292765c8e366e1e262
+  data.tar.gz: 990b4033d9123af1ee0b471d6117f2f570a250e1
+SHA512:
+  metadata.gz: cccc98abfaf52295b9d7f959a94bfbc2ea01310f71893018e586a2137dfaf72d93cca14ffe75af29326bd1aeed3ce511c8b452c2dc0d0999bd85d02a6bc9f233
+  data.tar.gz: 5f4c8f525be757b44e21626a846ca45484fb13eb9690a199cfb40da244726e2b00a7e83e331cee81385267baa6002d16b400f786847e277370bc177247208f26

data/lib/jschema.rb

@@ -0,0 +1,41 @@
+require 'bigdecimal'
+require 'uri'
+require 'delegate'
+
+require 'jschema/json_reference'
+require 'jschema/schema_ref'
+require 'jschema/schema'
+require 'jschema/simple_validator'
+require 'jschema/validator'
+require 'jschema/string_length_validator'
+require 'jschema/validator/max_length'
+require 'jschema/validator/min_length'
+require 'jschema/validator/pattern'
+require 'jschema/validator/enum'
+require 'jschema/validator/items'
+require 'jschema/validator/required'
+require 'jschema/validator/properties'
+require 'jschema/validator/max_properties'
+require 'jschema/validator/min_properties'
+require 'jschema/validator/dependencies'
+require 'jschema/validator/type'
+require 'jschema/validator/all_of'
+require 'jschema/validator/any_of'
+require 'jschema/validator/one_of'
+require 'jschema/validator/not'
+require 'jschema/validator/max_items'
+require 'jschema/validator/min_items'
+require 'jschema/validator/unique_items'
+require 'jschema/validator/multiple_of'
+require 'jschema/validator/maximum'
+require 'jschema/validator/minimum'
+require 'jschema/validator/format'
+
+module JSchema
+  class InvalidSchema < StandardError; end
+  class UnknownError < StandardError; end
+
+  def self.build(*args)
+    Schema.build(*args)
+  end
+end

data/lib/jschema/json_reference.rb

@@ -0,0 +1,65 @@
+module JSchema
+  module JSONReference
+    @mutex = Mutex.new
+    @schemas = {}
+
+    class << self
+      def register_schema(schema)
+        schema_key = key(schema.uri, schema)
+        @mutex.synchronize do
+          @schemas[schema_key] = schema
+        end
+      end
+
+      def dereference(uri, schema)
+        schema_key = key(uri, schema)
+        @mutex.synchronize do
+          @schemas[schema_key]
+        end || build_external_schema(uri, schema)
+      end
+
+      private
+
+      def build_external_schema(uri, schema)
+        unless valid_external_uri?(uri)
+          fail InvalidSchema, 'Invalid URI for external schema'
+        end
+
+        sch = JSON.parse download_schema(uri)
+        register_schema Schema.new(sch, uri, schema.parent)
+      rescue JSON::ParserError, Timeout::Error
+        raise InvalidSchema, 'Failed to download external schema'
+      end
+
+      def valid_external_uri?(uri)
+        uri.is_a?(URI::HTTP) && uri.absolute?
+      end
+
+      def download_schema(uri)
+        request = Net::HTTP::Get.new(uri.to_s)
+        request['Accept'] = 'application/json+schema'
+
+        http = Net::HTTP.new(uri.hostname, uri.port)
+        http.read_timeout = 1
+        http.continue_timeout = 1
+        http.open_timeout = 1
+
+        http.request(request).body
+      end
+
+      def key(uri, schema)
+        root_schema = root(schema)
+        "#{root_schema.object_id}:#{uri}"
+      end
+
+      def root(schema)
+        root = schema
+        loop do
+          break if root.parent.nil?
+          root = root.parent
+        end
+        root
+      end
+    end
+  end
+end

data/lib/jschema/schema.rb

@@ -0,0 +1,84 @@
+module JSchema
+  class Schema
+    VERSION_ID = 'http://json-schema.org/draft-04/schema#'.freeze
+
+    class << self
+      def build(sch = {}, parent = nil, id = nil)
+        schema = sch || {}
+
+        check_schema_version schema
+
+        if (json_reference = schema['$ref'])
+          ref_uri = URI(json_reference)
+          SchemaRef.new(ref_uri, parent)
+        else
+          uri = establish_uri(schema, parent, id)
+          jschema = new(schema, uri, parent)
+          register_definitions schema, jschema
+          JSONReference.register_schema jschema
+        end
+      end
+
+      private
+
+      def check_schema_version(schema)
+        version = schema['$schema']
+        if version && version != VERSION_ID
+          fail InvalidSchema, 'Specified schema version is not supported'
+        end
+      end
+
+      # rubocop:disable MethodLength
+      def establish_uri(schema, parent, id)
+        this_id = URI(schema['id'] || id || '#')
+
+        # RFC 3986, cl. 5.1
+        if parent
+          if parent.uri.absolute?
+            parent.uri.merge(this_id).normalize
+          elsif parent.uri.path.empty?
+            URI('#' + File.join(parent.uri.fragment, id || '')) # FIXME
+          else
+            # RFC 3986, cl. 5.1.4
+            fail InvalidSchema, 'Can not establish a base URI'
+          end
+        else
+          this_id
+        end
+      end
+
+      def register_definitions(schema, parent)
+        if (definitions = schema['definitions'])
+          definitions.each do |definition, sch|
+            schema_def = build(sch, parent, "definitions/#{definition}")
+            JSONReference.register_schema schema_def
+          end
+        end
+      end
+    end
+
+    attr_reader :uri, :parent
+
+    def valid?(instance)
+      validate(instance).empty?
+    end
+
+    def validate(instance)
+      @validators.map do |validator|
+        validator.validate(instance)
+      end.compact
+    end
+
+    def to_s
+      uri.to_s
+    end
+
+    private
+
+    def initialize(schema, uri, parent)
+      @uri = uri
+      @parent = parent
+      @validators = Validator.build(schema, self)
+    end
+  end
+end

data/lib/jschema/schema_ref.rb

@@ -0,0 +1,13 @@
+module JSchema
+  # Schema reference is lazy evaluated.
+  class SchemaRef < Delegator
+    def initialize(uri, parent)
+      @uri = uri
+      @parent = parent
+    end
+
+    def __getobj__
+      @schema ||= JSONReference.dereference(@uri, @parent)
+    end
+  end
+end

data/lib/jschema/simple_validator.rb

@@ -0,0 +1,86 @@
+module JSchema
+  class SimpleValidator
+    class << self
+      def build(schema, parent)
+        # Validator keywords must be explicitly specified.
+        fail UnknownError unless keywords
+
+        args = schema.values_at(*keywords)
+        new(*args, parent) unless args.compact.empty?
+      end
+
+      private
+
+      attr_accessor :keywords
+    end
+
+    attr_reader :parent
+
+    def initialize(*args, parent)
+      @parent = parent
+
+      if validate_args(*args)
+        post_initialize(*args)
+      else
+        fail InvalidSchema
+      end
+    end
+
+    def valid?(instance)
+      validate(instance).nil?
+    end
+
+    def validate(instance)
+      if !applicable_types || applicable_types.include?(instance.class)
+        validate_instance(instance)
+      end
+    end
+
+    private
+
+    # Hook method
+    def applicable_types; end
+
+    def invalid_schema(keyword, value)
+      fail InvalidSchema, "Invalid `#{keyword}` value: #{value.inspect}"
+    end
+
+    # Argument validation helpers
+
+    def boolean?(value)
+      value.is_a?(TrueClass) || value.is_a?(FalseClass)
+    end
+
+    def integer?(value)
+      value.is_a?(Fixnum) || value.is_a?(Bignum)
+    end
+
+    def greater_or_equal_to?(value, limit)
+      integer?(value) && value >= limit
+    end
+
+    def number?(value)
+      integer?(value) || value.is_a?(Float) || value.is_a?(BigDecimal)
+    end
+
+    def unique_non_empty_array?(value)
+      value.is_a?(Array) &&
+      !value.empty? &&
+      value.size == value.uniq.size
+    end
+
+    def schema_array?(value, id)
+      unique_non_empty_array?(value) &&
+      value.to_enum.with_index.all? do |schema, index|
+        full_id = [id, index].join('/')
+        valid_schema? schema, full_id
+      end
+    end
+
+    def valid_schema?(schema, id)
+      schema.is_a?(Hash) && !!Schema.build(schema, parent, id)
+    rescue InvalidSchema
+      false
+    end
+  end
+end

data/lib/jschema/string_length_validator.rb

@@ -0,0 +1,17 @@
+module JSchema
+  class StringLengthValidator < SimpleValidator
+    private
+
+    def post_initialize(length_limit)
+      @length_limit = length_limit
+    end
+
+    def applicable_types
+      [String]
+    end
+
+    def valid_length_limit?(length_limit, min_length_limit)
+      greater_or_equal_to? length_limit, min_length_limit
+    end
+  end
+end

data/lib/jschema/validator.rb

@@ -0,0 +1,14 @@
+module JSchema
+  module Validator
+    def self.build(schema, parent)
+      if schema.is_a?(Hash)
+        constants.map do |validator_class_sym|
+          validator_class = const_get(validator_class_sym)
+          validator_class.build(schema, parent)
+        end.compact
+      else
+        []
+      end
+    end
+  end
+end

data/lib/jschema/validator/all_of.rb

@@ -0,0 +1,29 @@
+module JSchema
+  module Validator
+    class AllOf < SimpleValidator
+      private
+
+      self.keywords = ['allOf']
+
+      def validate_args(all_of)
+        schema_array?(all_of, 'allOf') || invalid_schema('allOf', all_of)
+      end
+
+      def post_initialize(all_of)
+        @all_of = all_of.map.with_index do |sch, index|
+          Schema.build(sch, parent, "allOf/#{index}")
+        end
+      end
+
+      def validate_instance(instance)
+        valid = @all_of.all? do |schema|
+          schema.valid?(instance)
+        end
+
+        unless valid
+          "#{instance} must be valid against all the schemas"
+        end
+      end
+    end
+  end
+end

data/lib/jschema/validator/any_of.rb

@@ -0,0 +1,29 @@
+module JSchema
+  module Validator
+    class AnyOf < SimpleValidator
+      private
+
+      self.keywords = ['anyOf']
+
+      def validate_args(any_of)
+        schema_array?(any_of, 'anyOf') || invalid_schema('anyOf', any_of)
+      end
+
+      def post_initialize(any_of)
+        @any_of = any_of.map.with_index do |sch, index|
+          Schema.build(sch, parent, "anyOf/#{index}")
+        end
+      end
+
+      def validate_instance(instance)
+        valid = @any_of.any? do |schema|
+          schema.valid?(instance)
+        end
+
+        unless valid
+          "#{instance} must be valid against any of the schemas"
+        end
+      end
+    end
+  end
+end

data/lib/jschema/validator/dependencies.rb

@@ -0,0 +1,63 @@
+module JSchema
+  module Validator
+    class Dependencies < SimpleValidator
+      private
+
+      self.keywords = ['dependencies']
+
+      def validate_args(dependencies)
+        valid_dependencies?(dependencies) ||
+          invalid_schema('dependencies', dependencies)
+      end
+
+      def valid_dependencies?(dependencies)
+        dependencies.is_a?(Hash) &&
+          dependencies.values.all? do |dependency|
+            valid_schema_dependency?(dependency) ||
+            valid_property_dependency?(dependency)
+          end
+      end
+
+      def valid_schema_dependency?(dependency)
+        dependency.is_a?(Hash)
+      end
+
+      def valid_property_dependency?(dependency)
+        unique_non_empty_array?(dependency) &&
+        dependency.all? { |property| property.is_a?(String) }
+      end
+
+      def post_initialize(dependencies)
+        @dependencies = dependencies
+      end
+
+      def validate_instance(instance)
+        @dependencies.each do |property, validator|
+          if instance.key?(property)
+            errors = validate_against_dependency(instance, validator, property)
+            unless errors.empty?
+              return errors.first
+            end
+          end
+        end and nil
+      end
+
+      def validate_against_dependency(instance, validator, property)
+        case validator
+        when Hash
+          schema = Schema.build(validator, parent, property)
+          schema.validate(instance)
+        when Array
+          required = Validator::Required.new(validator)
+          required.validate(instance)
+        else
+          fail UnknownError
+        end
+      end
+
+      def applicable_types
+        [Hash]
+      end
+    end
+  end
+end