jsi-dev 0.0.8 → 0.0.9

data/lib/jsi/schema/elements.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Elements
+    def self.element_map(&block)
+      Util::MemoMap::Immutable.new(&block)
+    end
+  end
+
+  module Schema::Elements
+    # the schema itself
+    autoload(:SELF, 'jsi/schema/elements/self')
+
+    # $schema
+    autoload(:XSCHEMA, 'jsi/schema/elements/xschema')
+
+    # $vocabulary
+    autoload(:XVOCABULARY, 'jsi/schema/elements/xvocabulary')
+
+    # id
+    autoload(:ID, 'jsi/schema/elements/id')
+
+    # anchor
+    autoload(:ANCHOR, 'jsi/schema/elements/anchor')
+
+    # definitions
+    autoload(:DEFINITIONS, 'jsi/schema/elements/definitions')
+
+    # $comment
+    autoload(:COMMENT, 'jsi/schema/elements/comment')
+
+    # ref in-place application
+    autoload(:REF, 'jsi/schema/elements/ref')
+    autoload(:DYNAMIC_REF, 'jsi/schema/elements/dynamic_ref')
+
+    # in-place subschema application
+    autoload(:IF_THEN_ELSE, 'jsi/schema/elements/if_then_else')
+    autoload(:DEPENDENCIES, 'jsi/schema/elements/dependencies')
+    autoload(:DEPENDENT_SCHEMAS, 'jsi/schema/elements/dependent_schemas')
+    autoload(:ALL_OF, 'jsi/schema/elements/some_of')
+    autoload(:ANY_OF, 'jsi/schema/elements/some_of')
+    autoload(:ONE_OF, 'jsi/schema/elements/some_of')
+
+    # child subschema application
+    autoload(:ITEMS, 'jsi/schema/elements/items')
+    autoload(:ITEMS_PREFIXED, 'jsi/schema/elements/items_prefixed')
+    autoload(:CONTAINS, 'jsi/schema/elements/contains')
+    autoload(:CONTAINS_MINMAX, 'jsi/schema/elements/contains_minmax')
+    autoload(:PROPERTIES, 'jsi/schema/elements/properties')
+    autoload(:UNEVALUATED_PROPERTIES, 'jsi/schema/elements/unevaluated_properties')
+    autoload(:UNEVALUATED_ITEMS, 'jsi/schema/elements/unevaluated_items')
+
+    # property names subschema application
+    autoload(:PROPERTY_NAMES, 'jsi/schema/elements/property_names')
+
+    # any type validation
+    autoload(:TYPE, 'jsi/schema/elements/type')
+    autoload(:ENUM, 'jsi/schema/elements/enum')
+    autoload(:CONST, 'jsi/schema/elements/const')
+    autoload(:NOT, 'jsi/schema/elements/not')
+
+    # object validation
+    autoload(:REQUIRED,    'jsi/schema/elements/required')
+    autoload(:DEPENDENT_REQUIRED, 'jsi/schema/elements/dependent_required')
+    autoload(:MAX_PROPERTIES, 'jsi/schema/elements/object_validation')
+    autoload(:MIN_PROPERTIES, 'jsi/schema/elements/object_validation')
+
+    # array validation
+    autoload(:MAX_ITEMS, 'jsi/schema/elements/array_validation')
+    autoload(:MIN_ITEMS, 'jsi/schema/elements/array_validation')
+    autoload(:UNIQUE_ITEMS, 'jsi/schema/elements/array_validation')
+
+    # string validation
+    autoload(:MAX_LENGTH, 'jsi/schema/elements/string_validation')
+    autoload(:MIN_LENGTH, 'jsi/schema/elements/string_validation')
+    autoload(:PATTERN, 'jsi/schema/elements/pattern')
+
+    # numeric validation
+    autoload(:MULTIPLE_OF, 'jsi/schema/elements/numeric')
+    autoload(:MAXIMUM,           'jsi/schema/elements/numeric')
+    autoload(:EXCLUSIVE_MAXIMUM, 'jsi/schema/elements/numeric')
+    autoload(:MINIMUM,           'jsi/schema/elements/numeric')
+    autoload(:EXCLUSIVE_MINIMUM, 'jsi/schema/elements/numeric')
+    autoload(:MAXIMUM_BOOLEAN_EXCLUSIVE, 'jsi/schema/elements/numeric_draft04')
+    autoload(:MINIMUM_BOOLEAN_EXCLUSIVE, 'jsi/schema/elements/numeric_draft04')
+
+    # format
+    autoload(:FORMAT, 'jsi/schema/elements/format')
+
+    # content
+    autoload(:CONTENT_ENCODING, 'jsi/schema/elements/content_encoding')
+    autoload(:CONTENT_MEDIA_TYPE, 'jsi/schema/elements/content_media_type')
+    autoload(:CONTENT_SCHEMA, 'jsi/schema/elements/content_schema')
+
+    # metadata
+    autoload(:INFO_STRING, 'jsi/schema/elements/info_string')
+    autoload(:INFO_BOOL, 'jsi/schema/elements/info_bool')
+    autoload(:DEFAULT, 'jsi/schema/elements/default')
+    autoload(:EXAMPLES, 'jsi/schema/elements/examples')
+  end
+end

