coradoc-adoc 2.0.0

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

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Serializer
+      # Context object passed through serialization pipeline
+      #
+      # Provides a type-safe, extensible way to pass serialization state
+      # through the document tree, replacing the opaque options hash.
+      #
+      # @example Create a context
+      #   context = SerializationContext.new(
+      #     format: :adoc,
+      #     last_element: false,
+      #     depth: 0
+      #   )
+      #
+      # @example Create context for a child
+      #   child_context = context.for_child(0, 3)
+      #
+      # @example Add custom option
+      #   context_with_option = context.with_option(:preserve_whitespace, true)
+      #
+      class SerializationContext
+        # Output format (:adoc, :html, :xml, etc.)
+        #
+        # @return [Symbol] the output format
+        attr_reader :format
+
+        # Whether this is the last element in its container
+        # Used to control trailing newlines and spacing
+        #
+        # @return [Boolean] true if last element
+        attr_reader :last_element
+
+        # Nesting depth in the document tree
+        # Can be used for indentation or formatting decisions
+        #
+        # @return [Integer] current depth
+        attr_reader :depth
+
+        # Parent context (if any)
+        # Allows traversing up the context chain
+        #
+        # @return [SerializationContext, nil] parent context
+        attr_reader :parent
+
+        # Additional options hash for extension
+        # Provides backward compatibility and extensibility
+        #
+        # @return [Hash] additional options
+        attr_reader :options
+
+        # Create a new serialization context
+        #
+        # @param format [Symbol] Output format
+        # @param last_element [Boolean] Whether this is the last element
+        # @param depth [Integer] Nesting depth
+        # @param parent [SerializationContext, nil] Parent context
+        # @param options [Hash] Additional options
+        def initialize(format: :adoc, last_element: false, depth: 0,
+                       parent: nil, options: {})
+          @format = format
+          @last_element = last_element
+          @depth = depth
+          @parent = parent
+          @options = options.freeze
+          freeze
+        end
+
+        # Create a context for a child element
+        #
+        # Automatically adjusts depth and calculates last_element
+        # based on the child's position.
+        #
+        # @param child_index [Integer] Index of this child (0-based)
+        # @param total_children [Integer] Total number of children
+        # @return [SerializationContext] Context for the child
+        #
+        # @example
+        #   children.each_with_index do |child, i|
+        #     serialize(child, context.for_child(i, children.length))
+        #   end
+        def for_child(child_index, total_children)
+          SerializationContext.new(
+            format: format,
+            last_element: child_index == total_children - 1,
+            depth: depth + 1,
+            parent: self,
+            options: options
+          )
+        end
+
+        # Create a context with an additional option
+        #
+        # Returns a new context with the option added to the options hash.
+        # Does not mutate the original context.
+        #
+        # @param key [Symbol] Option key
+        # @param value [Object] Option value
+        # @return [SerializationContext] New context with the option
+        #
+        # @example Add a custom option
+        #   context.with_option(:preserve_whitespace, true)
+        def with_option(key, value)
+          SerializationContext.new(
+            format: format,
+            last_element: last_element,
+            depth: depth,
+            parent: parent,
+            options: options.merge(key => value)
+          )
+        end
+
+        # Create a context for a different format
+        #
+        # @param new_format [Symbol] New format
+        # @return [SerializationContext] Context with new format
+        #
+        # @example Switch to HTML format
+        #   html_context = context.with_format(:html)
+        def with_format(new_format)
+          SerializationContext.new(
+            format: new_format,
+            last_element: last_element,
+            depth: depth,
+            parent: parent,
+            options: options
+          )
+        end
+
+        # Create a context with last_element set to true
+        #
+        # @return [SerializationContext] Context as last element
+        def as_last_element
+          return self if last_element
+
+          SerializationContext.new(
+            format: format,
+            last_element: true,
+            depth: depth,
+            parent: parent,
+            options: options
+          )
+        end
+
+        # Check if we're inside a table cell
+        #
+        # Traverses up the parent chain to detect table context.
+        #
+        # @return [Boolean] true if in a table cell
+        #
+        # @example
+        #   if context.in_table_cell?
+        #     # Don't add block-level spacing
+        #   end
+        def in_table_cell?
+          return false unless parent
+
+          # Check if any ancestor is a table
+          current = parent
+          while current
+            return true if current.options[:in_table] == true
+
+            current = current.parent
+          end
+          false
+        end
+
+        # Get an option value
+        #
+        # @param key [Symbol] Option key
+        # @param default [Object] Default value if not found
+        # @return [Object] Option value or default
+        #
+        # @example
+        #   preserve = context.option(:preserve_whitespace, false)
+        def option(key, default = nil)
+          options.fetch(key, default)
+        end
+
+        # Check if an option is present
+        #
+        # @param key [Symbol] Option key
+        # @return [Boolean] true if option exists
+        def has_option?(key)
+          options.key?(key)
+        end
+
+        # Check if this is the root context (no parent)
+        #
+        # @return [Boolean] true if root
+        def root?
+          parent.nil?
+        end
+
+        # Create a root context for a new serialization
+        #
+        # @param format [Symbol] Output format
+        # @param options [Hash] Additional options
+        # @return [SerializationContext] Root context
+        #
+        # @example
+        #   context = SerializationContext.root(format: :adoc)
+        def self.root(format: :adoc, options: {})
+          new(format: format, last_element: false, depth: 0, parent: nil, options: options)
+        end
+
+        # Backward compatibility: convert options hash to context
+        #
+        # @param options_or_context [Hash, SerializationContext] Options or context
+        # @return [SerializationContext] Serialization context
+        #
+        # @example Convert options hash
+        #   context = SerializationContext.from_options(last_element: true)
+        def self.from_options(options_or_context)
+          return options_or_context if options_or_context.is_a?(SerializationContext)
+
+          new(
+            format: options_or_context.fetch(:format, :adoc),
+            last_element: options_or_context.fetch(:last_element, false),
+            depth: options_or_context.fetch(:depth, 0),
+            parent: nil,
+            options: options_or_context
+          )
+        end
+
+        # String representation for debugging
+        #
+        # @return [String] Debug string
+        def inspect
+          "#<#{self.class.name} format=#{format} last_element=#{last_element} depth=#{depth}>"
+        end
+        alias to_s inspect
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/serializer/serializers/admonition.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Serializer
+      module Serializers
+        class Admonition < Base
+          def to_adoc(model, _options = {})
+            _content = serialize_children(model.content).to_s.strip
+            "#{model.type.to_s.upcase}: #{_content}#{model.line_break}"
+          end
+        end
+      end
+
+      # Self-register this serializer
+      ElementRegistry.register(Coradoc::AsciiDoc::Model::Admonition, Serializers::Admonition)
+    end
+  end
+end

