json_schema 0.20.3 → 0.20.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 45216e42386e80c6e481d45fafb3bcecad1c55cde5137efb455bb45261e87424
-  data.tar.gz: 8764080e6a1c38b519110a8001b53ebda5864e7b16cdf418b272459542f60e1f
+  metadata.gz: 239a8df86c5fd746683d265f47f53ee415ac40613c8411abc8e4492cc3e02e18
+  data.tar.gz: 5614b247d018816964ab128923d4a86fd1fd4e6c397309bb74864c06a4ee95fd
 SHA512:
-  metadata.gz: 0f43b198fc8050550fb78d3a96ad14dff765fdcce80b5ae73ce080e6fb13600697658cf3b9d2b73e1ed9adc0d40cedfb890047696778dc5e3770dead5889e666
-  data.tar.gz: 6f30c6b07f81396b3f7366fd30186b83ddbf1ef474e375838c77df5a635b96bc2ac4dc4bf2036789a235f19efa3bc22ac76c246d31db9a697b8235790f045c4b
+  metadata.gz: fad2007fa5541c260baa72dd32527fba69ed292c7ec589959f023ef8a4edc206a1bb260dc0d3b6421586758f3d707c6284aac5c300d1dda00d30250d3f78c45f
+  data.tar.gz: cf384d7f97d445df492f9cb67737d852b725d63542d5da2bd30809a91a36c5277ea851c7502cda03724a13ab1eb2036122eaf4c1aeb5a661e25ec4bf81993cc7

data/README.md

@@ -67,7 +67,8 @@ ruby -Ilib -Itest test/json_schema/validator_test.rb -n /anyOf/
 
 1. Update the version in `json_schema.gemspec` as appropriate for [semantic
    versioning](http://semver.org) and add details to `CHANGELOG`.
-2. Run the `release` task:
+2. `git commit` those changes with a message like "Bump version to x.y.z".
+3. Run the `release` task:
 
     ```
     bundle exec rake release

data/bin/validate-schema

@@ -26,17 +26,15 @@ parser = OptionParser.new { |opts|
   end
 }
 
-if $0 == __FILE__
-  parser.parse!
-  success = command.run(ARGV.dup)
+parser.parse!
+success = command.run(ARGV.dup)
 
-  if success
-    command.messages.each { |m| $stdout.puts(m) }
-  elsif !command.errors.empty?
-    command.errors.each { |e| $stderr.puts(e) }
-    exit(1)
-  else
-    print_usage!
-    exit(1)
-  end
+if success
+  command.messages.each { |m| $stdout.puts(m) }
+elsif !command.errors.empty?
+  command.errors.each { |e| $stderr.puts(e) }
+  exit(1)
+else
+  print_usage!
+  exit(1)
 end

data/lib/json_schema/parser.rb

@@ -17,6 +17,10 @@ module JsonSchema
       TrueClass  => "boolean",
     }
 
+    # Reuse these frozen objects to avoid allocations
+    EMPTY_ARRAY = [].freeze
+    EMPTY_HASH = {}.freeze
+
     attr_accessor :errors
 
     # Basic parsing of a schema. May return a malformed schema! (Use `#parse!`
@@ -101,21 +105,21 @@ module JsonSchema
     end
 
     def parse_all_of(schema)
-      if schema.all_of
+      if schema.all_of && !schema.all_of.empty?
         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
+      if schema.any_of && !schema.any_of.empty?
         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
+      if schema.one_of && !schema.one_of.empty?
         schema.one_of = schema.one_of.each_with_index.
           map { |s, i| parse_data(s, schema, "oneOf/#{i}") }
       end
@@ -140,7 +144,7 @@ module JsonSchema
     end
 
     def parse_definitions(schema)
-      if schema.definitions
+      if schema.definitions && !schema.definitions.empty?
         # leave the original data reference intact
         schema.definitions = schema.definitions.dup
         schema.definitions.each do |key, definition|
@@ -151,7 +155,7 @@ module JsonSchema
     end
 
     def parse_dependencies(schema)
-      if schema.dependencies
+      if schema.dependencies && !schema.dependencies.empty?
         # leave the original data reference intact
         schema.dependencies = schema.dependencies.dup
         schema.dependencies.each do |k, s|
@@ -181,7 +185,7 @@ module JsonSchema
     end
 
     def parse_links(schema)
-      if schema.links
+      if schema.links && !schema.links.empty?
         schema.links = schema.links.each_with_index.map { |l, i|
           link             = Schema::Link.new
           link.parent      = schema
@@ -231,7 +235,7 @@ module JsonSchema
     end
 
     def parse_pattern_properties(schema)
-      if schema.pattern_properties
+      if schema.pattern_properties && !schema.pattern_properties.empty?
         # leave the original data reference intact
         properties = schema.pattern_properties.dup
         properties = properties.map do |k, s|
@@ -254,8 +258,8 @@ module JsonSchema
 
     def parse_properties(schema)
       # leave the original data reference intact
-      schema.properties = schema.properties.dup
-      if schema.properties && schema.properties.is_a?(Hash)
+      if schema.properties && schema.properties.is_a?(Hash) && !schema.properties.empty?
+        schema.properties = schema.properties.dup
         schema.properties.each do |key, definition|
           subschema = parse_data(definition, schema, "properties/#{key}")
           schema.properties[key] = subschema
@@ -282,11 +286,11 @@ module JsonSchema
       schema.default     = schema.data["default"]
 
       # validation: any
-      schema.all_of        = validate_type(schema, [Array], "allOf") || []
-      schema.any_of        = validate_type(schema, [Array], "anyOf") || []
-      schema.definitions   = validate_type(schema, [Hash], "definitions") || {}
+      schema.all_of        = validate_type(schema, [Array], "allOf") || EMPTY_ARRAY
+      schema.any_of        = validate_type(schema, [Array], "anyOf") || EMPTY_ARRAY
+      schema.definitions   = validate_type(schema, [Hash], "definitions") || EMPTY_HASH
       schema.enum          = validate_type(schema, [Array], "enum")
-      schema.one_of        = validate_type(schema, [Array], "oneOf") || []
+      schema.one_of        = validate_type(schema, [Array], "oneOf") || EMPTY_ARRAY
       schema.not           = validate_type(schema, [Hash], "not")
       schema.type          = validate_type(schema, [Array, String], "type")
       schema.type          = [schema.type] if schema.type.is_a?(String)
@@ -309,11 +313,11 @@ module JsonSchema
       # validation: object
       schema.additional_properties =
         validate_type(schema, BOOLEAN + [Hash], "additionalProperties")
-      schema.dependencies       = validate_type(schema, [Hash], "dependencies") || {}
+      schema.dependencies       = validate_type(schema, [Hash], "dependencies") || EMPTY_HASH
       schema.max_properties     = validate_type(schema, [Integer], "maxProperties")
       schema.min_properties     = validate_type(schema, [Integer], "minProperties")
-      schema.pattern_properties = validate_type(schema, [Hash], "patternProperties") || {}
-      schema.properties         = validate_type(schema, [Hash], "properties") || {}
+      schema.pattern_properties = validate_type(schema, [Hash], "patternProperties") || EMPTY_HASH
+      schema.properties         = validate_type(schema, [Hash], "properties") || EMPTY_HASH
       schema.required           = validate_type(schema, [Array], "required")
       schema.strict_properties  = validate_type(schema, BOOLEAN, "strictProperties")
 

data/lib/json_schema/reference_expander.rb

@@ -84,9 +84,26 @@ module JsonSchema
       end
     end
 
-    def dereference(ref_schema, ref_stack)
+    def dereference(ref_schema, ref_stack, parent_ref: nil)
       ref = ref_schema.reference
 
+      # Some schemas don't have a reference, but do
+      # have children. If that's the case, we need to
+      # dereference the subschemas.
+      if !ref
+        schema_children(ref_schema) do |subschema|
+          next unless subschema.reference
+          next if ref_schema.uri == parent_ref.uri.to_s
+
+          if !subschema.reference.uri && parent_ref
+            subschema.reference = JsonReference::Reference.new("#{parent_ref.uri}#{subschema.reference.pointer}")
+          end
+
+          dereference(subschema, ref_stack)
+        end
+        return true
+      end
+
       # detects a reference cycle
       if ref_stack.include?(ref)
         message = %{Reference loop detected: #{ref_stack.sort.join(", ")}.}
@@ -110,22 +127,44 @@ module JsonSchema
       # references.
       if ref.uri
         schema_children(new_schema) do |subschema|
-          next if subschema.expanded?
-          next unless subschema.reference
-
           # Don't bother if the subschema points to the same
           # schema as the reference schema.
           next if ref_schema == subschema
 
-          if !subschema.reference.uri
-            # the subschema's ref is local to the file that the
-            # subschema is in; however since there's no URI
-            # the 'resolve_pointer' method would try to look it up
-            # within @schema. So: manually reconstruct the reference to
-            # use the URI of the parent ref.
-            subschema.reference = JsonReference::Reference.new("#{ref.uri}#{subschema.reference.pointer}")
+          if subschema.reference
+            # If the subschema has a reference, then
+            # we don't need to recurse if the schema is
+            # already expanded.
+            next if subschema.expanded?
+
+            if !subschema.reference.uri
+              # the subschema's ref is local to the file that the
+              # subschema is in; however since there's no URI
+              # the 'resolve_pointer' method would try to look it up
+              # within @schema. So: manually reconstruct the reference to
+              # use the URI of the parent ref.
+              subschema.reference = JsonReference::Reference.new("#{ref.uri}#{subschema.reference.pointer}")
+            end
           end
-          dereference(subschema, ref_stack)
+
+          if subschema.items && subschema.items.reference
+            next if subschema.expanded?
+
+            if !subschema.items.reference.uri
+              # The subschema's ref is local to the file that the
+              # subschema is in. Manually reconstruct the reference
+              # so we can resolve it.
+              subschema.items.reference = JsonReference::Reference.new("#{ref.uri}#{subschema.items.reference.pointer}")
+            end
+          end
+
+          # If we're recursing into a schema via a global reference, then if
+          # the current subschema doesn't have a reference, we have no way of
+          # figuring out what schema we're in. The resolve_pointer method will
+          # default to looking it up in the initial schema. Instead, we're
+          # passing the parent ref here, so we can grab the URI
+          # later if needed.
+          dereference(subschema, ref_stack, parent_ref: ref)
         end
       end
 

data/test/bin_test.rb

@@ -1,12 +1,10 @@
 require "test_helper"
 
 #
-# The purpose of this sets of tests is just to include our Ruby executables
-# where possible so that we can get very basic sanity checks on their syntax
-# (which is something that of course Ruby can't do by default).
+# The purpose of this sets of tests is just to test our Ruby executables
+# where possible so that we can get very basic sanity checks on their syntax.
 #
-# We can do this without actually executing them because they're gated by `if
-# $0 == __FILE__` statements.
+# We can do this without actually executing them with a "ruby -c" call.
 #
 
 describe "executables in bin/" do
@@ -15,6 +13,7 @@ describe "executables in bin/" do
   end
 
   it "has roughly valid Ruby structure for validate-schema" do
-    load File.join(@bin_dir, "validate-schema")
+    IO.popen(["ruby", "-c", File.join(@bin_dir, "validate-schema")]) { |io| io.read }
+    assert_equal $?.exitstatus, 0, "Ruby syntax check failed; see error above"
   end
 end

data/test/json_schema/reference_expander_test.rb

@@ -265,6 +265,87 @@ describe JsonSchema::ReferenceExpander do
     assert schema.expanded?
   end
 
+  it "expands a schema with a reference to an external schema in a oneOf array" do
+    sample1 = {
+      "$schema" => "http://json-schema.org/draft-04/schema#",
+      "id" => "http://json-schema.org/draft-04/schema#",
+      "definitions" => {
+        "schemaArray" => {
+          "type" => "array",
+          "minItems" => 1,
+          "items" => { "$ref" => "#" }
+        }
+      }
+    }
+    schema1 = JsonSchema::Parser.new.parse!(sample1)
+
+    sample2 = {
+      "$schema" => "http://json-schema.org/draft-04/hyper-schema#",
+      "id" => "http://json-schema.org/draft-04/hyper-schema#",
+      "allOf" => [
+        {
+          "$ref" => "http://json-schema.org/draft-04/schema#"
+        }
+      ]
+    }
+    schema2 = JsonSchema::Parser.new.parse!(sample2)
+
+    store = JsonSchema::DocumentStore.new
+    expander = JsonSchema::ReferenceExpander.new
+
+    store.add_schema(schema1)
+    store.add_schema(schema2)
+
+    expander.expand!(schema2, store: store)
+
+    assert schema1.expanded?
+    assert schema2.expanded?
+  end
+
+  it "expands a schema with a nested reference to an external schema in a oneOf array" do
+    sample1 = {
+      "$schema" => "http://json-schema.org/draft-04/schema#",
+      "id" => "http://json-schema.org/draft-04/schema#",
+      "definitions" => {
+        "thingy" => {
+          "type" => ["string"]
+        },
+        "schemaArray" => {
+          "type" => "array",
+          "minItems" => 1,
+          "items" => { "$ref" => "#/definitions/thingy" }
+        }
+      },
+      "properties" => {
+        "whatsit" => {
+          "$ref" => "#/definitions/schemaArray"
+        },
+      }
+    }
+    schema1 = JsonSchema::Parser.new.parse!(sample1)
+
+    sample2 = {
+      "$schema" => "http://json-schema.org/draft-04/hyper-schema#",
+      "id" => "http://json-schema.org/draft-04/hyper-schema#",
+      "allOf" => [
+        {
+          "$ref" => "http://json-schema.org/draft-04/schema#"
+        }
+      ]
+    }
+    schema2 = JsonSchema::Parser.new.parse!(sample2)
+
+    store = JsonSchema::DocumentStore.new
+    expander = JsonSchema::ReferenceExpander.new
+
+    store.add_schema(schema1)
+    store.add_schema(schema2)
+
+    expander.expand!(schema2, store: store)
+
+    assert_equal ["string"], schema2.all_of[0].properties["whatsit"].items.type
+  end
+
   it "expands a schema with a reference to an external schema with a nested external property reference" do
     sample1 = {
       "$schema" => "http://json-schema.org/draft-04/hyper-schema",
@@ -320,6 +401,136 @@ describe JsonSchema::ReferenceExpander do
     assert_equal 3, schema1.properties["foo"].properties["omg"].max_length
   end
 
+  it "it handles oneOf with nested references to an external schema" do
+    sample1 = {
+      "$schema" => "http://json-schema.org/draft-04/hyper-schema",
+      "type" => "object",
+      "properties" => {
+        "foo" => {
+          "$ref" => "http://json-schema.org/b.json#"
+        }
+      }
+    }
+    schema1 = JsonSchema::Parser.new.parse!(sample1)
+    schema1.uri = "http://json-schema.org/a.json"
+
+    sample2 = {
+      "$schema" => "http://json-schema.org/draft-04/hyper-schema",
+      "type" => "object",
+      "properties" => {
+        "bar" => {
+          "oneOf" => [
+            {"type" => "null"},
+            {"$ref" => "http://json-schema.org/c.json#"}
+          ]
+        }
+      },
+    }
+    schema2 = JsonSchema::Parser.new.parse!(sample2)
+    schema2.uri = "http://json-schema.org/b.json"
+
+    sample3 = {
+      "$schema" => "http://json-schema.org/draft-04/hyper-schema",
+      "type" => "object",
+      "properties" => {
+        "baz" => {
+          "type" => "string",
+          "maxLength" => 3
+        }
+      }
+    }
+    schema3 = JsonSchema::Parser.new.parse!(sample3)
+    schema3.uri = "http://json-schema.org/c.json"
+
+    # Initialize a store and add our schema to it.
+    store = JsonSchema::DocumentStore.new
+    store.add_schema(schema1)
+    store.add_schema(schema2)
+    store.add_schema(schema3)
+
+    expander = JsonSchema::ReferenceExpander.new
+    expander.expand(schema1, store: store)
+
+    assert_equal 3, schema1.properties["foo"].properties["bar"].one_of[1].properties["baz"].max_length
+  end
+
+  it "does not infinitely recurse when external ref is local to its schema" do
+    sample1 = {
+      "id" => "http://json-schema.org/draft-04/schema#",
+      "$schema" => "http://json-schema.org/draft-04/schema#",
+      "properties" => {
+        "additionalItems" => {
+          "anyOf" => [ { "$ref" => "#" } ]
+        }
+      }
+    }
+    schema1 = JsonSchema::Parser.new.parse!(sample1)
+    sample2 = {
+      "$schema" => "http://json-schema.org/draft-04/hyper-schema#",
+      "id" => "http://json-schema.org/draft-04/hyper-schema#",
+      "allOf" => [
+        { "$ref" => "http://json-schema.org/draft-04/schema#" }
+      ]
+    }
+    schema2 = JsonSchema::Parser.new.parse!(sample2)
+
+    store = JsonSchema::DocumentStore.new
+    expander = JsonSchema::ReferenceExpander.new
+
+    store.add_schema(schema1)
+    store.add_schema(schema2)
+
+    expander.expand!(schema2, store: store)
+
+    assert schema1.expanded?
+    assert schema2.expanded?
+  end
+
+  it "it handles oneOf with nested references to a local schema" do
+    sample1 = {
+      "$schema" => "http://json-schema.org/draft-04/hyper-schema",
+      "type" => "object",
+      "properties" => {
+        "foo" => {
+          "$ref" => "http://json-schema.org/b.json#"
+        }
+      }
+    }
+    schema1 = JsonSchema::Parser.new.parse!(sample1)
+    schema1.uri = "http://json-schema.org/a.json"
+
+    sample2 = {
+      "$schema" => "http://json-schema.org/draft-04/hyper-schema",
+      "type" => "object",
+      "definitions" => {
+        "baz" => {
+          "type" => "string",
+          "maxLength" => 3
+        }
+      },
+      "properties" => {
+        "bar" => {
+          "oneOf" => [
+            {"type" => "null"},
+            {"$ref" => "#/definitions/baz"}
+          ]
+        }
+      },
+    }
+    schema2 = JsonSchema::Parser.new.parse!(sample2)
+    schema2.uri = "http://json-schema.org/b.json"
+
+    # Initialize a store and add our schema to it.
+    store = JsonSchema::DocumentStore.new
+    store.add_schema(schema1)
+    store.add_schema(schema2)
+
+    expander = JsonSchema::ReferenceExpander.new
+    expander.expand(schema1, store: store)
+
+    assert_equal 3, schema1.properties["foo"].properties["bar"].one_of[1].max_length
+  end
+
   it "expands a schema with a reference to an external schema with a nested local property reference" do
     sample1 = {
       "$schema" => "http://json-schema.org/draft-04/hyper-schema",

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: json_schema
 version: !ruby/object:Gem::Version
-  version: 0.20.3
+  version: 0.20.8
 platform: ruby
 authors:
 - Brandur
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-02-23 00:00:00.000000000 Z
+date: 2019-09-13 00:00:00.000000000 Z
 dependencies: []
 description: 
 email:
@@ -69,8 +69,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.7
+rubygems_version: 3.0.6
 signing_key: 
 specification_version: 4
 summary: A JSON Schema V4 and Hyperschema V4 parser and validator.