json_schema 0.20.4 → 0.20.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0b59e2abb8260fc05004ddde201c9107a0be38149e0dbf9aff1f3d774e5d5ae8
-  data.tar.gz: b40758dada1ba42ac46f7aa45c9370eae4d9ef5178126813fff6ba6ad8ab0ece
+  metadata.gz: e21a1e4dc51b894f1374f46872ed71f49d2b45702dc99783286aafefca69f8c8
+  data.tar.gz: 7002f0a54a8de78318b676d9f1c0465dc8ff40d70163b3d83b8fafa412cee52e
 SHA512:
-  metadata.gz: e06bc21c170498b1bcb09b1142a1971b64c8c9e376b395e72017d0aab538eacf54c1061e1a09be7e633734f75706fafe399b9272d9ac633fc7976b4d8084decc
-  data.tar.gz: 98cb1d66418ebcdfe94367c01e946c210f7f79ffa89ee3daa609876398753cb7239c9e8f189087f01f81d33b55f4f038764d21d8da64049c6cc5dfd0034606aa
+  metadata.gz: a9d51a9b64731ad8e2aa3bb79f65e3b7c555a38b181a6a00789b9025903a5049e1be0043a3637456a07d008f8878b2a61f56b3a6b9bacd90c1fc7acb20a5415a
+  data.tar.gz: 71e615dc945f0bd926f41211e56a48424f0f45df706df4394779ebf03d96316764a0b6433b2413469e314d0c1a42d08bcc0f479c2c0b2f3736732c4815993361

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")
 
@@ -358,10 +362,10 @@ module JsonSchema
     end
 
     def validate_type(schema, types, field)
-      friendly_types =
-        types.map { |t| FRIENDLY_TYPES[t] || t }.sort.uniq.join("/")
       value = schema.data[field]
       if !value.nil? && !types.any? { |t| value.is_a?(t) }
+        friendly_types =
+          types.map { |t| FRIENDLY_TYPES[t] || t }.sort.uniq.join("/")
         message = %{#{value.inspect} is not a valid "#{field}", must be a #{friendly_types}.}
         @errors << SchemaError.new(schema, message, :invalid_type)
         nil

data/lib/json_schema/reference_expander.rb

@@ -93,6 +93,7 @@ module JsonSchema
       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}")
@@ -146,6 +147,17 @@ module JsonSchema
             end
           end
 
+          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

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",
@@ -373,6 +454,38 @@ describe JsonSchema::ReferenceExpander do
     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",

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: json_schema
 version: !ruby/object:Gem::Version
-  version: 0.20.4
+  version: 0.20.9
 platform: ruby
 authors:
 - Brandur
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-03-12 00:00:00.000000000 Z
+date: 2020-06-16 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.3
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
 summary: A JSON Schema V4 and Hyperschema V4 parser and validator.