coradoc-adoc 2.0.0

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

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+module Coradoc
+  module AsciiDoc
+    module Parser
+      # Parser cache for optimizing repeated parses of the same content
+      #
+      # This is an opt-in feature that caches parse results based on content hashing.
+      # Useful for IDE integrations, watch mode, or any scenario where the same
+      # content is parsed multiple times.
+      #
+      # @example Basic usage
+      #   cache = Coradoc::AsciiDoc::Parser::Cache.new
+      #   ast = cache.fetch_or_parse(content) { Parser::Base.parse(content) }
+      #
+      # @example With size limit
+      #   cache = Coradoc::AsciiDoc::Parser::Cache.new(max_size: 100)
+      #
+      # @example Global cache (use with caution)
+      #   Coradoc::AsciiDoc::Parser::Cache.global do |c|
+      #     c.fetch_or_parse(content) { Parser::Base.parse(content) }
+      #   end
+      class Cache
+        # Default maximum cache size
+        DEFAULT_MAX_SIZE = 50
+
+        # Get the global cache instance
+        # @return [Cache, nil] The global cache instance
+        def self.global
+          @global ||= nil
+        end
+
+        # Set the global cache instance
+        # @param cache [Cache, nil] The cache instance
+        class << self
+          attr_writer :global
+        end
+
+        # Execute a block with a global cache
+        # @param max_size [Integer] Maximum cache entries
+        # @yield [Cache] The cache instance
+        # @return [Object] The block result
+        def self.with_global(max_size: DEFAULT_MAX_SIZE)
+          previous = @global
+          @global = new(max_size: max_size)
+          begin
+            yield @global
+          ensure
+            @global = previous
+          end
+        end
+
+        # Clear the global cache
+        def self.clear_global!
+          @global&.clear
+        end
+
+        # Initialize a new cache
+        # @param max_size [Integer] Maximum number of entries to cache
+        def initialize(max_size: DEFAULT_MAX_SIZE)
+          @max_size = max_size
+          @cache = {}
+          @access_order = []
+          @mutex = Mutex.new
+        end
+
+        # Fetch a cached result or parse and cache
+        #
+        # @param content [String] The content to parse
+        # @yield Block to execute if cache miss
+        # @return [Object] The parsed AST
+        def fetch_or_parse(content)
+          key = content_hash(content)
+
+          mutex.synchronize do
+            if cache.key?(key)
+              # Move to end of access order (most recently used)
+              access_order.delete(key)
+              access_order.push(key)
+              return cache[key]
+            end
+          end
+
+          # Parse outside the lock for concurrency
+          result = yield if block_given?
+
+          mutex.synchronize do
+            # Evict oldest if at capacity
+            evict_oldest if cache.size >= max_size
+
+            cache[key] = result
+            access_order.push(key)
+          end
+
+          result
+        end
+
+        # Check if content is cached
+        # @param content [String] The content to check
+        # @return [Boolean] True if cached
+        def cached?(content)
+          key = content_hash(content)
+          mutex.synchronize { cache.key?(key) }
+        end
+
+        # Get cache statistics
+        # @return [Hash] Statistics including size, max_size, hits, misses
+        def stats
+          mutex.synchronize do
+            {
+              size: cache.size,
+              max_size: max_size,
+              keys: access_order.dup
+            }
+          end
+        end
+
+        # Clear the cache
+        def clear
+          mutex.synchronize do
+            cache.clear
+            access_order.clear
+          end
+        end
+
+        # Get the current cache size
+        # @return [Integer] Number of cached entries
+        def size
+          mutex.synchronize { cache.size }
+        end
+
+        private
+
+        attr_reader :cache, :max_size, :access_order, :mutex
+
+        # Generate a hash key for content
+        # @param content [String] The content
+        # @return [String] SHA256 hash of content
+        def content_hash(content)
+          Digest::SHA256.hexdigest(content)
+        end
+
+        # Evict the oldest (least recently used) entry
+        def evict_oldest
+          return if access_order.empty?
+
+          oldest_key = access_order.shift
+          cache.delete(oldest_key)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Parser
+      module Citation
+        def xref_anchor
+          match('[^,>]').repeat(1).as(:href_arg).repeat(1, 1)
+        end
+
+        def xref_str
+          match('[^,>]').repeat(1).as(:text)
+        end
+
+        def xref_arg
+          (str('section') | str('paragraph') | str('clause') | str('annex') | str('table')).as(:key) >>
+            match('[ =]').as(:delimiter) >>
+            match('[^,>=]').repeat(1).as(:value)
+        end
+
+        def cross_reference
+          (str('<<') >> xref_anchor >>
+          ((str(',') >> xref_arg).repeat(1) |
+            (str(',') >> xref_str).repeat(1)
+          ).maybe >>
+            str('>>')
+          ).as(:cross_reference)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Parser
+      module Content
+        def literal_space
+          (match[' '] | match[' \t']).repeat(1)
+        end
+
+        # Override
+        def literal_space?
+          literal_space.maybe
+        end
+
+        def list_prefix
+          (line_start? >>
+            ((match('^[*]') >> str('*').repeat(1, 5)) |
+            (match('^[\.]') >> str('.').repeat(1, 5))) >>
+            str(' '))
+        end
+
+        # Text
+        # :zero :one :many
+        def text_line(many_breaks = false, unguarded: false, verbatim: false)
+          tl = if verbatim
+                 text_any.as(:text)
+               elsif unguarded
+                 literal_space? >> text_any.as(:text)
+               else
+                 (asciidoc_char_with_id.absent? | element_id_inline) >>
+                   literal_space? >> text_any.as(:text)
+               end
+          if many_breaks
+            tl >> (line_ending.repeat(1).as(:line_break) | eof?)
+          else
+            tl >> (line_ending.as(:line_break) | eof?)
+          end
+        end
+
+        def asciidoc_char
+          line_start? >> match['*_:+=\-']
+        end
+
+        def asciidoc_char_with_id
+          asciidoc_char | str('[#') | str('[[')
+        end
+
+        def element_id
+          line_start? >>
+            ((str('[[') >> keyword.as(:id) >> str(']]')) |
+               (str('[#') >> keyword.as(:id) >> str(']'))
+            ) >> newline
+        end
+
+        def element_id_inline
+          (str('[[') >> keyword.as(:id) >> str(']]')) |
+            (str('[#') >> keyword.as(:id) >> str(']'))
+        end
+
+        def glossary
+          keyword.as(:key) >> str('::') >> (str(' ') | newline) >>
+            text.as(:value) >> line_ending.as(:line_break)
+        end
+
+        def glossaries
+          glossary.repeat(1)
+        end
+
+        def page_break
+          str('<<<') >> line_ending
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Parser
+      module DocumentAttributes
+        def attribute_name
+          match('[a-zA-Z0-9_-]').repeat(1)
+        end
+
+        def attribute_value
+          text | (str('') >> str("\n").absent?)
+        end
+
+        def document_attributes
+          document_attribute.repeat(1)
+                            .as(:document_attributes)
+        end
+
+        def document_attribute
+          str(':') >> attribute_name.as(:key) >> str(':') >>
+            space? >> (attribute_value | str('')).as(:value) >> (line_ending | eof?)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+# Script to fix parser file structure
+
+files = %w[attribute_list.rb bibliography.rb block.rb block_assembler.rb citation.rb
+           content.rb document_attributes.rb header.rb inline.rb list.rb
+           metadata_detector.rb paragraph.rb section.rb table.rb term.rb text.rb]
+
+files.each do |filename|
+  next unless File.exist?(filename)
+
+  content = File.read(filename)
+  lines = content.lines
+
+  # The correct structure should be:
+  # module Coradoc
+  #   module AsciiDoc
+  #     module Parser
+  #       module SomeModule
+  #         ...content...
+  #       end
+  #     end
+  #   end
+  # end
+
+  # Count structure
+  puts "=== #{filename} ==="
+
+  # Find all lines that are just "end" with various indentation
+  end_lines = lines.each_with_index.select { |line, _i| line.strip == 'end' }
+  puts "Found #{end_lines.size} 'end' statements"
+
+  # We should have exactly 4 'end' statements for the module nesting
+  # (Coradoc, AsciiDoc, Parser, SomeModule)
+  # But we might have a class inside which adds more
+
+  # Let's just fix the pattern: if we have "  end" followed by "end" at the end,
+  # the "  end" is extra
+
+  new_lines = []
+  i = 0
+  while i < lines.size
+    line = lines[i]
+
+    # Check for the pattern: "    end" followed by "  end" followed by "end"
+    if line == "    end\n" && i + 2 < lines.size &&
+       lines[i + 1] == "  end\n" && lines[i + 2] == "end\n"
+      # Keep the "    end", skip the extra "  end", keep "end"
+      new_lines << line
+      new_lines << lines[i + 2]
+      i += 3
+      next
+    end
+
+    # Check for pattern: "      end" followed by "    end" followed by "  end" followed by "end"
+    if line == "      end\n" && i + 3 < lines.size &&
+       lines[i + 1] == "    end\n" && lines[i + 2] == "  end\n" && lines[i + 3] == "end\n"
+      # This is: end (class/module), end (Parser), end (AsciiDoc), end (Coradoc)
+      # But we have an extra one - the correct should be:
+      # end (inner module), end (Parser), end (AsciiDoc), end (Coradoc)
+      # Let's see what's inside...
+      new_lines << line
+      new_lines << "    end\n"
+      new_lines << "  end\n"
+      new_lines << "end\n"
+      i += 4
+      next
+    end
+
+    new_lines << line
+    i += 1
+  end
+
+  File.write(filename, new_lines.join)
+  puts "Fixed: #{filename}"
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Parser
+      module Header
+        def header
+          header_title >>
+            author.maybe.as(:author) >>
+            revision.maybe.as(:revision) >> newline.maybe
+        end
+
+        def header_title
+          match('^=') >> str('=').absent? >> space? >> text.as(:title) >> newline
+        end
+
+        def author
+          words.as(:first_name) >> str(',') >>
+            space? >> words.as(:last_name) >>
+            space? >> str('<') >> email.as(:email) >> str('>') >> newline
+        end
+
+        def revision
+          (word >> (str('.') >> word).maybe).as(:number) >>
+            str(',') >> space? >> date.as(:date) >> str(':') >>
+            space? >> words.as(:remark) >> newline
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Parser
+      module Inline
+        def attribute_reference
+          str('{').present? >> str('{') >>
+            match('[a-zA-Z0-9_-]').repeat(1).as(:attribute_reference) >>
+            str('}')
+        end
+
+        def bold_constrained
+          (str('*').present? >> str('*') >>
+            match('[^*\n]').repeat(1).as(:text).repeat(1, 1) >>
+             str('*') >> str('*').absent? >>
+             str("\n\n").absent?
+          ).as(:bold_constrained)
+        end
+
+        def bold_unconstrained
+          (str('**').present? >> str('**') >>
+            match('[^*\n]').repeat(1).as(:text).repeat(1, 1) >>
+             str('**')
+          ).as(:bold_unconstrained)
+        end
+
+        def span_constrained
+          (attribute_list >>
+            str('#') >>
+            match('[^#\n]').repeat(1).as(:text) >>
+             str('#') >> str('#').absent?
+          ).as(:span_constrained)
+        end
+
+        def span_unconstrained
+          (attribute_list >>
+            str('##') >>
+            match('[^#\n]').repeat(1).as(:text) >>
+             str('##')
+          ).as(:span_unconstrained)
+        end
+
+        def italic_constrained
+          (str('_') >> str('_').absent? >>
+            match('[^_\n]').repeat(1).as(:text).repeat(1, 1) >>
+             str('_') >> str('_').absent?
+          ).as(:italic_constrained)
+        end
+
+        def italic_unconstrained
+          (str('__') >>
+            match('[^_\n]').repeat(1).as(:text).repeat(1, 1) >>
+             str('__')
+          ).as(:italic_unconstrained)
+        end
+
+        def highlight_constrained
+          (str('#') >>
+            match('[^#\n]').repeat(1).as(:text).repeat(1, 1) >>
+             str('#') >> str('#').absent?
+          ).as(:highlight_constrained)
+        end
+
+        def highlight_unconstrained
+          (str('##') >>
+            match('[^#\n]').repeat(1).as(:text).repeat(1, 1) >>
+             str('##')
+          ).as(:highlight_unconstrained)
+        end
+
+        def monospace_constrained
+          (str('`') >>
+            match('[^`\n]').repeat(1).as(:text).repeat(1, 1) >>
+             str('`') >> str('`').absent?
+          ).as(:monospace_constrained)
+        end
+
+        def monospace_unconstrained
+          (str('``') >>
+            match('[^`\n]').repeat(1).as(:text).repeat(1, 1) >>
+             str('``')
+          ).as(:monospace_unconstrained)
+        end
+
+        def superscript
+          (str('^') >>
+            match('[^^\n]').repeat(1).as(:text).repeat(1, 1) >>
+             str('^')
+          ).as(:superscript)
+        end
+
+        def subscript
+          (str('~') >>
+            match('[^~\n]').repeat(1).as(:text).repeat(1, 1) >>
+             str('~')
+          ).as(:subscript)
+        end
+
+        def span
+          attribute_list >>
+            (str('#') >>
+              match('[^#\n]').repeat(1).as(:text) >>
+               str('#') >> str('#').absent?
+            ).as(:span)
+        end
+
+        def link
+          ((str('http').present? | str('https').present? | str('ftp').present?) >>
+            match('[A-Za-z0-9_.\\-:/&?=+,%#~;]+').repeat(1).as(:path) >>
+            (str('[') >> match('[^\\]]').repeat(1).as(:text) >> str(']')).maybe
+          ).as(:link) |
+            (str('link:').present? >> str('link:') >>
+              match('[A-Za-z0-9_.\\-:/&?=+,%#~;]+').repeat(1).as(:path) >>
+              (str('[') >> match('[^\\]]').repeat(1).as(:text) >> str(']')).maybe
+            ).as(:link)
+        end
+
+        def inline_image
+          (str('image:').present? >> str('image:') >>
+            match('[A-Za-z0-9_.\\-:/&?=+,%#~;]+').repeat(1).as(:path) >>
+            (str('[') >> match('[^\\]]').repeat(1).as(:text) >> str(']')).maybe
+          ).as(:inline_image)
+        end
+
+        def underline
+          (attribute_list >> match('\\[.underline\\]').as(:role) >>
+            str('#') >>
+            match('[^#\n]').repeat(1).as(:text) >>
+            str('#')
+          ).as(:underline)
+        end
+
+        def small
+          (attribute_list >> match('\\[.small\\]').as(:role) >>
+            str('#') >>
+            match('[^#\n]').repeat(1).as(:text) >>
+            str('#')
+          ).as(:small)
+        end
+
+        def inline_chars?
+          match('[\[*#_{<^~`]').present? |
+            str('http').present? |
+            str('https').present? |
+            str('link:').present? |
+            str('image:').present? |
+            term_type.present? |
+            str('footnote').present? |
+            stem_type.present?
+        end
+
+        def inline
+          bold_unconstrained |
+            bold_constrained |
+            span_unconstrained |
+            span_constrained |
+            italic_unconstrained |
+            italic_constrained |
+            highlight_unconstrained |
+            highlight_constrained |
+            monospace_unconstrained |
+            monospace_constrained |
+            superscript |
+            subscript |
+            attribute_reference |
+            cross_reference |
+            term_inline |
+            term_inline2 |
+            footnote |
+            stem |
+            link |
+            inline_image |
+            underline |
+            small
+        end
+
+        def text_unformatted
+          # line_not_text? >>
+          (inline.absent? >>
+            match("[^\n]")
+          ).repeat(1)
+        end
+
+        def text_formatted
+          (inline_chars? >> inline)
+        end
+
+        def text_any
+          (text_formatted |
+                  text_unformatted.as(:text)
+          ).repeat(2) |
+            text_formatted.repeat(1, 1) |
+            text_unformatted
+        end
+      end
+    end
+  end
+end