json-schema 1.0.5 → 1.0.6

data/README.textile

@@ -18,7 +18,7 @@ From the git repo:
 
 <pre>
 $ gem build json-schema.gemspec
-$ gem install json-schema-1.0.5.gem
+$ gem install json-schema-1.0.6.gem
 </pre>
 
 

data/lib/json-schema.rb

@@ -11,7 +11,7 @@ if begin
   
   # Force MultiJson to load an engine before we define the JSON constant here; otherwise,
   # it looks for things that are under the JSON namespace that aren't there (since we have defined it here)
-  MultiJson.engine
+  MultiJson.respond_to?(:adapter) ? MultiJson.adapter : MultiJson.engine
 end
 
 $LOAD_PATH.unshift "#{File.dirname(__FILE__)}/json-schema"
@@ -21,4 +21,4 @@ require 'schema'
 require 'validator'
 Dir[File.join(File.dirname(__FILE__), "json-schema/attributes/*.rb")].each {|file| require file }
 Dir[File.join(File.dirname(__FILE__), "json-schema/validators/*.rb")].each {|file| require file }
-require 'uri/file'
+require 'uri/file'

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

@@ -4,12 +4,12 @@ module JSON
       def self.validate(current_schema, data, fragments, validator, options = {})
         case current_schema.schema['format']
 
-        # Timestamp in restricted ISO-8601 YYYY-MM-DDThh:mm:ssZ
+        # Timestamp in restricted ISO-8601 YYYY-MM-DDThh:mm:ssZ with optional decimal fraction of the second
         when 'date-time'
           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"
+            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"
             validation_error(error_message, fragments, current_schema, self, options[:record_errors]) and return if !data.is_a?(String)
-            r = Regexp.new('^\d\d\d\d-\d\d-\d\dT(\d\d):(\d\d):(\d\d)Z$')
+            r = Regexp.new('^\d\d\d\d-\d\d-\d\dT(\d\d):(\d\d):(\d\d)([\.,]\d+)?Z$')
             if (m = r.match(data))
               parts = data.split("T")
               begin

data/lib/json-schema/validator.rb

@@ -296,6 +296,14 @@ module JSON
         end
       end
 
+      def validate_json(schema, data, opts={})
+        validate(schema, data, opts.merge(:json => true))
+      end
+
+      def validate_uri(schema, data, opts={})
+        validate(schema, data, opts.merge(:uri => true))
+      end
+
       def validate!(schema, data,opts={})
         validator = JSON::Validator.new(schema, data, opts)
         validator.validate
@@ -303,6 +311,13 @@ module JSON
       end
       alias_method 'validate2', 'validate!'
 
+      def validate_json!(schema, data, opts={})
+        validate!(schema, data, opts.merge(:json => true))
+      end
+
+      def validate_uri!(schema, data, opts={})
+        validate!(schema, data, opts.merge(:uri => true))
+      end
 
       def fully_validate(schema, data, opts={})
         opts[:record_errors] = true
@@ -316,6 +331,13 @@ module JSON
         fully_validate(schema, data, opts)
       end
 
+      def fully_validate_json(schema, data, opts={})
+        fully_validate(schema, data, opts.merge(:json => true))
+      end
+
+      def fully_validate_uri(schema, data, opts={})
+        fully_validate(schema, data, opts.merge(:uri => true))
+      end
 
       def clear_cache
         @@schemas = {} if @@cache_schemas == false
@@ -363,7 +385,7 @@ module JSON
 
       def json_backend
         if defined?(MultiJson)
-          MultiJson.engine
+          MultiJson.respond_to?(:adapter) ? MultiJson.adapter : MultiJson.engine
         else
           @@json_backend
         end
@@ -372,7 +394,7 @@ module JSON
       def json_backend=(backend)
         if defined?(MultiJson)
           backend = backend == 'json' ? 'json_gem' : backend
