json_schema 0.14.1 → 0.14.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 23a2151b76d4fb55e79b7b2c38d1738cb6d891cc
-  data.tar.gz: fac096a0e499f17e6a64c732284278d7f4e4c764
+  metadata.gz: b1d59f23d58a9aeed30273ccdcec6a106dbede93
+  data.tar.gz: d25d184e8fc7bc6345e67ebb89b9c8d21b601ad9
 SHA512:
-  metadata.gz: f5fa881adb1b78efeafcaade0d20b5caba675d998591cea60a2ed0d56ef1c7b77377bde23bc9ddfb61a6da6d462225666fbdaa3f01b24559f652c31b68ff3b7d
-  data.tar.gz: 0327c85a93f4f51e8e4092458168b3822d45c0eabe00c51b82a0273ef93c04191e5fd457229dd774a5cac6a368bc6160aa3eeb3e3a1d17f1983eb218102921f1
+  metadata.gz: f33b776903af3753baa223758920ecbb77e1d48dec0973c8cf85fea4bf92c19115f78a5dc8202912ab3d4b6faf861cdf24bf34595f1a882030721364fd56c099
+  data.tar.gz: c0e594eb23d5faf03c6b8d14b54e24af9db99be45ae786ccb3ec33af383470b131a5b20b1fa94a2236eb8bb1391cbc2e64a7fca3b1e08fbd0cf14cd621a0e102

data/bin/validate-schema

@@ -10,7 +10,7 @@ end
 
 command = Commands::ValidateSchema.new
 
-OptionParser.new { |opts|
+parser = OptionParser.new { |opts|
   opts.on("-d", "--detect", "Detect schema from $schema") do
     command.detect = true
 
@@ -21,16 +21,19 @@ OptionParser.new { |opts|
   opts.on("-s", "--schema SCHEMA", "Additional schema to use for references") do |s|
     command.extra_schemas << s
   end
-}.parse!
+}
 
-success = command.run(ARGV.dup)
+if $0 == __FILE__
+  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)
+  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
 end

data/lib/json_schema/attributes.rb

@@ -0,0 +1,108 @@
+module JsonSchema
+  # Attributes mixes in some useful attribute-related methods for use in
+  # defining schema classes in a spirit similar to Ruby's attr_accessor and
+  # friends.
+  module Attributes
+    # Provides class-level methods for the Attributes module.
+    module ClassMethods
+      # Attributes that should be copied between classes when invoking
+      # Attributes#copy_from.
+      #
+      # Hash contains instance variable names mapped to a default value for the
+      # field.
+      attr_reader :copyable_attrs
+
+      # Attributes that are part of the JSON schema and hyper-schema
+      # specifications. These are allowed to be accessed with the [] operator.
+      #
+      # Hash contains the access key mapped to the name of the method that should
+      # be invoked to retrieve a value. For example, `type` maps to `type` and
+      # `additionalItems` maps to `additional_items`.
+      attr_reader :schema_attrs
+
+      # identical to attr_accessible, but allows us to copy in values from a
+      # target schema to help preserve our hierarchy during reference expansion
+      def attr_copyable(attr, options = {})
+        attr_accessor(attr)
+
+        # Usually the default being assigned here is nil.
+        self.copyable_attrs["@#{attr}".to_sym] = options[:default]
+
+        if default = options[:default]
+          # remove the reader already created by attr_accessor
+          remove_method(attr)
+
+          define_method(attr) do
+            val = instance_variable_get(:"@#{attr}")
+            if !val.nil?
+              val
+            else
+              if [Array, Hash, Set].include?(default.class)
+                default.dup
+              else
+                default
+              end
+            end
+          end
+        end
+      end
+
+      def attr_schema(attr, options = {})
+        attr_copyable(attr, :default => options[:default])
+        self.schema_attrs[options[:schema_name] || attr] = attr
+      end
+
+      # Directive indicating that attributes should be inherited from a parent
+      # class.
+      #
+      # Must appear as first statement in class that mixes in (or whose parent
+      # mixes in) the Attributes module.
+      def inherit_attrs
+        @copyable_attrs = self.superclass.instance_variable_get(:@copyable_attrs).dup
+        @schema_attrs = self.superclass.instance_variable_get(:@schema_attrs).dup
+      end
+
+      # Initializes some class instance variables required to make other
+      # methods in the Attributes module work. Run automatically when the
+      # module is mixed into another class.
+      def initialize_attrs
+        @copyable_attrs = {}
+        @schema_attrs = {}
+      end
+    end
+
+    def self.included(klass)
+      klass.extend(ClassMethods)
+      klass.send(:initialize_attrs)
+    end
+
+    # Allows the values of schema attributes to be accessed with a symbol or a
+    # string. So for example, the value of `schema.additional_items` could be
+    # procured with `schema[:additionalItems]`. This only works for attributes
+    # that are part of the JSON schema specification; other methods on the
+    # class are not available (e.g. `expanded`.)
+    #
+    # This is implemented so that `JsonPointer::Evaluator` can evaluate a
+    # reference on an sintance of this class (as well as plain JSON data).
+    def [](name)
+      name = name.to_sym
+      if self.class.schema_attrs.key?(name)
+        send(self.class.schema_attrs[name])
+      else
+        raise NoMethodError, "Schema does not respond to ##{name}"
+      end
+    end
+
+    def copy_from(schema)
+      self.class.copyable_attrs.each do |copyable, _|
+        instance_variable_set(copyable, schema.instance_variable_get(copyable))
+      end
+    end
+
+    def initialize_attrs
+      self.class.copyable_attrs.each do |attr, _|
+        instance_variable_set(attr, nil)
+      end
+    end
+  end
+end

