json-schema 2.3.0 → 2.4.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    YzRhZDY5NzVjYTlkZTM4MDU4YjI1Mjg5YWI3MmJkMDdhNjFiZGE3OA==
+    ZjMyNzMwODM4YmUyNjNkZjBhNzkzN2E4M2MxYTM2YzhiMzg4MzZlYw==
   data.tar.gz: !binary |-
-    YWJhZDY3ZWRlZDBlNWFiNDc0ZTM5MzcyZjkyNWJkNWViOGNjN2NiMA==
+    ZWY0NWQ1ZWRlMzVlNTI4N2NhYjk0ZGM4OGIxMzMzNzU5NGE2ZmEwYg==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    OTYzYzFkYzlkMjM5NjY0ZjBmNTVjM2IwZmM0ODQxZWQwMDk5OGE5MTliMmQw
-    MmMwYjAwNWE3NzkzMDYzNzUzN2Q0M2RhMjNmNTFlZGYzZDE0MmMxMTRjM2I2
-    NGM2ZWIxMmE0N2NjMjBjMjRmZTk3NDYyY2Q2YTcyMjNhYzEzMTY=
+    MDE3Yzc0MmYwNmFkNjUzYmNiYTFhYjg4ODY5MzZjODgyZWIyODBkYWUwZjJh
+    NjJjODk4MGFhNTFlOTkyOTZkYTQ5ODQ2YjYxYjJjZGNjZWIxOTcxNzEyMmYy
+    NzI2MDcwNGU5Mzg0N2IyYzU5NzU0NThkMTNjZjFmZDVhZGNiNjc=
   data.tar.gz: !binary |-
-    YWY3ZjZkMTcxMWRhNDA0MWQxODk3MWQwNzc0NjgyZTc2ZjE5YzE4MjYwYjFj
-    NzI5N2I3NDRhYWM0Y2U4MjhmNDMxZTc1YWYwZmRhNWMxODk5ZjU1YzliZmFm
-    YmY4MTA0ZWRlMzYyMWQ1NDA3MDk5MzUwYmJkN2ExNmQ0NDU5ZjA=
+    ZDJjNzIyZDg0NDUxODQyZjM4MzZkNWUxOWViYTA3MDM4MjdmN2Q2ZjBkOTBi
+    NzllYzUyNDc5MDZkZmM0M2U3NmFiZDc5Njk3YTYxNzBiMjYwYjIwMjZmZWY0
+    M2QxMzIwN2EzOTUxNWRjZmQ5ZGQwZTEwNjBjMDVjZTBlNTAxZWE=

data/README.textile

@@ -1,4 +1,5 @@
 !https://travis-ci.org/hoxworth/json-schema.svg?branch=master!:https://travis-ci.org/hoxworth/json-schema
+!https://codeclimate.com/github/hoxworth/json-schema/badges/gpa.svg!:https://codeclimate.com/github/hoxworth/json-schema
 
 h1. Ruby JSON Schema Validator
 
@@ -24,7 +25,7 @@ From the git repo:
 
 <pre>
 $ gem build json-schema.gemspec
-$ gem install json-schema-2.3.0.gem
+$ gem install json-schema-2.4.0.gem
 </pre>
 
 
@@ -329,6 +330,46 @@ data = {"a" => 0, "b" => "taco"}
 JSON::Validator.validate(schema,data) # => false
 </pre>
 
+h3. Custom format validation
+
+The JSON schema standard allows custom formats in schema definitions which should be ignored by validators that do not support them. JSON::Schema allows registering procs as custom format validators which receive the value to be checked as parameter and must raise a <code>JSON::Schema::CustomFormatError</code> to indicate a format violation. The error message will be prepended by the property namne, e.g. "The property '#a'":
+
+<pre>
+require 'rubygems'
+require 'json-schema'
+
+format_proc = -> value {
+  raise JSON::Schema::CustomFormatError.new("must be 42") unless value == "42"
+}
+
+# register the proc for format 'the-answer' for draft4 schema
+JSON::Validator.register_format_validator("the-answer", format_proc, ["draft4"])
+
+# omitting the version parameter uses ["draft1", "draft2", "draft3", "draft4"] as default
+JSON::Validator.register_format_validator("the-answer", format_proc)
+
+# deregistering the custom validator
+# (also ["draft1", "draft2", "draft3", "draft4"] as default version)
+JSON::Validator.deregister_format_validator('the-answer', ["draft4"])
+
+# shortcut to restore the default formats for validators (same default as before)
+JSON::Validator.restore_default_formats(["draft4"])
+
+# with the validator registered as above, the following results in
+# ["The property '#a' must be 42"] as returned errors
+schema = {
+  "$schema" => "http://json-schema.org/draft-04/schema#",
+  "properties" => {
+    "a" => {
+      "type" => "string",
+      "format" => "the-answer",
+    }
+  }
+}
+errors = JSON::Validator.fully_validate(schema, {"a" => "23"})
+
+</pre>
+
 h2. JSON Backends
 
 The JSON Schema library currently supports the <code>json</code> and <code>yajl-ruby</code> backend JSON parsers. If either of these libraries are installed, they will be automatically loaded and used to parse any JSON strings supplied by the user.
@@ -348,8 +389,10 @@ The 'format' attribute is only validated for the following values:
 * date-time
 * date
 * time
-* ip-address
+* ip-address (IPv4 address in draft1, draft2 and draft3)
+* ipv4 (IPv4 address in draft4)
 * ipv6
