json_schema 0.13.6 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ad178e92388beab0aa3fb7711c8302cc2b82e28d
-  data.tar.gz: 4b49ae2eb3984d02e2fe22d2cf64850cf0ca1a47
+  metadata.gz: c0bf452530b4b54246e04aae4fb36c02222c9631
+  data.tar.gz: e04f230e83d2da306a5c2462eda95a12f1b579cf
 SHA512:
-  metadata.gz: 19a0ecfe134501cd724985385611a5bb9b04613f6cc25f81f5163fb228c757555bfb363fe1dacae7e7a420235e46d6034eed0c5177d29ffd40c2f9b0c382db1d
-  data.tar.gz: 28db95313452012277f5ce37426e15f04e342c30c7c637f72dc58763a3d6f66e419534c25782ee72ebe22e92a4f17b9af86c4aab401590babf27be695f94de8c
+  metadata.gz: 0dd9c714bcbdb4d882c2e4a931aabacf1b57ed5cb5c0af409c18b1fcc5700d6ec821276a593175d6af8ca5a2cb91ef06c8a5e58cd40bc82056450210f2f5d883
+  data.tar.gz: a0aef6c2277dd70609a723aa8e23b8b955baf1f98538e98dd645c2530ddd1ddcac7da36b1ba13d258bb1f9a47f922355e5e6b76a441fada5cadafb5e46b3fb15

data/lib/json_pointer/evaluator.rb

@@ -1,4 +1,9 @@
 module JsonPointer
+  # Evaluates a JSON pointer within a JSON document.
+  #
+  # Note that this class is designed to evaluate references across a plain JSON
+  # data object _or_ an instance of `JsonSchema::Schema`, so the constructor's
+  # `data` argument can be of either type.
   class Evaluator
     def initialize(data)
       @data = data

data/lib/json_schema/reference_expander.rb

@@ -139,10 +139,10 @@ module JsonSchema
       ref = ref_schema.reference
 
       if !(new_schema = lookup_pointer(ref.uri, ref.pointer))
-        data = JsonPointer.evaluate(resolved_schema.data, ref.pointer)
+        new_schema = JsonPointer.evaluate(resolved_schema, ref.pointer)
 
         # couldn't resolve pointer within known schema; that's an error
-        if data.nil?
+        if new_schema.nil?
           message = %{Couldn't resolve pointer "#{ref.pointer}".}
           @errors << SchemaError.new(resolved_schema, message, :unresolved_pointer)
           return
@@ -153,14 +153,13 @@ module JsonSchema
         #
         #     https://github.com/brandur/json_schema/issues/50
         #
-        if new_schema = lookup_pointer(ref.uri, data["$ref"])
-          new_schema.clones << ref_schema
+        if new_schema.reference &&
+          new_new_schema = lookup_pointer(ref.uri, new_schema.reference.pointer)
+            new_new_schema.clones << ref_schema
         else
           # Parse a new schema and use the same parent node. Basically this is
           # exclusively for the case of a reference that needs to be
           # de-referenced again to be resolved.
-          # TODO: Fix to never parse.
-          new_schema = Parser.new.parse(data, ref_schema.parent)
           build_schema_paths(ref.uri, resolved_schema)
         end
       else

data/lib/json_schema/schema.rb

@@ -2,13 +2,26 @@ require "json"
 
 module JsonSchema
   class Schema
-    @@copyable = []
+    @@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 << "@#{attr}".to_sym
+      @@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)
@@ -71,22 +84,22 @@ module JsonSchema
     # the parent, and absolute URI's will replace it.
     #
     # Type: String
-    attr_copyable :id
+    attr_schema :id
 
     # Short title of the schema.
     #
     # Type: String
-    attr_copyable :title
+    attr_schema :title
 
     # More detailed description of the schema.
     #
     # Type: String
-    attr_copyable :description
+    attr_schema :description
 
     # Default JSON value for this particular schema
     #
     # Type: [any]
-    attr_copyable :default
+    attr_schema :default
 
     #
     # Validation: Any
@@ -96,79 +109,79 @@ module JsonSchema
     # set of to be valid.
     #
     # Type: Array[Schema]
-    attr_copyable :all_of
+    attr_schema :all_of, :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_copyable :any_of
+    attr_schema :any_of, :schema_name => :anyOf
 
     # A collection of inlined subschemas. Standard convention is to subschemas
     # here and reference them from elsewhere.
     #
     # Type: Hash[String => Schema]
-    attr_copyable :definitions
+    attr_schema :definitions
 
     # A collection of objects that must include the data for it to be valid.
     #
     # Type: Array
-    attr_copyable :enum
+    attr_schema :enum
 
     # A collection of subschemas of which data must validate against exactly
     # one of to be valid.
     #
     # Type: Array[Schema]
-    attr_copyable :one_of
+    attr_schema :one_of, :schema_name => :oneOf
 
     # A subschema which data must not validate against to be valid.
     #
     # Type: Schema
-    attr_copyable :not
+    attr_schema :not
 
     # An array of types that data is allowed to be. The spec allows this to be
     # a string as well, but the parser will always normalize this to an array
     # of strings.
     #
     # Type: Array[String]