data/lib/json_schema/parser.rb

@@ -186,6 +186,13 @@ module JsonSchema
           link             = Schema::Link.new
           link.parent      = schema
 
+          link.data        = l
+
+          # any parsed schema is automatically expanded
+          link.expanded    = true
+
+          link.uri         = nil
+
           link.description = l["description"]
           link.enc_type    = l["encType"]
           link.href        = l["href"]

data/lib/json_schema/reference_expander.rb

@@ -254,10 +254,12 @@ module JsonSchema
           each { |s| yielder << s }
 
         # schemas contained inside hyper-schema links objects
-        schema.links.map { |l| [l.schema, l.target_schema] }.
-          flatten.
-          compact.
-          each { |s| yielder << s }
+        if schema.links
+          schema.links.map { |l| [l.schema, l.target_schema] }.
+            flatten.
+            compact.
+            each { |s| yielder << s }
+        end
       end
     end
 

data/lib/json_schema/schema.rb

@@ -2,45 +2,18 @@ require "json"
 
 module JsonSchema
   class Schema
-    @@copyable_attrs = []
-
-    # Attributes that are part of the JSON schema and hyper-schema
-    # specifications. These are allowed to be accessed with the [] operator.
-    #
-    # Hash contains the access key mapped to the name of the method that should
-    # be invoked to retrieve a value. For example, `type` maps to `type` and
-    # `additionalItems` maps to `additional_items`.
-    @@schema_attrs = {}
-
-    # identical to attr_accessible, but allows us to copy in values from a
-    # target schema to help preserve our hierarchy during reference expansion
-    def self.attr_copyable(attr)
-      attr_accessor(attr)
-      @@copyable_attrs << "@#{attr}".to_sym
-    end
-
-    def self.attr_schema(attr, options = {})
-      attr_copyable(attr)
-      @@schema_attrs[options[:schema_name] || attr] = attr
-    end
-
-    def self.attr_reader_default(attr, default)
-      # remove the reader already created by attr_accessor
-      remove_method(attr)
-
-      class_eval("def #{attr} ; !@#{attr}.nil? ? @#{attr} : #{default} ; end")
-    end
+    include Attributes
 
     def initialize
+      # nil out all our fields so that it's possible to instantiate a schema
+      # instance without going through the parser and validate against it
+      # without Ruby throwing warnings about uninitialized instance variables.
+      initialize_attrs
+
+      # Don't put this in as an attribute default. We require that this precise
+      # pointer gets copied between all clones of any given schema so that they
+      # all share exactly the same set.
       @clones = Set.new
-
-      # nil out all our schema fields so that it's possible to instantiate a
-      # schema instance without going through the parser and validate against
-      # it without Ruby throwing warnings about uninitialized instance
-      # variables.
-      @@schema_attrs.each do |_, a|
-        send(:"#{a}=", nil)
-      end
     end
 
     # Fragment of a JSON Pointer that can help us build a pointer back to this
@@ -73,6 +46,9 @@ module JsonSchema
     # initialized after the original. Used for JSON Reference expansion. The
     # only copy not present in this set is the original Schema object.
     #
+    # Note that this doesn't have a default option because we rely on the fact
+    # that the set is the *same object* between all clones of any given schema.
+    #
     # Type: Set[Schema]
     attr_copyable :clones
 
@@ -94,12 +70,13 @@ module JsonSchema
     # Type: String
     attr_schema :id
 
-    # Short title of the schema.
+    # Short title of the schema (or the hyper-schema link if this is one).
     #
     # Type: String
     attr_schema :title
 
