coradoc-adoc 2.0.9 → 2.0.10

data/lib/coradoc/asciidoc/transformer.rb

@@ -29,6 +29,10 @@ module Coradoc
       autoload :ListRules, "#{__dir__}/transformer/list_rules"
       autoload :StructuralRules, "#{__dir__}/transformer/structural_rules"
       autoload :MiscRules, "#{__dir__}/transformer/misc_rules"
+      autoload :AttributeListNormalizer, "#{__dir__}/transformer/attribute_list_normalizer"
+      autoload :BlockTypeClassifier, "#{__dir__}/transformer/block_type_classifier"
+      autoload :TableLayout, "#{__dir__}/transformer/table_layout"
+      autoload :TableCellBuilder, "#{__dir__}/transformer/table_cell_builder"
 
       # Apply all rule modules (triggers autoload)
       HeaderRules.apply(self)
@@ -76,319 +80,35 @@ module Coradoc
         end
       end
 
-      # Helper method for parsing inline content from raw text
-      # This is used for table cells where content is captured as raw text
-      # @param text [String] Raw text to parse
-      # @param style [String, nil] Cell style ('a' for AsciiDoc, 'l' for literal, etc.)
-      # @return [Array<TextElement>] Parsed content as array of TextElement objects
+      # Helper method for parsing inline content from raw text.
+      # Kept as a thin delegator for backwards compatibility; implementation
+      # lives in TableCellBuilder (table cells are the primary consumer).
       def self.parse_inline_content(text, style = nil)
-        return [Coradoc::AsciiDoc::Model::TextElement.new(content: '')] if text.nil? || text.to_s.strip.empty?
-
-        # For AsciiDoc style cells, parse as block content
-        return parse_block_content(text) if style == 'a'
-
-        # For literal style cells, preserve text as-is
-        return [Coradoc::AsciiDoc::Model::TextElement.new(content: text.to_s)] if style == 'l'
-
-        # For default cells, parse inline content
-        parser = Coradoc::AsciiDoc::Parser::Base.new
-        begin
-          ast = parser.text_any.parse(text.to_s)
-          # Transform the AST to model objects
-          transformed = new.apply(ast)
-
-          # Wrap in TextElement
-          content_array = transformed.is_a?(Array) ? transformed : [transformed]
-          [Coradoc::AsciiDoc::Model::TextElement.new(content: content_array)]
-        rescue Parslet::ParseFailed
-          # If parsing fails, return the text as a simple TextElement
-          [Coradoc::AsciiDoc::Model::TextElement.new(content: text.to_s)]
-        end
+        TableCellBuilder.parse_inline_content(text, style)
       end
 
-      # Parse block-level AsciiDoc content (for 'a' style cells)
-      # @param text [String] Raw text containing AsciiDoc blocks
-      # @return [Array] Parsed block content
       def self.parse_block_content(text)
-        return [Coradoc::AsciiDoc::Model::TextElement.new(content: '')] if text.nil? || text.to_s.strip.empty?
-
-        parser = Coradoc::AsciiDoc::Parser::Base.new
-        text_str = text.to_s
-
-        # Try parsing as a list if content contains list markers
-        # List markers can appear after other content (e.g., "Title:\n\n* item")
-        if /^(\*+|-+|\d+\.)/m.match?(text_str)
-          # Extract just the list portion
-          list_match = text_str.match(/\n(\*+|-+|\d+\.)(.*)$/m)
-          if list_match
-            list_text = list_match[1] + list_match[2]
-            begin
-              ast = parser.list.parse(list_text)
-              transformed = new.apply(ast)
-
-              # Parse the text before the list as inline content
-              before_list = text_str[0, list_match.begin(1) - 1].strip
-              before_elements = []
-              unless before_list.empty?
-                begin
-                  before_ast = parser.text_any.parse(before_list)
-                  before_transformed = new.apply(before_ast)
-                  before_array = before_transformed.is_a?(Array) ? before_transformed : [before_transformed]
-                  before_elements = [Coradoc::AsciiDoc::Model::TextElement.new(content: before_array)]
-                rescue Parslet::ParseFailed
-                  before_elements = [Coradoc::AsciiDoc::Model::TextElement.new(content: before_list)]
-                end
-              end
-
-              return before_elements + [transformed]
-            rescue Parslet::ParseFailed
-              # Fall through to inline parsing
-            end
-          end
-        end
-
-        # Try parsing as inline content
-        begin
-          ast = parser.text_any.parse(text_str)
-          transformed = new.apply(ast)
-          content_array = transformed.is_a?(Array) ? transformed : [transformed]
-          [Coradoc::AsciiDoc::Model::TextElement.new(content: content_array)]
-        rescue Parslet::ParseFailed
-          # If parsing fails, return the text as a simple TextElement
-          [Coradoc::AsciiDoc::Model::TextElement.new(content: text_str)]
-        end
+        TableCellBuilder.parse_block_content(text)
       end
 