data/lib/jsi/schema/issue.rb

@@ -2,12 +2,12 @@
 
 module JSI
   module Schema
-    Issue = Util::AttrStruct[*%w(
+    Issue = Struct.subclass(*%i(
       level
       message
       keyword
       schema
-    )]
+    ))
 
     # an issue or problem with a schema.
     #
@@ -30,7 +30,6 @@ module JSI
     # @!attribute schema
     #   the schema that has an issue
     #   @return [JSI::Schema]
-    class Issue
-    end
+    class Issue end
   end
 end

data/lib/jsi/schema/schema_ancestor_node.rb

@@ -16,74 +16,122 @@ module JSI
       end
     end
 
-    # the base URI used to resolve the ids of schemas at or below this JSI.
-    # this is always an absolute URI (with no fragment).
-    # this may be the absolute schema URI of a parent schema or the URI from which the document was retrieved.
-    # @api private
-    # @return [Addressable::URI, nil]
-    attr_reader :jsi_schema_base_uri
+    # Base URI for URI resolution - always an absolute URI (with no fragment).
+    # If this node is a resource, its {#jsi_resource_uri} (i.e. its `$id`) is resolved against this URI, if that is relative.
+    #
+    # At the root this comes from param `base_uri` of {SchemaSet#new_jsi new_jsi}/{JSI.new_schema new_schema},
+    # or from a configured {Base::Conf#root_uri root_uri}.
+    # Below the root this comes from the parent's {#jsi_next_base_uri}.
+    # @return [URI, nil]
+    attr_reader(:jsi_base_uri)
+
+    # @deprecated after v0.8
+    def jsi_schema_base_uri
+      jsi_base_uri
+    end
 
     # resources which are ancestors of this JSI in the document. this does not include self.
     # @api private
     # @return [Array<JSI::Schema>]
     attr_reader :jsi_schema_resource_ancestors
 
-    # See {SchemaSet#new_jsi} param `schema_registry`
-    # @return [SchemaRegistry]
-    attr_reader(:jsi_schema_registry)
+    # @return [Schema::DynamicAnchorMap]
+    # @api private
+    attr_reader(:jsi_schema_dynamic_anchor_map)
 
-    # the URI of the resource containing this node.
-    # this is always an absolute URI (with no fragment).
-    # if this node is a schema with an id, this is its absolute URI; otherwise a parent resource's URI,
-    # or nil if not contained by a resource with a URI.
-    # @return [Addressable::URI, nil]
-    def jsi_resource_ancestor_uri
-      (is_a?(Schema) && schema_absolute_uri) || jsi_schema_base_uri
+    # @deprecated after v0.8
+    def jsi_schema_registry
+      jsi_registry
     end
 
