coradoc-adoc 2.0.8 → 2.0.10

data/lib/coradoc/asciidoc/transform/text_extract_visitor.rb

@@ -74,8 +74,33 @@ module Coradoc
           model.alt || model.src || ''
         end
 
+        def visit_inline_span(model)
+          model.text.to_s
+        end
+
+        def visit_list(model)
+          visit_array(model.items)
+        end
+
+        def visit_block(model)
+          visit_array(model.lines)
+        end
+
+        def visit_core_model_list(model)
+          model.items.map { |i| visit(i.content) }.join(' ')
+        end
+
+        def visit_definition_item(model)
+          terms_text = visit(model.terms)
+          contents_text = visit(model.contents)
+          [terms_text, contents_text].reject(&:empty?).join(': ')
+        end
+
         def visit_base_model(model)
-          model.content ? visit(model.content) : ''
+          content = model.content
+          content ? visit(content) : ''
+        rescue NoMethodError
+          ''
         end
 
         def visit_core_model_inline(model)
@@ -115,6 +140,13 @@ module Coradoc
           when Model::Inline::Footnote then visit_footnote(model)
           when Model::Inline::AttributeReference then visit_attribute_reference(model)
           when Model::Image::Core then visit_adoc_image(model)
+          when CoreModel::ListBlock then visit_core_model_list(model)
+          when Model::Inline::Span then visit_inline_span(model)
+          when Model::List::Core then visit_list(model)
+          when Model::List::Definition then visit_list(model)
+          when Model::List::DefinitionItem then visit_definition_item(model)
+          when Model::Block::Core then visit_block(model)
+          when Model::LineBreak, Model::CommentLine, Model::CommentBlock then ''
           when Model::Base then visit_base_model(model)
           else
             model.class.name.start_with?('Parslet::') ? model.to_s : ''

data/lib/coradoc/asciidoc/transform/to_core_model.rb

@@ -1,15 +1,23 @@
 # frozen_string_literal: true
 
-require_relative 'to_core_model_registrations'
-
 module Coradoc
   module AsciiDoc
     module Transform
       class ToCoreModel
         include Coradoc::Transform::Base
 
+        @registered = false
+
         class << self
+          def register!
+            return if @registered
+
+            Transform::ToCoreModelRegistrations.register_all!
+            @registered = true
+          end
+
           def transform(model)
+            register!
             return model.filter_map { |item| transform(item) } if model.is_a?(Array)
             return model unless model.is_a?(Coradoc::AsciiDoc::Model::Base)
 

data/lib/coradoc/asciidoc/transform/to_core_model_registrations.rb

@@ -75,6 +75,15 @@ module Coradoc
                 )
               }
             )
+
+            Registry.register(
+              Coradoc::AsciiDoc::Model::CommentLine,
+              lambda { |model|
+                Coradoc::CoreModel::CommentLine.new(
+                  text: model.text.to_s
+                )
+              }
+            )
           end
 
           def register_list_transformers!
@@ -179,6 +188,11 @@ module Coradoc
               ->(model) { Oth.transform_image(model) }
             )
 
+            Registry.register(
+              Coradoc::AsciiDoc::Model::Image::InlineImage,
+              ->(model) { Oth.transform_image(model) }
+            )
+
             Registry.register(
               Coradoc::AsciiDoc::Model::Bibliography,
               ->(model) { Oth.transform_bibliography(model) }
@@ -190,17 +204,11 @@ module Coradoc
             )
 
             [
-              Coradoc::AsciiDoc::Model::TextElement,
               Coradoc::AsciiDoc::Model::Include,
               Coradoc::AsciiDoc::Model::Audio,
               Coradoc::AsciiDoc::Model::Video,
               Coradoc::AsciiDoc::Model::ContentList,
-              Coradoc::AsciiDoc::Model::Tag
-            ].each do |klass|
-              Registry.register(klass, ->(model) { model })
-            end
-
-            [
+              Coradoc::AsciiDoc::Model::Tag,
               Coradoc::AsciiDoc::Model::LineBreak,
               Coradoc::AsciiDoc::Model::Break::PageBreak
             ].each do |klass|
