coradoc 2.0.27 → 2.0.28

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6f0a260bb97d25d5c24d430e81c1f4c8c4a0d816612d4826ab890f8d96b22d14
-  data.tar.gz: e65497a27738a34a7bfb8800386318419202314e12844b551f49ee6a02894aaf
+  metadata.gz: 6f0dbc8feba7133bc83baf88a6458774f364f7266b79625a0afc50434beeac89
+  data.tar.gz: f4fe999b18666604d2b615545acb073e1b6f74d7b26c3ff8fa8fd403ee45ec5d
 SHA512:
-  metadata.gz: d45b3690762230b10766ffabc1228b42533f30d8acc28016f226a6ea692bc4403f9589996e8bf61d059f8fddf29c1f9d6adaa1c98b4593089886089bedc4e1e5
-  data.tar.gz: 9c70fcfee207fd897113f62beb55c08c1cff19212daa65b8590f65a2af4a4221d00162529df154c50b38b3578f48c96adf431fea03c1dda4ed59228ebc57c680
+  metadata.gz: c4c0f7a479cfdf622faa4a26cad085c60b4e943d3ba30348e5d0426ebb10c9fbd417ceb5d069225f1e72dd9ff0960ca5e5304572d6d6cf4018236a579c4c391c
+  data.tar.gz: 6e4e649b83732a5cbf77c1edf16c70fb04a167d2d3b7ad3c3c657a029ebea5b079408dc78641f432241ac8737afb2a46fc1d3b6e2113c01075c332c2efadde9e

data/lib/coradoc/cli.rb

@@ -23,15 +23,15 @@ 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
     def convert(file)
       source_format = resolve_format(file, :from)
       target_format = options[:to] ? Coradoc.normalize_format(options[:to]) : Coradoc.resolve_output_format(options[:output])

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)

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/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/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,8 @@ 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
 
       def convert(text, from:, to:, **)
@@ -72,8 +72,8 @@ module Coradoc
         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)

data/lib/coradoc/query.rb

@@ -234,8 +234,8 @@ module Coradoc
         @elements = Array(elements).compact
       end
 
-      def each(&block)
-        @elements.each(&block)
+      def each(&)
+        @elements.each(&)
       end
 
       def [](index)
@@ -272,16 +272,16 @@ module Coradoc
         ResultSet.new(results.uniq)
       end
 
-      def map(&block)
-        ResultSet.new(@elements.map(&block))
+      def map(&)
+        ResultSet.new(@elements.map(&))
       end
 
-      def select(&block)
-        ResultSet.new(@elements.select(&block))
+      def select(&)
+        ResultSet.new(@elements.select(&))
       end
 
-      def reject(&block)
-        ResultSet.new(@elements.reject(&block))
+      def reject(&)
+        ResultSet.new(@elements.reject(&))
       end
 
       def to_a

data/lib/coradoc/registry.rb

@@ -102,24 +102,24 @@ module Coradoc
     #
     # @yield [Symbol, Object] name and item
     # @return [Enumerator]
-    def each(&block)
-      @items.each(&block)
+    def each(&)
+      @items.each(&)
     end
 
     # Iterate over item values
     #
     # @yield [Object]
     # @return [Enumerator]
-    def each_value(&block)
-      @items.each_value(&block)
+    def each_value(&)
+      @items.each_value(&)
     end
 
     # Iterate over item names
     #
     # @yield [Symbol]
     # @return [Enumerator]
-    def each_key(&block)
-      @items.each_key(&block)
+    def each_key(&)
+      @items.each_key(&)
     end
 
     # Find an item whose processor_match? returns true for the given filename

data/lib/coradoc/resolve_includes.rb

@@ -24,8 +24,8 @@ module Coradoc
     DEFAULT_MAX_DEPTH = 64
 
     class << self
-      def call(core, resolver:, base_dir:, **opts)
-        new(resolver: resolver, base_dir: base_dir, **opts).call(core)
+      def call(core, resolver:, base_dir:, **)
+        new(resolver: resolver, base_dir: base_dir, **).call(core)
       end
     end
 

data/lib/coradoc/validation.rb

@@ -600,8 +600,8 @@ module Coradoc
       #
       # @yield Schema definition block
       # @return [Schema] The defined schema
-      def define(&block)
-        Schema.define(&block)
+      def define(&)
+        Schema.define(&)
       end
 
       # Generate a validation schema from a CoreModel class
@@ -614,8 +614,8 @@ module Coradoc
       #   schema = Coradoc::Validation.auto_schema(Coradoc::CoreModel::Block)
       #   result = schema.validate(document)
       #
-      def auto_schema(model_class, **options)
-        SchemaGenerator.generate(model_class, **options)
+      def auto_schema(model_class, **)
+        SchemaGenerator.generate(model_class, **)
       end
 
       # Validate a document with default schema

data/lib/coradoc/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Coradoc
-  VERSION = '2.0.27'
+  VERSION = '2.0.28'
 end

data/lib/coradoc.rb

@@ -30,9 +30,9 @@
 #   Coradoc.serialize(doc, to: :html)
 
 require_relative 'coradoc/coradoc'
-require_relative 'coradoc/version'
 
 module Coradoc
+  autoload :VERSION, 'coradoc/version'
   autoload :CLI, 'coradoc/cli'
   autoload :Visitor, 'coradoc/visitor'
   autoload :LinkRewriter, 'coradoc/link_rewriter'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: coradoc
 version: !ruby/object:Gem::Version
-  version: 2.0.27
+  version: 2.0.28
 platform: ruby
 authors:
 - Ribose Inc.
@@ -144,6 +144,7 @@ metadata:
   homepage_uri: https://github.com/lutaml/coradoc
   source_code_uri: https://github.com/lutaml/coradoc
   changelog_uri: https://github.com/lutaml/coradoc/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib