dato_json_schema 0.20.8

data/lib/json_schema/reference_expander.rb

@@ -0,0 +1,364 @@
+require "set"
+
+module JsonSchema
+  class ReferenceExpander
+    attr_accessor :errors
+    attr_accessor :store
+
+    def expand(schema, options = {})
+      @errors       = []
+      @local_store  = DocumentStore.new
+      @schema       = schema
+      @schema_paths = {}
+      @store        = options[:store] || DocumentStore.new
+
+      # If the given JSON schema is _just_ a JSON reference and nothing else,
+      # short circuit the whole expansion process and return the result.
+      if schema.reference && !schema.expanded?
+        return dereference(schema, [])
+      end
+
+      @uri = URI.parse(schema.uri)
+
+      @store.each do |uri, store_schema|
+        build_schema_paths(uri, store_schema)
+      end
+
+      # we run #to_s on lookup for URIs; the #to_s of nil is ""
+      build_schema_paths("", schema)
+
+      traverse_schema(schema)
+
+      refs = unresolved_refs(schema).sort
+      if refs.count > 0
+        message = %{Couldn't resolve references: #{refs.to_a.join(", ")}.}
+        @errors << SchemaError.new(schema, message, :unresolved_references)
+      end
+
+      @errors.count == 0
+    end
+
+    def expand!(schema, options = {})
+      if !expand(schema, options)
+        raise AggregateError.new(@errors)
+      end
+      true
+    end
+
+    private
+
+    def add_reference(schema)
+      uri = URI.parse(schema.uri)
+
+      # In case we've already added a schema for the same reference, don't
+      # re-add it unless the new schema's pointer path is shorter than the one
+      # we've already stored.
+      stored_schema = lookup_reference(uri)
+      if stored_schema && stored_schema.pointer.length < schema.pointer.length
+        return
+      end
+
+      if uri.absolute?
+        @store.add_schema(schema)
+      else
+        @local_store.add_schema(schema)
+      end
+    end
+
+    def build_schema_paths(uri, schema)
+      return if schema.reference
+
+      paths = @schema_paths[uri] ||= {}
+      paths[schema.pointer] = schema
+
+      schema_children(schema) do |subschema|
+        build_schema_paths(uri, subschema)
+      end
+
+      # Also insert alternate tree for schema's custom URI. O(crazy).
+      if schema.uri != uri
+        fragment, parent = schema.fragment, schema.parent
+        schema.fragment, schema.parent = "#", nil
+        build_schema_paths(schema.uri, schema)
+        schema.fragment, schema.parent = fragment, parent
+      end
+    end
+
+    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(", ")}.}
+        @errors << SchemaError.new(ref_schema, message, :loop_detected)
+        return false
+      end
+
+      new_schema = resolve_reference(ref_schema)
+      return false unless new_schema
+
+      # if the reference resolved to a new reference we need to continue
+      # dereferencing until we either hit a non-reference schema, or a
+      # reference which is already resolved
+      if new_schema.reference && !new_schema.expanded?
+        success = dereference(new_schema, ref_stack + [ref])
+        return false unless success
+      end
+
+      # If the reference schema is a global reference
+      # then we'll need to manually expand any nested
+      # references.
+      if ref.uri
+        schema_children(new_schema) do |subschema|
+          # Don't bother if the subschema points to the same
+          # schema as the reference schema.
+          next if ref_schema == subschema
+
+          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
+
+          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
+
+      # 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) do |schema|
+          schema.parent = ref_schema
+        end
+      end
+
+      true
+    end
+
+    def lookup_pointer(uri, pointer)
+      paths = @schema_paths[uri.to_s] ||= {}
+      paths[pointer]
+    end
+
+    def lookup_reference(uri)
+      if uri.absolute?
+        @store.lookup_schema(uri.to_s)
+      else
+        @local_store.lookup_schema(uri.to_s)
+      end
+    end
+
+    def resolve_pointer(ref_schema, resolved_schema)
+      ref = ref_schema.reference
+
+      if !(new_schema = lookup_pointer(ref.uri, ref.pointer))
+        new_schema = JsonPointer.evaluate(resolved_schema, ref.pointer)
+
+        # couldn't resolve pointer within known schema; that's an error
+        if new_schema.nil?
+          message = %{Couldn't resolve pointer "#{ref.pointer}".}
+          @errors << SchemaError.new(resolved_schema, message, :unresolved_pointer)
+          return
+        end
+
+        # Try to aggressively detect a circular dependency in case of another
+        # reference. See:
+        #
+        #     https://github.com/brandur/json_schema/issues/50
+        #
+        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.
+          build_schema_paths(ref.uri, resolved_schema)
+        end
+      else
+        # insert a clone record so that the expander knows to expand it when
+        # the schema traversal is finished
+        new_schema.clones << ref_schema
+      end
+      new_schema
+    end
+
+    def resolve_reference(ref_schema)
+      ref = ref_schema.reference
+      uri = ref.uri
+
+      if uri && uri.host
+        scheme = uri.scheme || "http"
+        # allow resolution if something we've already parsed has claimed the
+        # full URL
+        if @store.lookup_schema(uri.to_s)
+          resolve_uri(ref_schema, uri)
+        else
+          message =
+            %{Reference resolution over #{scheme} is not currently supported (URI: #{uri}).}
+          @errors << SchemaError.new(ref_schema, message, :scheme_not_supported)
+          nil
+        end
+      # absolute
+      elsif uri && uri.path[0] == "/"
+        resolve_uri(ref_schema, uri)
+      # relative
+      elsif uri
+        # Build an absolute path using the URI of the current schema.
+        #
+        # Note that this code path will never currently be hit because the
+        # incoming reference schema will never have a URI.
+        if ref_schema.uri
+          schema_uri = ref_schema.uri.chomp("/")
+          resolve_uri(ref_schema, URI.parse(schema_uri + "/" + uri.path))
+        else
+          nil
+        end
+
+      # just a JSON Pointer -- resolve against schema root
+      else
+        resolve_pointer(ref_schema, @schema)
+      end
+    end
+
+    def resolve_uri(ref_schema, uri)
+      if schema = lookup_reference(uri)
+        resolve_pointer(ref_schema, schema)
+      else
+        message = %{Couldn't resolve URI: #{uri.to_s}.}
+        @errors << SchemaError.new(ref_schema, message, :unresolved_pointer)
+        nil
+      end
+    end
+
+    def schema_children(schema)
+      schema.all_of.each { |s| yield s }
+      schema.any_of.each { |s| yield s }
+      schema.one_of.each { |s| yield s }
+      schema.definitions.each { |_, s| yield s }
+      schema.pattern_properties.each { |_, s| yield s }
+      schema.properties.each { |_, s| yield s }
+
+      if additional = schema.additional_properties
+        if additional.is_a?(Schema)
+          yield additional
+        end
+      end
+
+      if schema.not
+        yield schema.not
+      end
+
+      # can either be a single schema (list validation) or multiple (tuple
+      # validation)
+      if items = schema.items
+        if items.is_a?(Array)
+          items.each { |s| yield s }
+        else
+          yield items
+        end
+      end
+
+      # dependencies can either be simple or "schema"; only replace the
+      # latter
+      schema.dependencies.
+        each_value { |s| yield s if s.is_a?(Schema) }
+
+      # schemas contained inside hyper-schema links objects
+      if schema.links
+        schema.links.each { |l|
+          yield l.schema if l.schema
+          yield l.target_schema if l.target_schema
+        }
+      end
+    end
+
+    def unresolved_refs(schema)
+      # prevent endless recursion
+      return [] unless schema.original?
+
+      arr = []
+      schema_children(schema) do |subschema|
+        if !subschema.expanded?
+          arr += [subschema.reference]
+        else
+          arr += unresolved_refs(subschema)
+        end
+      end
+      arr
+    end
+
+    def traverse_schema(schema)
+      add_reference(schema)
+
+      schema_children(schema) do |subschema|
+        if subschema.reference && !subschema.expanded?
+          dereference(subschema, [])
+        end
+
+        if !subschema.reference
+          traverse_schema(subschema)
+        end
+      end
+
+      # after finishing a schema traversal, find all clones and re-hydrate them
+      if schema.original?
+        schema.clones.each do |clone_schema|
+          parent = clone_schema.parent
+          clone_schema.copy_from(schema)
+          clone_schema.parent = parent
+        end
+      end
+    end
+  end
+end

data/lib/json_schema/schema.rb

@@ -0,0 +1,295 @@
+require "json"
+
+module JsonSchema
+  class Schema
+    TYPE_MAP = {
+      "array"   => Array,
+      "boolean" => [FalseClass, TrueClass],
+      "integer" => Integer,
+      "number"  => [Integer, Float],
+      "null"    => NilClass,
+      "object"  => Hash,
+      "string"  => String,
+    }
+
+    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
+    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
+
+    attr_copyable :expanded
+
+    # A reference to the data which the Schema was initialized from. Used for
+    # resolving JSON Pointer references.
+    #
+    # Type: Hash
+    attr_copyable :data
+
+    #
+    # Relations
+    #
+
+    # Parent Schema object. Child may come from any of `definitions`,
+    # `properties`, `anyOf`, etc.
+    #
+    # Type: Schema
+    attr_copyable :parent
+
+    # Collection of clones of this schema object, meaning all Schemas that were
+    # 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
+
+    # The normalized URI of this schema. Note that child schemas inherit a URI
+    # from their parent unless they have one explicitly defined, so this is
+    # likely not a unique value in any given schema hierarchy.
+    #
+    # Type: String
+    attr_copyable :uri
+
+    #
+    # Metadata
+    #
+
+    # Alters resolution scope. This value is used along with the parent scope's
+    # URI to build a new address for this schema. Relative ID's will append to
+    # the parent, and absolute URI's will replace it.
+    #
+    # Type: String
+    attr_schema :id
+
+    # 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 (or the hyper-schema link if this
+    # is one).
+    #
+    # Type: String
+    attr_schema :description
+
+    # Default JSON value for this particular schema
+    #
+    # Type: [any]
+    attr_schema :default
+
+    #
+    # Validation: Any
+    #
+
+    # A collection of subschemas of which data must validate against the full
+    # set of to be valid.
+    #
+    # Type: Array[Schema]
+    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, :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, :default => {}
+
+    # A collection of objects that must include the data for it to be valid.
+    #
+    # Type: Array
+    attr_schema :enum
+
+    # A collection of subschemas of which data must validate against exactly
+    # one of to be valid.
+    #
+    # Type: Array[Schema]
+    attr_schema :one_of, :default => [], :schema_name => :oneOf
+
+    # A subschema which data must not validate against to be valid.
+    #
+    # Type: Schema
+    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_schema :type, :default => [], :clear_cache => :@type_parsed
+
+    # validation: array
+    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
+    attr_schema :unique_items, :schema_name => :uniqueItems
+
+    # validation: number/integer
+    attr_schema :max, :schema_name => :maximum
+    attr_schema :max_exclusive, :default => false, :schema_name => :exclusiveMaximum
+    attr_schema :min, :schema_name => :minimum
+    attr_schema :min_exclusive, :default => false, :schema_name => :exclusiveMinimum
+    attr_schema :multiple_of, :schema_name => :multipleOf
+
+    # validation: object
+    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, :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, :default => false, :schema_name => :strictProperties
+
+    # validation: string
+    attr_schema :format
+    attr_schema :max_length, :schema_name => :maxLength
+    attr_schema :min_length, :schema_name => :minLength
+    attr_schema :pattern
+
+    # hyperschema
+    attr_schema :links, :default => []
+    attr_schema :media
+    attr_schema :path_start, :schema_name => :pathStart
+    attr_schema :read_only, :schema_name => :readOnly
+
+    # hyperschema link attributes
+    attr_schema :enc_type, :schema_name => :encType, :default => "application/json"
+    attr_schema :href
+    attr_schema :media_type, :schema_name => :mediaType, :default => "application/json"
+    attr_schema :method
+    attr_schema :rel
+    attr_schema :schema
+    attr_schema :target_schema, :schema_name => :targetSchema
+    attr_schema :job_schema, :schema_name => :jobSchema
+
+    # allow booleans to be access with question mark
+    alias :additional_items? :additional_items
+    alias :expanded? :expanded
+    alias :max_exclusive? :max_exclusive
+    alias :min_exclusive? :min_exclusive
+    alias :read_only? :read_only
+    alias :unique_items? :unique_items
+
+    def expand_references(options = {})
+      expander = ReferenceExpander.new
+      if expander.expand(self, options)
+        [true, nil]
+      else
+        [false, expander.errors]
+      end
+    end
+
+    def expand_references!(options = {})
+      ReferenceExpander.new.expand!(self, options)
+      true
+    end
+
+    # An array of Ruby classes that are equivalent to the types defined in the
+    # schema.
+    #
+    # Type: Array[Class]
+    def type_parsed
+      @type_parsed ||= type.flat_map { |t| TYPE_MAP[t] }.compact
+    end
+
+    def inspect
+      "\#<JsonSchema::Schema pointer=#{pointer}>"
+    end
+
+    def inspect_schema
+      if reference
+        str = reference.to_s
+        str += expanded? ? " [EXPANDED]" : " [COLLAPSED]"
+        str += original? ? " [ORIGINAL]" : " [CLONE]"
+        str
+      else
+        hash = {}
+        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)
+              if !value.empty?
+                hash[copyable] = value.map { |v| inspect_value(v) }
+              end
+            elsif value.is_a?(Hash)
+              if !value.empty?
+                hash[copyable] =
+                  Hash[*value.map { |k, v| [k, inspect_value(v)] }.flatten]
+              end
+            else
+              hash[copyable] = inspect_value(value)
+            end
+          end
+        end
+        hash
+      end
+    end
+
+    def inspect_value(value)
+      if value.is_a?(Schema)
+        value.inspect_schema
+      else
+        value.inspect
+      end
+    end
+
+    def original?
+      !clones.include?(self)
+    end
+
+    def pointer
+      if parent
+        (parent.pointer + "/".freeze + fragment).freeze
+      else
+        fragment
+      end
+    end
+
+    def validate(data, fail_fast: false)
+      validator = Validator.new(self)
+      valid = validator.validate(data, fail_fast: fail_fast)
+      [valid, validator.errors]
+    end
+
+    def validate!(data, fail_fast: false)
+      Validator.new(self).validate!(data, fail_fast: fail_fast)
+    end
+
+    # Link subobject for a hyperschema.
+    class Link < Schema
+      inherit_attrs
+    end
+
+    # Media type subobject for a hyperschema.
+    class Media
+      attr_accessor :binary_encoding
+      attr_accessor :type
+    end
+  end
+end