@@ -212,6 +220,3 @@ module Coradoc
     end
   end
 end
-
-# Auto-register when this file is loaded
-Coradoc::AsciiDoc::Transform::ToCoreModelRegistrations.register_all!

data/lib/coradoc/asciidoc/transform.rb

@@ -12,6 +12,7 @@ module Coradoc
       autoload :TextExtractVisitor, "#{__dir__}/transform/text_extract_visitor"
       autoload :InlineTransformVisitor, "#{__dir__}/transform/inline_transform_visitor"
       autoload :ElementTransformers, "#{__dir__}/transform/element_transformers"
+      autoload :FrontmatterAttributeMap, "#{__dir__}/transform/frontmatter_attribute_map"
     end
   end
 end

data/lib/coradoc/asciidoc/transformer/attribute_list_normalizer.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    class Transformer < Parslet::Transform
+      # Pure-function module for normalizing raw parser `:attribute_list`
+      # values into a single canonical Model::AttributeList.
+      #
+      # The parser's `block_header` rule captures every consecutive `[...]`
+      # block before a structural element as a Parslet sequence under
+      # `:attribute_list`. Real-world AsciiDoc often stacks multiple lists
+      # before a single delimiter:
+      #
+      #   [role=quote]
+      #   [source, ruby]
+      #   ----
+      #   code
+      #   ----
+      #
+      # This module is the single source of truth for converting any of those
+      # shapes (nil, single list, array of lists, array of hashes) into one
+      # canonical AttributeList that downstream model constructors can use.
+      module AttributeListNormalizer
+        module_function
+
+        # @param value [Object, nil] Raw parser value bound to :attribute_list
+        # @return [Model::AttributeList, nil]
+        def coerce(value)
+          case value
+          when nil then nil
+          when Model::AttributeList then value
+          when Array
+            lists = value.map { |entry| unwrap(entry) }.compact
+            return nil if lists.empty?
+            return lists.first if lists.size == 1
+
+            merge(lists)
+          else
+            value
+          end
+        end
+
+        # Merge several AttributeLists into one, preserving positional order
+        # and concatenating named keys in input order.
+        # @param lists [Array<Model::AttributeList>]
+        # @return [Model::AttributeList]
+        def merge(lists)
+          merged = Model::AttributeList.new
+          lists.each do |list|
+            next unless list.is_a?(Model::AttributeList)
+
+            list.positional.each { |p| merged.add_positional(p.value) }
+            list.named.each { |n| merged.add_named(n.name, n.value) }
+          end
+          merged
+        end
+
+        # Unwrap a single entry of the parser's :attribute_list sequence.
+        # @param entry [Object]
+        # @return [Model::AttributeList, nil]
+        def unwrap(entry)
+          return entry if entry.is_a?(Model::AttributeList)
+
+          entry[:attribute_list] if entry.is_a?(Hash) && entry.key?(:attribute_list)
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/transformer/block_rules.rb

@@ -11,12 +11,11 @@ module Coradoc
             rule(block: subtree(:block)) do
               id = block[:id]
               title = block[:title]
-              attribute_list = block[:attribute_list]
+              attribute_list = AttributeListNormalizer.coerce(block[:attribute_list])
               delimiter = block[:delimiter].to_s
-              delimiter_c = delimiter[0]
               lines = block[:lines]
               ordering = block.keys.select do |k|
-                %i[id title attribute_list attribute_list2].include?(k)
+                %i[id title attribute_list].include?(k)
               end
 
               opts = {
@@ -26,44 +25,7 @@ module Coradoc
                 lines: lines,
                 ordering: ordering
               }