data/lib/coradoc/asciidoc/serializer/serializers/attribute.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Serializer
+      module Serializers
+        class Attribute < Base
+          # Pre-compiled regex for performance
+          QUOTE_REGEX = /^'|'$/
+
+          def to_adoc(model, _options = {})
+            _value = model.value.to_s.gsub(QUOTE_REGEX, '') # Remove surrounding single quotes
+            v = _value.empty? ? '' : " #{_value}"
+            ":#{model.key}:#{v}#{model.line_break}"
+          end
+        end
+      end
+
+      # Self-register this serializer (in Adoc module scope)
+      ElementRegistry.register(Coradoc::AsciiDoc::Model::Attribute, Serializers::Attribute)
+    end
+  end
+end

data/lib/coradoc/asciidoc/serializer/serializers/attribute_list.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Serializer
+      module Serializers
+        class AttributeList < Base
+          def to_adoc(model, options_or_context = {})
+            context = normalize_context(options_or_context)
+            show_empty = context.option(:show_empty, true)
+
+            valid_positional = model.positional.reject.with_index do |_p, i|
+              model.rejected_positional.any? { |r| r.position == i }
+            end
+
+            valid_named = model.named.reject do |n|
+              model.rejected_named.any? { |r| r.name == n.name }
+            end
+
+            adoc = [valid_positional,
+                    valid_named].flatten.map { |a| serialize_child(a, context) }.join(',')
+
+            if adoc.empty? && show_empty
+              '[]'
+            elsif adoc.empty?
+              ''
+            else
+              "[#{adoc}]"
+            end
+          end
+        end
+      end
+
+      # Self-register this serializer
+      ElementRegistry.register(Coradoc::AsciiDoc::Model::AttributeList, Serializers::AttributeList)
+      # Also register for Image::Core::AttributeList which inherits from AttributeList
+      ElementRegistry.register(Coradoc::AsciiDoc::Model::Image::Core::AttributeList, Serializers::AttributeList)
+    end
+  end
+end

