json_schema 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c09e98d77f8312b241a686e9754c64868f3168cd
-  data.tar.gz: 37c8aa03c7b3c20f1297521e1ad028450ef1dbe9
+  metadata.gz: 090872e4eabd4666b863192705b856a9bed17f95
+  data.tar.gz: d663a4d178b532eedea87e3b9e103e11c618169a
 SHA512:
-  metadata.gz: c4eaccae952cb463de80492d3e5903e0f597dfed795ccdd2929c253ba4efd27a4b97b07527f6eef6b9f4ba3a0c943ab6c305ada987586f4d52c9a47d8adfb9b4
-  data.tar.gz: c126e71608055b4747d7556548a268021ba388fbccf77893408e5b6e166d9c9d53ca25a1e4da4a78416a4893f6797bf81a56c73795097302a776528679cae2ca
+  metadata.gz: ab37926ea68afd15a71c4ca1be9ee265b990caf1e24901c031ea094bea806b671472cd65cec3225f420ba1baed6ec3acc41063b505d6eda3a95bbb028c20664b
+  data.tar.gz: 2345cc253f9cb16f2f542234f0c705a4d97e256beb55c1cba45b190be570b46c7691193ca01b176f13c702bc2356e9e300e63dcfe17532ab714e27500ba3397b

data/README.md

@@ -15,11 +15,11 @@ validate-schema schema.json data.json
 require "json"
 require "json_schema"
 
-# parse the schema
+# parse the schema - raise SchemaError if it's invalid
 schema_data = JSON.parse(File.read("schema.json"))
 schema = JsonSchema.parse!(schema_data)
 
-# validate some data
+# validate some data - raise ValidationError if it doesn't conform
 data = JSON.parse(File.read("data.json"))
 schema.validate!(data)
 
@@ -29,6 +29,14 @@ schema.links.each do |link|
 end
 ```
 
+Errors have a `message` (for humans), and `type` (for machines).
+`ValidationError`s also include a `path`, a JSON pointer to the location in
+the supplied document which violated the schema. See [errors](docs/errors.md)
+for more info.
+
+Non-bang methods return a two-element array, with `true`/`false` at index 0
+to indicate pass/fail, and an array of errors at index 1 (if any).
+
 ## Development
 
 Run the test suite with:
@@ -42,4 +50,4 @@ Or run specific suites or tests with:
 ```
 ruby -Ilib -Itest test/json_schema/validator_test.rb
 ruby -Ilib -Itest test/json_schema/validator_test.rb -n /anyOf/
-```
+```

data/lib/json_schema/parser.rb

@@ -108,8 +108,8 @@ module JsonSchema
       if !data.is_a?(Hash)
         # it would be nice to make this message more specific/nicer (at best it
         # points to the wrong schema)