-              opts[:attributes] = attribute_list if attribute_list
-              delimiter_len = opts[:delimiter_len]
-
-              if delimiter_c == '*'
-                if attribute_list
-                  if attribute_list.positional == [] &&
-                     attribute_list.named.first&.name == 'reviewer'
-                    Model::Block::ReviewerComment.new(
-                      id:,
-                      title:,
-                      lines:,
-                      delimiter_len:,
-                      attributes: attribute_list
-                    )
-                  else
-                    Model::Block::Side.new(id:, title:, lines:, delimiter_len:,
-                                           attributes: attribute_list)
-                  end
-                else
-                  Model::Block::Side.new(id:, title:, lines:, delimiter_len:,
-                                         attributes: attribute_list)
-                end
-              elsif delimiter_c == '='
-                Model::Block::Example.new(id:, title:, lines:, delimiter_len:,
-                                          attributes: attribute_list)
-              elsif delimiter_c == '+'
-                Model::Block::Pass.new(id:, title:, lines:, delimiter_len:,
-                                       attributes: attribute_list)
-              elsif delimiter_c == '-' && delimiter.size == 2
-                Model::Block::Open.new(id:, title:, lines:, delimiter_len:,
-                                       attributes: attribute_list)
-              elsif delimiter_c == '-' && delimiter.size >= 4
-                Model::Block::SourceCode.new(id:, title:, lines:, delimiter_len:,
-                                             attributes: attribute_list)
-              elsif delimiter_c == '_'
-                Model::Block::Quote.new(id:, title:, lines:, delimiter_len:,
-                                        attributes: attribute_list)
-              end
+              BlockTypeClassifier.classify(delimiter, opts, attribute_list)
             end
 
             # Example
@@ -84,7 +46,7 @@ module Coradoc
               id = block_image[:id]
               title = block_image[:title]
               path = block_image[:path]
-              attrs = block_image[:attribute_list]
+              attrs = AttributeListNormalizer.coerce(block_image[:attribute_list])
               Model::Image::BlockImage.new(
                 title: title,
                 id: id,

data/lib/coradoc/asciidoc/transformer/block_type_classifier.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    class Transformer < Parslet::Transform
+      # Single source of truth for "which delimiter maps to which block model".
+      #
+      # The block rule in BlockRules delegates here to convert a parser
+      # delimiter string (e.g., `----`, `****`, `--`) into the appropriate
+      # Model::Block::* subclass instance. Adding a new block type means
+      # appending one entry to DELIMITER_CLASSIFICATIONS — no edits to the
+      # block rule itself. (Open/Closed Principle.)
+      module BlockTypeClassifier
+        # Each entry is [char, min_length, max_length, factory].
+        # The factory is a callable taking (opts, attribute_list) and
+        # returning a Model::Block::* instance. `max_length` nil means
+        # unbounded.
+        DELIMITER_CLASSIFICATIONS = [
+          ['*', 4, nil, ->(opts, attrs) {
+            if attrs && attrs.positional == [] && attrs.named.first&.name == 'reviewer'
+              Model::Block::ReviewerComment.new(**opts.merge(attributes: attrs))
+            else
+              Model::Block::Side.new(**opts.merge(attributes: attrs))
+            end
+          }],
+          ['=', 4, nil, ->(opts, attrs) { Model::Block::Example.new(**opts.merge(attributes: attrs)) }],
+          ['+', 4, nil, ->(opts, attrs) { Model::Block::Pass.new(**opts.merge(attributes: attrs)) }],
+          ['_', 4, nil, ->(opts, attrs) { Model::Block::Quote.new(**opts.merge(attributes: attrs)) }],
+          ['-', 4, nil, ->(opts, attrs) { Model::Block::SourceCode.new(**opts.merge(attributes: attrs)) }],
+          ['-', 2, 2,  ->(opts, attrs) { Model::Block::Open.new(**opts.merge(attributes: attrs)) }]
+        ].freeze
+
+        module_function
+
+        # @param delimiter [String] e.g., "----", "**", "--"
+        # @param opts [Hash] Constructor options (id, title, lines, delimiter_len, ordering)
+        # @param attrs [Model::AttributeList, nil]
+        # @return [Model::Block::Base, nil]
+        def classify(delimiter, opts, attrs)
+          char = delimiter[0]
+          len = delimiter.size
+          entry = DELIMITER_CLASSIFICATIONS.find do |c, min_len, max_len, _|
+            next false unless c == char
+            next false unless len >= min_len
+            next false if max_len && len > max_len
+
+            true
+          end
+          return nil unless entry
+
+          entry.last.call(opts, attrs)
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/transformer/header_rules.rb

@@ -7,40 +7,25 @@ module Coradoc
       module HeaderRules
         def self.apply(transformer_class)
           transformer_class.class_eval do
-            # Header with author and revision
-            rule(
-              title: simple(:title),
-              author: simple(:author),
-              revision: simple(:revision)
-            ) do
-              id = title.is_a?(Model::Title) ? title.id : nil
-              Model::Header.new(id:, title:, author:, revision:)
-            end
+            # Header — single canonical rule covering all combinations of
+            # optional :author and :revision slots. The previous design had
+            # four explicit rules (one per combination); this version reads
+            # the same data with one `subtree` match.
+            rule(header: subtree(:header)) do
+              title = header[:title]
+              author = header[:author]
+              revision = header[:revision]
 
-            # Header with author only
-            rule(
-              title: simple(:title),
-              author: simple(:author)
-            ) do
-              id = title.is_a?(Model::Title) ? title.id : nil
-              Model::Header.new(id:, title:, author:, revision: nil)
-            end
+              id = header[:id]
+              id = title.id if title.is_a?(Model::Title) && title.id && !id
+              id = id.to_s unless id.nil?
+              id = nil if id && id.empty?
 
-            # Header with revision only
-            rule(
-              title: simple(:title),
-              revision: simple(:revision)
-            ) do
-              id = title.is_a?(Model::Title) ? title.id : nil
-              Model::Header.new(id:, title:, author: nil, revision:)
+              Model::Header.new(id:, title:, author:, revision:)
             end
 
-            # Header with title only
-            rule(
-              title: simple(:title)
-            ) do
-              id = title.is_a?(Model::Title) ? title.id : nil
-              Model::Header.new(id:, title:, author: nil, revision: nil)
+            rule(header: simple(:header)) do
+              header
             end
 
             # Author
@@ -60,29 +45,6 @@ module Coradoc
             ) do
               Model::Revision.new(number:, date:, remark:)
             end
