coradoc 2.0.27 → 2.0.29

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6f0a260bb97d25d5c24d430e81c1f4c8c4a0d816612d4826ab890f8d96b22d14
-  data.tar.gz: e65497a27738a34a7bfb8800386318419202314e12844b551f49ee6a02894aaf
+  metadata.gz: 72d8a4fe9a86a7ed8f5dc806492ea147f321367f7a470b3c934747de9ea2b305
+  data.tar.gz: '042824f44538b6b64252c0667eb8d56f2ed059de0dab8866631c84394bee6a64'
 SHA512:
-  metadata.gz: d45b3690762230b10766ffabc1228b42533f30d8acc28016f226a6ea692bc4403f9589996e8bf61d059f8fddf29c1f9d6adaa1c98b4593089886089bedc4e1e5
-  data.tar.gz: 9c70fcfee207fd897113f62beb55c08c1cff19212daa65b8590f65a2af4a4221d00162529df154c50b38b3578f48c96adf431fea03c1dda4ed59228ebc57c680
+  metadata.gz: 6a603de0773f6b27449ccb511c3ec53860e6ec37aeb55a62f63f5902b7d0c4c0e74c5681dd1749b5f09411bd04ca34ff7bca45e4da4f9e8d4bd74f4cec3972b9
+  data.tar.gz: ebbc0d4ae30878f6793964a437dfd62a0ba79aafdfa57f3307d6e0b5c865650627bb6f025aa94f2c18813b16973819e3358a1458eecd3d6d9db5ac47af99efb8

data/lib/coradoc/cli.rb

@@ -23,15 +23,18 @@ module Coradoc
     option :section_number_levels, desc: 'Section numbering depth (1-6)', type: :numeric, default: 3
     option :lang, desc: 'Document language code', type: :string, default: 'en'
     option :resolve_includes, desc: 'Resolve include:: directives inline (default: leave as link nodes)',
-           type: :boolean, default: false
+                              type: :boolean, default: false
     option :base_dir, desc: 'Base directory for include resolution (default: dirname of FILE)',
-           type: :string
+                      type: :string
     option :missing_include, desc: 'Policy for missing includes: error, warn, silent, passthrough',
-           type: :string, default: 'error'
+                             type: :string, default: 'error'
     option :max_include_depth, desc: 'Maximum include nesting depth', type: :numeric,
-           default: 64
+                               default: 64
     option :allow_unsafe_includes, desc: 'Disable path-traversal protection (asciidoctor :unsafe mode)',
-           type: :boolean, default: false
+                                   type: :boolean, default: false
+    option :allow_unresolved_includes, desc: 'Allow serialization with unresolved includes ' \
+                                             '(formats that cannot represent them drop them)',
+                                       type: :boolean, default: false
     def convert(file)
       source_format = resolve_format(file, :from)
       target_format = options[:to] ? Coradoc.normalize_format(options[:to]) : Coradoc.resolve_output_format(options[:output])
@@ -213,7 +216,7 @@ module Coradoc
 
     CONVERT_OPTIONS = %i[
       toc toc_levels section_numbers section_number_levels
-      lang theme asset_delivery
+      lang theme asset_delivery allow_unresolved_includes
     ].freeze
     private_constant :CONVERT_OPTIONS
 

data/lib/coradoc/configurable.rb

@@ -99,7 +99,10 @@ module Coradoc
       def apply_options(options)
         options.each do |key, value|
           setter = "#{key}="
-          instance_variable_set("@#{key}", value) if public_methods.include?(setter.to_sym)
+          # Use public_send (not instance_variable_set) so we route
+          # through the public setter method — encapsulation is
+          # preserved and any setter-side validation runs.
+          public_send(setter, value) if public_methods.include?(setter.to_sym)
         end
       end
     end
@@ -521,7 +524,7 @@ module Coradoc
   #
   # @yield [Configuration]
   # @return [void]
-  def self.configure(&block)
-    Configurable.configure(&block) if block_given?
+  def self.configure(&)
+    Configurable.configure(&) if block_given?
   end
 end

data/lib/coradoc/coradoc.rb

@@ -56,8 +56,8 @@ module Coradoc
 
     def registry = FormatCatalog.registry
 