-          MultiJson.engine = backend
+          MultiJson.respond_to?(:use) ? MultiJson.use(backend) : MultiJson.engine = backend
         else
           backend = backend.to_s
           if @@available_json_backends.include?(backend)
@@ -385,7 +407,7 @@ module JSON
 
       def parse(s)
         if defined?(MultiJson)
-          MultiJson.decode(s)
+          MultiJson.respond_to?(:load) ? MultiJson.load(s) : MultiJson.decode(s)
         else
           case @@json_backend.to_s
           when 'json'
@@ -451,7 +473,7 @@ module JSON
 
     def serialize schema
       if defined?(MultiJson)
-        MultiJson.encode(schema)
+        MultiJson.respond_to?(:dump) ? MultiJson.dump(schema) : MultiJson.encode(schema)
       else
         @@serializer.call(schema)
       end
@@ -510,20 +532,35 @@ module JSON
 
 
     def initialize_data(data)
-      # Parse the data, if any
-      if data.is_a?(String)
+      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
+        data = JSON::Validator.parse(open(json_uri.to_s).read)
+      elsif data.is_a?(String)
         begin
           data = JSON::Validator.parse(data)
         rescue
-          json_uri = URI.parse(data)
-          if json_uri.relative?
-            if data[0,1] == '/'
-              schema_uri = URI.parse("file://#{data}")
-            else
-              schema_uri = URI.parse("file://#{Dir.pwd}/#{data}")
+          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
+            data = JSON::Validator.parse(open(json_uri.to_s).read)
+          rescue
+            # Silently discard the error - the data will not change
           end
-          data = JSON::Validator.parse(open(json_uri.to_s).read)
         end
       end
       data

data/test/test_files.rb

@@ -16,13 +16,21 @@ class JSONSchemaTest < Test::Unit::TestCase
   
   def test_data_from_file
     schema = {"type" => "object", "properties" => {"a" => {"type" => "integer"}}}
-    assert(JSON::Validator.validate(schema,File.join(File.dirname(__FILE__),"data/good_data_1.json")))
-    assert(!JSON::Validator.validate(schema,File.join(File.dirname(__FILE__),"data/bad_data_1.json")))
+    assert(JSON::Validator.validate_uri(schema,File.join(File.dirname(__FILE__),"data/good_data_1.json")))
+    assert(!JSON::Validator.validate_uri(schema,File.join(File.dirname(__FILE__),"data/bad_data_1.json")))
+  end
+  
+  def test_data_from_json
+    if JSON::Validator.json_backend != nil
+      schema = {"type" => "object", "properties" => {"a" => {"type" => "integer"}}}
+      assert(JSON::Validator.validate_json(schema, %Q({"a" : 5})))
+      assert(!JSON::Validator.validate_json(schema, %Q({"a" : "poop"})))
+    end
   end
   
   def test_both_from_file
-    assert(JSON::Validator.validate(File.join(File.dirname(__FILE__),"schemas/good_schema_1.json"),File.join(File.dirname(__FILE__),"data/good_data_1.json")))
-    assert(!JSON::Validator.validate(File.join(File.dirname(__FILE__),"schemas/good_schema_1.json"),File.join(File.dirname(__FILE__),"data/bad_data_1.json")))
+    assert(JSON::Validator.validate_uri(File.join(File.dirname(__FILE__),"schemas/good_schema_1.json"),File.join(File.dirname(__FILE__),"data/good_data_1.json")))
+    assert(!JSON::Validator.validate_uri(File.join(File.dirname(__FILE__),"schemas/good_schema_1.json"),File.join(File.dirname(__FILE__),"data/bad_data_1.json")))
   end
     
   def test_file_ref

data/test/test_full_validation.rb

@@ -145,4 +145,65 @@ class JSONFullValidation < Test::Unit::TestCase
     assert(errors[1][:failed_attribute] == "Type")
     assert(errors[1][:fragment] == "#/c")
   end
+  
+  def test_full_validation_with_nested_required_properties
+    schema = {
+      "$schema" => "http://json-schema.org/draft-03/schema#",
+      "type" => "object",
+      "properties" => {
+        "x" => {
+          "required" => true,
+          "type" => "object",
+          "properties" => {
+            "a" => {"type"=>"integer","required"=>true},
+            "b" => {"type"=>"integer","required"=>true},
+            "c" => {"type"=>"integer","required"=>false},
+            "d" => {"type"=>"integer","required"=>false},
+            "e" => {"type"=>"integer","required"=>false},
+          }
+        }
+      }
+    }
+    data = {"x" => {"a"=>5, "d"=>5, "e"=>"what?"}}
+    
+    errors = JSON::Validator.fully_validate(schema,data,:errors_as_objects => true)
+    assert_equal 2, errors.length
+    assert_equal '#/x', errors[0][:fragment]
+    assert_equal 'Properties', errors[0][:failed_attribute]
+    assert_equal '#/x/e', errors[1][:fragment]
+    assert_equal 'Type', errors[1][:failed_attribute]
+  end
+  
+  def test_full_validation_with_nested_required_propertiesin_array
+    schema = {
+      "$schema" => "http://json-schema.org/draft-03/schema#",
+      "type" => "object",
+      "properties" => {
+        "x" => {
+          "required" => true,
+          "type" => "array",
+          "items" => {
+            "type" => "object",
+            "properties" => {
+              "a" => {"type"=>"integer","required"=>true},
+              "b" => {"type"=>"integer","required"=>true},
+              "c" => {"type"=>"integer","required"=>false},
+              "d" => {"type"=>"integer","required"=>false},
+              "e" => {"type"=>"integer","required"=>false},
+            }
+          }
+        }
+      }
+    }
+    missing_b= {"a"=>5}
+    e_is_wrong_type= {"a"=>5,"b"=>5,"e"=>"what?"}
+    data = {"x" => [missing_b, e_is_wrong_type]}
+    
+    errors = JSON::Validator.fully_validate(schema,data,:errors_as_objects => true)
+    assert_equal 2, errors.length
+    assert_equal '#/x/0', errors[0][:fragment]
+    assert_equal 'Properties', errors[0][:failed_attribute]
+    assert_equal '#/x/1/e', errors[1][:fragment]
+    assert_equal 'Type', errors[1][:failed_attribute]
+  end
 end

data/test/test_jsonschema_draft3.rb

@@ -28,6 +28,8 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
     data['a'] = true
     assert(!JSON::Validator.validate(schema,data))
     
+    assert(JSON::Validator.validate({'type' => 'integer'}, 3))
+    assert(!JSON::Validator.validate({'type' => 'integer'}, "hello"))
     
     # Test numbers
     schema["properties"]["a"]["type"] = "number"
@@ -43,6 +45,10 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
     data['a'] = true
     assert(!JSON::Validator.validate(schema,data))
     
+    assert(JSON::Validator.validate({'type' => 'number'}, 3))
+    assert(JSON::Validator.validate({'type' => 'number'}, 3.14159265358979))
+    assert(!JSON::Validator.validate({'type' => 'number'}, "hello"))
+    
     
     # Test strings
     schema["properties"]["a"]["type"] = "string"
@@ -58,6 +64,10 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
     data['a'] = true
     assert(!JSON::Validator.validate(schema,data))
     
+    assert(JSON::Validator.validate({'type' => 'string'}, 'hello'))
+    assert(!JSON::Validator.validate({'type' => 'string'}, 3.14159265358979))
+    assert(!JSON::Validator.validate({'type' => 'string'}, []))
+    
     
     # Test booleans
     schema["properties"]["a"]["type"] = "boolean"
@@ -76,6 +86,12 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
     data['a'] = false
     assert(JSON::Validator.validate(schema,data))
     