+* uri
 
 All other 'format' attribute values are simply checked to ensure the instance value is of the correct datatype (e.g., an instance value is validated to be an integer or a float in the case of 'utc-millisec').
 

data/lib/json-schema.rb

@@ -1,12 +1,6 @@
 require 'rubygems'
 
-if begin
-  Gem::Specification::find_by_name('multi_json')
-  rescue Gem::LoadError
-    false
-  rescue
-    Gem.available?('multi_json')
-  end
+if Gem::Specification::find_all_by_name('multi_json').any?
   require 'multi_json'
 
   # Force MultiJson to load an engine before we define the JSON constant here; otherwise,
@@ -14,7 +8,6 @@ if begin
   MultiJson.respond_to?(:adapter) ? MultiJson.adapter : MultiJson.engine
 end
 
-require 'rubygems'
 require 'json-schema/util/hash'
 require 'json-schema/util/array_set'
 require 'json-schema/schema'

data/lib/json-schema/attributes/dependencies_v4.rb

@@ -6,12 +6,17 @@ module JSON
       def self.validate(current_schema, data, fragments, processor, validator, options = {})
         if data.is_a?(Hash)
           current_schema.schema['dependencies'].each do |property,dependency_value|
-            if (data.has_key?(property.to_s) || data.has_key?(property.to_sym)) && dependency_value.is_a?(Array)
-              dependency_value.each do |value|
-                if !data.has_key?(value.to_s) && !data.has_key?(value.to_sym)
-                  message = "The property '#{build_fragment(fragments)}' has a property '#{property}' that depends on a missing property '#{value}'"
-                  validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
+            if (data.has_key?(property.to_s) || data.has_key?(property.to_sym))
+              if dependency_value.is_a?(Array)
+                dependency_value.each do |value|
+                  if !data.has_key?(value.to_s) && !data.has_key?(value.to_sym)
+                    message = "The property '#{build_fragment(fragments)}' has a property '#{property}' that depends on a missing property '#{value}'"
+                    validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
+                  end
                 end
+              elsif dependency_value.is_a?(Hash)
+                schema = JSON::Schema.new(dependency_value,current_schema.uri,validator)
+                schema.validate(data, fragments, processor, options)
               end
             end
           end

data/lib/json-schema/attributes/formats/custom.rb

@@ -1,7 +1,6 @@
 require 'json-schema/attribute'
 require 'json-schema/errors/custom_format_error'
 
-require 'uri'
 module JSON
   class Schema
     class CustomFormat < FormatAttribute

data/lib/json-schema/attributes/formats/date.rb

@@ -1,22 +1,21 @@
 require 'json-schema/attribute'
-require 'uri'
+
 module JSON
   class Schema
     class DateFormat < FormatAttribute
+      REGEXP = /\A\d{4}-\d{2}-\d{2}\z/
+
       def self.validate(current_schema, data, fragments, processor, validator, options = {})
         if data.is_a?(String)
           error_message = "The property '#{build_fragment(fragments)}' must be a date in the format of YYYY-MM-DD"
-          r = Regexp.new('^\d\d\d\d-\d\d-\d\d$')
-          if (r.match(data))
+          if REGEXP.match(data)
             begin
               Date.parse(data)
             rescue Exception
               validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors])
-              return
             end
           else
             validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors])
-            return
           end
         end
       end

data/lib/json-schema/attributes/formats/date_time.rb

@@ -1,32 +1,33 @@
 require 'json-schema/attribute'
-require 'uri'
+
 module JSON
   class Schema
     class DateTimeFormat < FormatAttribute
+      REGEXP = /\A\d{4}-\d{2}-\d{2}T(\d{2}):(\d{2}):(\d{2})([\.,]\d+)?(Z|[+-](\d{2})(:?\d{2})?)?\z/
+
       def self.validate(current_schema, data, fragments, processor, validator, options = {})
         # Timestamp in restricted ISO-8601 YYYY-MM-DDThh:mm:ssZ with optional decimal fraction of the second
         if data.is_a?(String)
           error_message = "The property '#{build_fragment(fragments)}' must be a date/time in the ISO-8601 format of YYYY-MM-DDThh:mm:ssZ or YYYY-MM-DDThh:mm:ss.ssZ"
-          r = Regexp.new('^\d\d\d\d-\d\d-\d\dT(\d\d):(\d\d):(\d\d)([\.,]\d+)?(Z|[+-](\d\d)(:?\d\d)?)?$')
-          if (m = r.match(data))
+          if (m = REGEXP.match(data))
             parts = data.split("T")
+
             begin
               Date.parse(parts[0])
             rescue Exception
               validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors])
               return
             end
+
             begin
               validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors]) and return if m[1].to_i > 23
               validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors]) and return if m[2].to_i > 59
               validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors]) and return if m[3].to_i > 59
             rescue Exception
               validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors])
-              return
             end
           else
             validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors])
-            return
           end
         end
       end

data/lib/json-schema/attributes/formats/date_time_v4.rb

@@ -0,0 +1,18 @@
+require 'json-schema/attribute'
+
+module JSON
+  class Schema
+    class DateTimeV4Format < FormatAttribute
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+        if data.is_a?(String)
+          error_message = "The property '#{build_fragment(fragments)}' must be a valid RFC3339 date/time string"
+          begin
+            DateTime.rfc3339(data)
+          rescue ArgumentError
+            validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json-schema/attributes/formats/ip4.rb