data/lib/coradoc/asciidoc/serializer/serializers/attribute_list_attribute.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Serializer
+      module Serializers
+        class AttributeListAttribute < Base
+          def to_adoc(model, _options = {})
+            [nil, ''].include?(model.value) ? '""' : model.value
+          end
+        end
+      end
+
+      # Self-register this serializer
+      ElementRegistry.register(Coradoc::AsciiDoc::Model::AttributeListAttribute, Serializers::AttributeListAttribute)
+    end
+  end
+end

data/lib/coradoc/asciidoc/serializer/serializers/audio.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Serializer
+      module Serializers
+        class Audio < Base
+          def to_adoc(model, _options = {})
+            @model = model
+            _anchor = gen_anchor
+            _title = model.title.nil? || model.title.empty? ? '' : ".#{model.title}\n"
+            _attrs = model.attributes.empty? ? '[]' : model.attributes.to_adoc
+            [_anchor, _title, 'audio::', model.src, _attrs].join + model.line_break
+          end
+
+          private
+
+          attr_reader :model
+
+          def gen_anchor
+            return '' unless @model.anchor
+
+            anchor_str = @model.anchor.to_adoc
+            anchor_str.empty? ? '' : "#{anchor_str}\n"
+          end
+        end
+      end
+
+      # Self-register this serializer
+      ElementRegistry.register(Coradoc::AsciiDoc::Model::Audio, Serializers::Audio)
+    end
+  end
+end

data/lib/coradoc/asciidoc/serializer/serializers/author.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Serializer
+      module Serializers
+        class Author < Base
+          def to_adoc(model, _options = {})
+            adoc = [model.first_name, model.middle_name, model.last_name].compact.join(' ')
+            adoc << " <#{model.email}>\n" if model.email
+            adoc
+          end
+        end
+      end
+
+      # Self-register this serializer
+      ElementRegistry.register(Coradoc::AsciiDoc::Model::Author, Serializers::Author)
+    end
+  end
+end