-    def register_format(format_name, format_module, **options)
-      FormatCatalog.register_format(format_name, format_module, **options)
+    def register_format(format_name, format_module, **)
+      FormatCatalog.register_format(format_name, format_module, **)
     end
 
     def get_format(format_name) = FormatCatalog.get_format(format_name)
@@ -70,6 +70,8 @@ module Coradoc
 
     def resolve_includes(document, **) = Pipeline.resolve_includes(document, **)
 
+    def resolve_references(document, **) = Pipeline.resolve_references(document, **)
+
     def rewrite_links(...) = Pipeline.rewrite_links(...)
 
     def convert(text, **) = Pipeline.convert(text, **)
@@ -150,6 +152,7 @@ module Coradoc
   autoload :FormatCatalog, "#{__dir__}/format_catalog"
   autoload :Introspection, "#{__dir__}/introspection"
   autoload :Dispatch, "#{__dir__}/dispatch"
+  autoload :Reference, "#{__dir__}/reference"
 end
 
 # Format gems self-register via Coradoc.register_format when they are required.

data/lib/coradoc/core_model/attribute_reference_resolver.rb

@@ -61,7 +61,7 @@ module Coradoc
       end
 
       def rebuild_children(node)
-        return node unless node.respond_to?(:children)
+        return node unless node.is_a?(CoreModel::HasChildren)
 
         original = node.children
         return node if original.nil?
@@ -79,23 +79,27 @@ module Coradoc
         original = node.public_send(attr_name)
         return node if original.nil?
 
-        updated = original.is_a?(Array) ?
-                    original.map { |c| visit(c) } :
+        updated = if original.is_a?(Array)
+                    original.map { |c| visit(c) }
+                  else
                     visit(original)
+                  end
         return node if updated == original
 
         node.dup.tap { |copy| copy.public_send("#{attr_name}=", updated) }
       end
 
       def rebuild_block(node)
-        return node unless node.respond_to?(:children)
+        return node unless node.is_a?(CoreModel::HasChildren)
 
         original_children = node.children
         return node if original_children.nil?
 
-        updated_children = original_children.is_a?(Array) ?
-                             original_children.map { |c| visit(c) } :
+        updated_children = if original_children.is_a?(Array)
+                             original_children.map { |c| visit(c) }
+                           else
                              visit(original_children)
+                           end
 
         if inline_resolvable?(node)
           original_content = node.content
@@ -113,7 +117,15 @@ module Coradoc
       end
 
       def inline_resolvable?(node)
-        node.respond_to?(:content) && node.content.is_a?(String)
+        # Capability check: nodes that include ChildrenContent expose a
+        # `content` attribute alongside `children`. We resolve attribute
+        # references only when content is a String (plain-text inline
+        # content). Using is_a?(ChildrenContent) instead of
+        # respond_to?(:content) catches type drift early: if a node
+        # acquires string content without including ChildrenContent,
+        # this method returns false (no resolution) rather than
+        # silently resolving on a mis-typed node.
+        node.is_a?(CoreModel::ChildrenContent) && node.content.is_a?(String)
       end
 
       # Resolve attribute references inside a flat content string.

data/lib/coradoc/core_model/base.rb

@@ -147,7 +147,7 @@ module Coradoc
       end
 
       def flat_text
-        ""
+        ''
       end
 
       # Flatten this element to a plain-text string.
@@ -160,7 +160,50 @@ module Coradoc
       #
       # @return [String]
       def flat_text
-        ""
+        ''
+      end
+
+      # True when this node counts as real body content for empty-body
+      # detection and similar structural queries. Default is true;
+      # ephemeral and metadata nodes override to false.
+      #
+      # Override sites: CommentBlock, CommentLine, FrontmatterBlock.
+      # Adding a new "skip me" type = overriding this method locally —
+      # no central walker to edit (OCP).
+      #
+      # @return [Boolean]
+      def body_content?
+        true
+      end
+
+      # True when this node's text content should be processed by text
+      # consumers (link rewriters, spell checkers, search indexers, etc.).
+      # Default delegates to +body_content?+ — ephemeral/metadata nodes
+      # (CommentBlock, FrontmatterBlock, …) are not prose because they
+      # are not body content. Verbatim block subclasses (SourceBlock,
+      # ListingBlock, LiteralBlock, PassBlock, StemBlock) override this
+      # to false because their text is literal, not subject to
+      # substitution or spell-checking.
+      #
+      # Override sites for verbatim: SourceBlock, ListingBlock,
+      # LiteralBlock, PassBlock, StemBlock, HorizontalRuleBlock.
+      #
+      # Distinct from +body_content?+: a SourceBlock IS body content
+      # (the doc has real substance) but its text is not prose (a link
+      # shaped string inside source is literal text, not a link).
+      #
+      # @return [Boolean]
+      def prose?
+        body_content?
+      end
+
+      # True when this node is structurally present but carries no
+      # visible characters (e.g., a paragraph whose text strips to
+      # empty). Default is false; inline content and paragraphs override.
+      #
+      # @return [Boolean]
+      def whitespace_only?
+        false
       end
 
       # Accept a visitor to traverse this element

