coradoc-adoc 2.0.0

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

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Parser
+      module Text
+        def space?
+          space.maybe
+        end
+
+        def space
+          str(' ').repeat(1)
+        end
+
+        def text
+          match("[^\n]").repeat(1)
+        end
+
+        def line_start?
+          match('^[^\n]').present?
+        end
+
+        def line_ending
+          str("\n") # | match('[\z]')# | match('$')
+        end
+
+        def eof?
+          any.absent?
+        end
+
+        def line_end
+          str("\n") | str("\r\n") | eof?
+        end
+
+        def endline
+          newline | any.absent?
+        end
+
+        # def endline_single
+        #   newline_single | any.absent?
+        # end
+
+        def newline
+          (str("\n") | str("\r\n")).repeat(1)
+        end
+
+        def newline_single
+          (str("\n") | str("\r\n"))
+        end
+
+        def keyword
+          (match('[a-zA-Z0-9_\-.,]') | str('.')).repeat(1)
+        end
+
+        def empty_line
+          str("\n")
+        end
+
+        def digit
+          match('[0-9]')
+        end
+
+        def digits
+          match('[0-9]').repeat(1)
+        end
+
+        def word
+          match('[a-zA-Z0-9_-]').repeat(1)
+        end
+
+        def words
+          word >> (space? >> word).repeat
+        end
+
+        def rich_texts
+          rich_text >> (space? >> rich_text).repeat
+        end
+
+        def rich_text
+          (match('[a-zA-Z0-9_-]') | str('.') | str('*') | match('@')).repeat(1)
+        end
+
+        def email
+          word >> str('@') >> word >> str('.') >> word
+        end
+
+        def special_character
+          match('^[*:=-]') | str('[#') | str('[[')
+        end
+
+        def date
+          digit.repeat(2, 4) >> str('-') >>
+            digit.repeat(1, 2) >> str('-') >> digit.repeat(1, 2)
+        end
+
+        def attr_name
+          match("[^\t\s]").repeat(1)
+        end
+
+        def file_path
+          match('[^\[]').repeat(1)
+        end
+
+        def include_directive
+          (str('include::') >>
+            file_path.as(:path) >>
+            attribute_list >>
+          (newline | str('')).as(:line_break)
+          ).as(:include)
+        end
+
+        # block_image is defined in inline.rb with full syntax
+        # inline_image is defined in inline.rb for inline images (image:)
+
+        def block_image
+          (element_id.maybe >>
+            block_title.maybe >>
+            (attribute_list >> newline).maybe >>
+            match('^i') >> str('mage::') >>
+            file_path.as(:path) >>
+            attribute_list(:attribute_list_macro) >>
+            newline.as(:line_break)
+          ).as(:block_image)
+        end
+
+        def comment_line
+          tag.absent? >>
+            (str('//') >> str('/').absent? >>
+              space? >>
+              text.maybe.as(:comment_text) >>
+              line_ending.as(:line_break)
+            ).as(:comment_line)
+        end
+
+        def tag
+          (str('//') >> str('/').absent? >>
+            space? >>
+            (str('tag') | str('end')).as(:prefix) >>
+            str('::') >> str(':').absent? >>
+            match('[^\[]').repeat(1).as(:name) >>
+            attribute_list >>
+            line_ending.maybe.as(:line_break)
+          ).as(:tag)
+        end
+
+        def comment_block
+          (str('////') >> line_ending >>
+          ((line_ending >> str('////')).absent? >> any
+          ).repeat.as(:comment_text) >>
+          line_ending >> str('////')
+          ).as(:comment_block)
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/parser.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Parser
+      autoload :Base, "#{__dir__}/parser/base"
+      autoload :Cache, "#{__dir__}/parser/cache"
+    end
+  end
+end