@@ -1,20 +1,18 @@
 require 'json-schema/attribute'
-require 'uri'
+require 'ipaddr'
+
 module JSON
   class Schema
     class IP4Format < FormatAttribute
       def self.validate(current_schema, data, fragments, processor, validator, options = {})
         if data.is_a?(String)
           error_message = "The property '#{build_fragment(fragments)}' must be a valid IPv4 address"
-          r = Regexp.new('^(\d+){1,3}\.(\d+){1,3}\.(\d+){1,3}\.(\d+){1,3}$')
-          if (m = r.match(data))
-            1.upto(4) do |x|
-              validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors]) and return if m[x].to_i > 255
-            end
-          else
-            validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors])
-            return
+          begin
+            ip = IPAddr.new data
+          rescue ArgumentError => e
+            raise e unless e.message == 'invalid address'
           end
+          validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors]) unless ip && ip.ipv4?
         end
       end
     end

data/lib/json-schema/attributes/formats/ip6.rb

@@ -1,28 +1,18 @@
 require 'json-schema/attribute'
-require 'uri'
+require 'ipaddr'
+
 module JSON
   class Schema
     class IP6Format < FormatAttribute
       def self.validate(current_schema, data, fragments, processor, validator, options = {})
         if data.is_a?(String)
           error_message = "The property '#{build_fragment(fragments)}' must be a valid IPv6 address"
-          r = Regexp.new('^[a-f0-9:]+$')
-          if (r.match(data))
-            # All characters are valid, now validate structure
-            parts = data.split(":")
-            validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors]) and return if parts.length > 8
-            condensed_zeros = false
-            parts.each do |part|
-              if part.length == 0
-                validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors]) and return if condensed_zeros
-                condensed_zeros = true
-              end
-              validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors]) and return if part.length > 4
-            end
-          else
-            validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors])
-            return
+          begin
+            ip = IPAddr.new data
+          rescue ArgumentError => e
+            raise e unless e.message == 'invalid address'
           end
+          validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors]) unless ip && ip.ipv6?
         end
       end
     end

data/lib/json-schema/attributes/formats/time.rb

@@ -1,19 +1,19 @@
 require 'json-schema/attribute'
-require 'uri'
+
 module JSON
   class Schema
     class TimeFormat < FormatAttribute
+      REGEXP = /\A(\d{2}):(\d{2}):(\d{2})\z/
+
       def self.validate(current_schema, data, fragments, processor, validator, options = {})
         if data.is_a?(String)
           error_message = "The property '#{build_fragment(fragments)}' must be a time in the format of hh:mm:ss"
-          r = Regexp.new('^(\d\d):(\d\d):(\d\d)$')
-          if (m = r.match(data))
+          if (m = REGEXP.match(data))
             validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors]) and return if m[1].to_i > 23
             validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors]) and return if m[2].to_i > 59
             validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors]) and return if m[3].to_i > 59
           else
             validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors])
-            return
           end
         end
       end

data/lib/json-schema/attributes/ref.rb

@@ -49,6 +49,7 @@ module JSON
           fragment_path = ''
           fragments.each do |fragment|
             if fragment && fragment != ''
+              fragment = URI.unescape(fragment.gsub('~0', '~').gsub('~1', '/'))
               if target_schema.is_a?(Array)
                 target_schema = target_schema[fragment.to_i]
               else

data/lib/json-schema/schema/validator.rb

@@ -1,7 +1,7 @@
 module JSON
   class Schema
     class Validator
-      attr_accessor :attributes, :formats, :uri, :names, :metaschema
+      attr_accessor :attributes, :formats, :uri, :names
       attr_reader :default_formats
 
       def initialize()
@@ -10,7 +10,7 @@ module JSON
         @default_formats = {}
         @uri = nil
         @names = []
-        @metaschema = ''
+        @metaschema_name = ''
       end
 
       def extend_schema_definition(schema_uri)
@@ -26,6 +26,11 @@ module JSON
         end
         data
       end
+
+      def metaschema
+        resources = File.expand_path('../../../../resources', __FILE__)
+        File.join(resources, @metaschema_name)
+      end
     end
   end
 end

data/lib/json-schema/validator.rb

@@ -70,6 +70,7 @@ module JSON
     end
 
     def schema_from_fragment(base_schema, fragment)
+      schema_uri = base_schema.uri
       fragments = fragment.split("/")
 
       # ensure the first element was a hash, per the fragment spec
@@ -82,17 +83,17 @@ module JSON
           if !base_schema.schema.has_key?(f)
             raise JSON::Schema::SchemaError.new("Invalid fragment resolution for :fragment option")
           end
-        base_schema = base_schema.schema[f]
+          base_schema = base_schema.schema[f]
         elsif base_schema.is_a?(Hash)
           if !base_schema.has_key?(f)
             raise JSON::Schema::SchemaError.new("Invalid fragment resolution for :fragment option")
           end
-        base_schema = initialize_schema(base_schema[f]) #need to return a Schema instance for validation to work
+          base_schema = JSON::Schema.new(base_schema[f],schema_uri,@options[:version])
         elsif base_schema.is_a?(Array)
           if base_schema[f.to_i].nil?
             raise JSON::Schema::SchemaError.new("Invalid fragment resolution for :fragment option")
           end
-        base_schema = initialize_schema(base_schema[f.to_i])
+          base_schema = JSON::Schema.new(base_schema[f.to_i],schema_uri,@options[:version])
         else
           raise JSON::Schema::SchemaError.new("Invalid schema encountered when resolving :fragment option")
         end
@@ -417,7 +418,7 @@ module JSON
           when 'yajl'
             json = StringIO.new(s)
             parser = Yajl::Parser.new
-            parser.parse(json)
+            parser.parse(json) or raise JSON::Schema::JsonParseError.new("The JSON could not be parsed by yajl")
           else
             raise JSON::Schema::JsonParseError.new("No supported JSON parsers found. The following parsers are suported:\n * yajl-ruby\n * json")
           end
@@ -425,33 +426,22 @@ module JSON
       end
 
       if !defined?(MultiJson)
-        if begin
-            Gem::Specification::find_by_name('json')
-          rescue Gem::LoadError
-            false
-          rescue
-            Gem.available?('json')
-          end
+        if Gem::Specification::find_all_by_name('json').any?
           require 'json'
           @@available_json_backends << 'json'
           @@json_backend = 'json'
+        else
+          # Try force-loading json for rubies > 1.9.2
+          begin
+            require 'json'
+            @@available_json_backends << 'json'
+            @@json_backend = 'json'
+          rescue LoadError
+          end
         end
 
-        # Try force-loading json for rubies > 1.9.2
-        begin
-          require 'json'
-          @@available_json_backends << 'json'
-          @@json_backend = 'json'
-        rescue LoadError
-        end
 
-        if begin
-            Gem::Specification::find_by_name('yajl-ruby')
-          rescue Gem::LoadError
-            false
-          rescue
-            Gem.available?('yajl-ruby')
-          end
+        if Gem::Specification::find_all_by_name('yajl-ruby').any?
           require 'yajl'
           @@available_json_backends << 'yajl'
           @@json_backend = 'yajl'
@@ -460,9 +450,7 @@ module JSON
         if @@json_backend == 'yajl'
           @@serializer = lambda{|o| Yajl::Encoder.encode(o) }
         else
-          @@serializer = lambda{|o|
-            YAML.dump(o)
-          }
+          @@serializer = lambda{|o| YAML.dump(o) }
         end
       end
 
@@ -478,18 +466,12 @@ module JSON
 
     private
 
-    if begin
-        Gem::Specification::find_by_name('uuidtools')
-      rescue Gem::LoadError
-        false
-      rescue
-        Gem.available?('uuidtools')
-      end
+    if Gem::Specification::find_all_by_name('uuidtools').any?
       require 'uuidtools'
-      @@fake_uri_generator = lambda{|s| UUIDTools::UUID.sha1_create(UUIDTools::UUID_URL_NAMESPACE, s).to_s }
+      @@fake_uuid_generator = lambda{|s| UUIDTools::UUID.sha1_create(UUIDTools::UUID_URL_NAMESPACE, s).to_s }
     else
-      require 'json-schema/uri/uuid'
-      @@fake_uri_generator = lambda{|s| JSON::Util::UUID.create_v5(s,JSON::Util::UUID::Nil).to_s }
+      require 'json-schema/util/uuid'
+      @@fake_uuid_generator = lambda{|s| JSON::Util::UUID.create_v5(s,JSON::Util::UUID::Nil).to_s }
     end
 
     def serialize schema
@@ -500,8 +482,8 @@ module JSON
       end
     end
 
-    def fake_uri schema
-      @@fake_uri_generator.call(schema)
+    def fake_uuid schema
+      @@fake_uuid_generator.call(schema)
     end
 
     def schema_to_list(schema)
@@ -517,7 +499,7 @@ module JSON
       if schema.is_a?(String)
         begin
           # Build a fake URI for this
-          schema_uri = URI.parse(fake_uri(schema))
+          schema_uri = URI.parse(fake_uuid(schema))
           schema = JSON::Validator.parse(schema)
           if @options[:list] && @options[:fragment].nil?
             schema = schema_to_list(schema)
@@ -526,15 +508,7 @@ module JSON
           Validator.add_schema(schema)
         rescue
           # Build a uri for it
-          schema_uri = URI.parse(schema)
-          if schema_uri.relative?
-            # Check for absolute path
-            if schema[0,1] == '/'
-              schema_uri = URI.parse("file://#{schema}")
-            else
-              schema_uri = URI.parse("file://#{Dir.pwd}/#{schema}")
-            end
-          end
+          schema_uri = normalized_uri(schema)
           if Validator.schemas[schema_uri.to_s].nil?
             schema = JSON::Validator.parse(open(schema_uri.to_s).read)
             if @options[:list] && @options[:fragment].nil?
@@ -546,7 +520,7 @@ module JSON
             schema = Validator.schemas[schema_uri.to_s]
             if @options[:list] && @options[:fragment].nil?
               schema = schema_to_list(schema.schema)
-              schema_uri = URI.parse(fake_uri(serialize(schema)))
+              schema_uri = URI.parse(fake_uuid(serialize(schema)))
               schema = JSON::Schema.new(schema, schema_uri, @options[:version])
               Validator.add_schema(schema)
             end
@@ -557,7 +531,7 @@ module JSON
         if @options[:list] && @options[:fragment].nil?
           schema = schema_to_list(schema)
         end
-        schema_uri = URI.parse(fake_uri(serialize(schema)))
+        schema_uri = URI.parse(fake_uuid(serialize(schema)))
         schema = JSON::Schema.new(schema,schema_uri,@options[:version])
         Validator.add_schema(schema)
       else
