jschema 0.0.2

data/lib/jschema/validator/not.rb

@@ -0,0 +1,23 @@
+module JSchema
+  module Validator
+    class Not < SimpleValidator
+      private
+
+      self.keywords = ['not']
+
+      def validate_args(schema)
+        valid_schema?(schema, 'not') || invalid_schema('not', schema)
+      end
+
+      def post_initialize(not_schema)
+        @schema = Schema.build(not_schema, parent, 'not')
+      end
+
+      def validate_instance(instance)
+        if @schema.valid?(instance)
+          "#{instance} must not validate against #{@schema}"
+        end
+      end
+    end
+  end
+end

data/lib/jschema/validator/one_of.rb

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

data/lib/jschema/validator/pattern.rb

@@ -0,0 +1,36 @@
+module JSchema
+  module Validator
+    class Pattern < SimpleValidator
+      private
+
+      # Fix because of Rubinius
+      unless defined? PrimitiveFailure
+        class PrimitiveFailure < Exception
+        end
+      end
+
+      self.keywords = ['pattern']
+
+      def validate_args(pattern)
+        Regexp.new(pattern)
+        true
+      rescue TypeError, PrimitiveFailure
+        invalid_schema 'pattern', pattern
+      end
+
+      def post_initialize(pattern)
+        @pattern = pattern
+      end
+
+      def validate_instance(instance)
+        unless instance.match(@pattern)
+          "#{instance} must match pattern #{@pattern.inspect}"
+        end
+      end
+
+      def applicable_types
+        [String]
+      end
+    end
+  end
+end

data/lib/jschema/validator/properties.rb

@@ -0,0 +1,106 @@
+module JSchema
+  module Validator
+    class Properties < SimpleValidator
+      private
+
+      self.keywords = [
+        'properties',
+        'patternProperties',
+        'additionalProperties'
+      ]
+
+      def validate_args(properties, pattern_properties, additional_properties)
+        validate_properties(properties)
+        validate_pattern_properties(pattern_properties)
+        validate_additional_properties(additional_properties)
+      end
+
+      def validate_properties(properties)
+        valid_properties?(properties) ||
+          invalid_schema('properties', properties)
+      end
+
+      def validate_pattern_properties(pattern_properties)
+        valid_properties?(pattern_properties) ||
+          invalid_schema('patternProperties', pattern_properties)
+      end
+
+      def validate_additional_properties(additional_properties)
+        (valid_properties?(additional_properties) ||
+          boolean?(additional_properties)) ||
+          invalid_schema('additionalProperties', additional_properties)
+      end
+
+      def valid_properties?(properties)
+        properties.nil? ||
+          (properties.is_a?(Hash) && properties.all? { |_, v| v.is_a?(Hash) })
+      end
+
+      def post_initialize(properties, pattern_properties, additional_properties)
+        @properties = properties
+        @additional_properties = additional_properties
+        @pattern_properties = pattern_properties
+      end
+
+      def applicable_types
+        [Hash]
+      end
+
+      def validate_instance(instance)
+        instance.each do |field, value|
+          schemas = schemas_for(field)
+
+          if schemas.empty? && @additional_properties == false
+            return "#{instance} must not have any additional fields"
+          end
+
+          schemas.each do |schema|
+            validation_errors = schema.validate(value)
+            unless validation_errors.empty?
+              return validation_errors.first
+            end
+          end
+        end
+        nil
+      end
+
+      private
+
+      def schemas_for(field)
+        [
+          properties_schema(field),
+          additional_properties_schema(field),
+          *pattern_properties_schema(field)
+        ].compact
+      end
+
+      def properties_schema(field)
+        if @properties.is_a?(Hash)
+          if (sch = @properties[field])
+            Schema.build(sch, parent, 'properties')
+          end
+        end
+      end
+
+      def additional_properties_schema(field)
+        if @additional_properties.is_a?(Hash)
+          if (sch = @additional_properties[field])
+            Schema.build(sch, parent, 'additionalProperties')
+          end
+        end
+      end
+
+      def pattern_properties_schema(field)
+        schemas = []
+        if @pattern_properties.is_a?(Hash)
+          @pattern_properties.each do |pattern, sch|
+            if field.match(pattern)
+              schemas << Schema.build(sch, parent, 'patternProperties')
+            end
+          end
+        end
+        schemas
+      end
+    end
+  end
+end

data/lib/jschema/validator/required.rb

@@ -0,0 +1,34 @@
+module JSchema
+  module Validator
+    class Required < SimpleValidator
+      private
+
+      self.keywords = ['required']
+
+      def validate_args(required)
+        valid_required?(required) || invalid_schema('required', required)
+      end
+
+      def post_initialize(required)
+        @required = required
+      end
+
+      def applicable_types
+        [Hash]
+      end
+
+      def validate_instance(instance)
+        @required.each do |required_property|
+          if instance[required_property].nil?
+            return "#{instance} must have property `#{required_property}`"
+          end
+        end and nil
+      end
+
+      def valid_required?(required)
+        unique_non_empty_array?(required) &&
+        required.all? { |req| req.is_a?(String) }
+      end
+    end
+  end
+end

data/lib/jschema/validator/type.rb

@@ -0,0 +1,57 @@
+module JSchema
+  module Validator
+    class Type < SimpleValidator
+      private
+
+      self.keywords = ['type']
+
+      def validate_args(type)
+        if type.is_a?(String) || unique_non_empty_array?(type)
+          true
+        else
+          invalid_schema 'type', type
+        end
+      end
+
+      def post_initialize(type)
+        @json_types = Array(type)
+        @ruby_classes = @json_types.map do |json_type|
+          json_type_to_ruby_class(json_type)
+        end.flatten.compact
+      end
+
+      def validate_instance(instance)
+        unless @ruby_classes.one? { |type| instance.is_a?(type) }
+          error_message(instance)
+        end
+      end
+
+      def json_type_to_ruby_class(json_type)
+        case json_type
+        when 'object'  then Hash
+        when 'null'    then NilClass
+        when 'string'  then String
+        when 'integer' then [Fixnum, Bignum]
+        when 'array'   then Array
+        when 'boolean' then [TrueClass, FalseClass]
+        when 'number'  then [Fixnum, Float, BigDecimal, Bignum]
+        else invalid_schema('type', json_type)
+        end
+      end
+
+      def error_message(instance)
+        types =
+          case @json_types.size
+          when 1
+            @json_types.first
+          when 2
+            @json_types.join(' or ')
+          when 3..Float::INFINITY
+            @json_types[0..-2].join(', ') << ", or #{@json_types.last}"
+          end
+
+        "#{instance.inspect} must be a #{types}"
+      end
+    end
+  end
+end

data/lib/jschema/validator/unique_items.rb

@@ -0,0 +1,27 @@
+module JSchema
+  module Validator
+    class UniqueItems < SimpleValidator
+      private
+
+      self.keywords = ['uniqueItems']
+
+      def validate_args(unique_items)
+        boolean?(unique_items) || invalid_schema('uniqueItems', unique_items)
+      end
+
+      def post_initialize(unique_items)
+        @unique_items = unique_items
+      end
+
+      def validate_instance(instance)
+        if @unique_items && instance.size != instance.uniq.size
+          "#{instance} must contain only unique items"
+        end
+      end
+
+      def applicable_types
+        [Array]
+      end
+    end
+  end
+end

data/test/assert_received.rb

@@ -0,0 +1,15 @@
+module MiniTest
+  module Assertions
+    def assert_received(receiver, message, args = [])
+      mock = MiniTest::Mock.new
+      mock.expect(message, nil, args)
+      receiver_stub = ->(*arg) { mock.__send__ message, *arg }
+
+      receiver.stub message, receiver_stub do
+        yield if block_given?
+      end
+
+      mock.verify
+    end
+  end
+end

data/test/string_length_validator_tests.rb

@@ -0,0 +1,18 @@
+module StringLengthValidatorTests
+  def test_that_argument_can_be_big_integer
+    validator(2**64)
+  end
+
+  def test_that_argument_is_integer
+    assert_raises(JSchema::InvalidSchema) { validator('invalid') }
+  end
+
+  def test_that_argument_is_not_null
+    assert_raises(JSchema::InvalidSchema) { validator(nil) }
+  end
+
+  def test_that_validation_always_passes_for_non_string_instances
+    assert validator(1).valid?(nil)
+    assert validator(1).valid?([1, 2])
+  end
+end

data/test/test_assert_received.rb

