json_schema 0.0.9 → 0.0.10

data/lib/commands/validate_schema.rb

@@ -48,8 +48,8 @@ module Commands
         if valid
           @messages += ["#{data_file} is valid."]
         else
-          errors = ["Invalid."] + errors.map { |e| e.message }
-          @errors += errors.map { |e| "#{data_file}: #{e}" }
+          @errors = ["#{data_file}: Invalid."] +
+            map_schema_errors(data_file, errors)
         end
       end
 
@@ -78,21 +78,25 @@ module Commands
       true
     end
 
+    # Builds a JSON Reference + message like "/path/to/file#/path/to/data".
+    def map_schema_errors(file, errors)
+      errors.map { |e| "#{file}#{e.schema.pointer}: #{e.message}" }
+    end
+
     def parse(file)
       return nil if !check_file(file)
 
       parser = JsonSchema::Parser.new
       if !(schema = parser.parse(JSON.parse(File.read(file))))
-        @errors = ["Schema is invalid."] + parser.errors.map { |e| e.message }
-        @errors.map! { |e| "#{file}: #{e}" }
+        @errors = ["#{file}: Schema is invalid."] + 
+          map_schema_errors(file, parser.errors)
         return nil
       end
 
       expander = JsonSchema::ReferenceExpander.new
       if !expander.expand(schema, store: @store)
-        @errors = ["Could not expand schema references."] +
-          expander.errors.map { |e| e.message }
-        @errors.map! { |e| "#{file}: #{e}" }
+        @errors = ["#{file}: Could not expand schema references."] +
+          map_schema_errors(file, expander.errors)
         return nil
       end
 

data/lib/json_schema/parser.rb

@@ -24,7 +24,7 @@ module JsonSchema
       # object, the @errors array is an instance-wide accumulator
       @errors = []
 
-      schema = parse_data(data, parent)
+      schema = parse_data(data, parent, "#")
       if @errors.count == 0
         schema
       else
@@ -73,69 +73,75 @@ module JsonSchema
         # an object indicates a schema that will be used to parse any
         # properties not listed in `properties`
         if schema.additional_properties.is_a?(Hash)
-          schema.additional_properties =
-            parse_data(schema.additional_properties, schema)
+          schema.additional_properties = parse_data(
+            schema.additional_properties,
+            schema,
+            "additionalProperties"
+          )
         end
         # otherwise, leave as boolean
       end
     end
 
     def parse_all_of(schema)
-      if schema.all_of && schema.all_of.is_a?(Array)
-        schema.all_of = schema.all_of.map { |s| parse_data(s, schema) }
+      if schema.all_of
+        schema.all_of = schema.all_of.each_with_index.
+          map { |s, i| parse_data(s, schema, "allOf/#{i}") }
       end
     end
 
     def parse_any_of(schema)
-      if schema.any_of && schema.any_of.is_a?(Array)
-        schema.any_of = schema.any_of.map { |s| parse_data(s, schema) }
+      if schema.any_of
+        schema.any_of = schema.any_of.each_with_index.
+          map { |s, i| parse_data(s, schema, "anyOf/#{i}") }
       end
     end
 
     def parse_one_of(schema)
-      if schema.one_of && schema.one_of.is_a?(Array)
-        schema.one_of = schema.one_of.map { |s| parse_data(s, schema) }
+      if schema.one_of
+        schema.one_of = schema.one_of.each_with_index.
+          map { |s, i| parse_data(s, schema, "oneOf/#{i}") }
       end
     end
 
-    def parse_data(data, parent = nil)
-      schema = Schema.new
-
+    def parse_data(data, parent, fragment)
       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)
       elsif ref = data["$ref"]
+        schema = Schema.new
+        schema.fragment = fragment
+        schema.parent = parent
         schema.reference = JsonReference::Reference.new(ref)
       else
-        schema = parse_schema(data, parent)
+        schema = parse_schema(data, parent, fragment)
       end
 
-      schema.parent = parent
       schema
     end
 
     def parse_definitions(schema)
-      if schema.definitions && schema.definitions.is_a?(Hash)
+      if schema.definitions
         # leave the original data reference intact
         schema.definitions = schema.definitions.dup
         schema.definitions.each do |key, definition|