data/lib/coradoc/asciidoc/serializer/serializers/base.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require 'coradoc/asciidoc/serializer/serialization_context'
+
+module Coradoc
+  module AsciiDoc
+    module Serializer
+      module Serializers
+        # Base serializer class for converting Coradoc models to AsciiDoc format.
+        # Provides common serialization infrastructure and helpers.
+        # Each model type should have its own serializer that inherits from this.
+        class Base
+          # Serialize a Coradoc model to AsciiDoc string
+          # @param model [Coradoc::AsciiDoc::Model::Base] The model to serialize
+          # @param options_or_context [Hash, SerializationContext] Options or context
+          # @return [String] AsciiDoc representation
+          def serialize(model, options_or_context = {})
+            return '' if model.nil?
+
+            context = SerializationContext.from_options(options_or_context)
+            to_adoc(model, context)
+          end
+
+          # Abstract method to be implemented by subclasses
+          # @param model [Coradoc::AsciiDoc::Model::Base] The model to convert
+          # @param options_or_context [Hash, SerializationContext] Options or context
+          # @return [String] AsciiDoc representation
+          def to_adoc(_model, options_or_context = {})
+            SerializationContext.from_options(options_or_context)
+            raise NotImplementedError,
+                  "#{self.class.name} must implement #to_adoc"
+          end
+
+          protected
+
+          # Normalize options_or_context to SerializationContext
+          # @param options_or_context [Hash, SerializationContext] Options or context
+          # @return [SerializationContext] Serialization context
+          def normalize_context(options_or_context)
+            SerializationContext.from_options(options_or_context)
+          end
+
+          # Serialize child elements of a model
+          # @param children [Array, Object] Child elements to serialize
+          # @param options_or_context [Hash, SerializationContext] Options or context
+          # @return [String] Serialized children
+          def serialize_children(children, options_or_context = {})
+            context = normalize_context(options_or_context)
+
+            case children
+            when Array
+              return '' if children.empty?
+
+              # Mark the last child as the last element for proper spacing
+              children.each_with_index.map do |child, index|
+                child_context = context.for_child(index, children.length)
+                serialize_child(child, child_context)
+              end.join
+            when nil
+              ''
+            else
+              serialize_child(children, context)
+            end
+          end
+
+          # Serialize a single child element
+          # @param child [Object] Child element to serialize
+          # @param options_or_context [Hash, SerializationContext] Options or context
+          # @return [String] Serialized child
+          def serialize_child(child, options_or_context = {})
+            return '' if child.nil?
+
+            context = normalize_context(options_or_context)
+
+            case child
+            when String
+              child
+            when Coradoc::AsciiDoc::Model::Base
+              # Use AdocSerializer for all Coradoc models
+              AdocSerializer.serialize(child, context)
+            when Lutaml::Model::Serializable
+              # Handle Lutaml::Model::Serializable objects (like CrossReference, Term)
+              # These are model objects that need proper serialization
+              AdocSerializer.serialize(child, context)
+            when Proc
+              child.call
+            else
+              # This is a programming error - we received an unexpected type
+              raise ArgumentError,
+                    "Cannot serialize child of type #{child.class.name}. " \
+                    'Expected String, Coradoc::AsciiDoc::Model::Base, ' \
+                    'Lutaml::Model::Serializable, or Proc. ' \
+                    "Got: #{child.inspect[0..100]}"
+            end
+          end
+
+          # Preserve model structure during serialization (recursive)
+          # This method handles nested inline models by recursively serializing
+          # them, unlike serialize_children which flattens to strings.
+          # @param content [Array, String, Object] Content to serialize
+          # @return [String] Serialized content with structure preserved
+          def serialize_content(content)
+            case content
+            when Array
+              content.map { |elem| serialize_content(elem) }.join
+            when String
+              content
+            when nil
+              ''
+            else
+              # Try AdocSerializer for Lutaml models
+              if content.is_a?(Lutaml::Model::Serializable) || content.is_a?(Coradoc::AsciiDoc::Model::Base)
+                AdocSerializer.serialize(content)
+              else
+                raise ArgumentError,
+                      "Cannot serialize content of type #{content.class.name}. " \
+                      'Expected String, nil, Array, or serializable object. ' \
+                      "Got: #{content.inspect[0..100]}"
+              end
+            end
+          end
+
+          # Helper to add spacing between elements
+          # @param elements [Array] Elements to space
+          # @param options [Hash] Spacing options
+          # @return [String] Elements with spacing
+          def add_spacing(elements, options = {})
+            SpacingStrategy.apply(elements, options)
+          end
+
+          # Helper to format attribute list
+          # @param attrs [Coradoc::AsciiDoc::Model::AttributeList] Attribute list
+          # @return [String] Formatted attribute list
+          def format_attribute_list(attrs)
+            return '' if attrs.nil?
+
+            Formatter.attribute_list(attrs)
+          end
+
+          # Helper to format block attributes
+          # @param model [Coradoc::AsciiDoc::Model::Base] Model with attributes
+          # @return [String] Formatted block attributes
+          def format_block_attributes(model)
+            return '' unless model.is_a?(Lutaml::Model::Serializable) && model.attributes
+
+            Formatter.block_attributes(model.attributes)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/serializer/serializers/bibliography.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Serializer
+      module Serializers
+        class Bibliography < Base
+          def to_adoc(model, _options = {})
+            @model = model
+            adoc = "#{gen_anchor}\n"
+            adoc << '[bibliography]'
+            adoc << "== #{model.title}\n\n"
+            model.entries&.each do |entry|
+              adoc << "#{entry.to_adoc}\n"
+            end
+            adoc
+          end
+
+          private
+
+          attr_reader :model
+
+          def gen_anchor
+            return '' unless @model.anchor
+
+            @model.anchor.to_adoc
+          end
+        end
+      end
+
+      # Self-register this serializer
+      ElementRegistry.register(Coradoc::AsciiDoc::Model::Bibliography, Serializers::Bibliography)
+    end
+  end
+end