-
-            # Unwrap header hash - handles cases where header wasn't transformed yet
-            rule(header: subtree(:header)) do
-              if header.is_a?(Hash) && header.key?(:title)
-                id = header[:id]
-                id = id.to_s unless id.nil?
-                id = nil if id && id.empty?
-
-                title = header[:title]
-                author = header[:author]
-                revision = header[:revision]
-
-                id = title.id if title.is_a?(Model::Title) && title.id && !id
-
-                Model::Header.new(id:, title:, author:, revision:)
-              else
-                header
-              end
-            end
-
-            rule(header: simple(:header)) do
-              header
-            end
           end
         end
       end

data/lib/coradoc/asciidoc/transformer/inline_rules.rb

@@ -5,6 +5,17 @@ module Coradoc
     class Transformer < Parslet::Transform
       # Module containing inline element transformation rules
       module InlineRules
+        # Inline formatting variants that share the same rule shape:
+        # constrained and unconstrained forms of the same model class.
+        # `span` is excluded because it carries `text:` + `attributes:`
+        # rather than `content:`, so it gets its own pair of rules.
+        FORMATTING_VARIANTS = [
+          %i[bold      Bold],
+          %i[italic    Italic],
+          %i[highlight Highlight],
+          %i[monospace Monospace]
+        ].freeze
+
         def self.apply(transformer_class)
           transformer_class.class_eval do
             # Link
@@ -82,64 +93,23 @@ module Coradoc
               href_arg.to_s
             end
 