-    # The schema at or below this node with the given anchor.
-    # If no schema has that anchor (or multiple schemas do, incorrectly), nil.
-    #
-    # @return [JSI::Schema, nil]
-    def jsi_anchor_subschema(anchor)
-      subschemas = @anchor_subschemas_map[anchor: anchor]
-      if subschemas.size == 1
-        subschemas.first
+    # See {Base#jsi_resource_root}
+    # @return [Schema::SchemaAncestorNode, nil]
+    def jsi_resource_root
+      # overridden by Base. may be nil from MetaSchemaNode::BootstrapSchema.
+      jsi_is_resource_root? ? self : jsi_schema_resource_ancestors.last
+    end
+
+    # @return [Boolean]
+    def jsi_is_resource_root?
+      # overridden by Schema
+      jsi_ptr.root?
+    end
+
+    # An absolute URI identifying this node, if this node is a resource root.
+    # Typically from a schema's `$id` keyword.
+    # @return [URI, nil]
+    def jsi_resource_uri
+      jsi_resource_uris.first
+    end
+
+    # Absolute URIs identifying this node - typically one URI if this is a resource root, otherwise none.
+    # @return [Enumerable<URI>]
+    def jsi_resource_uris
+      @resource_uris_map[content: jsi_node_content]
+    end
+
+    # @yield [URI]
+    private def jsi_each_resource_uri_compute
+      yield jsi_root_uri if jsi_ptr.root? && jsi_root_uri
+    end
+
+    # URI for resolution of relative URIs at or below this node - always an absolute URI (with no fragment).
+    # Mainly used to resolve relative `$ref`s.
+    # This is self's {#jsi_resource_uri} if this node is a resource; otherwise {#jsi_base_uri}.
+    # @return [URI, nil]
+    def jsi_next_base_uri
+      jsi_resource_uri || jsi_base_uri
+    end
+
+    # @private
+    # @param dynamic_anchor_map [Schema::DynamicAnchorMap]
+    # @return [Schema::SchemaAncestorNode]
+    def jsi_with_schema_dynamic_anchor_map(dynamic_anchor_map)
+      if dynamic_anchor_map == jsi_schema_dynamic_anchor_map
+        return self
+      end
+
+      if jsi_resource_root
+        # it might seem to make more sense to keep dynamic scope from the resource_root, merged with given scope, e.g.:
+        #new_dynamic_anchor_map = resource_root.jsi_next_schema_dynamic_anchor_map.merge(dynamic_anchor_map).without_node(resource_root)
+        # except the json schema test suite has (optional) tests "$dynamicRef skips over intermediate resources"
+        new_dynamic_anchor_map = dynamic_anchor_map.without_node(jsi_resource_root)
+        if new_dynamic_anchor_map == jsi_schema_dynamic_anchor_map
+          return self
+        end
       else
-        nil
+        new_dynamic_anchor_map = dynamic_anchor_map
       end
+
+      jsi_dynamic_root_descendent(new_dynamic_anchor_map)
     end
 
     # All schemas at or below this node with the given anchor.
     #
     # @return [Set<JSI::Schema>]
     def jsi_anchor_subschemas(anchor)
-      @anchor_subschemas_map[anchor: anchor]
+      @anchor_subschemas_map[anchor: anchor, content: jsi_node_content]
     end
 
     private
 
-    def jsi_schema_ancestor_node_initialize
-      @anchor_subschemas_map = jsi_memomap(&method(:jsi_anchor_subschemas_compute))
-    end
-
-    attr_writer :jsi_document
+    BY_ANCHOR = proc { |i| i[:anchor] }
 
-    def jsi_ptr=(jsi_ptr)
-      #chkbug raise(Bug, "jsi_ptr not #{Ptr}: #{jsi_ptr}") unless jsi_ptr.is_a?(Ptr)
-      @jsi_ptr = jsi_ptr
+    def jsi_schema_ancestor_node_initialize
+      @resource_uris_map = jsi_memomap(key_by: Schema::KEY_BY_NONE) { Set.new(to_enum(:jsi_each_resource_uri_compute)).freeze }
+      @anchor_subschemas_map = jsi_memomap(key_by: BY_ANCHOR, &method(:jsi_anchor_subschemas_compute))
     end
 
-    def jsi_schema_base_uri=(jsi_schema_base_uri)
-      #chkbug raise(Bug) if jsi_schema_base_uri && !jsi_schema_base_uri.is_a?(Addressable::URI)
-      #chkbug raise(Bug) if jsi_schema_base_uri && !jsi_schema_base_uri.absolute?
-      #chkbug raise(Bug) if jsi_schema_base_uri && jsi_schema_base_uri.fragment
+    def jsi_base_uri=(jsi_base_uri)
+      #chkbug fail(Bug) if jsi_base_uri && !jsi_base_uri.is_a?(URI)
+      #chkbug fail(Bug) if jsi_base_uri && !jsi_base_uri.absolute?
+      #chkbug fail(Bug) if jsi_base_uri && jsi_base_uri.fragment
 
-      @jsi_schema_base_uri = jsi_schema_base_uri
+      @jsi_base_uri = jsi_base_uri
     end
 
     def jsi_schema_resource_ancestors=(jsi_schema_resource_ancestors)
-      #chkbug raise(Bug) unless jsi_schema_resource_ancestors.respond_to?(:to_ary)
+      #chkbug fail(Bug) unless jsi_schema_resource_ancestors.respond_to?(:to_ary)
       #chkbug jsi_schema_resource_ancestors.each { |a| Schema.ensure_schema(a) }
       #chkbug # sanity check the ancestors are in order
       #chkbug last_anc_ptr = nil
@@ -91,14 +139,14 @@ module JSI
       #chkbug   if last_anc_ptr.nil?
       #chkbug     # pass
       #chkbug   elsif last_anc_ptr == anc.jsi_ptr
-      #chkbug     raise(Bug, "duplicate ancestors in #{jsi_schema_resource_ancestors.pretty_inspect}")
-      #chkbug   elsif !last_anc_ptr.contains?(anc.jsi_ptr)
-      #chkbug     raise(Bug, "ancestor ptr #{anc.jsi_ptr} not contained by previous: #{last_anc_ptr} in #{jsi_schema_resource_ancestors.pretty_inspect}")
+      #chkbug     fail(Bug, "duplicate ancestors in #{jsi_schema_resource_ancestors.pretty_inspect}")
+      #chkbug   elsif !last_anc_ptr.ancestor_of?(anc.jsi_ptr)
+      #chkbug     fail(Bug, "ancestor ptr #{anc.jsi_ptr} not descendent of previous: #{last_anc_ptr} in #{jsi_schema_resource_ancestors.pretty_inspect}")
       #chkbug   end
       #chkbug   if anc.jsi_ptr == jsi_ptr
-      #chkbug     raise(Bug, "ancestor is self")
-      #chkbug   elsif !anc.jsi_ptr.contains?(jsi_ptr)
-      #chkbug     raise(Bug, "ancestor does not contain self")
+      #chkbug     fail(Bug, "ancestor is self")
+      #chkbug   elsif !anc.jsi_ptr.ancestor_of?(jsi_ptr)
+      #chkbug     fail(Bug, "ancestor does not contain self")
       #chkbug   end
       #chkbug   last_anc_ptr = anc.jsi_ptr
       #chkbug end
@@ -106,17 +154,22 @@ module JSI
       @jsi_schema_resource_ancestors = jsi_schema_resource_ancestors
     end
 
-    attr_writer(:jsi_schema_registry)
+    def jsi_schema_dynamic_anchor_map=(dynamic_anchor_map)
+      #chkbug fail if !dynamic_anchor_map.is_a?(Schema::DynamicAnchorMap)
+      #chkbug fail if !dynamic_anchor_map.frozen?
+      #chkbug fail if dynamic_anchor_map != dynamic_anchor_map.without_node(self)
+      @jsi_schema_dynamic_anchor_map = dynamic_anchor_map
+    end
 
-    def jsi_anchor_subschemas_compute(anchor: )
-        jsi_each_descendent_node.select do |node|
-          node.is_a?(Schema) && node.respond_to?(:anchor) && node.anchor == anchor
-        end.to_set.freeze
+    def jsi_anchor_subschemas_compute(anchor: , content: )
+      SchemaSet.new(jsi_each_descendent_schema_same_resource.select do |schema|
+        schema.anchors.include?(anchor)
+      end)
     end
 
     # @return [Util::MemoMap]
     def jsi_memomap(**options, &block)
-      Util::MemoMap::Mutable.new(**options, &block)
+      jsi_memomap_class.new(**options, &block)
     end
   end
 end

data/lib/jsi/schema/vocabulary.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema
+    class Vocabulary
+      include(Util::Pretty)
+
+      # @param id [#to_str, nil]
+      # @param elements [Enumerable<Schema::Element>]
+      def initialize(id: nil, elements: )
+        @id = Util.uri(id, nnil: false, yabs: true, ynorm: true)
+        raise(TypeError, "elements: #{elements}") unless elements.all? { |e| e.is_a?(Schema::Element) }
+        @elements = Set.new(elements).freeze
+
+        freeze
+      end
+
+      # @return [URI, nil]
+      attr_reader(:id)
+
+      # @return [Set<Schema::Element>]
+      attr_reader(:elements)
+
+      # @param q
+      def pretty_print(q)
+        if id
+          jsi_pp_object_group(q, [self.class.name, -"id: <#{id}>"])
+        else
+          jsi_pp_object_group(q) do
+            q.seplist(elements) { |e| q.pp(e) }
+          end
+        end
+      end
+    end
+  end
+end