jschema 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4564a821e55e9336df4d64292765c8e366e1e262
-  data.tar.gz: 990b4033d9123af1ee0b471d6117f2f570a250e1
+  metadata.gz: 27963957079b8a36781b058fbfcc5a65d05bc982
+  data.tar.gz: a095f424265697a18c1ba7b27359a4352393d06c
 SHA512:
-  metadata.gz: cccc98abfaf52295b9d7f959a94bfbc2ea01310f71893018e586a2137dfaf72d93cca14ffe75af29326bd1aeed3ce511c8b452c2dc0d0999bd85d02a6bc9f233
-  data.tar.gz: 5f4c8f525be757b44e21626a846ca45484fb13eb9690a199cfb40da244726e2b00a7e83e331cee81385267baa6002d16b400f786847e277370bc177247208f26
+  metadata.gz: 9868e28a5802ba5102e443adfdcdd1342371157a5aa77a7a6a0adfe84a6ed56024436c5ee9a232524f4c36d15a16a2a25fb53f51fb68067dfbaae85144c7138a
+  data.tar.gz: 2455390ded90bb4a99f6f64cdc48a7bc29d2d4b55a3763b0e052fdb3b71555c092a3aeca3e068404763128893e39263b329182c2427c3856d779b0fc52571c03

data/lib/jschema.rb

@@ -4,6 +4,7 @@ require 'delegate'
 
 require 'jschema/json_reference'
 require 'jschema/schema_ref'
+require 'jschema/schema_uri'
 require 'jschema/schema'
 require 'jschema/simple_validator'
 require 'jschema/validator'

data/lib/jschema/json_reference.rb

@@ -1,3 +1,5 @@
+require 'json'
+
 module JSchema
   module JSONReference
     @mutex = Mutex.new
@@ -5,30 +7,66 @@ module JSchema
 
     class << self
       def register_schema(schema)
-        schema_key = key(schema.uri, schema)
+        schema_key = key(normalize(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)
+        schema_key = key(expand_uri(uri, schema), schema)
+        cached_schema = @mutex.synchronize do
+          @schemas[schema_key] if schema_key
+        end
+
+        if cached_schema
+          cached_schema
+        elsif uri.absolute? && !schema_part?(uri, schema)
+          build_external_schema(uri, schema)
+        end
       end
 
       private
 
+      def expand_uri(uri, schema)
+        if schema && schema.uri.absolute?
+          normalize schema.uri.merge(uri)
+        else
+          normalize uri
+        end
+      end
+
+      def normalize(uri)
+        normalized = uri.dup
+        normalized.fragment = nil if normalized.fragment == ''
+        normalized.normalize
+      end
+
+      def schema_part?(uri, schema)
+        if schema
+          uri1_base = uri.dup
+          uri1_base.fragment = ''
+
+          uri2_base = schema.uri.dup
+          uri2_base.fragment = ''
+
+          uri1_base == uri2_base
+        else
+          false
+        end
+      end
+
       def build_external_schema(uri, schema)
         unless valid_external_uri?(uri)
-          fail InvalidSchema, 'Invalid URI for external schema'
+          fail InvalidSchema, "Invalid URI for external schema: #{uri}"
         end
 
-        sch = JSON.parse download_schema(uri)
-        register_schema Schema.new(sch, uri, schema.parent)
+        schema_data = JSON.parse download_schema(uri)
+        parent_schema = schema && schema.parent
+        Schema.build(schema_data, parent_schema, uri.to_s)
       rescue JSON::ParserError, Timeout::Error
-        raise InvalidSchema, 'Failed to download external schema'
+        raise InvalidSchema, "Failed to download external schema: #{uri}"
       end
 
       def valid_external_uri?(uri)
@@ -40,16 +78,20 @@ module JSchema
         request['Accept'] = 'application/json+schema'
 
         http = Net::HTTP.new(uri.hostname, uri.port)
-        http.read_timeout = 1
+        http.read_timeout = 3
+        http.open_timeout = 2
         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}"
+        if schema
+          root_schema = root(schema)
+          "#{root_schema.object_id}:#{uri}"
+        else
+          uri.to_s
+        end
       end
 
       def root(schema)

data/lib/jschema/method_call_logger.rb

@@ -0,0 +1,70 @@
+require 'logger'
+
+# Unobtrusive logger for method calls.
+module JSchema
+  module MethodCallLogger
+    class << self
+      def enable(log_class)
+        sub_classes = [log_class]
+        sub_classes.each do |klass|
+          # We want to observe only the given class and all its subclasses
+          observe_class klass
+
+          klass.constants.each do |class_sym|
+            sub_class = klass.const_get(class_sym)
+
+            # FIXME: misleading condintion
+            if sub_class.is_a?(Module) &&
+                sub_class.name.start_with?(log_class.name)
+
+              sub_classes << sub_class
+            end
+          end
+        end
+      end
+
+      def log_method_call(klass, method, args)
+        logger.info "#{klass.name}##{method}(#{args.join(', ')})"
+      end
+
+      private
+
+      def logger
+        @logger ||= Logger.new(STDOUT)
+      end
+
+      def observe_class(observable)
+        # Override public instance methods
+        observable.public_instance_methods(false).each do |method|
+          observable.class_eval do
+
+            # Redefine each public method so that each method call is logged
+            # first and then it is forwarded to the origin method
+
+            original_method = public_instance_method(method)
+
+            define_method(method) do |*args, &block|
+              MethodCallLogger.log_method_call self.class, method, args
+              original_method.bind(self).call(*args, &block)
+            end
+          end
+        end
+
+        # Override public "class" methods
+        observable.methods(false).each do |method|
+          original_method = observable.method(method).unbind
+          observable.define_singleton_method(method) do |*args, &block|
+
+            # FIXME: The following line causes ruby (2.1.2 p95) to crash
+            # MethodCallLogger.log_method_call observable, method, args
+            # But it works when the method is inserted "inline"
+            logger = Logger.new(STDOUT)
+            logger.info "#{observable.name}.#{method}(#{args.join(', ')})"
+
+            original_method.bind(self).call(*args, &block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jschema/schema.rb

@@ -9,13 +9,15 @@ module JSchema
         check_schema_version schema
 
         if (json_reference = schema['$ref'])
-          ref_uri = URI(json_reference)
-          SchemaRef.new(ref_uri, parent)
+          unescaped_ref = json_reference.gsub(/~1|~0/, '~1' => '/', '~0' => '~')
+          SchemaRef.new(URI(unescaped_ref), parent)
         else
-          uri = establish_uri(schema, parent, id)
-          jschema = new(schema, uri, parent)
-          register_definitions schema, jschema
-          JSONReference.register_schema jschema
+          uri = SchemaURI.build(schema['id'], parent, id)
+          parent && JSONReference.dereference(uri, parent) || begin
+            jschema = new(schema, uri, parent)
+            register_definitions schema, jschema
+            JSONReference.register_schema jschema
+          end
         end
       end
 
@@ -28,25 +30,6 @@ module JSchema
         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|

data/lib/jschema/schema_ref.rb

@@ -7,7 +7,10 @@ module JSchema
     end
 
     def __getobj__
-      @schema ||= JSONReference.dereference(@uri, @parent)
+      @schema ||= begin
+        JSONReference.dereference(@uri, @parent) ||
+          Kernel.fail(InvalidSchema, "Failed to dereference schema: #{@uri}")
+      end
     end
   end
 end

data/lib/jschema/schema_uri.rb

@@ -0,0 +1,37 @@
+module JSchema
+  class SchemaURI
+    class << self
+      # String, Schema, String
+      def build(schema_id, parent_schema, id)
+        # RFC 3986, cl. 5.1
+        if parent_schema
+          if parent_schema.uri.absolute?
+            new_uri_part = schema_id ||
+              join_fragments(parent_schema.uri.fragment, id)
+
+            parent_schema.uri.merge(new_uri_part).normalize
+          elsif parent_schema.uri.path.empty?
+            join_fragments(parent_schema.uri.fragment, id)
+          else
+            # RFC 3986, cl. 5.1.4
+            fail InvalidSchema, 'Cannot establish base URI'
+          end
+        else
+          uri(schema_id || id || '#')
+        end
+      end
+
+      private
+
+      def join_fragments(primary, secondary)
+        uri('#' + File.join(primary || '', secondary || ''))
+      end
+
+      def uri(uri_string)
+        # NOTE: We need to escape % because URI class does not allow such
+        # characters within URI fragment (which is wrong).
+        URI(URI.escape(uri_string, '%'))
+      end
+    end
+  end
+end

data/lib/jschema/simple_validator.rb

@@ -2,14 +2,11 @@ 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
+      protected
 
       attr_accessor :keywords
     end
@@ -60,17 +57,20 @@ module JSchema
     end
 
     def number?(value)
-      integer?(value) || value.is_a?(Float) || value.is_a?(BigDecimal)
+      value.is_a?(Numeric)
     end
 
-    def unique_non_empty_array?(value)
-      value.is_a?(Array) &&
-      !value.empty? &&
-      value.size == value.uniq.size
+    def non_empty_array?(value, uniqueness_check = true)
+      result = value.is_a?(Array) && !value.empty?
+      if uniqueness_check
+        result && value.size == value.uniq.size
+      else
+        result
+      end
     end
 
-    def schema_array?(value, id)
-      unique_non_empty_array?(value) &&
+    def schema_array?(value, id, uniqueness_check = true)
+      non_empty_array?(value, uniqueness_check) &&
       value.to_enum.with_index.all? do |schema, index|
         full_id = [id, index].join('/')
         valid_schema? schema, full_id
@@ -78,7 +78,7 @@ module JSchema
     end
 
     def valid_schema?(schema, id)
-      schema.is_a?(Hash) && !!Schema.build(schema, parent, id)
+      schema.is_a?(Hash) && Schema.build(schema, parent, id)
     rescue InvalidSchema
       false
     end

data/lib/jschema/validator/dependencies.rb

@@ -23,7 +23,7 @@ module JSchema
       end
 
       def valid_property_dependency?(dependency)
-        unique_non_empty_array?(dependency) &&
+        non_empty_array?(dependency) &&
         dependency.all? { |property| property.is_a?(String) }
       end
 
@@ -48,8 +48,8 @@ module JSchema
           schema = Schema.build(validator, parent, property)
           schema.validate(instance)
         when Array
-          required = Validator::Required.new(validator)
-          required.validate(instance)
+          required = Validator::Required.new(validator, nil)
+          Array required.validate(instance)
         else
           fail UnknownError
         end

data/lib/jschema/validator/enum.rb

@@ -6,7 +6,7 @@ module JSchema
       self.keywords = ['enum']
 
       def validate_args(enum)
-        unique_non_empty_array?(enum) || invalid_schema('enum', enum)
+        non_empty_array?(enum) || invalid_schema('enum', enum)
       end
 
       def post_initialize(enum)

data/lib/jschema/validator/format.rb

@@ -9,7 +9,7 @@ module JSchema
 
       def validate_args(format)
         allowed_formats =
-          ['date-time', 'email', 'hostname', 'ipv4', 'ipv6', 'uri']
+          ['date-time', 'email', 'hostname', 'ipv4', 'ipv6', 'uri', 'regex']
 
         if allowed_formats.include?(format)
           true
@@ -70,6 +70,13 @@ module JSchema
       rescue URI::InvalidURIError
         false
       end
+
+      def regex(instance)
+        Regexp.new(instance)
+        true
+      rescue TypeError, RegexpError
+        false
+      end
     end
   end
 end

data/lib/jschema/validator/items.rb

@@ -20,12 +20,12 @@ module JSchema
       def items_valid?(items)
         items.nil? ||
         valid_schema?(items, 'items') ||
-        schema_array?(items, 'items') ||
+        schema_array?(items, 'items', false) ||
           invalid_schema('items', items)
       end
 
       def post_initialize(items, additional_items)
-        @items = items
+        @items = items || {}
         @additional_items = additional_items
       end
 

data/lib/jschema/validator/multiple_of.rb

@@ -14,12 +14,13 @@ module JSchema
       end
 
       def post_initialize(multiple_of)
-        @multiple_of = multiple_of
+        @multiple_of = BigDecimal.new(multiple_of.to_s)
       end
 
       def validate_instance(instance)
-        div_remainder = instance.abs % @multiple_of
-        unless div_remainder.abs < 1e-6
+        number = BigDecimal.new(instance.to_s)
+        div_remainder = number % @multiple_of
+        unless div_remainder == 0
           "#{instance} must be a multiple of #{@multiple_of}"
         end
       end

data/lib/jschema/validator/pattern.rb

@@ -14,7 +14,7 @@ module JSchema
       def validate_args(pattern)
         Regexp.new(pattern)
         true
-      rescue TypeError, PrimitiveFailure
+      rescue TypeError, PrimitiveFailure, RegexpError
         invalid_schema 'pattern', pattern
       end
 

data/lib/jschema/validator/properties.rb

@@ -32,13 +32,24 @@ module JSchema
       end
 
       def valid_properties?(properties)
-        properties.nil? ||
-          (properties.is_a?(Hash) && properties.all? { |_, v| v.is_a?(Hash) })
+        properties.nil? || properties.is_a?(Hash)
       end
 
       def post_initialize(properties, pattern_properties, additional_properties)
-        @properties = properties
-        @additional_properties = additional_properties
+        @properties =
+          if properties.is_a?(Hash)
+            properties.each_with_object({}) do |(field, sch), res|
+              res[field] = Schema.build(sch, parent, "properties/#{field}")
+            end
+          end
+
+        @additional_properties =
+          if additional_properties.is_a?(Hash)
+            Schema.build(additional_properties, parent, 'additionalProperties')
+          else
+            additional_properties
+          end
+
         @pattern_properties = pattern_properties
       end
 
@@ -67,26 +78,26 @@ module JSchema
       private
 
       def schemas_for(field)
-        [
-          properties_schema(field),
-          additional_properties_schema(field),
-          *pattern_properties_schema(field)
-        ].compact
+        schemas = pattern_properties_schema(field)
+
+        if (psch = properties_schema(field))
+          schemas << psch
+        end
+
+        if schemas.empty? && (asch = additional_properties_schema)
+          schemas << asch
+        end
+
+        schemas
       end
 
       def properties_schema(field)
-        if @properties.is_a?(Hash)
-          if (sch = @properties[field])
-            Schema.build(sch, parent, 'properties')
-          end
-        end
+        @properties[field] if @properties.is_a?(Hash)
       end
 
-      def additional_properties_schema(field)
-        if @additional_properties.is_a?(Hash)
-          if (sch = @additional_properties[field])
-            Schema.build(sch, parent, 'additionalProperties')
-          end
+      def additional_properties_schema
+        if @additional_properties.respond_to?(:validate)
+          @additional_properties 
         end
       end
 
@@ -95,7 +106,7 @@ module JSchema
         if @pattern_properties.is_a?(Hash)
           @pattern_properties.each do |pattern, sch|
             if field.match(pattern)
-              schemas << Schema.build(sch, parent, 'patternProperties')
+              schemas << Schema.build(sch, parent, "patternProperties/#{field}")
             end
           end
         end

data/lib/jschema/validator/required.rb

@@ -19,14 +19,14 @@ module JSchema
 
       def validate_instance(instance)
         @required.each do |required_property|
-          if instance[required_property].nil?
+          unless instance.key?(required_property)
             return "#{instance} must have property `#{required_property}`"
           end
         end and nil
       end
 
       def valid_required?(required)
-        unique_non_empty_array?(required) &&
+        non_empty_array?(required) &&
         required.all? { |req| req.is_a?(String) }
       end
     end

data/lib/jschema/validator/type.rb

@@ -6,7 +6,7 @@ module JSchema
       self.keywords = ['type']
 
       def validate_args(type)
-        if type.is_a?(String) || unique_non_empty_array?(type)
+        if type.is_a?(String) || non_empty_array?(type)
           true
         else
           invalid_schema 'type', type

data/test/test_json_reference.rb

@@ -9,7 +9,7 @@ class TestJSONReference < Minitest::Test
   def test_schema_registration_and_dereferencing
     schema = generate_schema('registered')
     JSchema::JSONReference.register_schema schema
-    assert_equal dereference(schema), schema
+    assert_equal schema, dereference(schema)
   end
 
   def test_schema_dereferencing_with_same_uri
@@ -18,8 +18,8 @@ class TestJSONReference < Minitest::Test
     JSchema::JSONReference.register_schema schema1
     JSchema::JSONReference.register_schema schema2
 
-    assert_equal dereference(schema1), schema1
-    assert_equal dereference(schema2), schema2
+    assert_equal schema1, dereference(schema1)
+    assert_equal schema2, dereference(schema2)
   end
 
   def test_dereferencing_external_schema
@@ -29,7 +29,7 @@ class TestJSONReference < Minitest::Test
     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
+        dereference_external_schema schema_uri, external_schema.to_json, false
       end
     end
   end
@@ -62,19 +62,50 @@ class TestJSONReference < Minitest::Test
     end
   end
 
+  def test_dereferencing_within_schema_with_non_default_uri
+    schema = generate_schema('http://example.com/', false)
+    JSchema::JSONReference.register_schema schema
+    assert_equal schema, JSchema::JSONReference.dereference(URI('#'), schema)
+  end
+
+  def test_dereferencing_root_schema
+    schema1 = generate_schema('#', false)
+    schema2 = generate_schema('http://example.com/', false)
+    JSchema::JSONReference.register_schema schema1
+    JSchema::JSONReference.register_schema schema2
+
+    assert_equal schema2,
+      JSchema::JSONReference.dereference(URI('#'), schema2)
+
+    assert_equal schema2,
+      JSchema::JSONReference.dereference(URI('http://example.com/#'), schema2)
+
+    assert_equal schema2,
+      JSchema::JSONReference.dereference(URI('http://example.com/'), schema2)
+  end
+
+  def test_dereferencing_schema_by_slightly_different_uri
+    schema = generate_schema('http://example.com/#', false)
+    JSchema::JSONReference.register_schema schema
+
+    assert_equal schema,
+      JSchema::JSONReference.dereference(URI('http://example.com/'), schema)
+  end
+
   private
 
-  def dereference_external_schema(uri, response_schema)
+  def dereference_external_schema(uri, response_schema, parent = true)
     stub_request(:get, uri).to_return(body: response_schema)
-    dereference generate_schema(uri)
+    dereference generate_schema(uri, parent)
   end
 
   def dereference(schema)
-    JSchema::JSONReference.dereference(schema.uri, schema)
+    JSchema::JSONReference.dereference(schema.uri, schema.parent)
   end
 
-  def generate_schema(uri)
-    OpenStruct.new(uri: URI(uri), id: generate_id)
+  def generate_schema(uri, parent = true)
+    parent_schema = generate_schema('#', false) if parent
+    OpenStruct.new(uri: URI(uri), id: generate_id, parent: parent_schema)
   end
 
   def generate_id

data/test/test_schema.rb

@@ -1,4 +1,5 @@
 require 'minitest/autorun'
+require 'webmock/minitest'
 require 'jschema'
 
 require_relative 'assert_received'
@@ -25,41 +26,6 @@ class TestSchema < Minitest::Test
     end
   end
 
-  def test_default_schema_uri
-    assert_equal URI('#'), schema_uri
-  end
-
-  def test_schema_uri_when_parent_is_not_specified
-    assert_equal URI('test'), schema_uri('test')
-  end
-
-  def test_schema_uri_when_parent_uri_is_absolute
-    uri = schema_uri('test', 'http://example.com/')
-    assert_equal URI('http://example.com/test'), uri
-  end
-
-  def test_schema_uri_when_parent_uri_is_relative
-    assert_raises(JSchema::InvalidSchema) do
-      schema_uri('relative/', 'relative/')
-    end
-  end
-
-  def test_schema_uri_when_both_parent_and_schema_uri_are_absolute
-    schema_id = 'http://example.com/'
-    parent_id = 'http://localhost/'
-    uri = schema_uri(schema_id, parent_id)
-    assert_equal URI(schema_id), uri
-  end
-
-  def test_schema_uri_when_ids_are_not_specified
-    assert_equal URI('#/child'), schema_uri(nil, nil, 'child')
-  end
-
-  def test_that_schema_uri_is_normalized
-    uri = schema_uri('etc/../path', 'http://Example.com')
-    assert_equal 'http://example.com/path', uri.to_s
-  end
-
   def test_json_refenrece
     schema = Object.new
     JSchema::SchemaRef.stub :new, schema do
@@ -68,6 +34,20 @@ class TestSchema < Minitest::Test
     end
   end
 
+  def test_that_tilda_is_unescaped
+    expected_ref_uri = URI('#/definitions/sch~')
+    assert_received JSchema::SchemaRef, :new, [expected_ref_uri, nil] do
+      JSchema::Schema.build('$ref' => '#/definitions/sch~0')
+    end
+  end
+
+  def test_that_forward_slash_is_unescaped
+    expected_ref_uri = URI('#/definitions/sch/sch')
+    assert_received JSchema::SchemaRef, :new, [expected_ref_uri, nil] do
+      JSchema::Schema.build('$ref' => '#/definitions/sch~1sch')
+    end
+  end
+
   def test_storing_schema_in_registry
     sch = Object.new
     JSchema::Schema.stub :new, sch do
@@ -77,12 +57,29 @@ class TestSchema < Minitest::Test
     end
   end
 
+  # TODO: Make it isolated.
+  def test_schema_caching
+    parent = JSchema::Schema.build
+    sch = { 'type' => 'string' }
+    schema1 = JSchema::Schema.build(sch, parent)
+    schema2 = JSchema::Schema.build(sch, parent)
+    assert_equal schema1.object_id, schema2.object_id
+  end
+
+  # TODO: Make it isolated.
+  def test_that_root_schemas_are_not_cached
+    sch = { 'type' => 'string' }
+    schema1 = JSchema::Schema.build(sch)
+    schema2 = JSchema::Schema.build(sch)
+    refute_equal schema1.object_id, schema2.object_id
+  end
+
   # TODO: Make it isolated.
   def test_definitions
-    schema_def_uri = '#/definitions/schema1'
+    schema_def_uri = URI('#/definitions/schema1')
     schema = JSchema::Schema.build('definitions' => { 'schema1' => {} })
     definition = JSchema::SchemaRef.new(schema_def_uri, schema)
-    assert_equal URI(schema_def_uri), definition.uri
+    assert_equal schema_def_uri, definition.uri
   end
 
   def test_that_exception_is_raised_when_schema_version_is_not_supported

data/test/test_schema_ref.rb

@@ -8,4 +8,12 @@ class TestSchemaRef < Minitest::Test
       assert_equal JSchema::SchemaRef.new(schema.uri, nil), schema
     end
   end
+
+  def test_that_exception_is_raised_if_reference_is_incorrect
+    JSchema::JSONReference.stub :dereference, nil do
+      assert_raises(JSchema::InvalidSchema) do
+        JSchema::SchemaRef.new('invalid', nil).parent
+      end
+    end
+  end
 end

data/test/test_schema_uri.rb

@@ -0,0 +1,56 @@
+require 'minitest/autorun'
+require 'jschema'
+
+class TestSchemaURI < Minitest::Test
+  def test_default_uri
+    assert_equal URI('#'), schema_uri
+  end
+
+  def test_schema_uri_when_parent_is_not_specified
+    assert_equal URI('test'), schema_uri('test')
+  end
+
+  def test_schema_uri_when_parent_uri_is_absolute
+    uri = schema_uri('test', 'http://example.com/')
+    assert_equal URI('http://example.com/test'), uri
+  end
+
+  def test_schema_uri_when_parent_uri_is_relative
+    assert_raises(JSchema::InvalidSchema) do
+      schema_uri('relative/', 'relative/')
+    end
+  end
+
+  def test_schema_uri_when_both_parent_and_schema_uri_are_absolute
+    schema_id = 'http://example.com/'
+    parent_id = 'http://localhost/'
+    uri = schema_uri(schema_id, parent_id)
+    assert_equal URI(schema_id), uri
+  end
+
+  def test_schema_uri_when_ids_are_not_specified
+    assert_equal URI('#/child'), schema_uri(nil, nil, 'child')
+  end
+
+  def test_that_schema_uri_is_normalized
+    uri = schema_uri('etc/../path', 'http://Example.com')
+    assert_equal URI('http://example.com/path'), uri
+  end
+
+  def test_that_implicit_schema_id_treated_as_uri_fragment
+    uri = schema_uri(nil, 'http://example.com/path#sch', 'sub')
+    assert_equal URI('http://example.com/path#sch/sub'), uri
+  end
+
+  def test_escaping
+    uri = schema_uri(nil, '#/definitions', 'schema%')
+    assert_equal URI('#/definitions/schema%25'), uri
+  end
+
+  private
+
+  def schema_uri(schema_id = nil, parent_id = nil, id = nil)
+    parent_schema = JSchema::Schema.build('id' => parent_id) if parent_id || id
+    JSchema::SchemaURI.build(schema_id, parent_schema, id)
+  end
+end

data/test/validator/test_dependencies.rb

@@ -94,7 +94,7 @@ class TestDependencies < Minitest::Test
     validator_stub =
       Struct.new(:valid) do
         def validate(_)
-          valid ? [] : ['error']
+          'error' unless valid
         end
       end
 

data/test/validator/test_format.rb

@@ -62,6 +62,14 @@ class TestFormat < Minitest::Test
     refute validator('uri').valid?('://')
   end
 
+  def test_passing_validation_by_regex
+    assert validator('regex').valid?('\d+')
+  end
+
+  def test_failing_validation_by_regex
+    refute validator('regex').valid?('**')
+  end
+
   private
 
   def validator_class

data/test/validator/test_items.rb

@@ -28,6 +28,11 @@ class TestItems < Minitest::Test
     assert_raises_unless_schema_array 'items'
   end
 
+  def test_default_value_for_items
+    validator = build_from_schema('additionalItems' => false)
+    assert validator.valid? [1, 2, 3]
+  end
+
   def test_passing_validation_by_items_schema
     stub_schema_validations(true) do
       assert build_from_schema('items' => {}).valid?(['test'])
@@ -35,8 +40,9 @@ class TestItems < Minitest::Test
   end
 
   def test_passing_validation_by_items_schema_array
+    basic_schema = generate_schema
     stub_schema_validations(true) do
-      schema = { 'items' => [generate_schema, generate_schema] }
+      schema = { 'items' => [basic_schema, basic_schema] }
       assert build_from_schema(schema).valid?(['test', 'test'])
     end
   end

data/test/validator/test_properties.rb

@@ -17,14 +17,6 @@ class TestProperties < Minitest::Test
     end
   end
 
-  def test_invalid_properties_schema_argument
-    keywords.each do |keyword|
-      assert_raises(JSchema::InvalidSchema) do
-        build_from_schema(keyword => { 'test' => 1 })
-      end
-    end
-  end
-
   def test_passing_properties_validation_by_sub_schema
     keywords.each do |keyword|
       assert_passing_validation keyword

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jschema
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors:
 - Konstantin Papkovskiy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-29 00:00:00.000000000 Z
+date: 2014-08-22 00:00:00.000000000 Z
 dependencies: []
 description: Implementation of JSON Schema Draft 4
 email: konstantin@papkovskiy.com
@@ -18,8 +18,10 @@ extra_rdoc_files: []
 files:
 - lib/jschema.rb
 - lib/jschema/json_reference.rb
+- lib/jschema/method_call_logger.rb
 - lib/jschema/schema.rb
 - lib/jschema/schema_ref.rb
+- lib/jschema/schema_uri.rb
 - lib/jschema/simple_validator.rb
 - lib/jschema/string_length_validator.rb
 - lib/jschema/validator.rb
@@ -52,6 +54,7 @@ files:
 - test/test_json_reference.rb
 - test/test_schema.rb
 - test/test_schema_ref.rb
+- test/test_schema_uri.rb
 - test/test_validator.rb
 - test/validator/argument_is_array_of_schemas_tests.rb
 - test/validator/assertions.rb
@@ -101,7 +104,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.0
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: JSON Schema implementation
@@ -113,6 +116,7 @@ test_files:
 - test/test_json_reference.rb
 - test/test_schema.rb
 - test/test_schema_ref.rb
+- test/test_schema_uri.rb
 - test/test_validator.rb
 - test/validator/argument_is_array_of_schemas_tests.rb
 - test/validator/assertions.rb