coradoc-adoc 2.0.0

data/lib/coradoc/asciidoc/parser/list.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+# $DEBUG = true
+module Coradoc
+  module AsciiDoc
+    module Parser
+      module List
+        def list(nesting_level = 1)
+          (
+          unordered_list(nesting_level) |
+             ordered_list(nesting_level) |
+             definition_list
+        ).as(:list)
+        end
+
+        def list_continuation
+          line_start? >> str("+\n")
+        end
+
+        def ordered_list(nesting_level = 1)
+          attrs = (attribute_list >> newline).maybe
+          r = olist_item(nesting_level)
+          attrs >> olist_item(nesting_level).present? >> r.repeat(1).as(:ordered)
+        end
+
+        def unordered_list(nesting_level = 1)
+          attrs = (attribute_list >> newline).maybe
+          r = ulist_item(nesting_level)
+          attrs >> r.repeat(1).as(:unordered)
+        end
+
+        def definition_list(delimiter = '::')
+          (attribute_list >> newline).maybe >>
+            dlist_item(delimiter).repeat(1).as(:definition_list) >>
+            dlist_item(delimiter).absent?
+        end
+
+        def list_marker(nesting_level = 1)
+          olist_marker(nesting_level) | ulist_marker(nesting_level)
+        end
+
+        def olist_marker(nesting_level = 1)
+          # Don't match table cell format specs like ".2+^.^|"
+          # Table cells have format: [colspan][.rowspan][halign][valign][style][*]|
+          # If we see a format spec pattern followed by "|", it's a table cell, not a list
+          line_start? >>
+            str('.' * nesting_level) >>
+            str('.').absent? >>
+            # Don't match if followed by table cell format spec
+            # Pattern: digits, dots, plus, alignment chars (^<>), style letters, then |
+            (
+              (match['0-9.<>^'] | str('+')).repeat(0, 3) >> str('|')
+            ).absent?
+        end
+
+        def olist_item(nesting_level = 1)
+          item = olist_marker(nesting_level).as(:marker) >>
+                 match("\n").absent? >> space >> text_line(true, unguarded: true)
+          # >>
+          # (list_continuation.present? >> list_continuation >>
+          # paragraph #| example_block(n_deep: 1)
+          # ).repeat(0).as(:attached)
+
+          att = (list_continuation.present? >>
+                  list_continuation >>
+                  (admonition_line | paragraph | block) # (n_deep: 1))
+                ).repeat(0).as(:attached)
+          item >>= att.maybe
+
+          if nesting_level <= 4
+            item >>= (list_marker(nesting_level + 1).present? >>
+                   list(nesting_level + 1)).repeat(0).as(:nested) # ).maybe
+          end
+          olist_marker(nesting_level).present? >> item.as(:list_item)
+        end
+
+        def ulist_marker(nesting_level = 1)
+          # Don't match table delimiters like "|==="
+          line_start? >>
+            str('*' * nesting_level) >>
+            str('*').absent? >>
+            # Don't match if followed by "===" (table delimiter)
+            str('===').absent?
+        end
+
+        def ulist_item(nesting_level = 1)
+          item = ulist_marker(nesting_level).as(:marker) >>
+                 str(' [[[').absent? >>
+                 match("\n").absent? >> space >> text_line(true, unguarded: true)
+
+          att = (list_continuation.present? >>
+                  list_continuation >>
+                  (admonition_line | paragraph | block) # (n_deep: 1))
+                ).repeat(0).as(:attached)
+          item >>= att.maybe
+
+          if nesting_level <= 4
+            item >>= (list_marker(nesting_level + 1).present? >>
+                   list(nesting_level + 1)).repeat(0).as(:nested) # ).maybe
+          end
+          ulist_marker(nesting_level).present? >> item.as(:list_item)
+        end
+
+        def dlist_delimiter
+          (str('::') | str(':::') | str('::::') | str(';;')
+          ).as(:delimiter)
+        end
+
+        def dlist_term(_delimiter)
+          match("[^\n:]").repeat(1) # >> empty_line.repeat(0)
+                         .as(:dlist_term) >> dlist_delimiter
+        end
+
+        def dlist_definition
+          text # >> empty_line.repeat(0)
+            .as(:definition) >> line_ending >> empty_line.repeat(0)
+        end
+
+        def dlist_item(delimiter)
+          (((dlist_term(delimiter).as(:terms).repeat(1) >> line_ending >>
+            empty_line.repeat(0)).repeat(1) >>
+            dlist_definition) |
+            (dlist_term(delimiter).repeat(1, 1).as(:terms) >> space >>
+              dlist_definition)
+          ).as(:definition_list_item)
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/parser/metadata_detector.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Parser
+      # Single Responsibility: Detect metadata markers in AsciiDoc input
+      # Stateless, no dependencies on other parser rules (Dependency Inversion)
+      class MetadataDetector
+        # Metadata types (MECE - Mutually Exclusive, Collectively Exhaustive)
+        METADATA_TYPES = {
+          block_title: /^\.[^ \n].*/,
+          attribute_list: /^\[.+\]$/,
+          element_id_double: /^\[\[.+\]\]$/,
+          element_id_single: /^\[#.+\]$/,
+          block_delimiter: /^(\*{4,}|={4,}|_{4,}|\+{4,}|-{4,}|--)/
+        }.freeze
+
+        # Scan input and return metadata markers with positions
+        # @param input [String] The input text to scan
+        # @param max_lines [Integer] Maximum lines to scan ahead
+        # @return [Array<Hash>] Array of {type:, content:, line:, position:}
+        def self.scan(input, max_lines: 20)
+          lines = input.lines
+          metadata = []
+          found_delimiter = false
+
+          lines.first(max_lines).each_with_index do |line, index|
+            # Skip blank lines - they are not metadata
+            next if line.strip.empty?
+
+            # Stop scanning after finding a delimiter
+            # (delimiter marks the start of block content)
+            break if found_delimiter
+
+            # Calculate absolute position in input
+            position = lines[0...index].sum(&:length)
+
+            # Detect each metadata type (MECE)
+            METADATA_TYPES.each do |type, pattern|
+              next unless line.strip&.match?(pattern)
+
+              metadata << {
+                type: type,
+                content: line.strip,
+                line: index,
+                position: position,
+                length: line.length
+              }
+              # Mark if we found a delimiter
+              found_delimiter = true if type == :block_delimiter
+              break # Each line has at most one metadata type
+            end
+          end
+
+          metadata
+        end
+
+        # Detect block title (Single Responsibility)
+        # @param line [String] Line to check
+        # @return [Hash, nil] {text:} or nil
+        def self.detect_block_title(line)
+          return nil unless /^\.[^ \n]/.match?(line)
+
+          # Extract title text (everything after '.')
+          text = line.sub(/^\./, '').strip
+          { text: text }
+        end
+
+        # Detect attribute list (Single Responsibility)
+        # @param line [String] Line to check
+        # @return [Hash, nil] {content:, attributes:} or nil
+        def self.detect_attribute_list(line)
+          return nil unless /^\[.+\]$/.match?(line)
+
+          content = line.strip
+          # Parse basic attribute structure
+          inner = content[1...-1] # Remove [ and ]
+
+          # Simple attribute parsing (positional)
+          attributes = inner.split(',').map(&:strip)
+
+          {
+            content: content,
+            attributes: attributes
+          }
+        end
+
+        # Detect element ID (Single Responsibility)
+        # @param line [String] Line to check
+        # @return [Hash, nil] {id:, style:} or nil
+        def self.detect_element_id(line)
+          # Double bracket style: [[id]]
+          return { id: ::Regexp.last_match(1), style: :double } if line =~ /^\[\[(.+)\]\]$/
+
+          # Single bracket style: [#id]
+          return { id: ::Regexp.last_match(1), style: :single } if line =~ /^\[#(.+)\]$/
+
+          nil
+        end
+
+        # Detect block delimiter (Single Responsibility)
+        # @param line [String] Line to check
+        # @return [Hash, nil] {char:, count:, type:} or nil
+        def self.detect_block_delimiter(line)
+          return nil unless line =~ /^(\*{4,}|={4,}|_{4,}|\+{4,}|-{4,}|--)$/
+
+          delimiter = ::Regexp.last_match(1)
+          char = delimiter[0]
+          count = delimiter.length
+
+          # Map to block type
+          type = case char
+                 when '*' then :sidebar
+                 when '=' then :example
+                 when '_' then :quote
+                 when '+' then :pass
+                 when '-' then count == 2 ? :open : :source
+                 end
+
+          {
+            char: char,
+            count: count,
+            type: type,
+            delimiter: delimiter
+          }
+        end
+
+        # Analyze block structure from metadata (MECE patterns)
+        # @param metadata [Array<Hash>] Metadata from scan()
+        # @return [Hash, nil] {pattern:, title:, attributes:, delimiter:} or nil
+        def self.analyze_block_structure(metadata)
+          return nil if metadata.empty?
+
+          # Find block delimiter (required for block)
+          delim_meta = metadata.find { |m| m[:type] == :block_delimiter }
+          return nil unless delim_meta
+
+          # Find title and attributes
+          title_meta = metadata.find { |m| m[:type] == :block_title }
+          attr_meta = metadata.find { |m| m[:type] == :attribute_list }
+
+          # Determine MECE pattern
+          pattern = if title_meta && attr_meta
+                      :title_attr_delim
+                    elsif title_meta
+                      :title_delim
+                    elsif attr_meta
+                      :attr_delim
+                    else
+                      :plain_delim
+                    end
+
+          {
+            pattern: pattern,
+            title: title_meta ? detect_block_title(title_meta[:content]) : nil,
+            attributes: attr_meta ? detect_attribute_list(attr_meta[:content]) : nil,
+            delimiter: detect_block_delimiter(delim_meta[:content]),
+            delimiter_line: delim_meta[:line]
+          }
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/parser/paragraph.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Parser
+      module Paragraph
+        def line_not_text?
+          line_start? >>
+            (attribute_list >> newline).absent? >>
+            block_delimiter.absent? >>
+            (str('|===') >> newline).absent? >>
+            list.absent? >>
+            list_prefix.absent? >>
+            list_continuation.absent? >>
+            element_id.absent? >>
+            section_prefix.absent?
+        end
+
+        # NOTE: many_breaks parameter has three states for different parsing contexts:
+        # - 0: Single line with EOF termination (no trailing newline)
+        # - true: Multiple lines with flexible newline handling
+        # - false: Single line with strict newline handling
+        # This ternary logic handles different paragraph parsing scenarios in AsciiDoc.
+        # rubocop:disable Style/OptionalBooleanParameter, Style/NumericPredicate
+        def paragraph_text_line(many_breaks = false)
+          tl = line_not_text? >>
+               (asciidoc_char_with_id.absent? |
+                 (element_id_inline >> literal_space?) |
+                 (line_start? >> line_not_text?)) >>
+               text_any.as(:text)
+          # Use == 0 instead of .zero? because many_breaks can be false (not a number)
+          if many_breaks == 0
+            tl >> eof?
+          elsif many_breaks
+            tl >> (newline.as(:line_break) | eof?)
+          else
+            tl >> (newline_single.as(:line_break) | eof?)
+          end
+        end
+        # rubocop:enable Style/OptionalBooleanParameter, Style/NumericPredicate
+
+        def paragraph
+          (element_id.maybe >>
+            block_title.maybe >>
+            (attribute_list >> newline).maybe >>
+            ((paragraph_text_line(0).repeat(1, 1) >>
+                   (newline.repeat(1).as(:line_break) | eof?)) |
+              (paragraph_text_line(false).repeat(1) >>
+              (paragraph_text_line(true).repeat(1, 1) >>
+                   (newline.repeat(1).as(:line_break) | eof?)).repeat(0, 1))
+            ).as(:lines) >>
+            (newline.repeat(0) | eof?)
+          ).as(:paragraph)
+        end
+
+        def paragraph_attributes
+          str('[') >>
+            keyword.as(:key) >> str('=') >>
+            word.as(:value) >> str(']') >> newline
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/parser/section.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Parser
+      module Section
+        def contents
+          (
+            bib_entry |
+            block_image |
+            tag |
+            comment_block |
+            comment_line |
+            include_directive |
+            admonition_line |
+            block |
+            table.as(:table) |
+            page_break.as(:page_break) |
+            # highlight.as(:highlight) |
+            # glossaries.as(:glossaries) |
+            paragraph |
+            list |
+            empty_line.as(:line_break)
+          ).repeat(1)
+        end
+
+        def section_block(level = 2)
+          return nil if level > 8
+
+          (attribute_list >> newline).maybe >>
+            element_id.maybe >>
+            (attribute_list >> newline).maybe >>
+            section_title(level).as(:title) >>
+            contents.as(:contents).maybe
+        end
+
+        def section_prefix
+          (line_start? >> match('^[=]') >> str('=').repeat(0) >> match('[^\n]'))
+        end
+
+        # Heading
+        def section_title(level = 2, max_level = 8)
+          line_start? >>
+            match('=').repeat(level, max_level).as(:level) >>
+            str('=').absent? >>
+            space? >> text.as(:text) >> endline.as(:line_break)
+        end
+
+        # section
+        def section(level = 2)
+          r = section_block(level)
+          r >>= section(level + 1).as(:section).repeat(0).as(:sections) if level < 8
+          if level == 2
+            r.as(:section)
+          else
+            r
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/parser/stem.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Parser
+      module Stem
+        def stem_type
+          (str('stem') | str('latexmath') | str('asciimath')).as(:stem_type)
+        end
+
+        def stem
+          (stem_type >> str(':[') >>
+            match('[^\]]').repeat(1).as(:content) >>
+            str(']')).as(:stem)
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/parser/table.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Parser
+      module Table
+        # AsciiDoc Table Parser
+        #
+        # Table syntax:
+        # - Table starts with: {delimiter}===
+        # - Table ends with: {delimiter}===
+        # - Delimiter can be: | ! , : ; (and other punctuation)
+        # - Cells are separated by: {delimiter}
+        # - Rows can span multiple lines using " +" at end of line
+        #
+        # IMPORTANT: AsciiDoc table row semantics
+        # - Column count is determined by:
+        #   1. `cols` attribute (e.g., [cols="3"] or [cols="1,a,a"])
+        #   2. First row's cell count (if no cols attribute)
+        # - A new row starts when:
+        #   1. Previous row has `column_count` cells
+        #   2. A line starts with the cell delimiter (indicates new row on next line)
+        # - Cells on the same line are part of the same row
+        #
+        # Example:
+        # |===
+        # | A | B | C     <- Row 1 (3 cells, defines 3 columns)
+        # | D              <- Cell 1 of Row 2
+        # | E              <- Cell 2 of Row 2
+        # | F              <- Cell 3 of Row 2
+        # | G | H | I      <- Row 3
+        # |===
+        #
+        # Cell format specification (before cell delimiter):
+        # Format: [colspan][.rowspan][halign][valign][style][*]
+        #
+        # Examples:
+        # - "|===" starts a table with | as cell delimiter
+        # - "2|" cell spanning 2 columns
+        # - ".3|" cell spanning 3 rows
+        # - "^e|" centered cell with emphasis style
+
+        def table
+          element_id.maybe >>
+            (attribute_list >> newline).maybe >>
+            block_title.maybe >>
+            (attribute_list >> newline).maybe >>
+            table_start.capture(:table_delim) >>
+            line_ending >>
+            table_rows.as(:rows) >>
+            table_end >>
+            (line_ending | eof?)
+        end
+
+        # Match opening delimiter: any valid delimiter char followed by ===
+        # Valid delimiter chars: | ! , : ; (punctuation commonly used)
+        def table_start
+          match['|!,:;'].as(:delim_char) >> str('===')
+        end
+
+        # Match closing delimiter using the captured delimiter char
+        def table_end
+          dynamic do |_s, c|
+            delim = c.captures[:table_delim]
+            if delim.is_a?(Hash) && delim[:delim_char]
+              str(delim[:delim_char]) >> str('===')
+            else
+              str('|===')
+            end
+          end
+        end
+
+        # Match all rows until closing delimiter
+        # A row is a sequence of cells until:
+        # 1. End of line (next cells start on new line = new row)
+        # 2. Closing delimiter
+        def table_rows
+          dynamic do |_s, c|
+            delim = c.captures[:table_delim]
+            delim_char = if delim.is_a?(Hash) && delim[:delim_char]
+                           delim[:delim_char]
+                         else
+                           '|'
+                         end
+            closing_delim = "#{delim_char}==="
+
+            # Match rows until we hit the closing delimiter
+            (
+              str(closing_delim).absent? >>
+              table_row(delim_char, closing_delim).as(:row)
+            ).repeat(1)
+          end
+        end
+
+        # Match a single table row
+        # A row consists of cells on the same line (until newline)
+        def table_row(delim_char, closing_delim)
+          dynamic do
+            # Match cells until we hit a newline or closing delimiter
+            (
+              str(closing_delim).absent? >>
+              (newline >> str(delim_char)).absent? >>
+              table_cell(delim_char, closing_delim).as(:cell)
+            ).repeat(1).as(:cells) >>
+              # Consume the newline at end of row (if present)
+              newline
+          end
+        end
+
+        # Match a single table cell
+        # A cell starts with delimiter, contains content
+        def table_cell(delim_char, closing_delim)
+          dynamic do
+            # Cell format spec (optional) + delimiter + content
+            # Leading space is optional (cells can start at column 0)
+            literal_space?.maybe >>
+              cell_format_spec.maybe.as(:cell_format) >>
+              str(delim_char) >>
+              cell_content(delim_char, closing_delim).as(:text)
+          end
+        end
+
+        # Match cell content - everything until next cell delimiter
+        # IMPORTANT: Must not consume format specs that belong to the next cell
+        # Supports multi-line cells with " +" continuation
+        def cell_content(delim_char, closing_delim)
+          dynamic do
+            # Pattern for format spec followed by delimiter
+            # Format specs contain: digits, dots, alignment (^<>), style letters, +
+            # Using alternation to avoid regex character class issues with ^
+            format_spec_char = (
+              match['0-9'] | match['.<>'] | match['dsemalhv'] | str('+') | str('^')
+            )
+            format_spec_then_delim = (
+              format_spec_char >>
+              format_spec_char.repeat(0) >>
+              str(delim_char)
+            )
+
+            # Row boundary: newline followed by (plain delimiter OR format spec + delimiter)
+            # This detects when the next line is a new row
+            new_row_signal = newline >> (str(delim_char) | format_spec_then_delim)
+
+            # A single content character - match any char that doesn't signal end of cell
+            (
+              str(closing_delim).absent? >>
+              new_row_signal.absent? >>
+              str(delim_char).absent? >>
+              format_spec_then_delim.absent? >>
+              any
+            ).repeat(0)
+          end
+        end
+
+        # Match cell format specification
+        # Format: [colspan][.rowspan][halign][valign][style][*]
+        # Using alternation to avoid regex character class issues with ^
+        def cell_format_spec
+          (
+            match['0-9'] | match['.<>'] | match['dsemalhv'] | str('+') | str('^')
+          ).repeat(1)
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/parser/term.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Parser
+      module Term
+        def term_type
+          (str('term') |
+            str('alt') |
+            str('deprecated') |
+            str('domain')).as(:term_type)
+        end
+
+        def term
+          line_start? >>
+            term_type >> str(':[') >>
+            match('[^\]]').repeat(1).as(:term) >>
+            str(']') >> str("\n").repeat(1).as(:line_break)
+        end
+
+        # Content that may contain nested macro:[...] patterns
+        # Handles balanced brackets for nested macros like stem:[x], term:[y]
+        def macro_content
+          # Match content that is either:
+          # 1. Any character that is not ]
+          # 2. Or a complete nested macro like stem:[...] where the content
+          #    itself can contain nested macros
+          (
+            # Non-bracket character (but not starting a macro keyword)
+            (macro_keyword.absent? >> match('[^\]]')) |
+            # A complete nested macro
+            nested_macro
+          ).repeat(0)
+        end
+
+        # Keywords that start macros
+        def macro_keyword
+          str('stem') | str('term') | str('footnote') |
+            str('latexmath') | str('asciimath') | str('alt') |
+            str('deprecated') | str('domain')
+        end
+
+        # A nested macro: keyword:[content]
+        def nested_macro
+          macro_keyword >> str(':[') >> macro_content >> str(']')
+        end
+
+        def footnote
+          str('footnote:') >>
+            keyword.as(:id).maybe >>
+            str('[') >>
+            macro_content.as(:footnote) >>
+            str(']')
+        end
+
+        def term_inline
+          term_type >> str(':[') >>
+            match('[^\]]').repeat(1).as(:term) >>
+            str(']')
+        end
+
+        def term_inline2
+          line_start? >>
+            match('^\[') >> term_type >> str(']#') >>
+            match('[^\#]').repeat(1).as(:term2) >> str('#')
+        end
+      end
+    end
+  end
+end