-            # Bold (constrained)
-            rule(bold_constrained: subtree(:bold)) do
-              content = Transformer.extract_inline_content(bold)
-              Model::Inline::Bold.new(content: content, unconstrained: false)
-            end
-
-            # Bold (unconstrained)
-            rule(bold_unconstrained: subtree(:bold)) do
-              content = Transformer.extract_inline_content(bold)
-              Model::Inline::Bold.new(content: content, unconstrained: true)
-            end
-
-            # Italic (constrained)
-            rule(italic_constrained: subtree(:italic)) do
-              content = Transformer.extract_inline_content(italic)
-              Model::Inline::Italic.new(content: content, unconstrained: false)
-            end
-
-            # Italic (unconstrained)
-            rule(italic_unconstrained: subtree(:italic)) do
-              content = Transformer.extract_inline_content(italic)
-              Model::Inline::Italic.new(content: content, unconstrained: true)
-            end
-
-            # Highlight (constrained)
-            rule(highlight_constrained: subtree(:highlight)) do
-              content = Transformer.extract_inline_content(highlight)
-              Model::Inline::Highlight.new(content: content, unconstrained: false)
-            end
-
-            # Highlight (unconstrained)
-            rule(highlight_unconstrained: subtree(:highlight)) do
-              content = Transformer.extract_inline_content(highlight)
-              Model::Inline::Highlight.new(content: content, unconstrained: true)
-            end
-
-            # Monospace (constrained)
-            rule(monospace_constrained: subtree(:monospace)) do
-              content = Transformer.extract_inline_content(monospace)
-              Model::Inline::Monospace.new(content: content, unconstrained: false)
-            end
-
-            # Monospace (unconstrained)
-            rule(monospace_unconstrained: subtree(:monospace)) do
-              content = Transformer.extract_inline_content(monospace)
-              Model::Inline::Monospace.new(content: content, unconstrained: true)
-            end
-
-            # Superscript
-            rule(superscript: subtree(:superscript)) do
-              content = Transformer.extract_simple_inline_content(superscript)
-              Model::Inline::Superscript.new(content:)
-            end
+            # Inline formatting rules generated from a single registry.
+            # See InlineRules::FORMATTING_VARIANTS. `span` is special
+            # because it carries `text:` + `attributes:` rather than
+            # `content:`, so it stays inline below.
+            InlineRules::FORMATTING_VARIANTS.each do |prefix, class_name|
+              klass = Model::Inline.const_get(class_name)
+              constrained_key = :"#{prefix}_constrained"
+              unconstrained_key = :"#{prefix}_unconstrained"
 
-            # Subscript
-            rule(subscript: subtree(:subscript)) do
-              content = Transformer.extract_simple_inline_content(subscript)
-              Model::Inline::Subscript.new(content:)
+              rule(constrained_key => subtree(:subtree)) do
+                content = Transformer.extract_inline_content(subtree)
+                klass.new(content: content, unconstrained: false)
+              end
+              rule(unconstrained_key => subtree(:subtree)) do
+                content = Transformer.extract_inline_content(subtree)
+                klass.new(content: content, unconstrained: true)
+              end
             end
 
             # Span (constrained)
@@ -160,6 +130,18 @@ module Coradoc
               )
             end
 
+            # Superscript
+            rule(superscript: subtree(:superscript)) do
+              content = Transformer.extract_simple_inline_content(superscript)
+              Model::Inline::Superscript.new(content:)
+            end
+
+            # Subscript
+            rule(subscript: subtree(:subscript)) do
+              content = Transformer.extract_simple_inline_content(subscript)
+              Model::Inline::Subscript.new(content:)
+            end
+
             # Highlight (simple)
             rule(highlight: simple(:text)) do
               Model::Highlight.new(content: text)

data/lib/coradoc/asciidoc/transformer/list_rules.rb

@@ -5,6 +5,42 @@ module Coradoc
     class Transformer < Parslet::Transform
       # Module containing list transformation rules
       module ListRules