-          subschema = parse_data(definition, schema)
+          subschema = parse_data(definition, schema, "definitions/#{key}")
           schema.definitions[key] = subschema
         end
       end
     end
 
     def parse_dependencies(schema)
-      if schema.dependencies && schema.dependencies.is_a?(Hash)
+      if schema.dependencies
         # leave the original data reference intact
         schema.dependencies = schema.dependencies.dup
         schema.dependencies.each do |k, s|
           # may be Array, String (simple dependencies), or Hash (schema
           # dependency)
           if s.is_a?(Hash)
-            schema.dependencies[k] = parse_data(s, schema)
+            schema.dependencies[k] = parse_data(s, schema, "dependencies")
           elsif s.is_a?(String)
             # just normalize all simple dependencies to arrays
             schema.dependencies[k] = [s]
@@ -148,17 +154,18 @@ module JsonSchema
       if schema.items
         # tuple validation: an array of schemas
         if schema.items.is_a?(Array)
-          schema.items = schema.items.map { |s| parse_data(s, schema) }
+          schema.items = schema.items.each_with_index.
+            map { |s, i| parse_data(s, schema, "items/#{i}") }
         # list validation: a single schema
         else
-          schema.items = parse_data(schema.items, schema)
+          schema.items = parse_data(schema.items, schema, "items")
         end
       end
     end
 
     def parse_links(schema)
       if schema.links
-        schema.links = schema.links.map { |l|
+        schema.links = schema.links.each_with_index.map { |l, i|
           link             = Schema::Link.new
           link.parent      = schema
 
@@ -169,7 +176,7 @@ module JsonSchema
           link.title       = l["title"]
 
           if l["schema"]
-            link.schema = parse_data(l["schema"], schema)
+            link.schema = parse_data(l["schema"], schema, "links/#{i}/schema")
           end
 
           link
@@ -186,17 +193,17 @@ module JsonSchema
     end
 
     def parse_not(schema)
-      if schema.not && schema.not.is_a?(Hash)
-        schema.not = parse_data(schema.not, schema)
+      if schema.not
+        schema.not = parse_data(schema.not, schema, "not")
       end
     end
 
     def parse_pattern_properties(schema)
-      if schema.pattern_properties && schema.pattern_properties.is_a?(Hash)
+      if schema.pattern_properties
         # leave the original data reference intact
         properties = schema.pattern_properties.dup
         properties = properties.map do |k, s|
-          [Regexp.new(k), parse_data(s, schema)]
+          [Regexp.new(k), parse_data(s, schema, "patternProperties/#{k}")]
         end
         schema.pattern_properties = Hash[*properties.flatten]
       end
@@ -207,14 +214,16 @@ module JsonSchema
       schema.properties = schema.properties.dup
       if schema.properties && schema.properties.is_a?(Hash)
         schema.properties.each do |key, definition|
-          subschema = parse_data(definition, schema)
+          subschema = parse_data(definition, schema, "properties/#{key}")
           schema.properties[key] = subschema
         end
       end
     end
 
-    def parse_schema(data, parent = nil)
+    def parse_schema(data, parent, fragment)
       schema = Schema.new
+      schema.fragment = fragment
+      schema.parent   = parent
 
       schema.data        = data
       schema.id          = validate_type(schema, [String], "id")

data/lib/json_schema/reference_expander.rb

@@ -52,11 +52,20 @@ module JsonSchema
         return false unless success
       end
 
-      # copy new schema into existing one while preserving parent
+      # copy new schema into existing one while preserving parent, fragment,
+      # and reference
       parent = ref_schema.parent
       ref_schema.copy_from(new_schema)
       ref_schema.parent = parent
 
+      # correct all parent references to point back to ref_schema instead of
+      # new_schema
+      if ref_schema.original?
+        schema_children(ref_schema).each do |schema|
+          schema.parent = ref_schema
+        end
+      end
+
       true
     end
 

data/lib/json_schema/schema.rb

@@ -19,6 +19,10 @@ module JsonSchema
       @clones = Set.new
     end
 
+    # Fragment of a JSON Pointer that can help us build a pointer back to this
+    # schema for debugging.
+    attr_accessor :fragment
+
     # Rather than a normal schema, the node may be a JSON Reference. In this
     # case, no other attributes will be filled in except for #parent.
     attr_accessor :reference
@@ -255,6 +259,14 @@ module JsonSchema
       !clones.include?(self)
     end
 
+    def pointer
+      if parent
+        parent.pointer + "/" + fragment
+      else
+        fragment
+      end
+    end
+
     def validate(data)
       validator = Validator.new(self)
       valid = validator.validate(data)

data/lib/json_schema/validator.rb

@@ -123,8 +123,10 @@ module JsonSchema
       valid = schema.any_of.any? do |subschema|
         validate_data(subschema, data, [])
       end
-      message = %{Data did not match any subschema of "anyOf" condition.}
-      errors << SchemaError.new(schema, message) if !valid
+      if !valid
+        message = %{Data did not match any subschema of "anyOf" condition.}
+        errors << SchemaError.new(schema, message)
+      end
       valid
     end
 
@@ -361,7 +363,6 @@ module JsonSchema
       return true if schema.properties.empty?
       valid = true
       schema.properties.each do |key, subschema|
-
         if value = data[key]
           valid = strict_and valid, validate_data(subschema, value, errors)
         end
@@ -374,7 +375,7 @@ module JsonSchema
       if (missing = required - data.keys).empty?
         true
       else
-        message = %{Missing required keys in object: #{missing.sort.join(", ")}.}
+        message = %{Missing required keys "#{missing.sort.join(", ")}" in object; keys are "#{data.keys.sort.join(", ")}".}
         errors << SchemaError.new(schema, message)
         false
       end

data/schemas/heroku-hyper-schema.json

@@ -0,0 +1,96 @@
+{
+    "$schema": "http://json-schema.org/draft-04/heroku-hyper-schema#",
+    "id": "http://json-schema.org/draft-04/heroku-hyper-schema#",
+    "title": "Heroku JSON Hyper-Schema",
+    "allOf": [
+        {
+            "$ref": "http://json-schema.org/draft-04/hyper-schema#"
+        }
+    ],
+    "definitions": {
+        "entity": {
+            "anyOf": [
+                {
+                    "$ref": "#/definitions/entityWithPatternProperties"
+                },
+                {
+                    "$ref": "#/definitions/entityWithProperties"
+                }
+            ]
+        },
+        "entityWithPatternProperties": {
+            "required": [
+                "definitions",
+                "description",
+                "id",
+                "links",
+                "patternProperties",
+                "title",
+                "type"
+            ]
+        },
+        "entityWithProperties": {
+            "properties": {
+                "definitions": {
+                    "additionalProperties": {
+                        "$ref": "#/definitions/property"
+                    },
+                    "properties": {
+                        "identity": {
+                            "$ref": "#/definitions/identity"
+                        }
+                    },
+                    "required": ["identity"]
+                }
+            },
+            "required": [
+                "definitions",
+                "description",
+                "id",
+                "links",
+                "properties",
+                "title",
+                "type"
+            ]
+        },
+        "identity": {
+            "additionalProperties": false,
+            "properties": {
+                "anyOf": {
+                    "additionalProperties": {
+                        "$ref": "#/definitions/ref"
+                    }
+                }
+            },
+            "required": ["anyOf"]
+        },
+        "property": {
+            "required": ["description", "type"]
+        },
+        "ref": {
+            "required": ["$ref"]
+        }
+    },
+    "properties": {
+        "definitions": {
+            "additionalProperties": {
+                "$ref": "#/definitions/entity"
+            }
+        },
+        "properties": {
+            "additionalProperties": {
+                "$ref": "#/definitions/ref"
+            }
+        }
+    },
+    "required": [
+        "$schema",
+        "definitions",
+        "description",
+        "id",
+        "links",
+        "properties",
+        "title",
+        "type"
+    ]
+}

data/test/json_schema/parser_test.rb

@@ -198,37 +198,46 @@ describe JsonSchema::Parser do
     assert_equal true, schema.read_only
   end
 
+  it "builds appropriate JSON Pointers" do
+    schema = parse.definitions["app"].definitions["name"]
+    assert_equal "#/definitions/app/definitions/name", schema.pointer
+  end
+
   it "errors on non-string ids" do
     schema_sample["id"] = 4
     refute parse
-    assert_includes error_messages, %{Expected "id" to be of type "string"; value was: 4.}
+    assert_includes errors,
+      %{Expected "id" to be of type "string"; value was: 4.}
   end
 
   it "errors on non-string titles" do
     schema_sample["title"] = 4
     refute parse
-    assert_includes error_messages, %{Expected "title" to be of type "string"; value was: 4.}
+    assert_includes errors,
+      %{Expected "title" to be of type "string"; value was: 4.}
   end
 
   it "errors on non-string descriptions" do
     schema_sample["description"] = 4
     refute parse
-    assert_includes error_messages, %{Expected "description" to be of type "string"; value was: 4.}
+    assert_includes errors,
+      %{Expected "description" to be of type "string"; value was: 4.}
   end
 
   it "errors on non-array and non-string types" do
     schema_sample["type"] = 4
     refute parse
-    assert_includes error_messages, %{Expected "type" to be of type "array/string"; value was: 4.}
+    assert_includes errors,
+      %{Expected "type" to be of type "array/string"; value was: 4.}
   end
 
   it "errors on unknown types" do
     schema_sample["type"] = ["float", "double"]
     refute parse
-    assert_includes error_messages, %{Unknown types: double, float.}
+    assert_includes errors, %{Unknown types: double, float.}
   end
 
-  def error_messages
+  def errors
     @parser.errors.map { |e| e.message }
   end
 

data/test/json_schema/reference_expander_test.rb

@@ -138,6 +138,36 @@ describe JsonSchema::ReferenceExpander do
     assert_equal ["object"], schema.type
   end
 
+  it "builds appropriate JSON Pointers for expanded references" do
+    expand
+    assert_equal [], errors
+
+    # the *referenced* schema should still have a proper pointer
+    schema = @schema.definitions["app"].definitions["name"]
+    assert_equal "#/definitions/app/definitions/name", schema.pointer
+
+    # the *reference* schema should have expanded a pointer
+    schema = @schema.properties["app"].properties["name"]
+    assert_equal "#/properties/app/properties/name", schema.pointer
+  end
+
+  # clones are special in that they retain their original pointer despite where
+  # they've been nested
+  it "builds appropriate JSON Pointers for circular dependencies" do
+    pointer("#/properties").merge!(
+      "app" => { "$ref" => "#" }
+    )
+    expand
+
+    # the first self reference has the standard pointer as expected
+    schema = @schema.properties["app"]
+    assert_equal "#/properties/app", schema.pointer
+
+    # but diving deeper results in the same pointer again
+    schema = schema.properties["app"]
+    assert_equal "#/properties/app", schema.pointer
+  end
+
   it "errors on a JSON Pointer that can't be resolved" do
     pointer("#/properties").merge!(
       "app" => { "$ref" => "#/definitions/nope" }

data/test/json_schema/validator_test.rb

@@ -336,7 +336,8 @@ describe JsonSchema::Validator do
     )
     data_sample["production"] = true
     refute validate
-    assert_includes error_messages, %{Missing required keys in object: ssl.}
+    assert_includes error_messages,
+      %{Missing required keys "ssl" in object; keys are "name, production".}
   end
 
   it "validates schema dependencies" do
@@ -396,7 +397,8 @@ describe JsonSchema::Validator do
     )
     data_sample.delete("name")
     refute validate
-    assert_includes error_messages, %{Missing required keys in object: name.}
+    assert_includes error_messages,
+      %{Missing required keys "name" in object; keys are "".}
   end
 
   it "validates allOf" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: json_schema
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.0.10
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-21 00:00:00.000000000 Z
+date: 2014-05-22 00:00:00.000000000 Z
 dependencies: []
 description: 
 email:
@@ -21,6 +21,7 @@ extra_rdoc_files: []
 files:
 - README.md
 - bin/validate-schema
+- schemas/heroku-hyper-schema.json
 - schemas/hyper-schema.json
 - schemas/schema.json
 - lib/commands/validate_schema.rb