+    assert(JSON::Validator.validate({'type' => 'boolean'}, true))
+    assert(JSON::Validator.validate({'type' => 'boolean'}, false))
+    assert(!JSON::Validator.validate({'type' => 'boolean'}, nil))
+    assert(!JSON::Validator.validate({'type' => 'boolean'}, 3))
+    assert(!JSON::Validator.validate({'type' => 'boolean'}, "hello"))
+    
     
     # Test object
     schema["properties"]["a"]["type"] = "object"
@@ -91,6 +107,12 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
     data['a'] = true
     assert(!JSON::Validator.validate(schema,data))
     
+    assert(JSON::Validator.validate({'type' => 'objec'}, {'a' => true}))
+    assert(JSON::Validator.validate({'type' => 'object'}, {}))
+    assert(!JSON::Validator.validate({'type' => 'object'}, []))
+    assert(!JSON::Validator.validate({'type' => 'object'}, 3))
+    assert(!JSON::Validator.validate({'type' => 'object'}, "hello"))
+    
     
     # Test array
     schema["properties"]["a"]["type"] = "array"
@@ -106,6 +128,12 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
     data['a'] = true
     assert(!JSON::Validator.validate(schema,data))
     
+    assert(JSON::Validator.validate({'type' => 'array'}, ['a']))
+    assert(JSON::Validator.validate({'type' => 'array'}, []))
+    assert(!JSON::Validator.validate({'type' => 'array'}, {}))
+    assert(!JSON::Validator.validate({'type' => 'array'}, 3))
+    assert(!JSON::Validator.validate({'type' => 'array'}, "hello"))
+    
     
     # Test null
     schema["properties"]["a"]["type"] = "null"
@@ -121,6 +149,11 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
     data['a'] = true
     assert(!JSON::Validator.validate(schema,data))
     
+    assert(JSON::Validator.validate({'type' => 'null'}, nil))
+    assert(!JSON::Validator.validate({'type' => 'null'}, false))
+    assert(!JSON::Validator.validate({'type' => 'null'}, []))
+    assert(!JSON::Validator.validate({'type' => 'null'}, "hello"))
+    
     
     # Test any
     schema["properties"]["a"]["type"] = "any"
@@ -136,6 +169,12 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
     data['a'] = true
     assert(JSON::Validator.validate(schema,data))
     
+    assert(JSON::Validator.validate({'type' => 'any'}, true))
+    assert(JSON::Validator.validate({'type' => 'any'}, nil))
+    assert(JSON::Validator.validate({'type' => 'any'}, {}))
+    assert(JSON::Validator.validate({'type' => 'any'}, 3))
+    assert(JSON::Validator.validate({'type' => 'any'}, "hello"))
+    
     
     # Test a union type
     schema["properties"]["a"]["type"] = ["integer","string"]
@@ -148,6 +187,9 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
     data["a"] = false
     assert(!JSON::Validator.validate(schema,data))
     
+    assert(JSON::Validator.validate({'type' => ['string', 'null']}, "hello"))
+    assert(!JSON::Validator.validate({'type' => ['integer', 'object']}, "hello"))
+    
     # Test a union type with schemas
     schema["properties"]["a"]["type"] = [{ "type" => "string" }, {"type" => "object", "properties" => {"b" => {"type" => "integer"}}}]
   
@@ -883,6 +925,10 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
     
     data = {"a" => "2010-01-01T12:00:00Z"}
     assert(JSON::Validator.validate(schema,data))
+  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))	
     data = {"a" => "2010-01-32T12:00:00Z"}
     assert(!JSON::Validator.validate(schema,data))
     data = {"a" => "2010-13-01T12:00:00Z"}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: json-schema
 version: !ruby/object:Gem::Version
-  version: 1.0.5
+  version: 1.0.6
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-21 00:00:00.000000000 Z
+date: 2012-05-29 00:00:00.000000000 Z
 dependencies: []
 description: 
 email: hoxworth@gmail.com