data/lib/coradoc/asciidoc/serializer/serializers/bibliography_entry.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Serializer
+      module Serializers
+        class BibliographyEntry < Base
+          def to_adoc(model, _options = {})
+            text = serialize_children(model.ref_text) if model.ref_text
+            adoc = "* [[[#{model.anchor_name}"
+            adoc << ",#{model.document_id}" if model.document_id
+            adoc << ']]]'
+            adoc << text.to_s if model.ref_text
+            adoc << (model.line_break || "\n")
+            adoc
+          end
+        end
+      end
+
+      # Self-register this serializer
+      ElementRegistry.register(Coradoc::AsciiDoc::Model::BibliographyEntry, Serializers::BibliographyEntry)
+    end
+  end
+end

data/lib/coradoc/asciidoc/serializer/serializers/block/core.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Serializer
+      module Serializers
+        module Block
+          class Core < Base
+            def to_adoc(model, _options = {})
+              @model = model
+              "\n\n#{gen_anchor}#{gen_title}#{gen_attributes}#{gen_delimiter}\n" <<
+                gen_lines << "\n#{gen_delimiter}\n\n"
+            end
+
+            private
+
+            attr_reader :model
+
+            def gen_title
+              t = serialize_children(model.title)
+              return '' if t.nil? || t.empty?
+
+              ".#{t}\n"
+            end
+
+            def gen_attributes
+              return '' if model.attributes.nil?
+
+              attrs = model.attributes.to_adoc(show_empty: false)
+              return "#{attrs}\n" unless attrs.empty?
+
+              ''
+            end
+
+            def gen_delimiter
+              return '' if model.delimiter_char.nil? || model.delimiter_len.nil?
+
+              model.delimiter_char.to_s * model.delimiter_len
+            end
+
+            def gen_lines
+              # Handle both String and model object lines
+              result = model.lines.map do |line|
+                serialized = serialize_child(line)
+                # Add newline if line is a plain string without one
+                serialized.is_a?(String) && !serialized.end_with?("\n") ? "#{serialized}\n" : serialized
+              end.join
+              # Remove trailing newline to avoid extra blank line before delimiter
+              result.chomp
+            end
+
+            def gen_anchor
+              return '' unless @model.anchor
+
+              anchor_str = if @model.anchor.is_a?(Coradoc::AsciiDoc::Model::Base)
+                             @model.anchor.to_adoc
+                           else
+                             @model.anchor.to_s
+                           end
+              "#{anchor_str}\n"
+            end
+          end
+        end
+
+        # Self-register this serializer
+        ElementRegistry.register(Coradoc::AsciiDoc::Model::Block::Core, Block::Core)
+      end
+    end
+  end
+end