coradoc-adoc 2.0.0

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

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    class Transformer < Parslet::Transform
+      # Module containing list transformation rules
+      module ListRules
+        def self.apply(transformer_class)
+          transformer_class.class_eval do
+            # List item
+            rule(list_item: subtree(:list_item)) do
+              marker = list_item[:marker]
+              id = list_item[:id]
+              text = list_item[:text]
+              text = list_item[:text].to_s if list_item[:text].instance_of?(Parslet::Slice)
+              attached = list_item[:attached]
+              nested = list_item[:nested]
+              line_break = list_item[:line_break]
+
+              # Convert nested array to proper List object if needed
+              if nested.is_a?(Array) && nested.any?
+                first_marker = nested.first.is_a?(Model::List::Item) ? nested.first.marker : marker
+                nested = if first_marker.to_s.start_with?('.', '1', 'a', 'A', 'i', 'I')
+                           Model::List::Ordered.new(items: nested)
+                         else
+                           Model::List::Unordered.new(items: nested)
+                         end
+              end
+
+              Model::List::Item.new(
+                content: text, id:, marker:, attached:, nested:, line_break:
+              )
+            end
+
+            # List passthrough
+            rule(list: simple(:list)) do
+              list
+            end
+
+            # Unordered list
+            rule(unordered: sequence(:list_items)) do
+              Model::List::Unordered.new(items: list_items)
+            end
+
+            rule(
+              attribute_list: simple(:attribute_list),
+              unordered: sequence(:list_items)
+            ) do
+              Model::List::Unordered.new(items: list_items, attrs: attribute_list)
+            end
+
+            # Ordered list
+            rule(ordered: sequence(:list_items)) do
+              Model::List::Ordered.new(items: list_items)
+            end
+
+            rule(
+              attribute_list: simple(:attribute_list),
+              ordered: sequence(:list_items)
+            ) do
+              Model::List::Ordered.new(items: list_items, attrs: attribute_list)
+            end
+
+            # Definition list term
+            rule(dlist_term: simple(:term), delimiter: simple(:_delim)) do
+              term.to_s
+            end
+
+            # Definition list item
+            rule(
+              definition_list_item: {
+                terms: sequence(:terms),
+                definition: simple(:contents)
+              }
+            ) do
+              Model::List::DefinitionItem.new(terms: terms, contents: contents)
+            end
+
+            # Definition list item with hash terms (single term case)
+            rule(
+              definition_list_item: subtree(:item_data)
+            ) do
+              terms_data = item_data[:terms]
+              definition = item_data[:definition]
+
+              # Extract terms
+              terms = if terms_data.is_a?(Array)
+                        terms_data.map do |t|
+                          if t.is_a?(Hash) && t[:dlist_term]
+                            t[:dlist_term].to_s
+                          else
+                            t.to_s
+                          end
+                        end
+                      else
+                        [terms_data.to_s]
+                      end
+
+              # Extract definition
+              if definition.is_a?(Parslet::Slice)
+              end
+              contents = definition.to_s
+
+              Model::List::DefinitionItem.new(terms: terms, contents: contents)
+            end
+
+            rule(definition_list: sequence(:list_items)) do
+              Model::List::Definition.new(items: list_items)
+            end
+
+            # Definition list with attribute_list (e.g., [%key])
+            rule(
+              attribute_list: simple(:attribute_list),
+              definition_list: sequence(:list_items)
+            ) do
+              Model::List::Definition.new(items: list_items, attrs: attribute_list)
+            end
+
+            # List containing definition_list
+            rule(
+              attribute_list: simple(:attribute_list),
+              definition_list: sequence(:list_items)
+            ) do
+              Model::List::Definition.new(items: list_items, attrs: attribute_list)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    class Transformer < Parslet::Transform
+      # Module containing miscellaneous transformation rules
+      module MiscRules
+        def self.apply(transformer_class)
+          transformer_class.class_eval do
+            # Comments
+            rule(comment_line: {
+                   comment_text: simple(:comment_text),
+                   line_break: simple(:line_break)
+                 }) do
+              Model::CommentLine.new(text: comment_text, line_break: line_break)
+            end
+
+            rule(comment_block: { comment_text: simple(:comment_text) }) do
+              Model::CommentBlock.new(text: comment_text)
+            end
+
+            # Page break
+            rule(page_break: simple(:page_break)) do
+              Model::Break::PageBreak.new
+            end
+
+            # Tag
+            rule(tag: subtree(:tag)) do
+              Model::Tag.new(
+                name: tag[:name],
+                attrs: tag[:attribute_list],
+                line_break: tag[:line_break],
+                prefix: tag[:prefix]
+              )
+            end
+
+            # AttributeList
+            rule(
+              named: {
+                named_key: simple(:key),
+                named_value: simple(:value)
+              }
+            ) do
+              Model::Attribute.new(key: key.to_s, value: value.to_s)
+            end
+
+            rule(positional: simple(:positional)) do
+              positional.to_s
+            end
+
+            rule(attribute_array: nil) do
+              Model::AttributeList.new
+            end
+
+            rule(attribute_array: sequence(:attributes)) do
+              attr_list = Model::AttributeList.new
+              attributes.each do |a|
+                if a.is_a?(String)
+                  attr_list.add_positional(a)
+                elsif a.is_a?(Model::Attribute)
+                  attr_list.add_named(a.key, a.value)
+                end
+              end
+              attr_list
+            end
+
+            # Attribute with line_break
+            rule(
+              key: simple(:key),
+              value: simple(:value),
+              line_break: simple(:line_break)
+            ) do
+              Model::Attribute.new(
+                key: key.to_s,
+                value: value.to_s,
+                line_break: line_break.to_s
+              )
+            end
+
+            # Attribute without line_break
+            rule(
+              key: simple(:key),
+              value: simple(:value)
+            ) do
+              Model::Attribute.new(
+                key: key.to_s,
+                value: value.to_s
+              )
+            end
+
+            # Document attributes
+            rule(document_attributes: sequence(:document_attribute)) do
+              Model::DocumentAttributes.new(data: document_attribute)
+            end
+
+            # Include
+            rule(
+              include: {
+                path: simple(:path),
+                attribute_list: simple(:attribute_list),
+                line_break: simple(:line_break)
+              }
+            ) do
+              Model::Include.new(
+                path: path.to_s,
+                attributes: attribute_list,
+                line_break: line_break
+              )
+            end
+
+            # Audio
+            rule(
+              audio: {
+                path: simple(:path),
+                attribute_list: simple(:attribute_list),
+                line_break: simple(:line_break)
+              }
+            ) do
+              Model::Audio.new(
+                src: path.to_s,
+                attributes: attribute_list,
+                line_break: line_break
+              )
+            end
+
+            # Video
+            rule(
+              video: {
+                path: simple(:path),
+                attribute_list: simple(:attribute_list),
+                line_break: simple(:line_break)
+              }
+            ) do
+              Model::Video.new(
+                src: path.to_s,
+                attributes: attribute_list,
+                line_break: line_break
+              )
+            end
+
+            # Reviewer Note
+            rule(reviewer_note: subtree(:reviewer_note)) do
+              reviewer_attributes_hash = reviewer_note[:reviewer_attributes]
+              lines = reviewer_note[:lines] || []
+
+              attrs = {}
+              if reviewer_attributes_hash.is_a?(Model::AttributeList)
+                reviewer_attributes_hash.named.each do |attr|
+                  attrs[attr.name.to_sym] = attr.value.is_a?(Array) ? attr.value.first : attr.value
+                end
+              elsif reviewer_attributes_hash.is_a?(Hash) && reviewer_attributes_hash[:attribute_list]
+                attr_list = Transformer.new.apply(reviewer_attributes_hash[:attribute_list])
+                if attr_list.is_a?(Model::AttributeList)
+                  attr_list.named.each do |attr|
+                    attrs[attr.name.to_sym] = attr.value.is_a?(Array) ? attr.value.first : attr.value
+                  end
+                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
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    class Transformer < Parslet::Transform
+      # Module containing table and structural element transformation rules
+      module StructuralRules
+        def self.apply(transformer_class)
+          transformer_class.class_eval do
+            # Table cell with format specification
+            rule(cell_format: simple(:format), text: simple(:text)) do
+              Transformer.build_table_cell(format, text)
+            end
+
+            rule(cell_format: simple(:format), text: sequence(:text)) do
+              Transformer.build_table_cell(format, text)
+            end
+
+            rule(cell_format: subtree(:format), text: simple(:text)) do
+              Transformer.build_table_cell(format, text)
+            end
+
+            rule(cell_format: subtree(:format), text: sequence(:text)) do
+              Transformer.build_table_cell(format, text)
+            end
+
+            # Table cell without format specification (plain content)
+            # NOTE: These rules should ONLY match within table context
+            # The generic text rules are handled by text_rules.rb
+            # rule(text: simple(:text)) do
+            #   Model::TableCell.new(content: text.to_s)
+            # end
+            #
+            # rule(text: sequence(:text)) do
+            #   Model::TableCell.new(content: text.map(&:to_s).join)
+            # end
+
+            # Single cell in a sequence - unwrap to TableCell
+            rule(cell: simple(:cell)) do
+              cell
+            end
+
+            # Unwrap single row
+            rule(row: simple(:row)) do
+              row
+            end
+
+            # Table row with cells
+            rule(cells: sequence(:cells)) do
+              Model::TableRow.new(columns: cells)
+            end
+
+            # Passthrough for attribute_list containing transformed attribute_array
+            rule(attribute_list: { attribute_array: simple(:attrs) }) do
+              attrs
+            end
+
+            # Passthrough for already-transformed Table
+            rule(table: simple(:table)) do
+              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))
+            end
+
+            # Title
+            rule(
+              level: simple(:level),
+              text: simple(:text),
+              line_break: simple(:line_break)
+            ) do
+              Model::Title.new(
+                content: text,
+                level_int: level.size - 1,
+                line_break: line_break
+              )
+            end
+
+            rule(
+              name: simple(:name),
+              level: simple(:level),
+              text: simple(:text),
+              line_break: simple(:line_break)
+            ) do
+              Model::Title.new(
+                content: text,
+                level_int: level.size - 1,
+                line_break: line_break,
+                id: name
+              )
+            end
+
+            # Section
+            rule(section: subtree(:section)) do
+              id = section[:id] || nil
+              title = section[:title] || nil
+
+              id = title.id if title.is_a?(Model::Title) && title.id && !id
+
+              attribute_list = section[:attribute_list] || nil
+              contents = section[:contents] || []
+              sections = section[:sections]
+              Model::Section.new(
+                title: title,
+                id: id,
+                attribute_list: attribute_list,
+                contents: contents,
+                sections: sections
+              )
+            end
+
+            rule(section: simple(:section)) do
+              section
+            end
+
+            # Document
+            rule(document: subtree(:document)) do
+              elements = document.is_a?(Array) ? document : [document]
+              Coradoc::AsciiDoc::Model::Document.from_ast(elements)
+            end
+
+            # Glossaries
+            rule(glossaries: sequence(:glossaries)) do
+              Model::Glossaries.new(items: glossaries)
+            end
+
+            # 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:
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    class Transformer < Parslet::Transform
+      # Module containing text and paragraph transformation rules
+      module TextRules
+        def self.apply(transformer_class)
+          transformer_class.class_eval do
+            # Text Model
+            rule(text: simple(:text)) do
+              Model::TextElement.new(content: text.to_s)
+            end
+
+            rule(text_string: subtree(:text_string)) do
+              text_string.to_s
+            end
+
+            rule(text: simple(:text), line_break: simple(:line_break)) do
+              Model::TextElement.new(content: text.to_s, line_break: line_break)
+            end
+
+            rule(text: sequence(:text), line_break: simple(:line_break)) do
+              Model::TextElement.new(content: text, line_break: line_break)
+            end
+
+            rule(id: simple(:id), text: simple(:text)) do
+              Model::TextElement.new(content: text.to_s, id: id.to_s)
+            end
+
+            rule(text: sequence(:text)) do
+              Model::TextElement.new(content: text)
+            end
+
+            rule(
+              id: simple(:id),
+              text: simple(:text),
+              line_break: simple(:line_break)
+            ) do
+              Model::TextElement.new(
+                content: text.to_s,
+                id: id.to_s,
+                line_break: line_break
+              )
+            end
+
+            rule(
+              id: simple(:id),
+              text: sequence(:text),
+              line_break: simple(:line_break)
+            ) do
+              Model::TextElement.new(
+                content: text,
+                id: id.to_s,
+                line_break: line_break
+              )
+            end
+
+            # Line break
+            rule(line_break: simple(:line_break)) do
+              Model::LineBreak.new(line_break:)
+            end
+
+            # Unparsed text
+            rule(unparsed: simple(:text)) do
+              text.to_s
+            end
+
+            # 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,
+                id: paragraph[:id],
+                attributes: paragraph[:attribute_list],
+                title: paragraph[:title]
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end