@@ -572,28 +546,14 @@ module JSON
       if @options[:json]
         data = JSON::Validator.parse(data)
       elsif @options[:uri]
-        json_uri = URI.parse(data)
-        if json_uri.relative?
-          if data[0,1] == '/'
-            json_uri = URI.parse("file://#{data}")
-          else
-            json_uri = URI.parse("file://#{Dir.pwd}/#{data}")
-          end
-        end
+        json_uri = normalized_uri(data)
         data = JSON::Validator.parse(open(json_uri.to_s).read)
       elsif data.is_a?(String)
         begin
           data = JSON::Validator.parse(data)
         rescue
           begin
-            json_uri = URI.parse(data)
-            if json_uri.relative?
-              if data[0,1] == '/'
-                json_uri = URI.parse("file://#{data}")
-              else
-                json_uri = URI.parse("file://#{Dir.pwd}/#{data}")
-              end
-            end
+            json_uri = normalized_uri(data)
             data = JSON::Validator.parse(open(json_uri.to_s).read)
           rescue
             # Silently discard the error - the data will not change
@@ -604,5 +564,18 @@ module JSON
       data
     end
 
+    def normalized_uri(data)
+      uri = URI.parse(data)
+      if uri.relative?
+        # Check for absolute path
+        if data[0,1] == '/'
+          uri = URI.parse("file://#{data}")
+        else
+          uri = URI.parse("file://#{Dir.pwd}/#{data}")
+        end
+      end
+      uri
+    end
+
   end
 end

data/lib/json-schema/validators/draft1.rb

@@ -35,7 +35,7 @@ module JSON
         @formats = @default_formats.clone
         @uri = URI.parse("http://json-schema.org/draft-01/schema#")
         @names = ["draft1"]
-        @metaschema = File.join("resources", "draft-01.json")
+        @metaschema_name = "draft-01.json"
       end
       
       JSON::Validator.register_validator(self.new)

data/lib/json-schema/validators/draft2.rb

@@ -36,7 +36,7 @@ module JSON
         @formats = @default_formats.clone
         @uri = URI.parse("http://json-schema.org/draft-02/schema#")
         @names = ["draft2"]
-        @metaschema = File.join("resources", "draft-02.json")
+        @metaschema_name = "draft-02.json"
       end
       
       JSON::Validator.register_validator(self.new)

data/lib/json-schema/validators/draft3.rb

@@ -40,7 +40,7 @@ module JSON
         @formats = @default_formats.clone
         @uri = URI.parse("http://json-schema.org/draft-03/schema#")
         @names = ["draft3", "http://json-schema.org/draft-03/schema#"]
-        @metaschema = File.join("resources", "draft-03.json")
+        @metaschema_name = "draft-03.json"
       end
       
       JSON::Validator.register_validator(self.new)

data/lib/json-schema/validators/draft4.rb

@@ -37,7 +37,7 @@ module JSON
           "$ref" => JSON::Schema::RefAttribute
         }
         @default_formats = {
-          'date-time' => DateTimeFormat,
+          'date-time' => DateTimeV4Format,
           'ipv4' => IP4Format,
           'ipv6' => IP6Format,
           'uri' => UriFormat
@@ -45,7 +45,7 @@ module JSON
         @formats = @default_formats.clone
         @uri = URI.parse("http://json-schema.org/draft-04/schema#")
         @names = ["draft4", "http://json-schema.org/draft-04/schema#"]
-        @metaschema = File.join("resources", "draft-04.json")
+        @metaschema_name = "draft-04.json"
       end
 
       JSON::Validator.register_validator(self.new)

data/lib/json-schema/validators/hyper-draft4.rb

@@ -0,0 +1,14 @@
+module JSON
+  class Schema
+
+    class HyperDraft4 < Draft4
+      def initialize
+        super
+        @uri = URI.parse("http://json-schema.org/draft-04/hyper-schema#")
+      end
+
+      JSON::Validator.register_validator(self.new)
+      JSON::Validator.register_default_validator(self.new)
+    end
+  end
+end

data/test/test_common_test_suite.rb

@@ -11,11 +11,8 @@ class CommonTestSuiteTest < Test::Unit::TestCase
     "draft3/disallow.json",
     "draft3/optional/format.json",
     "draft3/optional/jsregex.json",
-    "draft3/ref.json",
     "draft3/refRemote.json",
-    "draft4/dependencies.json",
     "draft4/optional/format.json",
-    "draft4/ref.json",
     "draft4/refRemote.json",
   ]
 
@@ -31,20 +28,20 @@ class CommonTestSuiteTest < Test::Unit::TestCase
         v = nil
 
         test["tests"].each do |t|
-          err_id = "#{rel_file}, '#{base_description}'/'#{t['description']}'"
-
-          define_method("test_#{err_id}") do
-            skip "Known incompatibility with common test suite" if IGNORED_TESTS.include?(rel_file)
-
-            assert_nothing_raised("Exception raised running #{err_id}") do
-              v = JSON::Validator.fully_validate(schema,
-                                                 t["data"],
-                                                 :validate_schema => true,
-                                                 :version => version
-                                                )
+          err_id = "#{rel_file}: #{base_description}/#{t['description']}"
+
+          unless IGNORED_TESTS.include?(rel_file)
+            define_method("test_#{err_id}") do
+              assert_nothing_raised("Exception raised running #{err_id}") do
+                v = JSON::Validator.fully_validate(schema,
+                                                   t["data"],
+                                                   :validate_schema => true,
+                                                   :version => version
+                                                  )
+              end
+
+              assert_equal t["valid"], v.empty?, "Common test suite case failed: #{err_id}\n#{v}"
             end
-
-            assert v.empty? == t["valid"], "Common test suite case failed: #{err_id}\n#{v}"
           end
         end
       end

data/test/test_custom_format.rb

@@ -5,7 +5,7 @@ require File.dirname(__FILE__) + '/../lib/json-schema'
 class JSONSchemaCustomFormatTest < Test::Unit::TestCase
   def setup
     @all_versions = ['draft1', 'draft2', 'draft3', 'draft4']
-    @format_proc = -> value { raise JSON::Schema::CustomFormatError.new("must be 42") unless value == "42" }
+    @format_proc = lambda { |value| raise JSON::Schema::CustomFormatError.new("must be 42") unless value == "42" }
     @schema_4 = {
       "$schema" => "http://json-schema.org/draft-04/schema#",
       "properties" => {

data/test/test_fragment_validation_with_ref.rb

@@ -0,0 +1,40 @@
+require File.expand_path('../test_helper', __FILE__)
+require 'json-schema'
+
+class FragmentValidationWithRef < Test::Unit::TestCase
+  def whole_schema
+    {
+      "$schema" => "http://json-schema.org/draft-04/schema#",
+      "type" => "object",
+      "definitions" => {
+        "post" => {
+          "type" => "object",
+          "properties" => {
+            "content" => {
+              "type" => "string"
+            },
+            "author" => {
+              "type" => "string"
+            }
+          }
+        },
+        "posts" => {
+          "type" => "array",
+          "items" => {
+            "$ref" => "#/definitions/post"
+          }
+        }
+      }
+    }
+  end
+
+  def test_validation_of_fragment
+    data = [{"content" => "ohai", "author" => "Bob"}]
+    v = nil
+    assert_nothing_raised do
+      v = JSON::Validator.fully_validate(whole_schema,data,:fragment => "#/definitions/posts")
+    end
+
+    assert(v.empty?, v.join("\n"))
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,2 @@
+require 'test/unit'
+$:.unshift(File.expand_path('../../lib', __FILE__))

data/test/test_jsonschema_draft1.rb

@@ -613,6 +613,8 @@ class JSONSchemaDraft1Test < Test::Unit::TestCase
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
     data = {"a" => "1111:2222:8888:9999:aaaa:cccc:eeee:ffff:bbbb"}
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
+    assert(JSON::Validator.validate(schema, {"a" => "::1"}, :version => :draft1), 'validate with shortcut')
+    assert(!JSON::Validator.validate(schema, {"a" => "42"}, :version => :draft1), 'not validate a simple number')
   end
 
   def test_format_time
@@ -637,6 +639,10 @@ class JSONSchemaDraft1Test < Test::Unit::TestCase
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
     data = {"a" => "12:00:00b"}
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
+    data = {"a" => "12:00:00"}
+    assert(JSON::Validator.validate(schema,data,:version => :draft1))
+    data = {"a" => "12:00:00\nabc"}
+    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
   end
 
 
@@ -658,6 +664,8 @@ class JSONSchemaDraft1Test < Test::Unit::TestCase
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
     data = {"a" => "2010-01-01n"}
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
+    data = {"a" => "2010-01-01\nabc"}
+    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
   end
 
   def test_format_datetime
@@ -682,6 +690,8 @@ class JSONSchemaDraft1Test < Test::Unit::TestCase
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
     data = {"a" => "2010-01-0112:00:00Z"}
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
+    data = {"a" => "2010-01-01T12:00:00Z\nabc"}
+    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
   end
 
   def test_format_unknown

data/test/test_jsonschema_draft2.rb

@@ -685,6 +685,8 @@ class JSONSchemaDraft2Test < Test::Unit::TestCase
     assert(!JSON::Validator.validate(schema,data,:version => :draft2))
     data = {"a" => "1111:2222:8888:9999:aaaa:cccc:eeee:ffff:bbbb"}
     assert(!JSON::Validator.validate(schema,data,:version => :draft2))
+    assert(JSON::Validator.validate(schema, {"a" => "::1"}, :version => :draft2), 'validate with shortcut')
+    assert(!JSON::Validator.validate(schema, {"a" => "42"}, :version => :draft2), 'not validate a simple number')
   end
 
   def test_format_time
@@ -709,6 +711,8 @@ class JSONSchemaDraft2Test < Test::Unit::TestCase
     assert(!JSON::Validator.validate(schema,data,:version => :draft2))
     data = {"a" => "12:00:00b"}
     assert(!JSON::Validator.validate(schema,data,:version => :draft2))
+    data = {"a" => "12:00:00\nabc"}
+    assert(!JSON::Validator.validate(schema,data,:version => :draft2))
   end
 
 
@@ -730,6 +734,8 @@ class JSONSchemaDraft2Test < Test::Unit::TestCase
     assert(!JSON::Validator.validate(schema,data,:version => :draft2))
     data = {"a" => "2010-01-01n"}
     assert(!JSON::Validator.validate(schema,data,:version => :draft2))
+    data = {"a" => "2010-01-01\nabc"}
+    assert(!JSON::Validator.validate(schema,data,:version => :draft2))
   end
 
   def test_format_datetime
@@ -754,6 +760,8 @@ class JSONSchemaDraft2Test < Test::Unit::TestCase
     assert(!JSON::Validator.validate(schema,data,:version => :draft2))
     data = {"a" => "2010-01-0112:00:00Z"}
     assert(!JSON::Validator.validate(schema,data,:version => :draft2))
+    data = {"a" => "2010-01-01T12:00:00Z\nabc"}
+    assert(!JSON::Validator.validate(schema,data,:version => :draft2))
   end
 
   def test_format_unknown

data/test/test_jsonschema_draft3.rb

@@ -984,6 +984,8 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
     assert(!JSON::Validator.validate(schema,data))
     data = {"a" => "1111:2222:8888:9999:aaaa:cccc:eeee:ffff:bbbb"}
     assert(!JSON::Validator.validate(schema,data))
+    assert(JSON::Validator.validate(schema, {"a" => "::1"}), 'validate with shortcut')
+    assert(!JSON::Validator.validate(schema, {"a" => "42"}), 'not validate a simple number')
   end
 
   def test_format_time
@@ -1009,6 +1011,8 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
     assert(!JSON::Validator.validate(schema,data))
     data = {"a" => "12:00:00b"}
     assert(!JSON::Validator.validate(schema,data))
+    data = {"a" => "12:00:00\nabc"}
+    assert(!JSON::Validator.validate(schema,data))
   end
 
 
@@ -1031,6 +1035,8 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
     assert(!JSON::Validator.validate(schema,data))
     data = {"a" => "2010-01-01n"}
     assert(!JSON::Validator.validate(schema,data))
+    data = {"a" => "2010-01-01\nabc"}
+    assert(!JSON::Validator.validate(schema,data))
   end
 
   def test_format_datetime
@@ -1060,6 +1066,8 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
     assert(!JSON::Validator.validate(schema,data))
     data = {"a" => "2010-01-0112:00:00Z"}
     assert(!JSON::Validator.validate(schema,data))
+    data = {"a" => "2010-01-01T12:00:00.1Z\nabc"}
+    assert(!JSON::Validator.validate(schema,data))
 
     # test with a specific timezone
     data = {"a" => "2010-01-01T12:00:00+01"}

data/test/test_jsonschema_draft4.rb

@@ -189,9 +189,7 @@ class JSONSchemaDraft4Test < Test::Unit::TestCase
 
     assert(JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-04/schema#",'type' => ['string', 'null']}, "hello"))
     assert(!JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-04/schema#",'type' => ['integer', 'object']}, "hello"))
-   end
-
-
+  end
 
   def test_required
     # Set up the default datatype
@@ -927,6 +925,8 @@ class JSONSchemaDraft4Test < Test::Unit::TestCase
     assert(!JSON::Validator.validate(schema,data))
     data = {"a" => "1111:2222:8888:9999:aaaa:cccc:eeee:ffff:bbbb"}
     assert(!JSON::Validator.validate(schema,data))
+    assert(JSON::Validator.validate(schema, {"a" => "::1"}), 'validate with shortcut')
+    assert(!JSON::Validator.validate(schema, {"a" => "42"}), 'not validate a simple number')
   end
 
 
@@ -942,9 +942,9 @@ class JSONSchemaDraft4Test < Test::Unit::TestCase
     data = {"a" => "2010-01-01T12:00:00.1Z"}
     assert(JSON::Validator.validate(schema,data))
     data = {"a" => "2010-01-01T12:00:00,1Z"}
-    assert(JSON::Validator.validate(schema,data))
+    assert(!JSON::Validator.validate(schema,data))
     data = {"a" => "2010-01-01T12:00:00+0000"}
-    assert(JSON::Validator.validate(schema,data))
+    assert(!JSON::Validator.validate(schema,data))
     data = {"a" => "2010-01-01T12:00:00+00:00"}
     assert(JSON::Validator.validate(schema,data))
     data = {"a" => "2010-01-32T12:00:00Z"}
@@ -952,13 +952,13 @@ class JSONSchemaDraft4Test < Test::Unit::TestCase
     data = {"a" => "2010-13-01T12:00:00Z"}
     assert(!JSON::Validator.validate(schema,data))
     data = {"a" => "2010-01-01T24:00:00Z"}
-    assert(!JSON::Validator.validate(schema,data))
+    assert(JSON::Validator.validate(schema,data))
     data = {"a" => "2010-01-01T12:60:00Z"}
     assert(!JSON::Validator.validate(schema,data))
     data = {"a" => "2010-01-01T12:00:60Z"}
-    assert(!JSON::Validator.validate(schema,data))
+    assert(JSON::Validator.validate(schema,data))
     data = {"a" => "2010-01-01T12:00:00z"}
-    assert(!JSON::Validator.validate(schema,data))
+    assert(JSON::Validator.validate(schema,data))
     data = {"a" => "2010-01-0112:00:00Z"}
     assert(!JSON::Validator.validate(schema,data))
   end
@@ -1060,6 +1060,32 @@ class JSONSchemaDraft4Test < Test::Unit::TestCase
     assert(JSON::Validator.validate(schema,data))
   end
 
+  def test_schema_dependency
+    schema = {
+      "type"=> "object",
+      "properties"=> {
+        "name"=> { "type"=> "string" },
+        "credit_card"=> { "type"=> "number" }
+      },
+      "required"=> ["name"],
+      "dependencies"=> {
+        "credit_card"=> {
+          "properties"=> {
+            "billing_address"=> { "type"=> "string" }
+          },
+          "required"=> ["billing_address"]
+        }
+      }
+    }
+    data = {
+      "name" => "John Doe",
+      "credit_card" => 5555555555555555
+    }
+    assert(!JSON::Validator.validate(schema,data), 'test schema dependency with invalid data')
+    data['billing_address'] = "Somewhere over the rainbow"
+    assert(JSON::Validator.validate(schema,data), 'test schema dependency with valid data')
+  end
+
   def test_default
     schema = {
       "$schema" => "http://json-schema.org/draft-04/schema#",

data/test/test_ruby_schema.rb

@@ -21,16 +21,16 @@ class RubySchemaTest < Test::Unit::TestCase
 
   def test_symbol_keys
     schema = {
-      type: 'object',
-      required: ["a"],
-      properties: {
-        a: {type: "integer", default: 42},
-        b: {type: "integer"}
+      :type => 'object',
+      :required => ["a"],
+      :properties => {
+        :a => {:type => "integer", :default => 42},
+        :b => {:type => "integer"}
       }
     }
 
     data = {
-      a: 5
+      :a => 5
     }
 
     assert(JSON::Validator.validate(schema, data))
@@ -38,15 +38,15 @@ class RubySchemaTest < Test::Unit::TestCase
 
   def test_symbol_keys_in_hash_within_array
     schema = {
-      type: 'object',
-      properties: {
-        a: {
-          type: "array",
-          items: [
+      :type => 'object',
+      :properties => {
+        :a => {
+          :type => "array",
+          :items => [
             {
-              properties: {
-                b: {
-                  type: "integer"
+              :properties => {
+                :b => {
+                  :type => "integer"
                 }
               }
             }
@@ -56,9 +56,9 @@ class RubySchemaTest < Test::Unit::TestCase
     }
 
     data = {
-      a: [
+      :a => [
         {
-          b: 1
+          :b => 1
         }
       ]
     }

data/test/test_schema_validation.rb

@@ -1,4 +1,5 @@
 require 'test/unit'
+require 'tmpdir'
 require File.dirname(__FILE__) + '/../lib/json-schema'
 
 class JSONSchemaValidation < Test::Unit::TestCase
@@ -82,4 +83,14 @@ class JSONSchemaValidation < Test::Unit::TestCase
     assert(JSON::Validator.validate(valid_schema_v3,data,:validate_schema => true))
     assert(!JSON::Validator.validate(invalid_schema_v3,data,:validate_schema => true))
   end
+
+  def test_schema_validation_from_different_directory
+    Dir.mktmpdir do |tmpdir|
+      Dir.chdir(tmpdir) do
+        data = {"b" => {"a" => 5}}
+        assert(JSON::Validator.validate(valid_schema_v4,data,:validate_schema => true, :version => :draft4))
+        assert(!JSON::Validator.validate(invalid_schema_v4,data,:validate_schema => true, :version => :draft4))
+      end
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: json-schema
 version: !ruby/object:Gem::Version
-  version: 2.3.0
+  version: 2.4.0
 platform: ruby
 authors:
 - Kenny Hoxworth
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-26 00:00:00.000000000 Z
+date: 2014-10-28 00:00:00.000000000 Z
 dependencies: []
 description: 
 email: hoxworth@gmail.com
@@ -33,6 +33,7 @@ files:
 - lib/json-schema/attributes/formats/custom.rb
 - lib/json-schema/attributes/formats/date.rb
 - lib/json-schema/attributes/formats/date_time.rb
+- lib/json-schema/attributes/formats/date_time_v4.rb
 - lib/json-schema/attributes/formats/ip4.rb
 - lib/json-schema/attributes/formats/ip6.rb
 - lib/json-schema/attributes/formats/time.rb
@@ -69,14 +70,15 @@ files:
 - lib/json-schema/schema/validator.rb
 - lib/json-schema/schema.rb
 - lib/json-schema/uri/file.rb
-- lib/json-schema/uri/uuid.rb
 - lib/json-schema/util/array_set.rb
 - lib/json-schema/util/hash.rb
+- lib/json-schema/util/uuid.rb
 - lib/json-schema/validator.rb
 - lib/json-schema/validators/draft1.rb
 - lib/json-schema/validators/draft2.rb
 - lib/json-schema/validators/draft3.rb
 - lib/json-schema/validators/draft4.rb
+- lib/json-schema/validators/hyper-draft4.rb
 - lib/json-schema.rb
 - resources/draft-01.json
 - resources/draft-02.json
@@ -93,7 +95,9 @@ files:
 - test/test_extends_and_additionalProperties.rb
 - test/test_files_v3.rb
 - test/test_fragment_resolution.rb
+- test/test_fragment_validation_with_ref.rb
 - test/test_full_validation.rb
+- test/test_helper.rb
 - test/test_jsonschema_draft1.rb
 - test/test_jsonschema_draft2.rb
 - test/test_jsonschema_draft3.rb
@@ -139,12 +143,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.8.7
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '1.8'
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.0.7
@@ -161,7 +165,9 @@ test_files:
 - test/test_extends_and_additionalProperties.rb
 - test/test_files_v3.rb
 - test/test_fragment_resolution.rb
+- test/test_fragment_validation_with_ref.rb
 - test/test_full_validation.rb
+- test/test_helper.rb
 - test/test_jsonschema_draft1.rb
 - test/test_jsonschema_draft2.rb
 - test/test_jsonschema_draft3.rb