data/lib/coradoc/core_model/comment_line.rb

@@ -20,4 +20,4 @@ module Coradoc
       attribute :text, :string
     end
   end
-end
+end

data/lib/coradoc/core_model/definition_item.rb

@@ -3,14 +3,35 @@
 module Coradoc
   module CoreModel
     class DefinitionItem < Base
+      # Primary term (first term in source order). For multi-term `<dt>`'s
+      # (AsciiDoc `term1::\nterm2::`), use {#terms} which carries the
+      # full list. `term` is kept as the singular accessor for legacy
+      # consumers; new consumers should prefer {#terms}.
       attribute :term, :string
+
+      # All terms on this `<dt>`. Single-element for the common case;
+      # multi-element for shared-`<dd>` AsciiDoc forms like
+      #   term1::
+      #   term2::
+      #   shared definition
+      # Order matches source order. Renderers emit one `<dt>` per entry.
+      attribute :terms, :string, collection: true, default: []
+
       attribute :definitions, :string, collection: true
       attribute :nested, DefinitionList
+      # `+`-continuation blocks attached to this dd in AsciiDoc source.
+      # Each entry is a CoreModel block (ParagraphBlock, AdmonitionBlock,
+      # etc.) that followed the dd after a `+` line — rendered as
+      # additional children of the dd.
+      attribute :attached_children, Base, collection: true, initialize_empty: true
 
       def initialize(args = {})
         @term_children = args.delete(:term_children) || []
         @definition_children = args.delete(:definition_children) || []
         super
+        # Backward-compat: if caller passed only `term:` (no `terms:`),
+        # seed the collection so #terms is always consistent with #term.
+        self.terms = [term].compact if terms.empty? && !term.to_s.empty?
       end
 
       attr_reader :term_children, :definition_children
@@ -40,7 +61,7 @@ module Coradoc
       private
 
       def comparable_attributes
-        super + %i[term definitions nested term_children definition_children]
+        super + %i[term terms definitions nested term_children definition_children attached_children]
       end
     end
   end

data/lib/coradoc/core_model/horizontal_rule_block.rb

@@ -7,6 +7,10 @@ module Coradoc
       def self.semantic_type
         :horizontal_rule
       end
+
+      def prose?
+        false
+      end
     end
   end
 end

data/lib/coradoc/core_model/include_level_offset.rb

@@ -58,7 +58,7 @@ module Coradoc
         private
 
         def matched_offset(trimmed)
-          %r{\A(?<sign>[+-]?)(?<digits>\d+)\z}.match(trimmed) do |m|
+          /\A(?<sign>[+-]?)(?<digits>\d+)\z/.match(trimmed) do |m|
             digits = m[:digits].to_i
             signed = m[:sign] == '-' ? -digits : digits
             mode = m[:sign].empty? ? 'absolute' : 'relative'

data/lib/coradoc/core_model/include_options.rb

@@ -73,6 +73,7 @@ module Coradoc
 
         def parse_tags(raw)
           return [] if raw.nil?
+
           trimmed = raw.strip
           return [] if trimmed.empty? || trimmed == '*' || trimmed == '**'
 

data/lib/coradoc/core_model/inline_content.rb

@@ -36,6 +36,7 @@ module Coradoc
 
           first_idx = content.index { |i| text_carrier?(i) }
           return content if first_idx.nil?
+
           last_idx = content.rindex { |i| text_carrier?(i) }
 
           content.map.with_index do |item, idx|

data/lib/coradoc/core_model/list_block.rb

