coradoc-adoc 2.0.0

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Serializer
+      module Serializers
+        class NamedAttribute < Base
+          def to_adoc(model, _options = {})
+            if model.value.length == 1
+              "#{model.name}=#{model.value.first}"
+            else
+              "#{model.name}=\"#{model.value.join(' ')}\""
+            end
+          end
+        end
+      end
+
+      # Self-register this serializer
+      ElementRegistry.register(Coradoc::AsciiDoc::Model::NamedAttribute, Serializers::NamedAttribute)
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Serializer
+      module Serializers
+        # Serializer for Paragraph models
+        class Paragraph < Base
+          def to_adoc(model, options_or_context = {})
+            context = normalize_context(options_or_context)
+
+            _title = model.title.nil? ? '' : ".#{serialize_child(model.title, context)}\n"
+            _anchor = gen_anchor(model, context)
+            attrs = if model.attributes.nil? || model.attributes.empty?
+                      ''
+                    else
+                      "#{AdocSerializer.serialize(
+                        model.attributes, context
+                      )}\n"
+                    end
+
+            result = if model.tdsinglepara
+                       "#{_title}#{_anchor}" <<
+                         serialize_content(model.content)
+                     else
+                       "#{_title}#{_anchor}#{attrs}" <<
+                         serialize_content(model.content)
+                     end
+
+            # Ensure paragraph ends with blank line for proper separation
+            # unless this is the last element in a document (determined by context)
+            # But not for tdsinglepara (table cell single paragraph)
+            unless model.tdsinglepara || context.last_element
+              if model.trailing_newlines.nil?
+                # Semantic mode: Use default "\n\n" ending
+                result = "#{result.chomp}\n\n" unless result.end_with?("\n\n")
+              else
+                # Exact mode: Use captured trailing newlines from original
+                result += model.trailing_newlines
+              end
+            end
+
+            result
+          end
+
+          private
+
+          def gen_anchor(model, context)
+            return '' if model.anchor.nil? || model.id.nil? || model.id.empty?
+
+            anchor_str = AdocSerializer.serialize(model.anchor, context)
+            if anchor_str.empty?
+              ''
+            else
+              "#{anchor_str}\n"
+            end
+          end
+        end
+      end
+
+      # Self-register this serializer
+      ElementRegistry.register(Coradoc::AsciiDoc::Model::Paragraph, Serializers::Paragraph)
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Serializer
+      module Serializers
+        class ReviewerNote < Base
+          def to_adoc(model, _options = {})
+            attrs = []
+            attrs << "reviewer=#{model.reviewer}" if model.reviewer
+            attrs << "date=#{model.date}" if model.date
+            attrs << "from=#{model.from}" if model.from
+            attrs << "to=#{model.to}" if model.to
+
+            result = "[#{attrs.join(',')}]\n"
+            result += "****\n"
+            result += serialize_children(model.content) if model.content
+            result += "****\n"
+            result
+          end
+        end
+      end
+
+      # Self-register this serializer
+      ElementRegistry.register(Coradoc::AsciiDoc::Model::ReviewerNote, Serializers::ReviewerNote)
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Serializer
+      module Serializers
+        class Revision < Base
+          def to_adoc(model, _options = {})
+            if model.date.nil? && model.remark.nil?
+              "v#{model.number}\n"
+            elsif model.remark.nil?
+              "#{model.number}, #{model.date}\n"
+            elsif model.date.nil?
+              "#{model.number}: #{model.remark}\n"
+            else
+              "#{model.number}, #{model.date}: #{model.remark}\n"
+            end
+          end
+        end
+      end
+
+      # Self-register this serializer
+      ElementRegistry.register(Coradoc::AsciiDoc::Model::Revision, Serializers::Revision)
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Serializer
+      module Serializers
+        class Section < Base
+          def to_adoc(model, options_or_context = {})
+            context = normalize_context(options_or_context)
+            parts = []
+
+            parts << "\n"
+            parts << "#{serialize_child(model.anchor, context)}\n" if model.anchor
+            parts << "#{model.attrs.map { |a| serialize_child(a, context) }.join(',')}\n" unless model.attrs.empty?
+            parts << serialize_child(model.title, context) if model.title
+
+            # Process contents
+            content_str = serialize_children(model.contents, context)
+
+            # A block of " +\n"s isn't parsed correctly. It needs to start
+            # with something.
+            content_str = "&nbsp;#{content_str}" if content_str.start_with?(" +\n")
+
+            parts << content_str
+            parts << serialize_children(model.sections, context)
+            parts << "\n"
+
+            parts.join
+          end
+        end
+      end
+
+      # Self-register this serializer
+      ElementRegistry.register(Coradoc::AsciiDoc::Model::Section, Serializers::Section)
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Serializer
+      module Serializers
+        class Table < Base
+          def to_adoc(model, _options = {})
+            @model = model
+            _anchor = @model.anchor.nil? ? '' : "#{serialize_child(@model.anchor)}\n"
+            _attrs = @model.attrs.to_s.empty? ? '' : "#{serialize_child(@model.attrs)}\n"
+            _title = @model.title.nil? || @model.title.empty? ? '' : ".#{serialize_child(@model.title)}\n"
+            _content = @model.rows.map { |row| serialize_child(row) }.join
+
+            "\n\n#{_anchor}#{_attrs}#{_title}|===\n#{_content}|===\n"
+          end
+        end
+      end
+
+      # Self-register this serializer
+      ElementRegistry.register(Coradoc::AsciiDoc::Model::Table, Serializers::Table)
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Serializer
+      module Serializers
+        class TableCell < Base
+          def to_adoc(model, _options = {})
+            @model = model
+            _anchor = @model.gen_anchor(inline: true)
+
+            # Handle content - if it's a single string, strip unicode; otherwise serialize children
+            if @model.content.is_a?(String)
+              _content = Coradoc.strip_unicode(@model.content) if defined?(Coradoc.strip_unicode)
+              _content ||= @model.content
+            elsif @model.content.is_a?(Array) && @model.content.size == 1 && @model.content.first.is_a?(String)
+              _content = Coradoc.strip_unicode(@model.content.first) if defined?(Coradoc.strip_unicode)
+              _content ||= @model.content.first.to_s
+            else
+              _content = serialize_children(@model.content)
+            end
+
+            # Build format specification: [colspan][.rowspan][halign][valign][style][*]
+            format_spec = build_format_specification
+
+            "#{format_spec}| #{_anchor}#{_content}"
+          end
+
+          private
+
+          # Build AsciiDoc cell format specification
+          # Format: [colspan][.rowspan][halign][valign][style][*]
+          def build_format_specification
+            spec = ''
+
+            # Colspan (digits)
+            spec += @model.colspan.to_s if @model.colspan && @model.colspan > 1
+
+            # Rowspan (.digits)
+            spec += ".#{@model.rowspan}" if @model.rowspan && @model.rowspan > 1
+
+            # Horizontal alignment (< ^ >)
+            spec += @model.halign if @model.halign && %w[< ^ >].include?(@model.halign)
+
+            # Vertical alignment (.< .^ .>)
+            spec += ".#{@model.valign}" if @model.valign && %w[< ^ >].include?(@model.valign)
+
+            # Style (d s e m a l v)
+            spec += @model.style if @model.style && %w[d s e m a l v].include?(@model.style)
+
+            # Repeat marker
+            spec += '*' if @model.repeat
+
+            # Fall back to legacy attributes if new attributes are empty
+            spec = build_legacy_format_spec if spec.empty? && (@model.colrowattr || @model.alignattr || @model.style)
+
+            spec
+          end
+
+          # Build format spec from legacy attributes (backward compatibility)
+          def build_legacy_format_spec
+            spec = ''
+            spec += @model.colrowattr.to_s
+            spec += @model.alignattr.to_s
+            # NOTE: style was included in colrowattr in old format
+            spec
+          end
+        end
+      end
+
+      # Self-register this serializer
+      ElementRegistry.register(Coradoc::AsciiDoc::Model::TableCell, Serializers::TableCell)
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Serializer
+      module Serializers
+        class TableRow < Base
+          def to_adoc(model, _options = {})
+            @model = model
+            delim = @model.asciidoc? ? "\n" : ' '
+            result = "#{@model.columns.map(&:to_adoc).join(delim)}\n"
+
+            # Add extra newline for header or asciidoc rows
+            result += "\n" if @model.header || @model.asciidoc?
+            result
+          end
+        end
+      end
+
+      # Self-register this serializer
+      ElementRegistry.register(Coradoc::AsciiDoc::Model::TableRow, Serializers::TableRow)
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Serializer
+      module Serializers
+        class Tag < Base
+          def to_adoc(model, _options = {})
+            attrs_str = model.attrs.to_adoc unless model.attrs.nil?
+            "// #{model.prefix}::#{model.name}#{attrs_str}#{model.line_break}"
+          end
+        end
+      end
+
+      # Self-register this serializer
+      ElementRegistry.register(Coradoc::AsciiDoc::Model::Tag, Serializers::Tag)
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Serializer
+      module Serializers
+        class Term < Base
+          def to_adoc(model, _options = {})
+            return "#{model.type}:[#{model.term}]#{model.line_break}" if model.lang.to_s == 'en'
+
+            "[#{model.type}]##{model.term}##{model.line_break}"
+          end
+        end
+      end
+
+      # Self-register this serializer
+      ElementRegistry.register(Coradoc::AsciiDoc::Model::Term, Serializers::Term)
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Serializer
+      module Serializers
+        # Serializer for TextElement models
+        class TextElement < Base
+          def to_adoc(model, _options = {})
+            result = ''
+            result += "[[#{model.id}]] " if model.id
+            result += serialize_content(model.content)
+            result += model.line_break.to_s
+            result
+          end
+        end
+      end
+
+      # Self-register this serializer
+      ElementRegistry.register(Coradoc::AsciiDoc::Model::TextElement, Serializers::TextElement)
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Serializer
+      module Serializers
+        class Title < Base
+          def to_adoc(model, options_or_context = {})
+            context = normalize_context(options_or_context)
+            @model = model
+            _anchor = model.anchor.nil? ? '' : "#{serialize_child(model.anchor, context)}\n"
+            _content = serialize_children(model.content, context)
+
+            # For ATX style headings, use # markers
+            if model.style == 'atx'
+              atx_markers = '#' * (model.level_int + 1)
+              "#{_anchor}#{atx_markers} #{_content}#{model.line_break}"
+            else
+              # Default setext style
+              "#{_anchor}#{style_str}#{level_str} #{_content}#{model.line_break}"
+            end
+          end
+
+          private
+
+          def level_str
+            return '' if @model.level_int.nil?
+
+            if @model.level_int <= 5
+              '=' * (@model.level_int + 1)
+            else
+              '======'
+            end
+          end
+
+          def style_str
+            return '' if @model.level_int.nil?
+
+            # Don't include style in output for atx since it's implicit
+            return '' if @model.style == 'atx'
+
+            _style = [@model.style].compact.reject { |s| s == 'atx' }
+            _style << "level=#{@model.level_int}" if @model.level_int > 5
+            _style = _style.join(',')
+
+            _style.empty? ? '' : "[#{_style}]\n"
+          end
+        end
+      end
+
+      # Self-register this serializer
+      ElementRegistry.register(Coradoc::AsciiDoc::Model::Title, Serializers::Title)
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Serializer
+      module Serializers
+        class Video < Base
+          def to_adoc(model, _options = {})
+            @model = model
+            _anchor = gen_anchor
+            _title = model.title.nil? || model.title.empty? ? '' : ".#{model.title}\n"
+            _attrs = model.attributes.to_adoc
+            [_anchor, _title, 'video::', 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::Video, Serializers::Video)
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Serializer
+      # Handles spacing logic for AsciiDoc serialization.
+      # Determines appropriate spacing between different element types.
+      class SpacingStrategy
+        class << self
+          # Apply spacing to elements based on their types
+          # @param elements [Array] Elements to add spacing between
+          # @param options [Hash] Spacing options
+          # @return [String] Elements with appropriate spacing
+          def apply(elements, _options = {})
+            return '' if elements.nil? || elements.empty?
+            return elements.first.to_s if elements.size == 1
+
+            result = []
+            elements.each_with_index do |element, index|
+              result << element.to_s
+
+              # Add spacing between current and next element
+              next unless index < elements.size - 1
+
+              next_element = elements[index + 1]
+              spacing = spacing_between(element, next_element)
+              result << spacing if spacing
+            end
+
+            result.join
+          end
+
+          # Determine spacing between two elements
+          # @param current [Object] Current element
+          # @param next_elem [Object] Next element
+          # @return [String, nil] Spacing string or nil
+          def spacing_between(current, next_elem)
+            # Block-level elements typically need double newline spacing
+            if block_level?(current) && block_level?(next_elem)
+              "\n\n"
+            # Inline elements don't need extra spacing
+            elsif inline_level?(current) && inline_level?(next_elem)
+              nil
+            # Mixed block/inline needs single newline
+            elsif block_level?(current) || block_level?(next_elem)
+              "\n"
+            end
+          end
+
+          def block_level?(element)
+            return false if element.nil?
+            return true if element.is_a?(String)
+
+            element.block_level?
+          end
+
+          # Check if element is inline-level
+          # @param element [Object] Element to check
+          # @return [Boolean] True if inline-level
+          def inline_level?(element)
+            return false if element.nil?
+            return true if element.is_a?(String)
+
+            element.inline?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/serializer.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    # Serializer module for converting AsciiDoc models to AsciiDoc text
+    module Serializer
+      autoload :AdocSerializer, "#{__dir__}/serializer/adoc_serializer"
+      autoload :ElementRegistry, "#{__dir__}/serializer/element_registry"
+      autoload :FallbackSerializer, "#{__dir__}/serializer/fallback_serializer"
+      autoload :Formatter, "#{__dir__}/serializer/formatter"
+      autoload :SpacingStrategy, "#{__dir__}/serializer/spacing_strategy"
+
+      class << self
+        # Serialize a model to AsciiDoc format
+        # @param model [Coradoc::AsciiDoc::Model::Base, Array, String] Model to serialize
+        # @param options [Hash] Serialization options
+        # @return [String] AsciiDoc representation
+        def serialize(model, options = {})
+          AdocSerializer.serialize(model, options)
+        end
+      end
+    end
+  end
+end
+
+# Set up Serializers module with autoloads
+module Coradoc
+  module AsciiDoc
+    module Serializer
+      module Serializers
+        # Autoload core serializers (flat structure)
+        autoload :Base, 'coradoc/asciidoc/serializer/serializers/base'
+        autoload :Admonition, 'coradoc/asciidoc/serializer/serializers/admonition'
+        autoload :Attribute, 'coradoc/asciidoc/serializer/serializers/attribute'
+        autoload :AttributeList, 'coradoc/asciidoc/serializer/serializers/attribute_list'
+        autoload :AttributeListAttribute, 'coradoc/asciidoc/serializer/serializers/attribute_list_attribute'
+        autoload :Audio, 'coradoc/asciidoc/serializer/serializers/audio'
+        autoload :Author, 'coradoc/asciidoc/serializer/serializers/author'
+        autoload :Bibliography, 'coradoc/asciidoc/serializer/serializers/bibliography'
+        autoload :BibliographyEntry, 'coradoc/asciidoc/serializer/serializers/bibliography_entry'
+        autoload :Break, 'coradoc/asciidoc/serializer/serializers/break'
+        autoload :CommentBlock, 'coradoc/asciidoc/serializer/serializers/comment_block'
+        autoload :CommentLine, 'coradoc/asciidoc/serializer/serializers/comment_line'
+        autoload :Document, 'coradoc/asciidoc/serializer/serializers/document'
+        autoload :DocumentAttributes, 'coradoc/asciidoc/serializer/serializers/document_attributes'
+        autoload :Header, 'coradoc/asciidoc/serializer/serializers/header'
+        autoload :Highlight, 'coradoc/asciidoc/serializer/serializers/highlight'
+        autoload :Include, 'coradoc/asciidoc/serializer/serializers/include'
+        autoload :LineBreak, 'coradoc/asciidoc/serializer/serializers/line_break'
+        autoload :NamedAttribute, 'coradoc/asciidoc/serializer/serializers/named_attribute'
+        autoload :Paragraph, 'coradoc/asciidoc/serializer/serializers/paragraph'
+        autoload :ReviewerNote, 'coradoc/asciidoc/serializer/serializers/reviewer_note'
+        autoload :Revision, 'coradoc/asciidoc/serializer/serializers/revision'
+        autoload :Section, 'coradoc/asciidoc/serializer/serializers/section'
+        autoload :Tag, 'coradoc/asciidoc/serializer/serializers/tag'
+        autoload :TableCell, 'coradoc/asciidoc/serializer/serializers/table_cell'
+        autoload :TableRow, 'coradoc/asciidoc/serializer/serializers/table_row'
+        autoload :Table, 'coradoc/asciidoc/serializer/serializers/table'
+        autoload :Term, 'coradoc/asciidoc/serializer/serializers/term'
+        autoload :TextElement, 'coradoc/asciidoc/serializer/serializers/text_element'
+        autoload :Title, 'coradoc/asciidoc/serializer/serializers/title'
+        autoload :Video, 'coradoc/asciidoc/serializer/serializers/video'
+
+        # Autoload submodules (each manages its own autoloads)
+        autoload :Block, 'coradoc/asciidoc/serializer/serializers/block'
+        autoload :Image, 'coradoc/asciidoc/serializer/serializers/image'
+        autoload :Inline, 'coradoc/asciidoc/serializer/serializers/inline'
+        autoload :List, 'coradoc/asciidoc/serializer/serializers/list'
+      end
+    end
+  end
+end
+
+# Load registrations last (triggers autoload of all serializers)
+require_relative 'serializer/registrations'