+        class << self
+          def build_dlist_tree(items)
+            root = Model::List::Definition.new(items: [])
+            stack = [[root, 0]]
+
+            items.each do |item|
+              depth = dlist_depth(item.delimiter)
+              stack.pop while stack.last[1] >= depth
+
+              stack.last[0].items << item
+              nested_list = Model::List::Definition.new(items: [])
+              item.nested << nested_list
+              stack.push([nested_list, depth])
+            end
+
+            prune_empty_nested(root)
+            root
+          end
+
+          def dlist_depth(delimiter)
+            delim = delimiter.to_s
+            return 1 if delim == ';;' || delim.empty?
+
+            [delim.count(':') - 1, 1].max
+          end
+
+          def prune_empty_nested(list)
+            list.items.each do |item|
+              item.nested.select! do |n|
+                n.is_a?(Model::List::Definition) && n.items.any?
+              end
+              item.nested.each { |n| prune_empty_nested(n) }
+            end
+          end
+        end
+
         def self.apply(transformer_class)
           transformer_class.class_eval do
             # List item
@@ -68,7 +104,7 @@ module Coradoc
             end
 
             # Definition list term (with optional anchor)
-            rule(dlist_term: subtree(:term_data), delimiter: simple(:_delim)) do
+            rule(dlist_term: subtree(:term_data), delimiter: simple(:delim)) do
               case term_data
               when Hash
                 text = term_data[:text]
@@ -76,11 +112,11 @@ module Coradoc
                 text = text.content.to_s if text.is_a?(Model::TextElement)
                 id = term_data[:id]
                 id = id.to_s if id.is_a?(Parslet::Slice)
-                { text: text.to_s, id: id }
+                { text: text.to_s, id: id, delimiter: delim.to_s }
               when Model::TextElement
-                { text: term_data.content.to_s, id: term_data.id }
+                { text: term_data.content.to_s, id: term_data.id, delimiter: delim.to_s }
               else
-                { text: term_data.to_s, id: nil }
+                { text: term_data.to_s, id: nil, delimiter: delim.to_s }
               end
             end
 
@@ -95,13 +131,15 @@ module Coradoc
                 t.is_a?(Hash) ? t[:text].to_s : t.to_s
               end
               item_id = nil
+              item_delim = '::'
               terms.each do |t|
-                next unless t.is_a?(Hash) && t[:id]
+                next unless t.is_a?(Hash)
 
-                item_id = t[:id].to_s
-                break
+                item_id = t[:id].to_s if t[:id]
+                item_delim = t[:delimiter].to_s if t[:delimiter]
               end
-              Model::List::DefinitionItem.new(terms: term_strings, contents: contents, id: item_id)
+              Model::List::DefinitionItem.new(terms: term_strings, contents: contents,
+                                              id: item_id, delimiter: item_delim)
             end
 
             # Definition list item with hash terms (single term case)
@@ -111,6 +149,7 @@ module Coradoc
               data = item_data.is_a?(Hash) ? item_data : { terms: Array(item_data), definition: '' }
 
               item_id = nil
+              item_delim = '::'
               terms_data = data[:terms]
               definition = data[:definition].to_s
 
@@ -118,17 +157,19 @@ module Coradoc
                 case t
                 when Hash
                   item_id ||= t[:id].to_s if t[:id]
+                  item_delim = t[:delimiter].to_s if t[:delimiter]
                   t[:text].to_s
                 else
                   t.to_s
                 end
               end
 
-              Model::List::DefinitionItem.new(terms: terms, contents: definition, id: item_id)
+              Model::List::DefinitionItem.new(terms: terms, contents: definition,
+                                              id: item_id, delimiter: item_delim)
             end
 
             rule(definition_list: sequence(:list_items)) do
-              Model::List::Definition.new(items: list_items)
+              ListRules.build_dlist_tree(list_items)
             end
 
             # Definition list with attribute_list (e.g., [%key])
@@ -136,7 +177,9 @@ module Coradoc
               attribute_list: simple(:attribute_list),
               definition_list: sequence(:list_items)
             ) do
-              Model::List::Definition.new(items: list_items, attrs: attribute_list)
+              tree = ListRules.build_dlist_tree(list_items)
+              tree.attrs = attribute_list if attribute_list
+              tree
             end
           end
         end