@@ -119,7 +119,7 @@ module Coradoc
       #   end
       #
       # Returns self for chaining at the list level.
-      def add_item(marker: self.marker_type == 'ordered' ? '.' : '*')
+      def add_item(marker: marker_type == 'ordered' ? '.' : '*')
         item = ListItem.build(marker: marker) { |li| yield li if block_given? }
         self.items = Array(items) + [item]
         self

data/lib/coradoc/core_model/listing_block.rb

@@ -10,6 +10,10 @@ module Coradoc
       def self.semantic_type
         :listing
       end
+
+      def prose?
+        false
+      end
     end
   end
 end

data/lib/coradoc/core_model/literal_block.rb

@@ -7,6 +7,10 @@ module Coradoc
       def self.semantic_type
         :literal
       end
+
+      def prose?
+        false
+      end
     end
   end
 end

data/lib/coradoc/core_model/pass_block.rb

@@ -7,6 +7,10 @@ module Coradoc
       def self.semantic_type
         :pass
       end
+
+      def prose?
+        false
+      end
     end
   end
 end

data/lib/coradoc/core_model/source_block.rb

@@ -7,6 +7,10 @@ module Coradoc
       def self.semantic_type
         :source_code
       end
+
+      def prose?
+        false
+      end
     end
   end
 end

data/lib/coradoc/core_model/stem_block.rb

@@ -16,6 +16,10 @@ module Coradoc
       def self.semantic_type
         :stem
       end
+
+      def prose?
+        false
+      end
     end
   end
 end

data/lib/coradoc/dispatch.rb

@@ -89,6 +89,7 @@ module Coradoc
 
     def apply_default(key)
       return @default.call(key) if @default
+
       nil
     end
   end

data/lib/coradoc/errors.rb

@@ -295,6 +295,25 @@ module Coradoc
     end
   end
 
+  # Raised when a document still contains unresolved +include::+ edges
+  # at serialization time and the target format cannot represent them
+  # (it would silently drop the content). Resolve the graph first with
+  # +Coradoc.resolve_includes+, or opt out with
+  # +allow_unresolved_includes: true+.
+  class UnresolvedIncludesError < Error
+    attr_reader :targets
+
+    def initialize(targets)
+      @targets = targets
+      super(
+        "Document has #{targets.size} unresolved include directive(s): " \
+        "#{targets.join(', ')}. Resolve them before serializing with " \
+        'Coradoc.resolve_includes(doc, base_dir: ...), or pass ' \
+        'allow_unresolved_includes: true.'
+      )
+    end
+  end
+
   # Error raised when an include chain exceeds the configured depth limit.
   class IncludeDepthExceededError < Error
     attr_reader :depth, :target

data/lib/coradoc/format_catalog.rb

@@ -18,6 +18,25 @@ module Coradoc
       end
 
       def get_format(format_name)
+        registry.get(format_name) || lazy_load_format(format_name)
+      end
+
+      # If a format gem (e.g. coradoc-adoc) is in the bundle but has not
+      # been required yet, attempt to require it on first lookup. This
+      # removes the friction where `Coradoc.parse(text, format: :asciidoc)`
+      # blows up just because the user only wrote `require "coradoc"` and
+      # never explicitly required `coradoc/asciidoc`. The require is for
+      # an external gem, not internal library code, so it stays within
+      # the autoload-over-require_relative rule.
+      def lazy_load_format(format_name)
+        return nil if format_name.nil? || format_name.to_s.empty?
+
+        begin
+          require "coradoc/#{format_name}"
+        rescue LoadError
+          return nil
+        end
+
         registry.get(format_name)
       end
 

data/lib/coradoc/format_module.rb

@@ -30,6 +30,16 @@ module Coradoc
         true
       end
 
+      # Whether the serializer can represent unresolved include edges
+      # (graph-mode CoreModel::Include nodes) without losing them.
+      # Formats that round-trip the directive natively (asciidoc,
+      # mirror) or preserve it explicitly (markdown comments) override
+      # this to true; formats that would silently drop the content keep
+      # the default false, and the pipeline raises instead of losing it.
+      def preserves_unresolved_includes?
+        false
+      end
+
       # Parse a file to CoreModel, handling file-specific concerns like include resolution.
       # Format modules that support include directives or file-relative references
       # should override this method.

data/lib/coradoc/hooks.rb