-    # More detailed description of the schema.
+    # More detailed description of the schema (or the hyper-schema link if this
+    # is one).
     #
     # Type: String
     attr_schema :description
@@ -117,19 +94,19 @@ module JsonSchema
     # set of to be valid.
     #
     # Type: Array[Schema]
-    attr_schema :all_of, :schema_name => :allOf
+    attr_schema :all_of, :default => [], :schema_name => :allOf
 
     # A collection of subschemas of which data must validate against any schema
     # in the set to be be valid.
     #
     # Type: Array[Schema]
-    attr_schema :any_of, :schema_name => :anyOf
+    attr_schema :any_of, :default => [], :schema_name => :anyOf
 
     # A collection of inlined subschemas. Standard convention is to subschemas
     # here and reference them from elsewhere.
     #
     # Type: Hash[String => Schema]
-    attr_schema :definitions
+    attr_schema :definitions, :default => {}
 
     # A collection of objects that must include the data for it to be valid.
     #
@@ -140,7 +117,7 @@ module JsonSchema
     # one of to be valid.
     #
     # Type: Array[Schema]
-    attr_schema :one_of, :schema_name => :oneOf
+    attr_schema :one_of, :default => [], :schema_name => :oneOf
 
     # A subschema which data must not validate against to be valid.
     #
@@ -152,10 +129,10 @@ module JsonSchema
     # of strings.
     #
     # Type: Array[String]
-    attr_schema :type
+    attr_schema :type, :default => []
 
     # validation: array
-    attr_schema :additional_items, :schema_name => :additionalItems
+    attr_schema :additional_items, :default => true, :schema_name => :additionalItems
     attr_schema :items
     attr_schema :max_items, :schema_name => :maxItems
     attr_schema :min_items, :schema_name => :minItems
@@ -163,21 +140,21 @@ module JsonSchema
 
     # validation: number/integer
     attr_schema :max
-    attr_schema :max_exclusive, :schema_name => :maxExclusive
+    attr_schema :max_exclusive, :default => false, :schema_name => :maxExclusive
     attr_schema :min
-    attr_schema :min_exclusive, :schema_name => :minExclusive
+    attr_schema :min_exclusive, :default => false, :schema_name => :minExclusive
     attr_schema :multiple_of, :schema_name => :multipleOf
 
     # validation: object
-    attr_schema :additional_properties, :schema_name => :additionalProperties
-    attr_schema :dependencies
+    attr_schema :additional_properties, :default => true, :schema_name => :additionalProperties
+    attr_schema :dependencies, :default => {}
     attr_schema :max_properties, :schema_name => :maxProperties
     attr_schema :min_properties, :schema_name => :minProperties
-    attr_schema :pattern_properties, :schema_name => :patternProperties
-    attr_schema :properties
+    attr_schema :pattern_properties, :default => {}, :schema_name => :patternProperties
+    attr_schema :properties, :default => {}
     attr_schema :required
     # warning: strictProperties is technically V5 spec (but I needed it now)
-    attr_schema :strict_properties, :schema_name => :strictProperties
+    attr_schema :strict_properties, :default => false, :schema_name => :strictProperties
 
     # validation: string
     attr_schema :format
@@ -186,29 +163,19 @@ module JsonSchema
     attr_schema :pattern
 
     # hyperschema
-    attr_schema :links
+    attr_schema :links, :default => []
     attr_schema :media
     attr_schema :path_start, :schema_name => :pathStart
     attr_schema :read_only, :schema_name => :readOnly
 
-    # Give these properties reader defaults for particular behavior so that we
-    # can preserve the `nil` nature of their instance variables. Knowing that
-    # these were `nil` when we read them allows us to properly reflect the
-    # parsed schema back to JSON.
-    attr_reader_default :additional_items, true
-    attr_reader_default :additional_properties, true
-    attr_reader_default :all_of, []
-    attr_reader_default :any_of, []
-    attr_reader_default :definitions, {}
-    attr_reader_default :dependencies, {}
-    attr_reader_default :links, []
-    attr_reader_default :one_of, []
-    attr_reader_default :max_exclusive, false
-    attr_reader_default :min_exclusive, false
-    attr_reader_default :pattern_properties, {}
-    attr_reader_default :properties, {}
-    attr_reader_default :strict_properties, false
-    attr_reader_default :type, []
+    # hyperschema link attributes
+    attr_schema :enc_type, :default => "application/json"
+    attr_schema :href
+    attr_schema :media_type, :default => "application/json"
+    attr_schema :method
+    attr_schema :rel
+    attr_schema :schema
+    attr_schema :target_schema
 
     # allow booleans to be access with question mark
     alias :additional_items? :additional_items