@@ -0,0 +1,39 @@
+require 'minitest/autorun'
+require_relative 'assert_received'
+
+class TestAssertReceived < Minitest::Test
+  def test_message_sending_without_params
+    assert_received(Object, :class) do
+      Object.class
+    end
+  end
+
+  def test_message_sending_with_params
+    assert_received(String, :==, [Fixnum]) do
+      String == Fixnum
+    end
+  end
+
+  def test_assertion_failure_when_message_is_not_received
+    assert_raises(MockExpectationError) do
+      assert_received(String, :class) do
+      end
+    end
+  end
+
+  def test_assertion_failure_when_unexpected_message_is_received
+    assert_raises(MockExpectationError) do
+      assert_received(String, :class) do
+        String.name
+      end
+    end
+  end
+
+  def test_assertion_failure_when_unexpected_params_are_received
+    assert_raises(MockExpectationError) do
+      assert_received(String, :==, [Fixnum]) do
+        String == Bignum
+      end
+    end
+  end
+end

data/test/test_integration.rb

@@ -0,0 +1,30 @@
+require 'minitest/autorun'
+require 'webmock/minitest'
+require 'jschema'
+require 'json'
+
+class TestIntegration < Minitest::Test
+  def test_simple_schema
+    stub_request(:get, 'http://json-schema.org/geo')
+      .to_return(body: Pathname.new('test/fixtures/geo.json'))
+
+    validate 'json_schema1.json', 'json_data1.json'
+  end
+
+  def test_advanced_schema
+    validate 'json_schema2.json', 'json_data2.json'
+  end
+
+  private
+
+  def validate(schema_file, data_file)
+    sch = json_fixture(schema_file).freeze
+    schema = JSchema::Schema.build(sch)
+    data = json_fixture(data_file)
+    assert schema.valid?(data)
+  end
+
+  def json_fixture(filename)
+    JSON.parse open(File.join('test', 'fixtures', filename)).read
+  end
+end

data/test/test_json_reference.rb

@@ -0,0 +1,84 @@
+require 'minitest/autorun'
+require 'webmock/minitest'
+require 'jschema'
+require 'ostruct'
+
+require_relative 'assert_received'
+
+class TestJSONReference < Minitest::Test
+  def test_schema_registration_and_dereferencing
+    schema = generate_schema('registered')
+    JSchema::JSONReference.register_schema schema
+    assert_equal dereference(schema), schema
+  end
+
+  def test_schema_dereferencing_with_same_uri
+    schema1 = generate_schema('uri')
+    schema2 = generate_schema('uri')
+    JSchema::JSONReference.register_schema schema1
+    JSchema::JSONReference.register_schema schema2
+
+    assert_equal dereference(schema1), schema1
+    assert_equal dereference(schema2), schema2
+  end
+
+  def test_dereferencing_external_schema
+    external_schema = { 'type' => 'number' }
+    schema_uri = 'http://example.com/geo'
+
+    expected_schema_args = [external_schema, URI(schema_uri), nil]
+    assert_received JSchema::Schema, :new, expected_schema_args do
+      JSchema::JSONReference.stub :register_schema, nil do
+        dereference_external_schema schema_uri, external_schema.to_json
+      end
+    end
+  end
+
+  def test_that_external_schema_is_cached_after_dereferencing
+    schema = Object.new
+    JSchema::Schema.stub :new, schema do
+      assert_received JSchema::JSONReference, :register_schema, [schema] do
+        dereference_external_schema 'http://example.com', '{}'
+      end
+    end
+  end
+
+  def test_dereferencing_external_schema_when_it_is_not_valid
+    assert_raises(JSchema::InvalidSchema) do
+      dereference_external_schema 'http://example.com/', '}'
+    end
+  end
+
+  def test_dereferencing_external_schema_when_it_is_not_available
+    assert_raises(JSchema::InvalidSchema) do
+      stub_request(:get, //).to_timeout
+      dereference generate_schema('http://example.com/')
+    end
+  end
+
+  def test_dereferencing_external_schema_when_protocol_is_not_supported
+    assert_raises(JSchema::InvalidSchema) do
+      dereference_external_schema 'ftp://example.com/', '{}'
+    end
+  end
+
+  private
+
+  def dereference_external_schema(uri, response_schema)
+    stub_request(:get, uri).to_return(body: response_schema)
+    dereference generate_schema(uri)
+  end
+
+  def dereference(schema)
+    JSchema::JSONReference.dereference(schema.uri, schema)
+  end
+
+  def generate_schema(uri)
+    OpenStruct.new(uri: URI(uri), id: generate_id)
+  end
+
+  def generate_id
+    @id ||= 0
+    @id += 1
+  end
+end