coradoc-adoc 2.0.8 → 2.0.10

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

@@ -157,35 +157,12 @@ module Coradoc
                 end
               end
 
-              content = lines.map do |line|
-                if line.is_a?(Hash) && line.key?(:text)
-                  text_content = line[:text]
-                  line_break = line[:line_break]
-
-                  transformed_text = if text_content.is_a?(Array)
-                                       text_content.map do |item|
-                                         if item.is_a?(Hash)
-                                           Transformer.new.apply(item)
-                                         else
-                                           item
-                                         end
-                                       end
-                                     else
-                                       text_content
-                                     end
-
-                  Model::TextElement.new(content: transformed_text, line_break: line_break)
-                else
-                  line
-                end
-              end
-
               Model::ReviewerNote.new(
                 reviewer: attrs[:reviewer],
                 date: attrs[:date],
                 from: attrs[:from],
                 to: attrs[:to],
-                content: content
+                content: Transformer.lines_to_text_elements(lines)
               )
             end
           end

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

@@ -60,81 +60,19 @@ module Coradoc
               table
             end
 
-            # Table with rows (new parser output - rows captured explicitly)
-            rule(
-              delim_char: simple(:delim_char),
-              rows: sequence(:rows)
-            ) do
-              Model::Table.new(rows: Transformer.regroup_table_rows(rows))
-            end
-
-            # Table with rows and title
-            rule(
-              title: simple(:title),
-              delim_char: simple(:delim_char),
-              rows: sequence(:rows)
-            ) do
-              Model::Table.new(title: title.to_s, rows: Transformer.regroup_table_rows(rows))
-            end
-
-            # Table with rows and id
-            rule(
-              id: simple(:id),
-              delim_char: simple(:delim_char),
-              rows: sequence(:rows)
-            ) do
-              Model::Table.new(id: id.to_s, rows: Transformer.regroup_table_rows(rows))
-            end
-
-            # Table with rows, id, and attributes
-            rule(
-              id: simple(:id),
-              attribute_list: simple(:attrs),
-              delim_char: simple(:delim_char),
-              rows: sequence(:rows)
-            ) do
-              Model::Table.new(id: id.to_s, rows: Transformer.regroup_table_rows(rows, attrs), attrs: attrs)
-            end
-
-            # Table with rows, title, and attributes
-            rule(
-              title: simple(:title),
-              attribute_list: simple(:attrs),
-              delim_char: simple(:delim_char),
-              rows: sequence(:rows)
-            ) do
-              Model::Table.new(title: title.to_s, rows: Transformer.regroup_table_rows(rows, attrs), attrs: attrs)
-            end
-
-            # Table with rows and attributes only
-            rule(
-              attribute_list: simple(:attrs),
-              delim_char: simple(:delim_char),
-              rows: sequence(:rows)
-            ) do
-              Model::Table.new(rows: Transformer.regroup_table_rows(rows, attrs), attrs: attrs)
-            end
-
-            # Table with rows, id, title, and attributes (full set)
-            rule(
-              id: simple(:id),
-              title: simple(:title),
-              attribute_list: simple(:attrs),
-              delim_char: simple(:delim_char),
-              rows: sequence(:rows)
-            ) do
-              Model::Table.new(id: id.to_s, title: title.to_s, rows: Transformer.regroup_table_rows(rows, attrs),
-                               attrs: attrs)
-            end
-
-            # Table with id and title (no attributes)
-            rule(
-              id: simple(:id),
-              title: simple(:title),
-              delim_char: simple(:delim_char),
-              rows: sequence(:rows)
-            ) do
-              Model::Table.new(id: id.to_s, title: title.to_s, rows: Transformer.regroup_table_rows(rows))
+            # Unified Table rule. Every variant (with or without title, id,
+            # attributes) flows through here. Parser::BlockHeader always
+            # captures attribute_lists as a sequence, so we funnel through
+            # coerce_attribute_list before constructing the model.
+            rule(table: subtree(:table)) do
+              id = table[:id]&.to_s
+              title = table[:title]&.to_s
+              attrs = AttributeListNormalizer.coerce(table[:attribute_list])
+              rows = table[:rows]
+              opts = { rows: Transformer.regroup_table_rows(rows, attrs), attrs: attrs }
+              opts[:id] = id if id
+              opts[:title] = title unless title.nil? || title.empty?
+              Model::Table.new(**opts)
             end
 
             # Title
@@ -171,7 +109,7 @@ module Coradoc
 
               id = title.id if title.is_a?(Model::Title) && title.id && !id
 
-              attribute_list = section[:attribute_list] || nil
+              attribute_list = AttributeListNormalizer.coerce(section[:attribute_list])
               contents = section[:contents] || []
               sections = section[:sections]
               Model::Section.new(
@@ -200,12 +138,11 @@ module Coradoc
 
             # Bibliography entry
             rule(bibliography_entry: subtree(:bib_entry)) do
-              anchor_name = bib_entry[:anchor_name]
-              document_id = bib_entry[:document_id]
-              ref_text = bib_entry[:ref_text]
-              line_break = bib_entry[:line_break]
               Model::BibliographyEntry.new(
-                anchor_name:, document_id:, ref_text:, line_break:
+                anchor_name: bib_entry[:anchor_name],
+                document_id: bib_entry[:document_id],
+                ref_text: Model::BibliographyEntry.coerce_ref_text(bib_entry[:ref_text]),
+                line_break: bib_entry[:line_break]
               )
             end
           end

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

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    class Transformer < Parslet::Transform
+      # Pure functions for parsing the cell-format prefix (`2+^.^a`) and
+      # building a Model::TableCell from raw parser values.
+      #
+      # Extracted from the Transformer god class. The format spec can come
+      # in two shapes from the parser — a Hash of named captures or a raw
+      # String from a capture group — and the layout/alignment/style parsing
+      # for each used to be inline in Transformer#build_table_cell.
+      module TableCellBuilder
+        module_function
+
+        # @param format [Hash, String, Object, nil] Cell format from parser
+        # @param content [Object] Cell content
+        # @return [Model::TableCell]
+        def build(format, content)
+          cell_opts = {}
+          style = parse_format(format, cell_opts)
+
+          unescaped_content = content.to_s.gsub(/\\([|!,:;])/, '\1')
+          cell_opts[:content] = parse_inline_content(unescaped_content, style)
+
+          Model::TableCell.new(**cell_opts)
+        end
+
+        # Coerce a raw parser cell value into a TableCell.
+        # Used by TableLayout.group_cells_into_rows when it encounters
+        # cells that the parser emitted as Hashes or plain strings.
+        # @param cell [Model::TableCell, Hash, Object]
+        # @return [Model::TableCell]
+        def normalize_cell(cell)
+          case cell
+          when Model::TableCell then 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
+
+        # Parse inline content from raw text for a cell.
+        # @param text [String, nil]
+        # @param style [String, nil] 'a' (AsciiDoc), 'l' (literal), or nil
+        # @return [Array<Model::TextElement>]
+        def parse_inline_content(text, style = nil)
+          return [Model::TextElement.new(content: '')] if text.nil? || text.to_s.strip.empty?
+
+          return parse_block_content(text) if style == 'a'
+          return [Model::TextElement.new(content: text.to_s)] if style == 'l'
+
+          parser = Coradoc::AsciiDoc::Parser::Base.new
+          begin
+            ast = parser.text_any.parse(text.to_s)
+            transformed = Transformer.new.apply(ast)
+            content_array = transformed.is_a?(Array) ? transformed : [transformed]
+            [Model::TextElement.new(content: content_array)]
+          rescue Parslet::ParseFailed
+            [Model::TextElement.new(content: text.to_s)]
+          end
+        end
+
+        # Parse block-level AsciiDoc content (for 'a' style cells).
+        # @param text [String, nil]
+        # @return [Array]
+        def parse_block_content(text)
+          return [Model::TextElement.new(content: '')] if text.nil? || text.to_s.strip.empty?
+
+          parser = Coradoc::AsciiDoc::Parser::Base.new
+          text_str = text.to_s
+
+          if /^(\*+|-+|\d+\.)/m.match?(text_str)
+            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 = Transformer.new.apply(ast)
+
+                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 = Transformer.new.apply(before_ast)
+                    before_array = before_transformed.is_a?(Array) ? before_transformed : [before_transformed]
+                    before_elements = [Model::TextElement.new(content: before_array)]
+                  rescue Parslet::ParseFailed
+                    before_elements = [Model::TextElement.new(content: before_list)]
+                  end
+                end
+
+                return before_elements + [transformed]
+              rescue Parslet::ParseFailed
+                # fall through to inline parsing
+              end
+            end
+          end
+
+          begin
+            ast = parser.text_any.parse(text_str)
+            transformed = Transformer.new.apply(ast)
+            content_array = transformed.is_a?(Array) ? transformed : [transformed]
+            [Model::TextElement.new(content: content_array)]
+          rescue Parslet::ParseFailed
+            [Model::TextElement.new(content: text_str)]
+          end
+        end
+
+        # Parse the cell-format prefix and populate cell_opts.
+        # @param format [Hash, String, Object, nil]
+        # @param cell_opts [Hash] Mutated in place
+        # @return [String, nil] The parsed style character
+        def parse_format(format, cell_opts)
+          if format.is_a?(Hash)
+            parse_format_hash(format, cell_opts)
+          elsif format.is_a?(String)
+            parse_format_string(format, cell_opts)
+          end
+        end
+
+        def parse_format_hash(format, cell_opts)
+          cell_opts[:colspan] = format[:colspan].to_i if format[:colspan]
+
+          if format[:rowspan]
+            rowspan_str = format[:rowspan].to_s.sub(/^\./, '')
+            cell_opts[:rowspan] = rowspan_str.to_i if rowspan_str.match?(/^\d+$/)
+          end
+
+          cell_opts[:halign] = format[:halign].to_s if format[:halign]
+
+          if format[:valign]
+            valign_str = format[:valign].to_s.sub(/^\./, '')
+            cell_opts[:valign] = valign_str if %w[< ^ >].include?(valign_str)
+          end
+
+          style = format[:style].to_s if format[:style]
+          cell_opts[:style] = style
+          cell_opts[:repeat] = true if format[:repeat]
+          style
+        end
+
+        def parse_format_string(format_str, cell_opts)
+          cell_opts[:colspan] = Regexp.last_match(1).to_i if format_str =~ /^(\d+)\+/
+          cell_opts[:rowspan] = Regexp.last_match(1).to_i if format_str =~ /\.(\d+)/
+          cell_opts[:halign] = Regexp.last_match(0) if format_str =~ /[<>^]/
+          cell_opts[:valign] = Regexp.last_match(0)[1] if format_str =~ /\.[.^<>]/
+
+          style = Regexp.last_match(0) if format_str =~ /[dsemalhv]/
+          cell_opts[:style] = style
+
+          cell_opts[:repeat] = true if format_str.include?('*')
+          style
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    class Transformer < Parslet::Transform
+      # Pure functions for table row/column layout.
+      #
+      # Extracted from the Transformer god class so that:
+      # - the Transformer stays focused on rule wiring
+      # - the layout math can be unit-tested in isolation
+      # - future formats (Markdown tables, DOCX) can reuse the math
+      #   without reaching into AsciiDoc::Transformer
+      module TableLayout
+        module_function
+
+        # Parse the `cols=` attribute to determine column count.
+        # @param attrs [Model::AttributeList, Hash, nil]
+        # @return [Integer, nil]
+        def parse_cols_attribute(attrs)
+          return nil if attrs.nil?
+
+          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_str = cols_value.is_a?(Array) ? cols_value.first.to_s : cols_value.to_s
+          cols_str = cols_str.gsub(/^["']|["']$/, '')
+
+          return Regexp.last_match(1).to_i if cols_str =~ /^(\d+)\*$/
+          return cols_str.split(',').size if cols_str.include?(',')
+
+          cols_str.to_i if /^\d+$/.match?(cols_str)
+        end
+
+        # Group a flat list of cells into rows of `col_count` slots.
+        # @param cells [Array<Model::TableCell, Hash, Object>]
+        # @param explicit_col_count [Integer, nil]
+        # @return [Array<Model::TableRow>]
+        def group_cells_into_rows(cells, explicit_col_count = nil)
+          return [] if cells.nil? || cells.empty?
+
+          normalized_cells = cells.map { |cell| TableCellBuilder.normalize_cell(cell) }
+
+          col_count = explicit_col_count
+          if col_count.nil? || col_count.zero?
+            col_count = infer_column_count(normalized_cells)
+          end
+          col_count = normalized_cells.size if col_count.nil? || col_count.zero?
+
+          rows = []
+          current_row = []
+          current_slots = 0
+
+          normalized_cells.each do |cell|
+            colspan = cell.is_a?(Model::TableCell) && cell.colspan ? cell.colspan : 1
+
+            current_row << cell
+            current_slots += colspan
+            next unless current_slots >= col_count
+
+            rows << Model::TableRow.new(columns: current_row)
+            current_row = []
+            current_slots = 0
+          end
+
+          rows << Model::TableRow.new(columns: current_row) if current_row.any?
+          rows
+        end
+
+        # Infer a column count that consistently divides the colspan slots.
+        # @param cells [Array<Model::TableCell>]
+        # @return [Integer, nil]
+        def 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
+
+          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
+        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>]
+        # @param attrs [Model::AttributeList, nil]
+        # @return [Array<Model::TableRow>]
+        def regroup_table_rows(rows, attrs = nil)
+          return rows if rows.nil? || rows.empty?
+
+          col_count = parse_cols_attribute(attrs)
+          if col_count.nil? && rows.first.is_a?(Model::TableRow) && rows.first.columns.any?
+            col_count = rows.first.columns.sum { |c| (c.colspan || 1).to_i }
+          end
+
+          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
+        end
+      end
+    end
+  end
+end

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

@@ -68,32 +68,8 @@ module Coradoc
 
             # Paragraph
             rule(paragraph: subtree(:paragraph)) do
-              lines = paragraph[:lines] || []
-              content = lines.map do |line|
-                if line.is_a?(Hash) && line.key?(:text)
-                  text_content = line[:text]
-                  line_break = line[:line_break]
-
-                  transformed_text = if text_content.is_a?(Array)
-                                       text_content.map do |item|
-                                         if item.is_a?(Hash)
-                                           Transformer.new.apply(item)
-                                         else
-                                           item
-                                         end
-                                       end
-                                     else
-                                       text_content
-                                     end
-
-                  Model::TextElement.new(content: transformed_text, line_break: line_break)
-                else
-                  line
-                end
-              end
-
               Model::Paragraph.new(
-                content: content,
+                content: Transformer.lines_to_text_elements(paragraph[:lines]),
                 id: paragraph[:id],
                 attributes: paragraph[:attribute_list],
                 title: paragraph[:title]