-    attr_copyable :type
+    attr_schema :type
 
     # validation: array
-    attr_copyable :additional_items
-    attr_copyable :items
-    attr_copyable :max_items
-    attr_copyable :min_items
-    attr_copyable :unique_items
+    attr_schema :additional_items, :schema_name => :additionalItems
+    attr_schema :items
+    attr_schema :max_items, :schema_name => :maxItems
+    attr_schema :min_items, :schema_name => :minItems
+    attr_schema :unique_items, :schema_name => :uniqueItems
 
     # validation: number/integer
-    attr_copyable :max
-    attr_copyable :max_exclusive
-    attr_copyable :min
-    attr_copyable :min_exclusive
-    attr_copyable :multiple_of
+    attr_schema :max
+    attr_schema :max_exclusive, :schema_name => :maxExclusive
+    attr_schema :min
+    attr_schema :min_exclusive, :schema_name => :minExclusive
+    attr_schema :multiple_of, :schema_name => :multipleOf
 
     # validation: object
-    attr_copyable :additional_properties
-    attr_copyable :dependencies
-    attr_copyable :max_properties
-    attr_copyable :min_properties
-    attr_copyable :pattern_properties
-    attr_copyable :properties
-    attr_copyable :required
+    attr_schema :additional_properties, :schema_name => :additionalProperties
+    attr_schema :dependencies
+    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 :required
     # warning: strictProperties is technically V5 spec (but I needed it now)
-    attr_copyable :strict_properties
+    attr_schema :strict_properties, :schema_name => :strictProperties
 
     # validation: string
-    attr_copyable :format
-    attr_copyable :max_length
-    attr_copyable :min_length
-    attr_copyable :pattern
+    attr_schema :format
+    attr_schema :max_length, :schema_name => :maxLength
+    attr_schema :min_length, :schema_name => :minLength
+    attr_schema :pattern
 
     # hyperschema
-    attr_copyable :links
-    attr_copyable :media
-    attr_copyable :path_start
-    attr_copyable :read_only
+    attr_schema :links
+    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
@@ -197,8 +210,25 @@ 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.each do |copyable|
+      @@copyable_attrs.each do |copyable|
         instance_variable_set(copyable, schema.instance_variable_get(copyable))
       end
     end
@@ -229,7 +259,7 @@ module JsonSchema
         str
       else
         hash = {}
-        @@copyable.each do |copyable|
+        @@copyable_attrs.each do |copyable|
           next if [:@clones, :@data, :@parent, :@uri].include?(copyable)
           if value = instance_variable_get(copyable)
             if value.is_a?(Array)

data/test/json_pointer/evaluator_test.rb

@@ -43,6 +43,14 @@ describe JsonPointer::Evaluator do
       e.message
   end
 
+  it "can evaluate on a schema object" do
+    schema = JsonSchema.parse!(DataScaffold.schema_sample)
+    evaluator = JsonPointer::Evaluator.new(schema)
+    res = evaluator.evaluate("#/definitions/app/definitions/contrived/allOf/0")
+    assert_kind_of JsonSchema::Schema, res
+    assert 30, res.max_length
+  end
+
   def data
    {
       "foo"  => ["bar", "baz"],

data/test/json_schema/schema_test.rb

@@ -0,0 +1,37 @@
+require "test_helper"
+
+require "json_schema"
+
+describe JsonSchema::Schema do
+  it "allows schema attribute access with #[]" do
+    schema = JsonSchema::Schema.new
+    schema.properties = { "foo" => nil }
+    assert_equal({ "foo" => nil }, schema[:properties])
+  end
+
+  it "allows schema attribute access with #[] and overridden name" do
+    schema = JsonSchema::Schema.new
+    schema.additional_properties = { "foo" => nil }
+    assert_equal({ "foo" => nil }, schema[:additionalProperties])
+  end
+
+  it "allows schema attribute access with #[] as string" do
+    schema = JsonSchema::Schema.new
+    schema.properties = { "foo" => nil }
+    assert_equal({ "foo" => nil }, schema["properties"])
+  end
+
+  it "raises if attempting to access #[] with bad method" do
+    schema = JsonSchema::Schema.new
+    assert_raises NoMethodError do
+      schema[:wat]
+    end
+  end
+
+  it "raises if attempting to access #[] with non-schema attribute" do
+    schema = JsonSchema::Schema.new
+    assert_raises NoMethodError do
+      schema[:expanded]
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: json_schema
 version: !ruby/object:Gem::Version
-  version: 0.13.6
+  version: 0.14.0
 platform: ruby
 authors:
 - Brandur
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-05 00:00:00.000000000 Z
+date: 2016-10-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ecma-re-validator
@@ -128,6 +128,7 @@ files:
 - test/json_schema/error_test.rb
 - test/json_schema/parser_test.rb
 - test/json_schema/reference_expander_test.rb
+- test/json_schema/schema_test.rb
 - test/json_schema/validator_test.rb
 - test/json_schema_test.rb
 - test/test_helper.rb