@@ -218,29 +185,6 @@ module JsonSchema
     alias :read_only? :read_only
     alias :unique_items? :unique_items
 
-    # Allows the values of schema attributes to be accessed with a symbol or a
-    # string. So for example, the value of `schema.additional_items` could be
-    # procured with `schema[:additionalItems]`. This only works for attributes
-    # that are part of the JSON schema specification; other methods on the
-    # class are not available (e.g. `expanded`.)
-    #
-    # This is implemented so that `JsonPointer::Evaluator` can evaluate a
-    # reference on an sintance of this class (as well as plain JSON data).
-    def [](name)
-      name = name.to_sym
-      if @@schema_attrs.key?(name)
-        send(@@schema_attrs[name])
-      else
-        raise NoMethodError, "Schema does not respond to ##{name}"
-      end
-    end
-
-    def copy_from(schema)
-      @@copyable_attrs.each do |copyable|
-        instance_variable_set(copyable, schema.instance_variable_get(copyable))
-      end
-    end
-
     def expand_references(options = {})
       expander = ReferenceExpander.new
       if expander.expand(self, options)
@@ -267,7 +211,7 @@ module JsonSchema
         str
       else
         hash = {}
-        @@copyable_attrs.each do |copyable|
+        self.class.copyable_attrs.each do |copyable, _|
           next if [:@clones, :@data, :@parent, :@uri].include?(copyable)
           if value = instance_variable_get(copyable)
             if value.is_a?(Array)
@@ -319,27 +263,8 @@ module JsonSchema
     end
 
     # Link subobject for a hyperschema.
-    class Link
-      attr_accessor :parent
-
-      # schema attributes
-      attr_accessor :description
-      attr_writer :enc_type
-      attr_accessor :href
-      attr_writer :media_type
-      attr_accessor :method
-      attr_accessor :rel
-      attr_accessor :schema
-      attr_accessor :target_schema
-      attr_accessor :title
-
-      def enc_type
-        @enc_type || "application/json"
-      end
-
-      def media_type
-        @media_type || "application/json"
-      end
+    class Link < Schema
+      inherit_attrs
     end
 
     # Media type subobject for a hyperschema.

data/lib/json_schema/validator.rb

@@ -409,8 +409,9 @@ module JsonSchema
 
       num_valid = schema.one_of.count do |subschema|
         current_sub_errors = []
+        valid = validate_data(subschema, data, current_sub_errors, path)
         sub_errors << current_sub_errors
-        validate_data(subschema, data, current_sub_errors, path)
+        valid
       end
 
       return true if num_valid == 1
@@ -498,7 +499,7 @@ module JsonSchema
     end
 
     def validate_type(schema, data, errors, path)
-      return true if schema.type.empty?
+      return true if !schema.type || schema.type.empty?
       valid_types = schema.type.map { |t| TYPE_MAP[t] }.flatten.compact
       if valid_types.any? { |t| data.is_a?(t) }
         true

data/lib/json_schema.rb

@@ -1,3 +1,4 @@
+require_relative "json_schema/attributes"
 require_relative "json_schema/configuration"
 require_relative "json_schema/document_store"
 require_relative "json_schema/error"

data/test/bin_test.rb

@@ -0,0 +1,20 @@
+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).
+#
+# We can do this without actually executing them because they're gated by `if
+# $0 == __FILE__` statements.
+#
+
+describe "executables in bin/" do
+  before do
+    @bin_dir = File.expand_path("../../bin", __FILE__)
+  end
+
+  it "has roughly valid Ruby structure for validate-schema" do
+    load File.join(@bin_dir, "validate-schema")
+  end
+end

data/test/json_pointer/evaluator_test.rb

@@ -1,6 +1,7 @@
 require "test_helper"
 
 require "json_pointer"
+require "json_schema"
 
 describe JsonPointer::Evaluator do
   before do

data/test/json_schema/attribute_test.rb

@@ -0,0 +1,98 @@
+require "test_helper"
+
+require "json_schema"
+
+describe JsonSchema::Attributes do
+  it "defines copyable attributes" do
+    obj = TestAttributes.new
+    obj.copyable = "foo"
+    assert_equal "foo", obj.copyable
+    assert_includes obj.class.copyable_attrs, :@copyable
+  end
+
+  it "defines schema attributes" do
+    obj = TestAttributes.new
+    obj.schema = "foo"
+    assert_equal "foo", obj.schema
+    assert_equal({:schema => :schema, :named => :schema_named},
+      obj.class.schema_attrs)
+  end
+
+  it "defines attributes with default readers" do
+    obj = TestAttributes.new
+    assert_equal [], obj.copyable_default
+
+    assert_equal "application/json", obj.copyable_default_with_string
+
+    hash = obj.copyable_default_with_object
+    assert_equal({}, hash)
+    hash[:x] = 123
+
+    # This is a check to make sure that the new object is not the same object
+    # as the one that we just mutated above. When assigning defaults the module
+    # should dup any common data strcutures that it puts in here.
+    obj = TestAttributes.new
+    hash = obj.copyable_default_with_object
+    assert_equal({}, hash)
+  end
+
+  it "inherits attributes when so instructed" do
+    obj = TestAttributesDescendant.new
+    assert_includes obj.class.copyable_attrs, :@copyable
+  end
+
+  it "allows schema attributes to be indexed but not others" do
+    obj = TestAttributes.new
+
+    obj.copyable = "non-schema"
+    obj.schema = "schema"
+
+    assert_raises NoMethodError do
+      assert_equal nil, obj[:copyable]
+    end
+
+    assert_equal "schema", obj[:schema]
+  end
+
+  it "copies attributes with #copy_from" do
+    obj = TestAttributes.new
+
+    obj.copyable = "copyable"
+    obj.schema = "schema"
+
+    obj2 = TestAttributes.new
+    obj2.copy_from(obj)
+
+    assert_equal "copyable", obj2.copyable
+    assert_equal "schema", obj2.schema
+  end
+
+  it "initializes attributes with #initialize_attrs" do
+    obj = TestAttributes.new
+
+    # should produce a nil value *without* a Ruby warning
+    assert_equal nil, obj.copyable
+    assert_equal nil, obj.schema
+  end
+
+  class TestAttributes
+    include JsonSchema::Attributes
+
+    def initialize
+      initialize_attrs
+    end
+
+    attr_copyable :copyable
+
+    attr_schema :schema
+    attr_schema :schema_named, :schema_name => :named
+
+    attr_copyable :copyable_default, :default => []
+    attr_copyable :copyable_default_with_string, :default => "application/json"
+    attr_copyable :copyable_default_with_object, :default => {}
+  end
+
+  class TestAttributesDescendant < TestAttributes
+    inherit_attrs
+  end
+end

data/test/json_schema/reference_expander_test.rb

@@ -265,6 +265,18 @@ describe JsonSchema::ReferenceExpander do
     assert schema.expanded?
   end
 
+  it "expands a reference to a link" do
+    pointer("#/properties").merge!(
+      "link" => { "$ref" => "#/links/0" }
+    )
+    assert expand
+
+    referenced = @schema.links[0]
+    reference = @schema.properties["link"]
+
+    assert_equal reference.href, referenced.href
+  end
+
   def error_messages
     @expander.errors.map { |e| e.message }
   end

data/test/test_helper.rb

@@ -1,3 +1,16 @@
+if RUBY_VERSION >= '2.0.0'
+  require 'simplecov'
+  SimpleCov.start do
+    # We do our utmost to test our executables by modularizing them into
+    # testable pieces, but testing them to completion is nearly impossible as
+    # far as I can tell, so include them in our tests but don't calculate
+    # coverage.
+    add_filter "/bin/"
+
+    add_filter "/test/"
+  end
+end
+
 require "minitest"
 require "minitest/autorun"
 #require "pry-rescue/minitest"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: json_schema
 version: !ruby/object:Gem::Version
-  version: 0.14.1
+  version: 0.14.3
 platform: ruby
 authors:
 - Brandur
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-07 00:00:00.000000000 Z
+date: 2016-10-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ecma-re-validator
@@ -94,6 +94,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 
 email:
 - brandur@mutelight.org
@@ -110,6 +124,7 @@ files:
 - lib/json_pointer/evaluator.rb
 - lib/json_reference.rb
 - lib/json_schema.rb
+- lib/json_schema/attributes.rb
 - lib/json_schema/configuration.rb
 - lib/json_schema/document_store.rb
 - lib/json_schema/error.rb
@@ -120,10 +135,12 @@ files:
 - schemas/hyper-schema.json
 - schemas/open-api-schema.json
 - schemas/schema.json
+- test/bin_test.rb
 - test/commands/validate_schema_test.rb
 - test/data_scaffold.rb
 - test/json_pointer/evaluator_test.rb
 - test/json_reference/reference_test.rb
+- test/json_schema/attribute_test.rb
 - test/json_schema/document_store_test.rb
 - test/json_schema/error_test.rb
 - test/json_schema/parser_test.rb