@@ -89,7 +89,7 @@ module Coradoc
         modified_args = invoke(hook_point, *args, **kwargs)
         result = yield(*modified_args)
 
-        after_point = "after_#{hook_point.to_s.sub('before_', '')}".to_sym
+        after_point = :"after_#{hook_point.to_s.sub('before_', '')}"
         result = invoke(after_point, result, **kwargs) if HOOK_POINTS.key?(after_point)
 
         result

data/lib/coradoc/include_selectors/level_offset.rb

@@ -50,8 +50,6 @@ module Coradoc
             node.level || 1
           when Coradoc::CoreModel::StructuralElement, Coradoc::CoreModel::Block
             walk_for_first_level(node.children)
-          else
-            nil
           end
         end
 

data/lib/coradoc/include_selectors/lines.rb

@@ -11,12 +11,12 @@ module Coradoc
     # Out-of-bounds clamps gracefully (SPEC 3.4). One-based indexing
     # (asciidoctor convention).
     module Lines
-      SPEC_PART = %r{
+      SPEC_PART = /
         \A
         (?<start>\d+)
         (?:\.\.(?<finish>\d+))?
         \z
-      }x.freeze
+      /x
 
       # @param text [String]
       # @param options [Coradoc::CoreModel::IncludeOptions]

data/lib/coradoc/include_selectors/tags.rb

@@ -17,8 +17,8 @@ module Coradoc
     # Markers may appear on their own line; they must be the first
     # non-whitespace token on that line (asciidoctor convention).
     module Tags