-        message = %{Expected schema; value was: #{data.inspect}.}
-        @errors << SchemaError.new(parent, message)
+        message = %{#{data.inspect} is not a valid schema.}
+        @errors << SchemaError.new(parent, message, :schema_not_found)
       elsif ref = data["$ref"]
         schema = Schema.new
         schema.fragment = fragment
@@ -314,7 +314,7 @@ module JsonSchema
       if schema.type
         if !(bad_types = schema.type - ALLOWED_TYPES).empty?
           message = %{Unknown types: #{bad_types.sort.join(", ")}.}
-          @errors << SchemaError.new(schema, message)
+          @errors << SchemaError.new(schema, message, :unknown_type)
         end
       end
     end
@@ -324,8 +324,8 @@ module JsonSchema
         types.map { |t| FRIENDLY_TYPES[t] || t }.sort.uniq.join("/")
       value = schema.data[field]
       if !value.nil? && !types.any? { |t| value.is_a?(t) }
-        message = %{Expected "#{field}" to be of type "#{friendly_types}"; value was: #{value.inspect}.}
-        @errors << SchemaError.new(schema, message)
+        message = %{#{value.inspect} is not a valid "#{field}", must be a #{friendly_types}.}
+        @errors << SchemaError.new(schema, message, :invalid_type)
         nil
       else
         value

data/lib/json_schema/reference_expander.rb

@@ -25,7 +25,7 @@ module JsonSchema
       refs = unresolved_refs(schema).sort
       if refs.count > 0
         message = %{Couldn't resolve references: #{refs.to_a.join(", ")}.}
-        @errors << SchemaError.new(schema, message)
+        @errors << SchemaError.new(schema, message, :unresolved_references)
       end
 
       @errors.count == 0
@@ -73,8 +73,8 @@ module JsonSchema
 
       # detects a reference cycle
       if ref_stack.include?(ref)
-        message = %{Reference cycle detected: #{ref_stack.sort.join(", ")}.}
-        @errors << SchemaError.new(ref_schema, message)
+        message = %{Reference loop detected: #{ref_stack.sort.join(", ")}.}
+        @errors << SchemaError.new(ref_schema, message, :loop_detected)
         return false
       end
 
@@ -128,7 +128,7 @@ module JsonSchema
         # couldn't resolve pointer within known schema; that's an error
         if data.nil?
           message = %{Couldn't resolve pointer "#{ref.pointer}".}
-          @errors << SchemaError.new(resolved_schema, message)
+          @errors << SchemaError.new(resolved_schema, message, :unresolved_pointer)
           return
         end
 
@@ -159,7 +159,7 @@ module JsonSchema
         else
           message =
             %{Reference resolution over #{scheme} is not currently supported.}
-          @errors << SchemaError.new(ref_schema, message)
+          @errors << SchemaError.new(ref_schema, message, :scheme_not_supported)
           nil
         end
       # absolute
@@ -182,7 +182,7 @@ module JsonSchema
         resolve_pointer(ref_schema, schema)
       else
         message = %{Couldn't resolve URI: #{uri.to_s}.}
-        @errors << SchemaError.new(ref_schema, message)
+        @errors << SchemaError.new(ref_schema, message, :unresolved_pointer)
         nil
       end
     end

data/lib/json_schema/schema_error.rb

@@ -1,15 +1,15 @@
 module JsonSchema
   class SchemaError
-    attr_accessor :message
-    attr_accessor :schema
+    attr_accessor :message, :schema, :type
 
     def self.aggregate(errors)
       errors.map(&:to_s)
     end
 
-    def initialize(schema, message)
+    def initialize(schema, message, type)
       @schema = schema
       @message = message
+      @type = type
     end
 
     def to_s
@@ -20,8 +20,8 @@ module JsonSchema
   class ValidationError < SchemaError
     attr_accessor :path
 
-    def initialize(schema, path, message)
-      super(schema, message)
+    def initialize(schema, path, message, type)
+      super(schema, message, type)
       @path = path
     end
 

data/lib/json_schema/validator.rb

@@ -45,7 +45,7 @@ module JsonSchema
         true
       else
         message = %{Validation loop detected.}
-        errors << ValidationError.new(schema, path, message)
+        errors << ValidationError.new(schema, path, message, :loop_detected)
         false
       end
 =end
@@ -143,8 +143,8 @@ module JsonSchema
       valid = schema.all_of.all? do |subschema|
         validate_data(subschema, data, errors, path)
       end
-      message = %{Data did not match all subschemas of "allOf" condition.}
-      errors << ValidationError.new(schema, path, message) if !valid
+      message = %{Not all subschemas of "allOf" matched.}
+      errors << ValidationError.new(schema, path, message, :all_of_failed) if !valid
       valid
     end
 
@@ -154,8 +154,8 @@ module JsonSchema
         validate_data(subschema, data, [], path)
       end
       if !valid
-        message = %{Data did not match any subschema of "anyOf" condition.}
-        errors << ValidationError.new(schema, path, message)
+        message = %{No subschema in "anyOf" matched.}
+        errors << ValidationError.new(schema, path, message, :any_of_failed)
       end
       valid
     end
@@ -197,8 +197,8 @@ module JsonSchema
       if valid
         true
       else
-        message = %{Expected data to match "#{schema.format}" format, value was: #{data}.}
-        errors << ValidationError.new(schema, path, message)
+        message = %{#{data} is not a valid #{schema.format}.}
+        errors << ValidationError.new(schema, path, message, :invalid_format)
         false
       end
     end
@@ -208,8 +208,8 @@ module JsonSchema
       if schema.enum.include?(data)
         true
       else
-        message = %{Expected data to be a member of enum #{schema.enum}, value was: #{data}.}
-        errors << ValidationError.new(schema, path, message)
+        message = %{#{data} is not a member of #{schema.enum}.}
+        errors << ValidationError.new(schema, path, message, :invalid_type)
         false
       end
     end
@@ -219,8 +219,12 @@ module JsonSchema
       if extra.empty?
         true
       else
-        message = %{Extra keys in object: #{extra.sort.join(", ")}.}
-        errors << ValidationError.new(schema, path, message)
+
+        message = %{"#{extra.sort.join('", "')}" } +
+          (extra.length == 1 ? "is not a" : "are not") +
+          %{ permitted key} +
+          (extra.length == 1 ? "." : "s.")
+        errors << ValidationError.new(schema, path, message, :invalid_keys)
         false
       end
     end
@@ -229,12 +233,20 @@ module JsonSchema
       return true unless schema.items
       if schema.items.is_a?(Array)
         if data.size < schema.items.count
-          message = %{Expected array to have at least #{schema.items.count} item(s), had #{data.size} item(s).}
-          errors << ValidationError.new(schema, path, message)
+          message = %{#{schema.items.count} item} +
+            (schema.items.count == 1 ? "" : "s") +
+            %{ required; only #{data.size} } +
+            (data.size == 1 ? "was" : "were") +
+            %{ supplied.}
+          errors << ValidationError.new(schema, path, message, :min_items_failed)
           false
         elsif data.size > schema.items.count && !schema.additional_items?
-          message = %{Expected array to have no more than #{schema.items.count} item(s), had #{data.size} item(s).}
-          errors << ValidationError.new(schema, path, message)
+          message = %{No more than #{schema.items.count} item} +
+            (schema.items.count == 1 ? " is" : "s are") +
+            %{ allowed; #{data.size} } +
+            (data.size > 1 ? "were" : "was") +
+            %{ supplied.}
+          errors << ValidationError.new(schema, path, message, :max_items_failed)
           false
         else
           valid = true
@@ -261,8 +273,10 @@ module JsonSchema
       elsif !schema.max_exclusive? && data <= schema.max
         true
       else
-        message = %{Expected data to be smaller than maximum #{schema.max} (exclusive: #{schema.max_exclusive?}), value was: #{data}.}
-        errors << ValidationError.new(schema, path, message)
+        message = %{#{data} must be less than} +
+          (schema.max_exclusive? ? "" : " or equal to") +
+          %{ #{schema.max}.}
+        errors << ValidationError.new(schema, path, message, :max_failed)
         false
       end
     end
@@ -272,8 +286,12 @@ module JsonSchema
       if data.size <= schema.max_items
         true
       else
-        message = %{Expected array to have no more than #{schema.max_items} item(s), had #{data.size} item(s).}
-        errors << ValidationError.new(schema, path, message)
+        message = %{No more than #{schema.max_items} item} +
+          (schema.max_items == 1 ? " is" : "s are") +
+          %{ allowed; #{data.size} } +
+          (data.size == 1 ? "was" : "were")+
+          %{ supplied.}
+        errors << ValidationError.new(schema, path, message, :max_items_failed)
         false
       end
     end
@@ -283,8 +301,12 @@ module JsonSchema
       if data.length <= schema.max_length
         true
       else
-        message = %{Expected string to have a maximum length of #{schema.max_length}, was #{data.length} character(s) long.}
-        errors << ValidationError.new(schema, path, message)
+        message = %{Only #{schema.max_length} character} +
+          (schema.max_length == 1 ? " is" : "s are") +
+          %{ allowed; #{data.length} } +
+          (data.length == 1 ? "was" : "were") +
+          %{ supplied.}
+        errors << ValidationError.new(schema, path, message, :max_length_failed)
         false
       end
     end
@@ -294,8 +316,12 @@ module JsonSchema
       if data.keys.size <= schema.max_properties
         true
       else
-        message = %{Expected object to have a maximum of #{schema.max_properties} property/ies; it had #{data.keys.size}.}
-        errors << ValidationError.new(schema, path, message)
+        message = %{No more than #{schema.max_properties} propert} +
+          (schema.max_properties == 1 ? "y is" : "ies are") +
+          %{ allowed; #{data.keys.size} } +
+          (data.keys.size == 1 ? "was" : "were") +
+          %{ supplied.}
+        errors << ValidationError.new(schema, path, message, :max_properties_failed)
         false
       end
     end
@@ -307,8 +333,10 @@ module JsonSchema
       elsif !schema.min_exclusive? && data >= schema.min
         true
       else
-        message = %{Expected data to be larger than minimum #{schema.min} (exclusive: #{schema.min_exclusive?}), value was: #{data}.}
-        errors << ValidationError.new(schema, path, message)
+        message = %{#{data} must be greater than} +
+          (schema.min_exclusive? ? "" : " or equal to") +
+          %{ #{schema.min}.}
+        errors << ValidationError.new(schema, path, message, :min_failed)
         false
       end
     end
@@ -318,8 +346,12 @@ module JsonSchema
       if data.size >= schema.min_items
         true
       else
-        message = %{Expected array to have at least #{schema.min_items} item(s), had #{data.size} item(s).}
-        errors << ValidationError.new(schema, path, message)
+        message = %{#{schema.min_items} item} +
+          (schema.min_items == 1 ? "" : "s") +
+          %{ required; only #{data.size} } +
+          (data.size == 1 ? "was" : "were") +
+          %{ supplied.}
+        errors << ValidationError.new(schema, path, message, :min_items_failed)
         false
       end
     end
@@ -329,8 +361,12 @@ module JsonSchema
       if data.length >= schema.min_length
         true
       else
-        message = %{Expected string to have a minimum length of #{schema.min_length}, was #{data.length} character(s) long.}
-        errors << ValidationError.new(schema, path, message)
+        message = %{At least #{schema.min_length} character} +
+          (schema.min_length == 1 ? " is" : "s are") +
+          %{ required; only #{data.length} } +
+          (data.length == 1 ? "was" : "were") +
+          %{ supplied.}
+        errors << ValidationError.new(schema, path, message, :min_length_failed)
         false
       end
     end
@@ -340,8 +376,12 @@ module JsonSchema
       if data.keys.size >= schema.min_properties
         true
       else
-        message = %{Expected object to have a minimum of #{schema.min_properties} property/ies; it had #{data.keys.size}.}
-        errors << ValidationError.new(schema, path, message)
+        message = %{At least #{schema.max_properties} propert}+
+          (schema.max_properties == 1 ? "y is" : "ies are") +
+          %{ required; #{data.keys.size} }+
+          (data.keys.size == 1 ? "was" : "were") +
+          %{ supplied.}
+        errors << ValidationError.new(schema, path, message, :min_properties_failed)
         false
       end
     end
@@ -351,8 +391,8 @@ module JsonSchema
       if data % schema.multiple_of == 0
         true
       else
-        message = %{Expected data to be a multiple of #{schema.multiple_of}, value was: #{data}.}
-        errors << ValidationError.new(schema, path, message)
+        message = %{#{data} is not a multiple of #{schema.multiple_of}.}
+        errors << ValidationError.new(schema, path, message, :multiple_of_failed)
         false
       end
     end
@@ -363,8 +403,13 @@ module JsonSchema
         validate_data(subschema, data, [], path)
       end
       if num_valid != 1
-        message = %{Data did not match exactly one subschema of "oneOf" condition.}
-        errors << ValidationError.new(schema, path, message)
+        message =
+          if num_valid == 0
+            %{No subschema in "oneOf" matched.}
+          else
+            %{More than one subschema in "oneOf" matched.}
+          end
+        errors << ValidationError.new(schema, path, message, :one_of_failed)
       end
       num_valid == 1
     end
@@ -375,8 +420,8 @@ module JsonSchema
       # incorrectly for the inverse condition
       valid = !validate_data(schema.not, data, [], path)
       if !valid
-        message = %{Data matched subschema of "not" condition.}
-        errors << ValidationError.new(schema, path, message)
+        message = %{Matched "not" subschema.}
+        errors << ValidationError.new(schema, path, message, :not_failed)
       end
       valid
     end
@@ -386,8 +431,8 @@ module JsonSchema
       if data =~ schema.pattern
         true
       else
-        message = %{Expected string to match pattern "#{schema.pattern.inspect}", value was: #{data}.}
-        errors << ValidationError.new(schema, path, message)
+        message = %{#{data} does not match #{schema.pattern.inspect}.}
+        errors << ValidationError.new(schema, path, message, :pattern_failed)
         false
       end
     end
@@ -423,8 +468,10 @@ module JsonSchema
       if (missing = required - data.keys).empty?
         true
       else
-        message = %{Missing required keys "#{missing.sort.join(", ")}" in object; keys are "#{data.keys.sort.join(", ")}".}
-        errors << ValidationError.new(schema, path, message)
+        message = %{"#{missing.sort.join('", "')}" } +
+          (missing.length == 1 ? "wasn't" : "weren't") +
+          %{ supplied.}
+        errors << ValidationError.new(schema, path, message, :required_failed)
         false
       end
     end
@@ -442,8 +489,8 @@ module JsonSchema
       if valid_types.any? { |t| data.is_a?(t) }
         true
       else
-        message = %{Expected data to be of type "#{schema.type.join("/")}"; value was: #{data.inspect}.}
-        errors << ValidationError.new(schema, path, message)
+        message = %{#{data.inspect} is not a #{schema.type.join("/")}.}
+        errors << ValidationError.new(schema, path, message, :invalid_type)
         false
       end
     end
@@ -453,8 +500,8 @@ module JsonSchema
       if data.size == data.uniq.size
         true
       else
-        message = %{Expected array items to be unique, but duplicate items were found.}
-        errors << ValidationError.new(schema, path, message)
+        message = %{Duplicate items are not allowed.}
+        errors << ValidationError.new(schema, path, message, :unique_items_failed)
         false
       end
     end
@@ -463,7 +510,7 @@ module JsonSchema
 
     HOSTNAME_PATTERN = /^(?=.{1,255}$)[0-9A-Za-z](?:(?:[0-9A-Za-z]|-){0,61}[0-9A-Za-z])?(?:\.[0-9A-Za-z](?:(?:[0-9A-Za-z]|-){0,61}[0-9A-Za-z])?)*\.?$/
 
-    DATE_TIME_PATTERN = /^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-2][0-9]:[0-5][0-9]:[0-5][0-9](Z|[\-+][0-9]{2}:[0-5][0-9])$/
+    DATE_TIME_PATTERN = /^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-2][0-9]:[0-5][0-9]:[0-5][0-9](\.[0-9]+)?(Z|[\-+][0-9]{2}:[0-5][0-9])$/
 
     # from: http://stackoverflow.com/a/17871737
     IPV4_PATTERN = /^((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])$/

data/test/json_schema/parser_test.rb

@@ -221,41 +221,50 @@ describe JsonSchema::Parser do
   it "errors on non-string ids" do
     schema_sample["id"] = 4
     refute parse
-    assert_includes errors,
-      %{Expected "id" to be of type "string"; value was: 4.}
+    assert_includes error_messages,
+      %{4 is not a valid "id", must be a string.}
+    assert_includes error_types, :invalid_type
   end
 
   it "errors on non-string titles" do
     schema_sample["title"] = 4
     refute parse
-    assert_includes errors,
-      %{Expected "title" to be of type "string"; value was: 4.}
+    assert_includes error_messages,
+      %{4 is not a valid "title", must be a string.}
+    assert_includes error_types, :invalid_type
   end
 
   it "errors on non-string descriptions" do
     schema_sample["description"] = 4
     refute parse
-    assert_includes errors,
-      %{Expected "description" to be of type "string"; value was: 4.}
+    assert_includes error_messages,
+      %{4 is not a valid "description", must be a string.}
+    assert_includes error_types, :invalid_type
   end
 
   it "errors on non-array and non-string types" do
     schema_sample["type"] = 4
     refute parse
-    assert_includes errors,
-      %{Expected "type" to be of type "array/string"; value was: 4.}
+    assert_includes error_messages,
+      %{4 is not a valid "type", must be a array/string.}
+    assert_includes error_types, :invalid_type
   end
 
   it "errors on unknown types" do
     schema_sample["type"] = ["float", "double"]
     refute parse
-    assert_includes errors, %{Unknown types: double, float.}
+    assert_includes error_messages, %{Unknown types: double, float.}
+    assert_includes error_types, :unknown_type
   end
 
-  def errors
+  def error_messages
     @parser.errors.map { |e| e.message }
   end
 
+  def error_types
+    @parser.errors.map { |e| e.type }
+  end
+
   def parse
     @parser = JsonSchema::Parser.new
     @parser.parse(schema_sample)

data/test/json_schema/reference_expander_test.rb

@@ -5,7 +5,7 @@ require "json_schema"
 describe JsonSchema::ReferenceExpander do
   it "expands references" do
     expand
-    assert_equal [], errors
+    assert_equal [], error_messages
 
     # this was always a fully-defined property
     referenced = @schema.definitions["app"]
@@ -27,7 +27,7 @@ describe JsonSchema::ReferenceExpander do
 
   it "will expand anyOf" do
     expand
-    assert_equal [], errors
+    assert_equal [], error_messages
     schema = @schema.properties["app"].definitions["contrived_plus"]
     assert_equal 3, schema.any_of[0].min_length
     assert_equal 5, schema.any_of[1].min_length
@@ -35,7 +35,7 @@ describe JsonSchema::ReferenceExpander do
 
   it "will expand allOf" do
     expand
-    assert_equal [], errors
+    assert_equal [], error_messages
     schema = @schema.properties["app"].definitions["contrived_plus"]
     assert_equal 30, schema.all_of[0].max_length
     assert_equal 3, schema.all_of[1].min_length
@@ -43,7 +43,7 @@ describe JsonSchema::ReferenceExpander do
 
   it "will expand dependencies" do
     expand
-    assert_equal [], errors
+    assert_equal [], error_messages
     schema = @schema.properties["app"].dependencies["ssl"].properties["name"]
     assert_equal ["string"], schema.type
   end
@@ -55,7 +55,7 @@ describe JsonSchema::ReferenceExpander do
       }
     )
     expand
-    assert_equal [], errors
+    assert_equal [], error_messages
     schema = @schema.properties["app"].properties["flags"].items
     assert_equal ["string"], schema.type
   end
@@ -68,7 +68,7 @@ describe JsonSchema::ReferenceExpander do
       ]
     )
     expand
-    assert_equal [], errors
+    assert_equal [], error_messages
     schema0 = @schema.properties["app"].properties["flags"].items[0]
     schema1 = @schema.properties["app"].properties["flags"].items[0]
     assert_equal ["string"], schema0.type
@@ -77,7 +77,7 @@ describe JsonSchema::ReferenceExpander do
 
   it "will expand oneOf" do
     expand
-    assert_equal [], errors
+    assert_equal [], error_messages
     schema = @schema.properties["app"].definitions["contrived_plus"]
     assert_equal /^(foo|aaa)$/, schema.one_of[0].pattern
     assert_equal /^(foo|zzz)$/, schema.one_of[1].pattern
@@ -85,7 +85,7 @@ describe JsonSchema::ReferenceExpander do
 
   it "will expand not" do
     expand
-    assert_equal [], errors
+    assert_equal [], error_messages
     schema = @schema.properties["app"].definitions["contrived_plus"]
     assert_equal /^$/, schema.not.pattern
   end
@@ -95,14 +95,14 @@ describe JsonSchema::ReferenceExpander do
       "additionalProperties" => { "$ref" => "#" }
     )
     expand
-    assert_equal [], errors
+    assert_equal [], error_messages
     schema = @schema.additional_properties
     assert_equal ["object"], schema.type
   end
 
   it "will expand patternProperties" do
     expand
-    assert_equal [], errors
+    assert_equal [], error_messages
     # value ([1]) of the #first tuple in hash
     schema = @schema.properties["app"].definitions["roles"].
       pattern_properties.first[1]
@@ -111,14 +111,14 @@ describe JsonSchema::ReferenceExpander do
 
   it "will expand hyperschema link schemas" do
     expand
-    assert_equal [], errors
+    assert_equal [], error_messages
     schema = @schema.properties["app"].links[0].schema.properties["name"]
     assert_equal ["string"], schema.type
   end
 
   it "will expand hyperschema link targetSchemas" do
     expand
-    assert_equal [], errors
+    assert_equal [], error_messages
     schema = @schema.properties["app"].links[0].target_schema.properties["name"]
     assert_equal ["string"], schema.type
   end
@@ -130,7 +130,7 @@ describe JsonSchema::ReferenceExpander do
       "app2" => { "$ref" => "#/definitions/app" },
     )
     expand
-    assert_equal [], errors
+    assert_equal [], error_messages
     schema = @schema.properties["app0"]
     assert_equal ["object"], schema.type
   end
@@ -140,14 +140,14 @@ describe JsonSchema::ReferenceExpander do
       "app" => { "$ref" => "#" }
     )
     expand
-    assert_equal [], errors
+    assert_equal [], error_messages
     schema = @schema.properties["app"]
     assert_equal ["object"], schema.type
   end
 
   it "builds appropriate JSON Pointers for expanded references" do
     expand
-    assert_equal [], errors
+    assert_equal [], error_messages
 
     # the *referenced* schema should still have a proper pointer
     schema = @schema.definitions["app"].definitions["name"]
@@ -180,10 +180,10 @@ describe JsonSchema::ReferenceExpander do
       "app" => { "$ref" => "#/definitions/nope" }
     )
     refute expand
-    assert_includes errors,
-      %{Couldn't resolve pointer "#/definitions/nope".}
-    assert_includes errors,
-      %{Couldn't resolve references: #/definitions/nope.}
+    assert_includes error_messages, %{Couldn't resolve pointer "#/definitions/nope".}
+    assert_includes error_types, :unresolved_pointer
+    assert_includes error_messages, %{Couldn't resolve references: #/definitions/nope.}
+    assert_includes error_types, :unresolved_references
   end
 
   it "errors on a URI that can't be resolved" do
@@ -191,9 +191,11 @@ describe JsonSchema::ReferenceExpander do
       "app" => { "$ref" => "/schemata/user#/definitions/name" }
     )
     refute expand
-    assert_includes errors,
+    assert_includes error_messages,
       %{Couldn't resolve references: /schemata/user#/definitions/name.}
-    assert_includes errors, %{Couldn't resolve URI: /schemata/user.}
+      assert_includes error_types, :unresolved_references
+    assert_includes error_messages, %{Couldn't resolve URI: /schemata/user.}
+    assert_includes error_types, :unresolved_pointer
   end
 
   it "errors on a reference cycle" do
@@ -204,14 +206,20 @@ describe JsonSchema::ReferenceExpander do
     )
     refute expand
     properties = "#/properties/app0, #/properties/app1, #/properties/app2"
-    assert_includes errors, %{Reference cycle detected: #{properties}.}
-    assert_includes errors, %{Couldn't resolve references: #{properties}.}
+    assert_includes error_messages, %{Reference loop detected: #{properties}.}
+    assert_includes error_types, :loop_detected
+    assert_includes error_messages, %{Couldn't resolve references: #{properties}.}
+    assert_includes error_types, :unresolved_references
   end
 
-  def errors
+  def error_messages
     @expander.errors.map { |e| e.message }
   end
 
+  def error_types
+    @expander.errors.map { |e| e.type }
+  end
+
   def pointer(path)
     JsonPointer.evaluate(schema_sample, path)
   end

data/test/json_schema/validator_test.rb

@@ -22,7 +22,8 @@ describe JsonSchema::Validator do
     data_sample["visibility"] = "personal"
     refute validate
     assert_includes error_messages,
-      %{Expected data to be a member of enum ["private", "public"], value was: personal.}
+      %{personal is not a member of ["private", "public"].}
+    assert_includes error_types, :invalid_type
   end
 
   it "validates type successfully" do
@@ -39,8 +40,8 @@ describe JsonSchema::Validator do
     )
     @data_sample = 4
     refute validate
-    assert_includes error_messages,
-      %{Expected data to be of type "object"; value was: 4.}
+    assert_includes error_messages, %{4 is not a object.}
+    assert_includes error_types, :invalid_type
   end
 
   it "validates items with list successfully" do
@@ -62,7 +63,8 @@ describe JsonSchema::Validator do
     data_sample["flags"] = ["1337"]
     refute validate
     assert_includes error_messages,
-      %{Expected string to match pattern "/^[a-z][a-z\\-]*[a-z]$/", value was: 1337.}
+      %{1337 does not match /^[a-z][a-z\\-]*[a-z]$/.}
+    assert_includes error_types, :pattern_failed
   end
 
   it "validates items with tuple successfully" do
@@ -98,7 +100,8 @@ describe JsonSchema::Validator do
     data_sample["flags"] = ["cedar"]
     refute validate
     assert_includes error_messages,
-      %{Expected array to have at least 2 item(s), had 1 item(s).}
+      %{2 items required; only 1 was supplied.}
+    assert_includes error_types, :min_items_failed
   end
 
   it "validates items with tuple unsuccessfully for too many items" do
@@ -112,7 +115,8 @@ describe JsonSchema::Validator do
     data_sample["flags"] = ["cedar", "https", "websockets"]
     refute validate
     assert_includes error_messages,
-      %{Expected array to have no more than 2 item(s), had 3 item(s).}
+      %{No more than 2 items are allowed; 3 were supplied.}
+      assert_includes error_types, :max_items_failed
   end
 
   it "validates items with tuple unsuccessfully for non-conforming items" do
@@ -126,7 +130,8 @@ describe JsonSchema::Validator do
     data_sample["flags"] = ["cedar", "1337"]
     refute validate
     assert_includes error_messages,
-      %{Expected data to be a member of enum ["http", "https"], value was: 1337.}
+      %{1337 is not a member of ["http", "https"].}
+    assert_includes error_types, :invalid_type
   end
 
   it "validates maxItems successfully" do
@@ -144,7 +149,8 @@ describe JsonSchema::Validator do
     data_sample["flags"] = (0...11).to_a
     refute validate
     assert_includes error_messages,
-      %{Expected array to have no more than 10 item(s), had 11 item(s).}
+      %{No more than 10 items are allowed; 11 were supplied.}
+    assert_includes error_types, :max_items_failed
   end
 
   it "validates minItems successfully" do
@@ -161,8 +167,8 @@ describe JsonSchema::Validator do
     )
     data_sample["flags"] = []
     refute validate
-    assert_includes error_messages,
-      %{Expected array to have at least 1 item(s), had 0 item(s).}
+    assert_includes error_messages, %{1 item required; only 0 were supplied.}
+    assert_includes error_types, :min_items_failed
   end
 
   it "validates uniqueItems successfully" do
@@ -179,8 +185,8 @@ describe JsonSchema::Validator do
     )
     data_sample["flags"] = ["websockets", "websockets"]
     refute validate
-    assert_includes error_messages,
-      %{Expected array items to be unique, but duplicate items were found.}
+    assert_includes error_messages, %{Duplicate items are not allowed.}
+    assert_includes error_types, :unique_items_failed
   end
 
   it "validates maximum for an integer with exclusiveMaximum false" do
@@ -190,8 +196,8 @@ describe JsonSchema::Validator do
     )
     data_sample["id"] = 11
     refute validate
-    assert_includes error_messages,
-      %{Expected data to be smaller than maximum 10 (exclusive: false), value was: 11.}
+    assert_includes error_messages, %{11 must be less than or equal to 10.}
+    assert_includes error_types, :max_failed
   end
 
   it "validates maximum for an integer with exclusiveMaximum true" do
@@ -201,8 +207,8 @@ describe JsonSchema::Validator do
     )
     data_sample["id"] = 10
     refute validate
-    assert_includes error_messages,
-      %{Expected data to be smaller than maximum 10 (exclusive: true), value was: 10.}
+    assert_includes error_messages, %{10 must be less than 10.}
+    assert_includes error_types, :max_failed
   end
 
   it "validates maximum for a number with exclusiveMaximum false" do
@@ -212,8 +218,8 @@ describe JsonSchema::Validator do
     )
     data_sample["cost"] = 10.1
     refute validate
-    assert_includes error_messages,
-      %{Expected data to be smaller than maximum 10.0 (exclusive: false), value was: 10.1.}
+    assert_includes error_messages, %{10.1 must be less than or equal to 10.0.}
+    assert_includes error_types, :max_failed
   end
 
   it "validates maximum for a number with exclusiveMaximum true" do
@@ -223,8 +229,8 @@ describe JsonSchema::Validator do
     )
     data_sample["cost"] = 10.0
     refute validate
-    assert_includes error_messages,
-      %{Expected data to be smaller than maximum 10.0 (exclusive: true), value was: 10.0.}
+    assert_includes error_messages, %{10.0 must be less than 10.0.}
+    assert_includes error_types, :max_failed
   end
 
   it "validates minimum for an integer with exclusiveMaximum false" do
@@ -234,8 +240,8 @@ describe JsonSchema::Validator do
     )
     data_sample["id"] = 0
     refute validate
-    assert_includes error_messages,
-      %{Expected data to be larger than minimum 1 (exclusive: false), value was: 0.}
+    assert_includes error_messages, %{0 must be greater than or equal to 1.}
+    assert_includes error_types, :min_failed
   end
 
   it "validates minimum for an integer with exclusiveMaximum true" do
@@ -245,8 +251,7 @@ describe JsonSchema::Validator do
     )
     data_sample["id"] = 1
     refute validate
-    assert_includes error_messages,
-      %{Expected data to be larger than minimum 1 (exclusive: true), value was: 1.}
+    assert_includes error_messages, %{1 must be greater than 1.}
   end
 
   it "validates minimum for a number with exclusiveMaximum false" do
@@ -257,7 +262,8 @@ describe JsonSchema::Validator do
     data_sample["cost"] = -0.01
     refute validate
     assert_includes error_messages,
-      %{Expected data to be larger than minimum 0.0 (exclusive: false), value was: -0.01.}
+      %{-0.01 must be greater than or equal to 0.0.}
+    assert_includes error_types, :min_failed
   end
 
   it "validates minimum for a number with exclusiveMaximum true" do
@@ -267,8 +273,8 @@ describe JsonSchema::Validator do
     )
     data_sample["cost"] = 0.0
     refute validate
-    assert_includes error_messages,
-      %{Expected data to be larger than minimum 0.0 (exclusive: true), value was: 0.0.}
+    assert_includes error_messages, %{0.0 must be greater than 0.0.}
+    assert_includes error_types, :min_failed
   end
 
   it "validates multipleOf for an integer" do
@@ -277,8 +283,8 @@ describe JsonSchema::Validator do
     )
     data_sample["id"] = 1
     refute validate
-    assert_includes error_messages,
-      %{Expected data to be a multiple of 2, value was: 1.}
+    assert_includes error_messages, %{1 is not a multiple of 2.}
+    assert_includes error_types, :multiple_of_failed
   end
 
   it "validates multipleOf for a number" do
@@ -287,8 +293,8 @@ describe JsonSchema::Validator do
     )
     data_sample["cost"] = 0.005
     refute validate
-    assert_includes error_messages,
-      %{Expected data to be a multiple of 0.01, value was: 0.005.}
+    assert_includes error_messages, %{0.005 is not a multiple of 0.01.}
+    assert_includes error_types, :multiple_of_failed
   end
 
   it "validates additionalProperties boolean successfully" do
@@ -309,7 +315,23 @@ describe JsonSchema::Validator do
     data_sample["foo"] = "bar"
     data_sample["matches_pattern"] = "yes!"
     refute validate
-    assert_includes error_messages, %{Extra keys in object: foo.}
+    assert_includes error_messages, %{"foo" is not a permitted key.}
+    assert_includes error_types, :invalid_keys
+  end
+
+  it "validates additionalProperties boolean unsuccessfully with multiple failures" do
+    pointer("#/definitions/app").merge!(
+      "additionalProperties" => false,
+      "patternProperties" => {
+        "^matches" => {}
+      }
+    )
+    data_sample["foo"] = "bar"
+    data_sample["baz"] = "blah"
+    data_sample["matches_pattern"] = "yes!"
+    refute validate
+    assert_includes error_messages, %{"baz", "foo" are not permitted keys.}
+    assert_includes error_types, :invalid_keys
   end
 
   it "validates additionalProperties schema successfully" do
@@ -334,8 +356,8 @@ describe JsonSchema::Validator do
     data_sample["foo"] = 4
     data_sample["matches_pattern"] = "yes!"
     refute validate
-    assert_includes error_messages,
-      %{Expected data to be of type "boolean"; value was: 4.}
+    assert_includes error_messages, %{4 is not a boolean.}
+    assert_includes error_types, :invalid_type
   end
 
   it "validates simple dependencies" do
@@ -345,7 +367,7 @@ describe JsonSchema::Validator do
     data_sample["production"] = true
     refute validate
     assert_includes error_messages,
-      %{Missing required keys "ssl" in object; keys are "name, production".}
+      %{"ssl" wasn't supplied.}
   end
 
   it "validates schema dependencies" do
@@ -361,7 +383,8 @@ describe JsonSchema::Validator do
     data_sample["cost"] = 10.0
     data_sample["ssl"] = true
     refute validate
-    assert_includes error_messages, %{Expected data to be larger than minimum 20.0 (exclusive: false), value was: 10.0.}
+    assert_includes error_messages, %{10.0 must be greater than or equal to 20.0.}
+    assert_includes error_types, :min_failed
   end
 
   it "validates maxProperties" do
@@ -370,7 +393,8 @@ describe JsonSchema::Validator do
     )
     data_sample["name"] = "cloudnasium"
     refute validate
-    assert_includes error_messages, %{Expected object to have a maximum of 0 property/ies; it had 1.}
+    assert_includes error_messages, %{No more than 0 properties are allowed; 1 was supplied.}
+    assert_includes error_types, :max_properties_failed
   end
 
   it "validates minProperties" do
@@ -379,7 +403,8 @@ describe JsonSchema::Validator do
     )
     data_sample["name"] = "cloudnasium"
     refute validate
-    assert_includes error_messages, %{Expected object to have a minimum of 2 property/ies; it had 1.}
+    assert_includes error_messages, %{At least 10 properties are required; 1 was supplied.}
+    assert_includes error_types, :min_properties_failed
   end
 
   it "validates patternProperties" do
@@ -395,8 +420,8 @@ describe JsonSchema::Validator do
       "KEY" => 456
     }
     refute validate
-    assert_includes error_messages,
-      %{Expected data to be of type "null/string"; value was: 456.}
+    assert_includes error_messages, %{456 is not a null/string.}
+    assert_includes error_types, :invalid_type
   end
 
   it "validates required" do
@@ -405,8 +430,8 @@ describe JsonSchema::Validator do
     )
     data_sample.delete("name")
     refute validate
-    assert_includes error_messages,
-      %{Missing required keys "name" in object; keys are "".}
+    assert_includes error_messages, %{"name" wasn't supplied.}
+    assert_includes error_types, :required_failed
   end
 
   it "validates strictProperties successfully" do
@@ -427,9 +452,9 @@ describe JsonSchema::Validator do
     data_sample["matches_pattern"] = "yes!"
     refute validate
     missing = @schema.properties.keys.sort - ["name"]
-    assert_includes error_messages,
-      %{Missing required keys "#{missing.join(", ")}" in object; keys are "extra_key, matches_pattern, name".}
-    assert_includes error_messages, %{Extra keys in object: extra_key.}
+    assert_includes error_messages, %{"#{missing.join('", "')}" weren't supplied.}
+    assert_includes error_messages, %{"extra_key" is not a permitted key.}
+    assert_includes error_types, :invalid_keys
   end
 
   it "validates allOf" do
@@ -441,8 +466,8 @@ describe JsonSchema::Validator do
     )
     data_sample["contrived"] = "ab"
     refute validate
-    assert_includes error_messages,
-      %{Expected string to have a minimum length of 3, was 2 character(s) long.}
+    assert_includes error_messages, %{At least 3 characters are required; only 2 were supplied.}
+    assert_includes error_types, :all_of_failed
   end
 
   it "validates anyOf" do
@@ -454,8 +479,8 @@ describe JsonSchema::Validator do
     )
     data_sample["contrived"] = "ab"
     refute validate
-    assert_includes error_messages,
-      %{Data did not match any subschema of "anyOf" condition.}
+    assert_includes error_messages, %{No subschema in "anyOf" matched.}
+    assert_includes error_types, :any_of_failed
   end
 
   it "validates oneOf" do
@@ -467,8 +492,8 @@ describe JsonSchema::Validator do
     )
     data_sample["contrived"] = "foo"
     refute validate
-    assert_includes error_messages,
-      %{Data did not match exactly one subschema of "oneOf" condition.}
+    assert_includes error_messages, %{More than one subschema in "oneOf" matched.}
+    assert_includes error_types, :one_of_failed
   end
 
   it "validates not" do
@@ -477,8 +502,8 @@ describe JsonSchema::Validator do
     )
     data_sample["contrived"] = ""
     refute validate
-    assert_includes error_messages,
-      %{Data matched subschema of "not" condition.}
+    assert_includes error_messages, %{Matched "not" subschema.}
+    assert_includes error_types, :not_failed
   end
 
   it "validates date-time format successfully" do
@@ -497,14 +522,22 @@ describe JsonSchema::Validator do
     assert validate
   end
 
+  it "validates date-time format with time fraction successfully" do
+    pointer("#/definitions/app/definitions/owner").merge!(
+      "format" => "date-time"
+    )
+    data_sample["owner"] = "2014-05-13T08:42:40.444Z"
+    assert validate
+  end
+
   it "validates date-time format unsuccessfully" do
     pointer("#/definitions/app/definitions/owner").merge!(
       "format" => "date-time"
     )
     data_sample["owner"] = "2014-05-13T08:42:40"
     refute validate
-    assert_includes error_messages,
-      %{Expected data to match "date-time" format, value was: 2014-05-13T08:42:40.}
+    assert_includes error_messages, %{2014-05-13T08:42:40 is not a valid date-time.}
+    assert_includes error_types, :invalid_format
   end
 
   it "validates email format successfully" do
@@ -521,8 +554,8 @@ describe JsonSchema::Validator do
     )
     data_sample["owner"] = "@example.com"
     refute validate
-    assert_includes error_messages,
-      %{Expected data to match "email" format, value was: @example.com.}
+    assert_includes error_messages, %{@example.com is not a valid email.}
+    assert_includes error_types, :invalid_format
   end
 
   it "validates hostname format successfully" do
@@ -539,8 +572,8 @@ describe JsonSchema::Validator do
     )
     data_sample["owner"] = "@example.com"
     refute validate
-    assert_includes error_messages,
-      %{Expected data to match "hostname" format, value was: @example.com.}
+    assert_includes error_messages, %{@example.com is not a valid hostname.}
+    assert_includes error_types, :invalid_format
   end
 
   it "validates ipv4 format successfully" do
@@ -557,8 +590,8 @@ describe JsonSchema::Validator do
     )
     data_sample["owner"] = "1.2.3.4.5"
     refute validate
-    assert_includes error_messages,
-      %{Expected data to match "ipv4" format, value was: 1.2.3.4.5.}
+    assert_includes error_messages, %{1.2.3.4.5 is not a valid ipv4.}
+    assert_includes error_types, :invalid_format
   end
 
   it "validates ipv6 format successfully" do
@@ -575,8 +608,8 @@ describe JsonSchema::Validator do
     )
     data_sample["owner"] = "1::3:4:5:6:7:8:9"
     refute validate
-    assert_includes error_messages,
-      %{Expected data to match "ipv6" format, value was: 1::3:4:5:6:7:8:9.}
+    assert_includes error_messages, %{1::3:4:5:6:7:8:9 is not a valid ipv6.}
+    assert_includes error_types, :invalid_format
   end
 
   it "validates regex format successfully" do
@@ -593,8 +626,8 @@ describe JsonSchema::Validator do
     )
     data_sample["owner"] = "^owner($"
     refute validate
-    assert_includes error_messages,
-      %{Expected data to match "regex" format, value was: ^owner($.}
+    assert_includes error_messages, %{^owner($ is not a valid regex.}
+    assert_includes error_types, :invalid_format
   end
 
   it "validates absolute uri format successfully" do
@@ -619,8 +652,8 @@ describe JsonSchema::Validator do
     )
     data_sample["owner"] = "http://"
     refute validate
-    assert_includes error_messages,
-      %{Expected data to match "uri" format, value was: http://.}
+    assert_includes error_messages, %{http:// is not a valid uri.}
+    assert_includes error_types, :invalid_format
   end
 
   it "validates uuid format successfully" do
@@ -637,8 +670,8 @@ describe JsonSchema::Validator do
     )
     data_sample["owner"] = "123"
     refute validate
-    assert_includes error_messages,
-      %{Expected data to match "uuid" format, value was: 123.}
+    assert_includes error_messages, %{123 is not a valid uuid.}
+    assert_includes error_types, :invalid_format
   end
 
   it "validates maxLength" do
@@ -647,8 +680,8 @@ describe JsonSchema::Validator do
     )
     data_sample["name"] = "abcd"
     refute validate
-    assert_includes error_messages,
-      %{Expected string to have a maximum length of 3, was 4 character(s) long.}
+    assert_includes error_messages, %{Only 3 characters are allowed; 4 were supplied.}
+    assert_includes error_types, :max_length_failed
   end
 
   it "validates minLength" do
@@ -657,8 +690,8 @@ describe JsonSchema::Validator do
     )
     data_sample["name"] = "ab"
     refute validate
-    assert_includes error_messages,
-      %{Expected string to have a minimum length of 3, was 2 character(s) long.}
+    assert_includes error_messages, %{At least 3 characters are required; only 2 were supplied.}
+    assert_includes error_types, :min_length_failed
   end
 
   it "validates pattern" do
@@ -667,8 +700,8 @@ describe JsonSchema::Validator do
     )
     data_sample["name"] = "ab"
     refute validate
-    assert_includes error_messages,
-      %{Expected string to match pattern "/^[a-z][a-z0-9-]{3,30}$/", value was: ab.}
+    assert_includes error_messages, %{ab does not match /^[a-z][a-z0-9-]{3,30}$/.}
+    assert_includes error_types, :pattern_failed
   end
 
   it "builds appropriate JSON Pointers to bad data" do
@@ -699,6 +732,10 @@ describe JsonSchema::Validator do
     @validator.errors.map { |e| e.message }
   end
 
+  def error_types
+    @validator.errors.map { |e| e.type }
+  end
+
   def pointer(path)
     JsonPointer.evaluate(schema_sample, path)
   end

data/test/json_schema_test.rb

@@ -15,8 +15,7 @@ describe JsonSchema do
       )
       schema, errors = JsonSchema.parse(schema_sample)
       refute schema
-      assert_includes errors.map { |e| e.message },
-        %{Expected schema; value was: 4.}
+      assert_includes errors.map { |e| e.type }, :schema_not_found
     end
   end
 
@@ -32,7 +31,7 @@ describe JsonSchema do
       e = assert_raises(RuntimeError) do
         JsonSchema.parse!(schema_sample)
       end
-      assert_includes e.message, %{Expected schema; value was: 4.}
+      assert_includes e.message, %{4 is not a valid schema.}
     end
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: json_schema
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Brandur
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-25 00:00:00.000000000 Z
+date: 2014-09-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest