coradoc-adoc 2.0.0

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

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require 'parslet'
+require 'parslet/convenience'
+
+module Coradoc
+  module AsciiDoc
+    module Parser
+      # Autoload parser modules - they will be loaded when included in Base class below
+      autoload :Admonition, 'coradoc/asciidoc/parser/admonition'
+      autoload :AttributeList, 'coradoc/asciidoc/parser/attribute_list'
+      autoload :Bibliography, 'coradoc/asciidoc/parser/bibliography'
+      autoload :Block, 'coradoc/asciidoc/parser/block'
+      autoload :Citation, 'coradoc/asciidoc/parser/citation'
+      autoload :Content, 'coradoc/asciidoc/parser/content'
+      autoload :DocumentAttributes, 'coradoc/asciidoc/parser/document_attributes'
+      autoload :Header, 'coradoc/asciidoc/parser/header'
+      autoload :Inline, 'coradoc/asciidoc/parser/inline'
+      autoload :List, 'coradoc/asciidoc/parser/list'
+      autoload :Paragraph, 'coradoc/asciidoc/parser/paragraph'
+      autoload :Section, 'coradoc/asciidoc/parser/section'
+      autoload :Table, 'coradoc/asciidoc/parser/table'
+      autoload :Term, 'coradoc/asciidoc/parser/term'
+      autoload :Text, 'coradoc/asciidoc/parser/text'
+      autoload :Stem, 'coradoc/asciidoc/parser/stem'
+
+      class Base < Parslet::Parser
+        include Admonition
+        include AttributeList
+        include Bibliography
+        include Block
+        include Citation
+        include Content
+        include DocumentAttributes
+        include Header
+        include Inline
+        include List
+        include Paragraph
+        include Section
+        include Table
+        include Term
+        include Text
+        include Stem
+
+        root :document
+
+        rule(:document) do
+          (
+            header.as(:header) |
+            document_attributes |
+            section |
+            admonition_line |
+            bib_entry |
+            block |
+            block_image |
+            comment_block |
+            comment_line |
+            include_directive |
+            list |
+            table.as(:table) |
+            page_break.as(:page_break) |
+            paragraph |
+            tag |
+            empty_line.as(:line_break) |
+            any.as(:unparsed)
+          ).repeat.as(:document)
+        end
+
+        # Parse an AsciiDoc file
+        # @param filename [String] The filename of the Asciidoc file to parse
+        # @return [Hash] The parsed AST object
+        def self.parse_file(filename)
+          parse(File.read(filename))
+        end
+
+        # Parse an AsciiDoc string
+        # @param string [String] The Asciidoc string to parse
+        # @return [Hash] The parsed AST object
+        def self.parse(string)
+          new.parse(string)
+        rescue Parslet::ParseFailed => e
+          warn e.parse_failure_cause.ascii_tree
+        end
+
+        def rule_dispatch(rule_name, *args, **kwargs)
+          @dispatch_data ||= {}
+          dispatch_key = [rule_name, args, kwargs.to_a.sort]
+          dispatch_hash = dispatch_key.hash.abs
+          unless @dispatch_data.key?(dispatch_hash)
+            alias_name = :"#{rule_name}_#{dispatch_hash}"
+            Coradoc::AsciiDoc::Parser::Base.class_exec do
+              rule(alias_name) do
+                send(rule_name, *args, **kwargs)
+              end
+            end
+            @dispatch_data[dispatch_hash] = alias_name
+          end
+          dispatch_method = @dispatch_data[dispatch_hash]
+          send(dispatch_method)
+        end
+
+        def self.config(key)
+          # NOTE: These are internal dispatch configuration options for the parser:
+          # - add_dispatch: Enables automatic method dispatching
+          # - with_params: Supports parameterized rule invocation
+          c = {
+            add_dispatch: true,
+            with_params: true
+          }
+
+          raise ArgumentError, "Unknown config key: #{key}. Available keys: #{c.keys.join(', ')}" unless c.key?(key)
+
+          c[key]
+        end
+
+        # Collect parser methods from all parser modules (excluding Base, Cache, and FixFiles)
+        # Base is the parser class, Cache is a utility class, FixFiles is a utility module
+        parser_constants = Coradoc::AsciiDoc::Parser.constants - %i[Base Cache FixFiles]
+        parser_methods = parser_constants.each_with_object({}) do |const, acc|
+          rule_names = Coradoc::AsciiDoc::Parser.const_get(const).instance_methods
+          rule_names.each do |rule_name|
+            acc[rule_name] ||= []
+            acc[rule_name] << const
+          end
+        end
+
+        # Warn about duplicated parser methods:
+        parser_methods.each do |rule_name, defn_sites|
+          count = defn_sites.length
+          if count > 1
+            defn_site_constants = defn_sites.map { |const| Coradoc::AsciiDoc::Parser.const_get(const) }
+            Coradoc::Logger.warn "Parser method '#{rule_name}' is defined #{count} times in #{defn_site_constants.join(', ')}"
+          end
+        end
+
+        parser_methods.each_key do |rule_name|
+          params = Coradoc::AsciiDoc::Parser::Base.instance_method(rule_name).parameters
+          if config(:add_dispatch) && params == []
+            alias_name = :"alias_nondispatch_#{rule_name}"
+            Coradoc::AsciiDoc::Parser::Base.class_exec do
+              alias_method alias_name, rule_name
+              rule(rule_name) do
+                send(alias_name)
+              end
+            end
+          elsif config(:add_dispatch) && config(:with_params)
+            alias_name = :"alias_dispatch_#{rule_name}"
+            Coradoc::AsciiDoc::Parser::Base.class_exec do
+              alias_method alias_name, rule_name
+              define_method(rule_name) do |*args, **kwargs|
+                rule_dispatch(alias_name, *args, **kwargs)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Parser
+      module Bibliography
+        def bibliography
+          (element_id.maybe >>
+          str("[bibliography]\n") >>
+          str('== ') >> match("[^\n]").repeat(1).as(:title) >> str("\n") >>
+          bib_entry.repeat(1).as(:entries)
+          ).as(:bibliography)
+        end
+
+        def bib_entry
+          (match('^*') >> str(' [[[') >>
+            match('[^,\[\]\n]').repeat(1).as(:anchor_name) >>
+          (str(',') >>
+            match('[^\]\n]').repeat(1).as(:document_id)
+          ).maybe >>
+          str(']]]') >>
+            (text_line.repeat(0, 1) >>
+              text_line.repeat(0)
+            ).as(:ref_text).maybe >>
+            line_ending.repeat(1).as(:line_break).maybe
+          ).as(:bibliography_entry)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Parser
+      module Block
+        # AsciiDoc Block Delimiter Patterns:
+        # - "4+" means 4 or more identical characters
+        # - "2+" means 2 or more identical characters
+        #
+        # Block types by delimiter character:
+        # - "=" (4+): Example block (====, =====, etc.)
+        # - "-" (4+): Source/listing block (----, -----, etc.)
+        # - "-" (2): Open block (--)
+        # - "_" (4+): Quote block (____, _____, etc.)
+        # - "*" (4+): Sidebar block (****, *****, etc.)
+        # - "+" (4+): Pass block (++++, +++++, etc.)
+        # - "." (4+): Literal block (...., ....., etc.)
+        #
+        # Table delimiters:
+        # - "|===" defines table boundaries
+        # - "|" separates cells within the table
+
+        def block(n_deep = 3)
+          (example_block(n_deep) |
+          sidebar_block(n_deep) |
+          source_block(n_deep) |
+          quote_block(n_deep) |
+          pass_block(n_deep) |
+          open_block(n_deep)).as(:block)
+        end
+
+        def reviewer_note_block(_n_deep = 3)
+          # Match blocks with reviewer attribute
+          # This should only match when attribute_list contains reviewer=
+          # For now, we'll make it not match anything specific
+          # The block() method will handle these cases
+          str('').absent? # Never matches - placeholder for future implementation
+        end
+
+        def example_block(n_deep)
+          block_style(n_deep, '=', 4)
+        end
+
+        def pass_block(n_deep)
+          block_style(n_deep, '+', 4, :pass)
+        end
+
+        def quote_block(n_deep)
+          block_style(n_deep, '_', 4)
+        end
+
+        def sidebar_block(n_deep)
+          block_style(n_deep, '*', 4)
+        end
+
+        def source_block(n_deep)
+          block_style(n_deep, '-', 4, verbatim: true)
+        end
+
+        # Open block: exactly 2 dashes (cannot nest within itself)
+        def open_block(n_deep)
+          block_style_exact(n_deep, '-', 2)
+        end
+
+        def block_title
+          str('.') >> space.absent? >> text.as(:title) >> newline
+        end
+
+        def block_type(type)
+          (line_start? >> str('[') >> str('[').absent? >>
+            str(type).as(:type) >>
+            str(']')) >> newline # |
+        end
+
+        def block_content(n_deep = 3)
+          c = block_image |
+              list |
+              text_line(false, unguarded: true) |
+              empty_line.as(:line_break)
+          c |= block(n_deep - 1) if n_deep.positive?
+          c.repeat(1)
+        end
+
+        # Block delimiter: 4+ identical characters (or 2 for open block)
+        # NOTE: repeat(4,) means 4 or more (not exactly 4)
+        def block_delimiter
+          line_start? >>
+            ((str('*') |
+              str('=') |
+              str('_') |
+              str('+') |
+              str('-')).repeat(4) | # 4+ characters for most blocks
+              str('-').repeat(2, 2)) >> # Exactly 2 for open block
+            newline
+        end
+
+        def element_attributes
+          block_title.maybe >>
+            element_id.maybe >>
+            (attribute_list >> newline).maybe >>
+            block_title.maybe >>
+            newline.maybe >>
+            (attribute_list >> newline).maybe >>
+            element_id.maybe
+        end
+
+        # Block style parser with variable delimiter length
+        # @param n_deep [Integer] Nesting depth for nested blocks
+        # @param delimiter [String] The delimiter character ("=", "-", "_", "*", "+")
+        # @param repeater [Integer] Minimum number of delimiter characters (default: 4)
+        # @param type [Symbol] Block type for special handling (e.g., :pass)
+        def block_style(n_deep = 3, delimiter = '*', repeater = 4, type = nil, verbatim: false)
+          # repeat(repeater,) means repeater or more characters
+          current_delimiter = str(delimiter).repeat(repeater).capture(:delimit)
+          closing_delimiter = dynamic do |_s, c|
+            str(c.captures[:delimit].to_s.strip)
+          end
+
+          # Create a block content parser that respects the closing delimiter
+          # This prevents nested blocks from consuming the closing delimiter
+          block_content_with_closing = dynamic do |_s, c|
+            delim_str = c.captures[:delimit].to_s.strip
+            closing_pattern = str(delim_str) >> newline
+
+            # Build content that doesn't match the closing delimiter
+            content = block_image | list | text_line(false, unguarded: true,
+                                                            verbatim: verbatim) | empty_line.as(:line_break)
+            if n_deep.positive?
+              # For nested blocks, also prevent them from consuming the closing delimiter
+              content |= block(n_deep - 1)
+            end
+
+            # Each content element must not start with the closing delimiter
+            (closing_pattern.absent? >> content).repeat(1)
+          end
+
+          element_attributes >>
+            (line_start? >> attribute_list >> newline).maybe >>
+            line_start? >>
+            current_delimiter.as(:delimiter) >> newline >>
+            if type == :pass
+              (text_line(false, unguarded: true, verbatim: verbatim) | empty_line.as(:line_break)).repeat(1).as(:lines)
+            else
+              # Use dynamic block content that respects closing delimiter
+              block_content_with_closing.as(:lines)
+            end >>
+            line_start? >>
+            closing_delimiter >> newline
+        end
+
+        # Block style parser with EXACT delimiter length (for open blocks)
+        # Open blocks use exactly 2 dashes and cannot nest within themselves
+        def block_style_exact(n_deep = 3, delimiter = '-', exact_chars = 2, type = nil)
+          current_delimiter = str(delimiter).repeat(exact_chars, exact_chars).capture(:delimit)
+          closing_delimiter = dynamic do |_s, c|
+            str(c.captures[:delimit].to_s.strip)
+          end
+
+          # Create a block content parser that respects the closing delimiter
+          block_content_with_closing = dynamic do |_s, c|
+            delim_str = c.captures[:delimit].to_s.strip
+            closing_pattern = str(delim_str) >> newline
+
+            content = block_image | list | text_line(false, unguarded: true) | empty_line.as(:line_break)
+            content |= block(n_deep - 1) if n_deep.positive?
+
+            (closing_pattern.absent? >> content).repeat(1)
+          end
+
+          element_attributes >>
+            (line_start? >> attribute_list >> newline).maybe >>
+            line_start? >>
+            current_delimiter.as(:delimiter) >> newline >>
+            if type == :pass
+              (text_line(false, unguarded: true) | empty_line.as(:line_break)).repeat(1).as(:lines)
+            else
+              block_content_with_closing.as(:lines)
+            end >>
+            line_start? >>
+            closing_delimiter >> newline
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Parser
+      # Single Responsibility: Assemble block AST from metadata hints
+      # Takes metadata analysis and input text, returns proper AST structure
+      class BlockAssembler
+        # Main entry point: assemble block AST from input and metadata
+        # @param input [String] The input text to parse
+        # @param metadata_analysis [Hash] Analysis from MetadataDetector
+        # @return [Hash] AST hash {:block => {...}}
+        def self.assemble(input, metadata_analysis)
+          return nil unless metadata_analysis
+
+          pattern = metadata_analysis[:pattern]
+
+          # Delegate to pattern-specific methods (Open/Closed Principle)
+          case pattern
+          when :title_attr_delim
+            assemble_title_attr_delim(input, metadata_analysis)
+          when :title_delim
+            assemble_title_delim(input, metadata_analysis)
+          when :attr_delim
+            assemble_attr_delim(input, metadata_analysis)
+          when :plain_delim
+            assemble_plain_delim(input, metadata_analysis)
+          end
+        end
+
+        # Handle: Title + Attribute + Delimiter pattern
+        # @param input [String] The input text
+        # @param metadata [Hash] Metadata analysis
+        # @return [Hash] Complete block hash
+        def self.assemble_title_attr_delim(input, metadata)
+          lines = input.lines
+          delimiter_line = metadata[:delimiter_line]
+          delimiter = metadata[:delimiter][:delimiter]
+
+          # Extract components
+          title_text = metadata[:title][:text]
+          attr_list = parse_attribute_list(metadata[:attributes])
+
+          # Extract block content
+          block_lines = extract_block_lines(lines, delimiter_line, delimiter)
+
+          {
+            title: title_text,
+            attribute_list: attr_list,
+            delimiter: delimiter,
+            lines: block_lines
+          }
+        end
+
+        # Handle: Title + Delimiter pattern (no attributes)
+        # @param input [String] The input text
+        # @param metadata [Hash] Metadata analysis
+        # @return [Hash] Block hash without attributes
+        def self.assemble_title_delim(input, metadata)
+          lines = input.lines
+          delimiter_line = metadata[:delimiter_line]
+          delimiter = metadata[:delimiter][:delimiter]
+
+          # Extract components
+          title_text = metadata[:title][:text]
+
+          # Extract block content
+          block_lines = extract_block_lines(lines, delimiter_line, delimiter)
+
+          {
+            title: title_text,
+            delimiter: delimiter,
+            lines: block_lines
+          }
+        end
+
+        # Handle: Attribute + Delimiter pattern (no title)
+        # @param input [String] The input text
+        # @param metadata [Hash] Metadata analysis
+        # @return [Hash] Block hash without title
+        def self.assemble_attr_delim(input, metadata)
+          lines = input.lines
+          delimiter_line = metadata[:delimiter_line]
+          delimiter = metadata[:delimiter][:delimiter]
+
+          # Extract components
+          attr_list = parse_attribute_list(metadata[:attributes])
+
+          # Extract block content
+          block_lines = extract_block_lines(lines, delimiter_line, delimiter)
+
+          {
+            attribute_list: attr_list,
+            delimiter: delimiter,
+            lines: block_lines
+          }
+        end
+
+        # Handle: Just Delimiter pattern
+        # @param input [String] The input text
+        # @param metadata [Hash] Metadata analysis
+        # @return [Hash] Minimal block hash
+        def self.assemble_plain_delim(input, metadata)
+          lines = input.lines
+          delimiter_line = metadata[:delimiter_line]
+          delimiter = metadata[:delimiter][:delimiter]
+
+          # Extract block content
+          block_lines = extract_block_lines(lines, delimiter_line, delimiter)
+
+          {
+            delimiter: delimiter,
+            lines: block_lines
+          }
+        end
+
+        # Helper: Extract content between delimiters
+        # @param lines [Array<String>] All lines of input
+        # @param delimiter_line [Integer] Line number of opening delimiter
+        # @param delimiter [String] The delimiter string (e.g., "****")
+        # @return [Array<Hash>] Array of {:text => "...", :line_break => "\n"}
+        def self.extract_block_lines(lines, delimiter_line, delimiter)
+          block_lines = []
+
+          # Start from line after opening delimiter
+          i = delimiter_line + 1
+
+          # Collect lines until closing delimiter
+          while i < lines.length
+            line = lines[i]
+
+            # Check if this is the closing delimiter
+            break if line.strip == delimiter
+
+            # Handle empty lines vs content lines
+            if line.strip.empty?
+              block_lines << { line_break: "\n" }
+            else
+              # Remove trailing newline for processing
+              text = line.chomp
+              block_lines << { text: text, line_break: "\n" }
+            end
+
+            i += 1
+          end
+
+          block_lines
+        end
+
+        # Parse attribute list to match expected AST structure
+        # @param attr_meta [Hash] Attribute metadata from detector
+        # @return [Hash] Properly formatted attribute_list hash
+        def self.parse_attribute_list(attr_meta)
+          return nil unless attr_meta
+
+          # Get the raw content (without brackets)
+          content = attr_meta[:content]
+          attr_content = content[1...-1] # Remove [ and ]
+
+          # Get attributes array from metadata
+          attributes = attr_meta[:attributes]
+
+          # Build attribute_array in expected format
+          attribute_array = attributes.map do |attr|
+            # Check if it's a named attribute (key=value)
+            if attr.include?('=')
+              key, value = attr.split('=', 2)
+              { named: { named_key: key.strip, named_value: value.strip } }
+            else
+              # Positional attribute
+              { positional: attr.strip }
+            end
+          end
+
+          {
+            attr_content: attr_content,
+            attribute_array: attribute_array
+          }
+        end
+      end
+    end
+  end
+end