-      MARKER_OPEN  = /\A[[:space:]]*(?:\/\/+|#+)[[:space:]]*tag::([^\[\]]+)\[[[:space:]]*\]/
-      MARKER_CLOSE = /\A[[:space:]]*(?:\/\/+|#+)[[:space:]]*end::([^\[\]]+)\[[[:space:]]*\]/
+      MARKER_OPEN  = %r{\A[[:space:]]*(?://+|#+)[[:space:]]*tag::([^\[\]]+)\[[[:space:]]*\]}
+      MARKER_CLOSE = %r{\A[[:space:]]*(?://+|#+)[[:space:]]*end::([^\[\]]+)\[[[:space:]]*\]}
 
       # @param text [String] raw included file content
       # @param options [Coradoc::CoreModel::IncludeOptions]
@@ -134,5 +134,3 @@ module Coradoc
     end
   end
 end
-
-require 'set'

data/lib/coradoc/introspection/element_counter.rb

@@ -17,10 +17,10 @@ module Coradoc
       attr_reader :counts
 
       def visit(element)
-        return super(element) unless element.is_a?(CoreModel::Base)
+        return super unless element.is_a?(CoreModel::Base)
 
         @counts[type_key_for(element)] += 1
-        super(element)
+        super
       end
 
       private

data/lib/coradoc/link_rewriter/visitor.rb

@@ -12,23 +12,14 @@ module Coradoc
     # new link-bearing subclass means overriding +link_kind+ on it,
     # not editing a case/when here (OCP).
     #
-    # Verbatim block types are also closed: +SourceBlock+, +ListingBlock+,
-    # +LiteralBlock+, +PassBlock+, +StemBlock+. The visitor returns them
-    # unchanged so the rewriter never sees link-shaped text that is, in
-    # fact, raw code/math.
+    # Verbatim block recognition is delegated to +CoreModel::Base#prose?+
+    # — each block class answers "is my text live or literal?". Adding a
+    # new verbatim block type means overriding +prose?+ on it, not editing
+    # a list here. The visitor is closed for that change.
     #
     # Dispatch is class-based (no +respond_to?+ duck-typing). Unrecognized
     # classes are returned unchanged — the visitor is closed by design.
     class Visitor
-      # Verbatim block classes — content is raw, no link semantics.
-      VERBATIM_TYPES = [
-        Coradoc::CoreModel::SourceBlock,
-        Coradoc::CoreModel::ListingBlock,
-        Coradoc::CoreModel::LiteralBlock,
-        Coradoc::CoreModel::PassBlock,
-        Coradoc::CoreModel::StemBlock
-      ].freeze
-
       # Structural/container classes that own a child collection. Each
       # entry maps the class to the reader method that exposes its
       # children. MECE — every "recurse into the children" case lands
@@ -68,7 +59,7 @@ module Coradoc
       private
 
       def visit_subtree(node)
-        return node if VERBATIM_TYPES.any? { |type| node.is_a?(type) }
+        return node unless node.prose?
         return rewrite_inline(node) if node.is_a?(Coradoc::CoreModel::InlineElement)
 
         reader = reader_for(node)

data/lib/coradoc/pipeline.rb

@@ -42,8 +42,65 @@ module Coradoc
         )
       end
 
-      def rewrite_links(document, rewriter: nil, &block)
-        Coradoc::LinkRewriter.rewrite(document, rewriter: rewriter, &block)
+      def rewrite_links(document, rewriter: nil, &)
+        Coradoc::LinkRewriter.rewrite(document, rewriter: rewriter, &)
+      end
+
+      # Resolve every reference (xref, citation, link, include, image,
+      # footnote) in a parsed document using a unified content-graph
+      # model. Mirrors +resolve_includes+ in shape: two-step, immutable.
+      #
+      # Step one always runs: every Edge is resolved through the
+      # Resolver and the +missing+/+ambiguous+ policies are enforced
+      # (raise or warn). Step two is opt-in: with +materialize: true+
+      # the tree is rebuilt with each Edge replaced by the output of
+      # the Materializer registered for its
+      # [kind, presentation, format] tuple.
+      #
+      # The input document is never mutated. With +materialize: false+
+      # the input document itself is returned; with +materialize: true+
+      # a new document is returned that structurally shares untouched
+      # subtrees with the input (treat both as immutable). Nodes whose
+      # kind has no registered materializer are preserved unchanged.
+      #
+      # @param document [CoreModel::Base] parsed document
+      # @param catalog [Reference::Catalog::*] index of addressable Content
+      # @param presentation [Reference::Presentation::Base] slicing and ordering
+      # @param resolver [Reference::Resolver::Base, nil] defaults to CatalogResolver
+      # @param missing [Symbol] :warn (default), :silent, :error, :passthrough
+      # @param ambiguous [Symbol] :disambiguate (default), :first, :error
+      # @param materialize [Boolean] when true, replace edges with rendered inlines
+      # @param format [Symbol, nil] target format for materializer lookup
+      #   (:html, :asciidoc, ...); nil matches format-agnostic materializers
+      # @return [CoreModel::Base] the input document (validation only) or
+      #   a new materialized document
+      #
+      # @example Resolve cross-references into HTML links
+      #   doc = Coradoc.parse(text, format: :asciidoc)
+      #   catalog = Coradoc::Reference::Catalog::Local.from_doc(doc)
+      #   presentation = Coradoc::Reference::Presentation::SingleDocument.new
+      #   resolved = Coradoc.resolve_references(
+      #     doc,
+      #     catalog: catalog,
+      #     presentation: presentation,
+      #     materialize: true,
+      #     format: :html
+      #   )
+      def resolve_references(document, catalog:, presentation:,
+                             resolver: nil,
+                             missing: :warn,
+                             ambiguous: :disambiguate,
+                             materialize: false,
+                             format: nil)
+        Coradoc::Reference::Resolution.new(
+          catalog: catalog,
+          presentation: presentation,
+          resolver: resolver,
+          missing: missing,
+          ambiguous: ambiguous,
+          materialize: materialize,
+          format: format
+        ).call(document)
       end
 
       def convert(text, from:, to:, **)
@@ -63,17 +120,19 @@ module Coradoc
         raise TransformationError, "No transformer found for #{model.class}"
       end
 
-      def serialize(model, to:, **)
+      def serialize(model, to:, allow_unresolved_includes: false, **)
         format_module = FormatCatalog.get_format(to)
         raise UnsupportedFormatError.new(to, available: FormatCatalog.registered_formats) unless format_module
 
+        Coradoc::Validation.guard_unresolved_includes!(model, format_module) unless allow_unresolved_includes
+
         model = Hooks.invoke(:before_serialize, model, format: to)
         result = format_module.serialize(model, **)
         Hooks.invoke(:after_serialize, result, format: to)
       end
 
-      def build(&block)
-        CoreModel::DocumentElement.build(children: [], &block)
+      def build(&)
+        CoreModel::DocumentElement.build(children: [], &)
       end
 
       def parse_file(path, format: nil)