-      # Helper method for building table cells with format specification
-      # @param format [Hash, String, Object] Cell format specification from parser
-      # @param content [Object] Cell content
-      # @return [Model::TableCell] Table cell model with parsed attributes
       def self.build_table_cell(format, content)
-        cell_opts = {}
-
-        # Extract style first for content parsing
-        style = nil
-
-        # Parse format specification if present
-        if format.is_a?(Hash)
-          # Colspan
-          cell_opts[:colspan] = format[:colspan].to_i if format[:colspan]
-
-          # Rowspan (remove leading dot)
-          if format[:rowspan]
-            rowspan_str = format[:rowspan].to_s
-            rowspan_str = rowspan_str.sub(/^\./, '')
-            cell_opts[:rowspan] = rowspan_str.to_i if rowspan_str.match?(/^\d+$/)
-          end
-
-          # Horizontal alignment
-          cell_opts[:halign] = format[:halign].to_s if format[:halign]
-
-          # Vertical alignment (remove leading dot)
-          if format[:valign]
-            valign_str = format[:valign].to_s
-            valign_str = valign_str.sub(/^\./, '')
-            cell_opts[:valign] = valign_str if %w[< ^ >].include?(valign_str)
-          end
-
-          # Style
-          style = format[:style].to_s if format[:style]
-          cell_opts[:style] = style
-
-          # Repeat marker
-          cell_opts[:repeat] = true if format[:repeat]
-        elsif format.is_a?(String)
-          # Parse format string like ".2+^.^" or "4+^" or ".3+a"
-          # Format: [colspan][.rowspan][halign][valign][style][*]
-          format_str = format.to_s
-
-          # Parse colspan (digits before +)
-          cell_opts[:colspan] = Regexp.last_match(1).to_i if format_str =~ /^(\d+)\+/
-
-          # Parse rowspan (.digits)
-          cell_opts[:rowspan] = Regexp.last_match(1).to_i if format_str =~ /\.(\d+)/
-
-          # Parse horizontal alignment (^ < >)
-          # Note: In AsciiDoc, ^ is center, < is left, > is right
-          cell_opts[:halign] = Regexp.last_match(0) if format_str =~ /[<>^]/
-
-          # Parse vertical alignment (.<. ^. >.)
-          cell_opts[:valign] = Regexp.last_match(0)[1] if format_str =~ /\.[.^<>]/
-
-          # Parse style (d=decimal, s=strong, e=emphasis, m=monospace, a=asciidoc, l=literal, h=header)
-          style = Regexp.last_match(0) if format_str =~ /[dsemalhv]/
-          cell_opts[:style] = style
-
-          # Parse repeat marker
-          cell_opts[:repeat] = true if format_str.include?('*')
-        end
-
-        # Strip escaped delimiters (\| → |) in cell content
-        unescaped_content = content.to_s.gsub(/\\([|!,:;])/, '\1')
-
-        # Parse content based on style
-        parsed_content = parse_inline_content(unescaped_content, style)
-        cell_opts[:content] = parsed_content
-
-        Model::TableCell.new(**cell_opts)
+        TableCellBuilder.build(format, content)
       end
 
-      # Parse the cols attribute to determine column count
-      # @param attrs [Model::AttributeList, nil] Table attributes
-      # @return [Integer, nil] Column count or nil if not specified
       def self.parse_cols_attribute(attrs)
-        return nil if attrs.nil?
-
-        # Get the cols value from named attributes
-        cols_value = if attrs.is_a?(Model::AttributeList)
-                       attrs.named.find { |n| n.name.to_s == 'cols' }&.value
-                     elsif attrs.is_a?(Hash)
-                       attrs['cols'] || attrs[:cols]
-                     end
-
-        return nil if cols_value.nil?
-
-        # cols can be:
-        # - A single number: "3" -> 3 columns
-        # - A list: "1,2,1" -> 3 columns
-        # - With multipliers: "3*" -> 3 columns
-        # - Quoted: "\"3\"" -> 3 columns
-        cols_str = cols_value.is_a?(Array) ? cols_value.first.to_s : cols_value.to_s
-
-        # Remove surrounding quotes if present
-        cols_str = cols_str.gsub(/^["']|["']$/, '')
-
-        # Handle multiplier syntax: "3*" means 3 columns
-        return Regexp.last_match(1).to_i if cols_str =~ /^(\d+)\*$/
-
-        # Handle comma-separated list: count the parts
-        return cols_str.split(',').size if cols_str.include?(',')
-
-        # Single number
-        cols_str.to_i if /^\d+$/.match?(cols_str)
+        TableLayout.parse_cols_attribute(attrs)
       end
 
-      # Group cells into rows based on column count
-      #
-      # AsciiDoc table row semantics:
-      # - Column count is determined by cols attribute or first row
-      # - A new row starts when previous row has `column_count` cells
-      # - Cells with colspan > 1 take multiple column slots
-      #
-      # @param cells [Array<Model::TableCell>] Flat list of cells
-      # @param explicit_col_count [Integer, nil] Column count from cols attribute
-      # @return [Array<Model::TableRow>] Grouped rows
       def self.group_cells_into_rows(cells, explicit_col_count = nil)
-        return [] if cells.nil? || cells.empty?
-
-        # Normalize cells to ensure they're TableCell objects
-        normalized_cells = cells.map do |cell|
-          case cell
-          when Model::TableCell
-            cell
-          when Hash
-            content = cell[:text] || cell[:content] || ''
-            Model::TableCell.new(content: parse_inline_content(content))
-          else
-            Model::TableCell.new(content: parse_inline_content(cell))
-          end
-        end
-
-        # Determine column count
-        # If explicit_col_count is provided, use it
-        # Otherwise, count cells until we find a row boundary
-        col_count = explicit_col_count
-
-        if col_count.nil? || col_count.zero?
-          # Infer from first row - count cells until we have a complete row
-          # A complete row is when the total column slots equals a consistent number
-          col_count = infer_column_count(normalized_cells)
-        end
-
-        # If still no column count, assume all cells are one row
-        col_count = normalized_cells.size if col_count.nil? || col_count.zero?
-
-        # Group cells into rows
-        rows = []
-        current_row_cells = []
-        current_col_slots = 0
-
-        normalized_cells.each do |cell|
-          # Get colspan (default 1)
-          colspan = cell.is_a?(Model::TableCell) && cell.colspan ? cell.colspan : 1
-
-          current_row_cells << cell
-          current_col_slots += colspan
-
-          # Check if row is complete
-          next unless current_col_slots >= col_count
-
-          rows << Model::TableRow.new(columns: current_row_cells)
-          current_row_cells = []
-          current_col_slots = 0
-        end
-
-        # Handle remaining cells (incomplete last row)
-        rows << Model::TableRow.new(columns: current_row_cells) if current_row_cells.any?
-
-        rows
+        TableLayout.group_cells_into_rows(cells, explicit_col_count)
       end
 
-      # Infer column count from cells
-      # Look for patterns where rows have consistent cell counts
       def self.infer_column_count(cells)
-        return nil if cells.nil? || cells.empty?
-
-        col_slots = cells.map do |cell|
-          cell.is_a?(Model::TableCell) && cell.colspan ? cell.colspan : 1
-        end
-
-        total_cells = col_slots.sum
-
-        # Find all valid column counts
-        possible_cols = (1..[total_cells, 12].min).select do |candidate|
-          next false if candidate > total_cells
-          next false if total_cells % candidate != 0
-
-          slots_used = 0
-          valid = true
-
-          col_slots.each do |slots|
-            slots_used += slots
-            if slots_used == candidate
-              slots_used = 0
-            elsif slots_used > candidate
-              valid = false
-              break
-            end
-          end
-
-          valid && slots_used.zero?
-        end
-
-        possible_cols.max || col_slots.first || 1
+        TableLayout.infer_column_count(cells)
       end
 
-      # Regroup parser-level rows into proper AsciiDoc rows.
-      # The parser produces one "row" per line; this flattens all cells
-      # and regroups by the cols attribute, then marks the first row as header.
-      #
-      # @param rows [Array<Model::TableRow>] Parser-level rows
-      # @param attrs [Model::AttributeList, nil] Table attributes containing cols
-      # @return [Array<Model::TableRow>] Properly grouped rows with header flag
       def self.regroup_table_rows(rows, attrs = nil)
-        return rows if rows.nil? || rows.empty?
-
-        col_count = parse_cols_attribute(attrs)
-        all_cells = rows.flat_map do |r|
-          r.is_a?(Model::TableRow) ? r.columns : []
-        end
-
-        return rows if all_cells.empty?
-
-        grouped = group_cells_into_rows(all_cells, col_count)
-        grouped.first.header = true unless grouped.empty?
-        grouped
+        TableLayout.regroup_table_rows(rows, attrs)
       end
 
       # Transform a syntax tree using this transformer's rules
@@ -399,6 +119,30 @@ module Coradoc
         new.apply(syntax_tree)
       end
 
+      # Convert parser-output "lines" into an array of TextElement model
+      # objects. Each line is one of:
+      #   - { text: <Array or scalar>, line_break: <str> }
+      #   - any other shape (passed through unchanged)
+      #
+      # Used by the paragraph and reviewer_note rules to share the same
+      # line-shape handling (DRY).
+      def self.lines_to_text_elements(lines)
+        Array(lines).map do |line|
+          next line unless line.is_a?(Hash) && line.key?(:text)
+
+          text_content = line[:text]
+          transformed = if text_content.is_a?(Array)
+                          text_content.map do |item|
+                            item.is_a?(Hash) ? new.apply(item) : item
+                          end
+                        else
+                          text_content
+                        end
+
+          Model::TextElement.new(content: transformed, line_break: line[:line_break])
+        end
+      end
+
       # Legacy transform method (deprecated)
       # @deprecated Use {.transform} instead
       def self.legacy_transform(syntax_tree)

data/lib/coradoc/asciidoc/version.rb

@@ -2,6 +2,6 @@
 
 module Coradoc
   module AsciiDoc
-    VERSION = '2.0.9'
+    VERSION = '2.0.10'
   end
 end

data/lib/coradoc/asciidoc.rb

@@ -2,7 +2,7 @@
 
 require 'parslet'
 require 'lutaml/model'
-require 'coradoc/core_model' # Required for CoreModel types in transformers
+require 'coradoc'
 
 module Coradoc
   # Utility module autoload
@@ -46,8 +46,11 @@ module Coradoc
       # @param text [String] AsciiDoc content to parse
       # @return [Coradoc::AsciiDoc::Model::Document] Parsed document model
       def parse(text)
-        ast = Coradoc::AsciiDoc::Parser::Base.parse(text)
-        Coradoc::AsciiDoc::Transformer.transform(ast)
+        split = Parser::FrontmatterParser.call(text)
+        ast = Coradoc::AsciiDoc::Parser::Base.parse(split.body)
+        doc = Coradoc::AsciiDoc::Transformer.transform(ast)
+        doc.frontmatter = split.frontmatter if split.frontmatter?
+        doc
       end
 
       # Parse AsciiDoc text and convert to CoreModel

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: coradoc-adoc
 version: !ruby/object:Gem::Version
-  version: 2.0.9
+  version: 2.0.10
 platform: ruby
 authors:
 - Ribose Inc.
@@ -175,6 +175,7 @@ files:
 - lib/coradoc/asciidoc/model/inline/underline.rb
 - lib/coradoc/asciidoc/model/line_break.rb
 - lib/coradoc/asciidoc/model/list.rb
+- lib/coradoc/asciidoc/model/list/base.rb
 - lib/coradoc/asciidoc/model/list/core.rb
 - lib/coradoc/asciidoc/model/list/definition.rb
 - lib/coradoc/asciidoc/model/list/definition_item.rb
@@ -214,16 +215,19 @@ files:
 - lib/coradoc/asciidoc/parser/bibliography.rb
 - lib/coradoc/asciidoc/parser/block.rb
 - lib/coradoc/asciidoc/parser/block_assembler.rb
+- lib/coradoc/asciidoc/parser/block_header.rb
 - lib/coradoc/asciidoc/parser/cache.rb
 - lib/coradoc/asciidoc/parser/citation.rb
 - lib/coradoc/asciidoc/parser/content.rb
 - lib/coradoc/asciidoc/parser/document_attributes.rb
 - lib/coradoc/asciidoc/parser/fix_files.rb
+- lib/coradoc/asciidoc/parser/frontmatter_parser.rb
 - lib/coradoc/asciidoc/parser/header.rb
 - lib/coradoc/asciidoc/parser/inline.rb
 - lib/coradoc/asciidoc/parser/list.rb
 - lib/coradoc/asciidoc/parser/metadata_detector.rb
 - lib/coradoc/asciidoc/parser/paragraph.rb
+- lib/coradoc/asciidoc/parser/rule_dispatcher.rb
 - lib/coradoc/asciidoc/parser/section.rb
 - lib/coradoc/asciidoc/parser/stem.rb
 - lib/coradoc/asciidoc/parser/table.rb
@@ -318,18 +322,23 @@ files:
 - lib/coradoc/asciidoc/transform/element_transformers/table_transformer.rb
 - lib/coradoc/asciidoc/transform/from_core_model.rb
 - lib/coradoc/asciidoc/transform/from_core_model_registrations.rb
+- lib/coradoc/asciidoc/transform/frontmatter_attribute_map.rb
 - lib/coradoc/asciidoc/transform/inline_transform_visitor.rb
 - lib/coradoc/asciidoc/transform/text_extract_visitor.rb
 - lib/coradoc/asciidoc/transform/to_core_model.rb
 - lib/coradoc/asciidoc/transform/to_core_model_registrations.rb
 - lib/coradoc/asciidoc/transform/transformer_registry.rb
 - lib/coradoc/asciidoc/transformer.rb
+- lib/coradoc/asciidoc/transformer/attribute_list_normalizer.rb
 - lib/coradoc/asciidoc/transformer/block_rules.rb
+- lib/coradoc/asciidoc/transformer/block_type_classifier.rb
 - lib/coradoc/asciidoc/transformer/header_rules.rb
 - lib/coradoc/asciidoc/transformer/inline_rules.rb
 - lib/coradoc/asciidoc/transformer/list_rules.rb
 - lib/coradoc/asciidoc/transformer/misc_rules.rb
 - lib/coradoc/asciidoc/transformer/structural_rules.rb
+- lib/coradoc/asciidoc/transformer/table_cell_builder.rb
+- lib/coradoc/asciidoc/transformer/table_layout.rb
 - lib/coradoc/asciidoc/transformer/text_rules.rb
 - lib/coradoc/asciidoc/version.rb
 - lib/coradoc/util.rb