data/lib/coradoc/asciidoc/serializer/adoc_serializer.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+# Autoload FallbackSerializer - only needed when no registered serializer is found
+autoload :FallbackSerializer, 'coradoc/asciidoc/serializer/fallback_serializer'
+
+module Coradoc
+  module AsciiDoc
+    module Serializer
+      # Main orchestrator for serializing Coradoc models to AsciiDoc format.
+      # Dispatches to appropriate serializer via ElementRegistry.
+      #
+      # This class is ONLY responsible for orchestration and dispatch.
+      # Element registration is handled by ElementRegistry.
+      class AdocSerializer
+        class << self
+          # Serialize a Coradoc model to AsciiDoc string
+          # @param model [Coradoc::AsciiDoc::Model::Base, Array, String] Model to serialize
+          # @param options [Hash] Serialization options
+          # @return [String] AsciiDoc representation
+          def serialize(model, options = {})
+            case model
+            when nil
+              ''
+            when String
+              model
+            when Array
+              serialize_array(model, options)
+            when Coradoc::AsciiDoc::Model::Base
+              serialize_model(model, options)
+            when Lutaml::Model::Serializable
+              raise ArgumentError,
+                    "Cannot serialize #{model.class.name} to AsciiDoc. " \
+                    'Expected a Coradoc::AsciiDoc::Model::Base with a registered serializer.'
+            else
+              raise ArgumentError,
+                    "Unknown element type for AsciiDoc serialization: #{model.class}. " \
+                    'Expected String, Array, or Coradoc::AsciiDoc::Model::Base.'
+            end
+          end
+
+          # Get appropriate serializer instance for a model
+          # @param model [Coradoc::AsciiDoc::Model::Base] Model to serialize
+          # @return [Serializers::Base] Serializer instance
+          def serializer_for(model)
+            # Try to find registered serializer
+            if ElementRegistry.registered?(model.class)
+              serializer_class = ElementRegistry.lookup(model.class)
+              return serializer_class.new
+            end
+
+            # Fallback: use FallbackSerializer which raises a clear error
+            return FallbackSerializer.new
+
+            raise ArgumentError, "No serializer registered for #{model.class.name} and model doesn't respond to to_adoc"
+          end
+
+          private
+
+          # Serialize an array of models
+          # @param models [Array] Array of models
+          # @param options [Hash] Serialization options
+          # @return [String] Serialized array
+          def serialize_array(models, options = {})
+            results = models.map { |model| serialize(model, options) }
+
+            # Apply spacing if needed
+            if options[:apply_spacing]
+              SpacingStrategy.apply(models.zip(results).map(&:first), options)
+            else
+              results.join
+            end
+          end
+
+          # Serialize a single model
+          # @param model [Coradoc::AsciiDoc::Model::Base] Model to serialize
+          # @param options [Hash] Serialization options
+          # @return [String] Serialized model
+          def serialize_model(model, options = {})
+            serializer = serializer_for(model)
+            serializer.serialize(model, options)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/serializer/element_registry.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Serializer
+      # Registry for mapping Coradoc model classes to their AsciiDoc serializers.
+      # This is the authoritative source for model→serializer mappings.
+      #
+      # Pattern mirrors Input::Html::Converters registry for symmetry.
+      #
+      # @example Registering a custom serializer
+      #   ElementRegistry.override(Model::Paragraph, CustomParagraphSerializer)
+      #
+      # @example Wrapping an existing serializer
+      #   original = ElementRegistry.get(Model::Paragraph)
+      #   ElementRegistry.override(Model::Paragraph, WrapperSerializer.new(original))
+      class ElementRegistry
+        class << self
+          # Register a serializer for a model class
+          # @param model_class [Class] The Coradoc model class
+          # @param serializer_class [Class] The serializer class
+          def register(model_class, serializer_class)
+            registry[model_class] = serializer_class
+          end
+
+          # Override a serializer for a model class
+          # This is an alias for register that makes the intent explicit
+          # @param model_class [Class] The Coradoc model class
+          # @param serializer_class [Class] The new serializer class
+          # @return [Class, nil] The previous serializer class, or nil if none
+          def override(model_class, serializer_class)
+            previous = registry[model_class]
+            registry[model_class] = serializer_class
+            previous
+          end
+
+          # Unregister a serializer for a model class
+          # @param model_class [Class] The model class to unregister
+          # @return [Class, nil] The removed serializer class, or nil if none
+          def unregister(model_class)
+            registry.delete(model_class)
+          end
+
+          # Get the serializer for a model class without raising
+          # @param model_class [Class] The model class
+          # @return [Class, nil] The serializer class, or nil if not registered
+          def get(model_class)
+            registry[model_class]
+          end
+
+          # Lookup serializer for a model class
+          # @param model_class [Class] The model class
+          # @return [Class] The serializer class
+          # @raise [ArgumentError] If no serializer is registered
+          def lookup(model_class)
+            serializer_class = registry[model_class]
+
+            unless serializer_class
+              raise ArgumentError,
+                    "No serializer registered for #{model_class.name}. " \
+                    'Please register a serializer in ElementRegistry, or the serializer ' \
+                    'may not have been loaded yet (check Registrations.load_all!)'
+            end
+
+            serializer_class
+          end
+
+          # Get all registered model classes
+          # @return [Array<Class>] Array of registered model classes
+          def registered_models
+            registry.keys
+          end
+
+          # Check if a model class has a registered serializer
+          # @param model_class [Class] The model class
+          # @return [Boolean] True if registered
+          def registered?(model_class)
+            registry.key?(model_class)
+          end
+
+          # Clear all registrations (mainly for testing)
+          def clear!
+            registry.clear
+          end
+
+          # Get the registry hash
+          # @return [Hash] Model class => Serializer class mapping
+          def registry
+            @@registry ||= {}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/serializer/fallback_serializer.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Serializer
+      # Fallback serializer for models that don't have explicit serializers.
+      #
+      # NOTE: This serializer does NOT call to_adoc on the model to avoid
+      # infinite recursion (model.to_adoc → Serializer.serialize → FallbackSerializer → model.to_adoc).
+      # Instead, it raises a clear error indicating the serializer is missing.
+      class FallbackSerializer
+        def serialize(model, _options = {})
+          raise ArgumentError,
+                "No serializer registered for #{model.class.name}. " \
+                'Please register a serializer in ElementRegistry, or the serializer ' \
+                'may not have been loaded yet (check Registrations.load_all!)'
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/serializer/formatter.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Serializer
+      # Handles AsciiDoc-specific formatting for attributes and special structures
+      class Formatter
+        class << self
+          # Format an attribute list for AsciiDoc output
+          # @param attrs [Coradoc::AsciiDoc::Model::AttributeList] Attribute list
+          # @return [String] Formatted attribute list
+          def attribute_list(attrs)
+            return '' if attrs.nil?
+
+            attrs.to_s
+          end
+
+          # Format block attributes (anchor, role, options, etc.)
+          # @param attrs [Hash, Coradoc::AsciiDoc::Model::AttributeList] Block attributes
+          # @return [String] Formatted block attributes
+          def block_attributes(attrs)
+            return '' if attrs.nil?
+            return '' if attrs.is_a?(String) && attrs.empty?
+            return '' if attrs.is_a?(Hash) && attrs.empty?
+
+            # If it's an AttributeList model, use its serialization
+            return attribute_list(attrs) if attrs.is_a?(Coradoc::AsciiDoc::Model::AttributeList)
+
+            # Otherwise format as hash
+            lines = []
+
+            # Handle anchor if present
+            if attrs[:id] || attrs['id']
+              id = attrs[:id] || attrs['id']
+              lines << "[[#{id}]]"
+            end
+
+            # Handle other attributes
+            attr_parts = []
+            attrs.each do |key, value|
+              next if [:id, 'id'].include?(key)
+
+              attr_parts << case key
+                            when :role, 'role'
+                              ".#{value}"
+                            when :options, 'options'
+                              "[#{value}]"
+                            else
+                              "#{key}=#{value}"
+                            end
+            end
+
+            lines << "[#{attr_parts.join(',')}]" unless attr_parts.empty?
+            lines.join("\n")
+          end
+
+          # Format a section heading
+          # @param level [Integer] Section level (1-6)
+          # @param title [String] Section title
+          # @param id [String, nil] Optional section ID
+          # @return [String] Formatted section heading
+          def section_heading(level, title, id = nil)
+            prefix = '=' * level
+            anchor = id ? "[[#{id}]]\n" : ''
+            "#{anchor}#{prefix} #{title}"
+          end
+
+          # Format a block delimiter
+          # @param type [Symbol] Block type (:example, :sidebar, :quote, etc.)
+          # @return [String] Block delimiter
+          def block_delimiter(type)
+            case type
+            when :example
+              '===='
+            when :sidebar
+              '****'
+            when :quote
+              '____'
+            when :listing, :literal
+              '----'
+            when :passthrough
+              '++++'
+            else
+              '----'
+            end
+          end
+
+          # Format an admonition
+          # @param type [String] Admonition type (NOTE, TIP, etc.)
+          # @param content [String] Admonition content
+          # @return [String] Formatted admonition
+          def admonition(type, content)
+            "#{type.upcase}: #{content}"
+          end
+
+          # Format a list marker
+          # @param type [Symbol] List type (:ordered, :unordered, :definition)
+          # @param level [Integer] Nesting level
+          # @param index [Integer, nil] Item index for ordered lists
+          # @return [String] List marker
+          def list_marker(type, level = 1, _index = nil)
+            case type
+            when :ordered
+              "#{'.' * level} "
+            when :unordered
+              "#{'*' * level} "
+            when :definition
+              ''
+            else
+              '* '
+            end
+          end
+
+          # Escape special AsciiDoc characters in text
+          # Works by prepending a backslash to all delimiter characters
+          # in the string that are adjacent to a whitespace.
+          # @param text [String] Text to escape
+          # @param escape_chars [Array<String>] Characters to escape by prepending backslash
+          # @param pass_through [Array<String>] Characters to pass through using pass:[] macro
+          # @return [String] Escaped text
+          def escape_text(text, escape_chars: [], pass_through: [])
+            return '' if text.nil?
+
+            result = text.to_s.dup
+
+            regex_chars = Regexp.escape(escape_chars.join)
+            unless regex_chars.empty?
+              result.gsub!(
+                /((?<=\s)[#{regex_chars}]+)|([#{regex_chars}]+(?=\s))/
+              ) do |match|
+                match.chars.map { |c| "\\#{c}" }.join
+              end
+            end
+
+            regex_pass = Regexp.escape(pass_through.join)
+            result.gsub!(/([#{regex_pass}]+)/, '{pass:[\\1]}') unless regex_pass.empty?
+
+            result
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/serializer/registrations.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Serializer
+      # Trigger loading of all serializer registrations
+      #
+      # Each serializer file self-registers when loaded via autoload.
+      # This module triggers the autoload of all serializers by accessing
+      # their constants, which causes the registration code in each file to execute.
+      module Registrations
+        class << self
+          # Load all serializers to trigger their registration
+          # rubocop:disable Lint/Void - Constants are referenced to trigger autoload
+          def load_all!
+            # Top-level serializers
+            Serializers::Base
+            Serializers::Admonition
+            Serializers::Attribute
+            Serializers::AttributeList
+            Serializers::AttributeListAttribute
+            Serializers::Audio
+            Serializers::Author
+            Serializers::Bibliography
+            Serializers::BibliographyEntry
+            Serializers::Break
+            Serializers::CommentBlock
+            Serializers::CommentLine
+            Serializers::Document
+            Serializers::DocumentAttributes
+            Serializers::Header
+            Serializers::Highlight
+            Serializers::Include
+            Serializers::LineBreak
+            Serializers::List
+            Serializers::NamedAttribute
+            Serializers::Paragraph
+            Serializers::ReviewerNote
+            Serializers::Revision
+            Serializers::Section
+            Serializers::Tag
+            Serializers::TableCell
+            Serializers::TableRow
+            Serializers::Table
+            Serializers::Term
+            Serializers::TextElement
+            Serializers::Title
+            Serializers::Video
+
+            # Block serializers
+            Serializers::Block
+            Serializers::Block::Core
+            Serializers::Block::Example
+            Serializers::Block::Listing
+            Serializers::Block::Literal
+            Serializers::Block::Open
+            Serializers::Block::Pass
+            Serializers::Block::Quote
+            Serializers::Block::ReviewerComment
+            Serializers::Block::Side
+            Serializers::Block::SourceCode
+
+            # Image serializers
+            Serializers::Image
+            Serializers::Image::Core
+
+            # Inline serializers
+            Serializers::Inline
+            Serializers::Inline::Anchor
+            Serializers::Inline::AttributeReference
+            Serializers::Inline::Bold
+            Serializers::Inline::CrossReference
+            Serializers::Inline::CrossReferenceArg
+            Serializers::Inline::Footnote
+            Serializers::Inline::HardLineBreak
+            Serializers::Inline::Highlight
+            Serializers::Inline::Italic
+            Serializers::Inline::Link
+            Serializers::Inline::Monospace
+            Serializers::Inline::Quotation
+            Serializers::Inline::Small
+            Serializers::Inline::Span
+            Serializers::Inline::Stem
+            Serializers::Inline::Strikethrough
+            Serializers::Inline::Subscript
+            Serializers::Inline::Superscript
+            Serializers::Inline::Underline
+
+            # List serializers
+            Serializers::List
+            Serializers::List::Core
+            Serializers::List::Definition
+            Serializers::List::DefinitionItem
+            Serializers::List::Item
+            Serializers::List::Ordered
+            Serializers::List::Unordered
+
+            true
+          end
+          # rubocop:enable Lint/Void
+        end
+
+        # Auto-load all on module inclusion
+        load_all!
+      end
+    end
+  end
+end