coradoc-adoc 2.0.0

data/lib/coradoc/asciidoc/model/spacing.rb

@@ -0,0 +1,282 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Model
+      # Value object for defining spacing behavior of document elements
+      #
+      # Provides a unified way to control spacing around blocks, replacing
+      # the scattered spacing_* attributes and trailing_newlines.
+      #
+      # @example Default spacing
+      #   spacing = Spacing.default
+      #   # before_block: 0, after_close: 2
+      #
+      # @example Compact spacing (for lists)
+      #   spacing = Spacing.compact
+      #   # after_close: 1
+      #
+      # @example No spacing (last element)
+      #   spacing = Spacing.none
+      #   # after_close: 0, trailing_newlines: ""
+      #
+      # @example Custom spacing
+      #   spacing = Spacing.new(
+      #     before_block: 1,
+      #     after_close: 3
+      #   )
+      #
+      # @example Exact round-trip spacing
+      #   spacing = Spacing.new(
+      #     trailing_newlines: "\n\n\n"
+      #   )
+      #
+      class Spacing
+        # Number of newlines before the block element
+        #
+        # @return [Integer] newlines before block
+        attr_reader :before_block
+
+        # Number of newlines after opening delimiter
+        # (for delimited blocks like ===, ****, etc.)
+        #
+        # @return [Integer] newlines after open delimiter
+        attr_reader :after_open
+
+        # Number of newlines before closing delimiter
+        # (for delimited blocks)
+        #
+        # @return [Integer] newlines before close delimiter
+        attr_reader :before_close
+
+        # Number of newlines after closing delimiter
+        # (most common spacing control)
+        #
+        # @return [Integer] newlines after close delimiter
+        attr_reader :after_close
+
+        # Exact trailing newlines for round-trip preservation
+        # When nil, uses calculated spacing from after_close
+        # When set to a string, uses that exact value
+        #
+        # @return [String, nil] exact trailing newlines or nil
+        attr_reader :trailing_newlines
+
+        # Create a new Spacing value object
+        #
+        # @param before_block [Integer] Newlines before block
+        # @param after_open [Integer] Newlines after opening delimiter
+        # @param before_close [Integer] Newlines before closing delimiter
+        # @param after_close [Integer] Newlines after closing delimiter
+        # @param trailing_newlines [String, nil] Exact trailing newlines for round-trip
+        #
+        # @example Create default spacing
+        #   spacing = Spacing.new
+        #
+        # @example Create compact spacing
+        #   spacing = Spacing.new(after_close: 1)
+        #
+        # @example Create exact spacing for round-trip
+        #   spacing = Spacing.new(trailing_newlines: "\n\n")
+        #
+        def initialize(before_block: 0, after_open: 1, before_close: 1,
+                       after_close: 2, trailing_newlines: nil)
+          @before_block = before_block
+          @after_open = after_open
+          @before_close = before_close
+          @after_close = after_close
+          @trailing_newlines = trailing_newlines
+          freeze
+        end
+
+        # Default spacing for standard blocks
+        # Most blocks have 2 newlines after them
+        #
+        # @return [Spacing] Default spacing configuration
+        #
+        # @example Use default spacing
+        #   paragraph.spacing = Spacing.default
+        #
+        def self.default
+          new
+        end
+
+        # Compact spacing for tight layouts
+        # Used in lists, nested blocks, etc.
+        #
+        # @return [Spacing] Compact spacing configuration
+        #
+        # @example Use compact spacing in lists
+        #   list_item.spacing = Spacing.compact
+        #
+        def self.compact
+          new(after_close: 1)
+        end
+
+        # No spacing after the element
+        # Used for the last element in a container
+        #
+        # @return [Spacing] No trailing spacing configuration
+        #
+        # @example Use for last element
+        #   last_paragraph.spacing = Spacing.none
+        #
+        def self.none
+          new(after_close: 0, trailing_newlines: '')
+        end
+
+        # Check if this is the default spacing
+        #
+        # @return [Boolean] true if default spacing
+        #
+        def default?
+          before_block.zero? &&
+            after_open == 1 &&
+            before_close == 1 &&
+            after_close == 2 &&
+            trailing_newlines.nil?
+        end
+
+        # Check if this is compact spacing
+        #
+        # @return [Boolean] true if compact spacing
+        #
+        def compact?
+          before_block.zero? &&
+            after_open == 1 &&
+            before_close == 1 &&
+            after_close == 1 &&
+            trailing_newlines.nil?
+        end
+
+        # Check if this has no trailing spacing
+        #
+        # @return [Boolean] true if no trailing spacing
+        #
+        def none?
+          after_close.zero? && trailing_newlines == ''
+        end
+
+        # Check if exact trailing newlines are set
+        #
+        # @return [Boolean] true if trailing_newlines is explicitly set
+        #
+        def exact_mode?
+          !trailing_newlines.nil?
+        end
+
+        # Get the trailing newlines string
+        #
+        # Returns the exact trailing_newlines if set,
+        # otherwise calculates from after_close
+        #
+        # @return [String] The trailing newlines string
+        #
+        # @example Get trailing newlines
+        #   spacing = Spacing.new(after_close: 2)
+        #   spacing.trailing # => "\n\n"
+        #
+        def trailing
+          return trailing_newlines if exact_mode?
+
+          "\n" * after_close
+        end
+
+        # Get newlines before block
+        #
+        # @return [String] Newlines before block
+        #
+        def before
+          "\n" * before_block
+        end
+
+        # Get newlines after opening delimiter
+        #
+        # @return [String] Newlines after open
+        #
+        def after_open_newlines
+          "\n" * after_open
+        end
+
+        # Get newlines before closing delimiter
+        #
+        # @return [String] Newlines before close
+        #
+        def before_close_newlines
+          "\n" * before_close
+        end
+
+        # Create a new spacing with modified after_close value
+        #
+        # @param value [Integer] New after_close value
+        # @return [Spacing] New spacing with modified value
+        #
+        # @example
+        #   spacing = Spacing.default.with_after_close(3)
+        #
+        def with_after_close(value)
+          Spacing.new(
+            before_block: before_block,
+            after_open: after_open,
+            before_close: before_close,
+            after_close: value,
+            trailing_newlines: trailing_newlines
+          )
+        end
+
+        # Create a new spacing with exact trailing newlines
+        #
+        # @param value [String] Exact trailing newlines
+        # @return [Spacing] New spacing with exact trailing newlines
+        #
+        # @example
+        #   spacing = Spacing.default.with_trailing("\n\n\n")
+        #
+        def with_trailing(value)
+          Spacing.new(
+            before_block: before_block,
+            after_open: after_open,
+            before_close: before_close,
+            after_close: after_close,
+            trailing_newlines: value
+          )
+        end
+
+        # String representation for debugging
+        #
+        # @return [String] Debug string
+        #
+        def inspect
+          "#<#{self.class.name} before=#{before_block} after_open=#{after_open} " \
+            "before_close=#{before_close} after_close=#{after_close} " \
+            "trailing=#{trailing_newlines.inspect}>"
+        end
+        alias to_s inspect
+
+        # Two spacings are equal if all attributes match
+        #
+        # @param other [Object] Object to compare
+        # @return [Boolean] true if equal
+        #
+        def ==(other)
+          return false unless other.is_a?(Spacing)
+
+          before_block == other.before_block &&
+            after_open == other.after_open &&
+            before_close == other.before_close &&
+            after_close == other.after_close &&
+            trailing_newlines == other.trailing_newlines
+        end
+        alias eql? ==
+
+        # Hash code for use in Hash keys
+        #
+        # @return [Integer] Hash code
+        #
+        def hash
+          [before_block, after_open, before_close, after_close, trailing_newlines].hash
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/model/table.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Model
+      # Table element for AsciiDoc tables.
+      #
+      # Represents a table with rows and cells. Tables can have titles,
+      # captions, and various formatting options.
+      #
+      # @!attribute [r] id
+      #   @return [String, nil] Optional identifier for the table
+      # @!attribute [r] title
+      #   @return [String, nil] Optional table title
+      # @!attribute [r] rows
+      #   @return [Array<TableRow>] Table rows
+      # @!attribute [r] content
+      #   @return [String, nil] Optional string content
+      # @!attribute [r] attrs
+      #   @return [AttributeList] Additional table attributes
+      #
+      # @example Create a simple table
+      #   table = Coradoc::AsciiDoc::Model::Table.new
+      #   table.rows << Coradoc::AsciiDoc::Model::TableRow.new
+      #
+      class Table < Base
+        include Coradoc::AsciiDoc::Model::Anchorable
+
+        def block_level?
+          true
+        end
+
+        attribute :id, :string
+        attribute :title, :string
+        attribute :rows, Coradoc::AsciiDoc::Model::TableRow, collection: true
+        attribute :content, :string
+        # attribute :anchor, Inline::Anchor, default: -> {
+        #   id.nil? ? nil : Inline::Anchor.new(id)
+        # }
+        attribute :attrs, Coradoc::AsciiDoc::Model::AttributeList
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/model/table_cell.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Model
+      # Table cell with full AsciiDoc format specification support
+      #
+      # Cell format specification: [colspan][.rowspan][halign][valign][style][*]
+      #
+      # @!attribute [r] id
+      #   @return [String, nil] Optional cell identifier
+      # @!attribute [r] content
+      #   @return [Array<TextElement>] Cell content
+      # @!attribute [r] colspan
+      #   @return [Integer, nil] Number of columns to span
+      # @!attribute [r] rowspan
+      #   @return [Integer, nil] Number of rows to span
+      # @!attribute [r] halign
+      #   @return [String, nil] Horizontal alignment: "<" left, "^" center, ">" right
+      # @!attribute [r] valign
+      #   @return [String, nil] Vertical alignment: "<" top, "^" middle, ">" bottom
+      # @!attribute [r] style
+      #   @return [String, nil] Cell style: d/s/e/m/a/l/v
+      # @!attribute [r] repeat
+      #   @return [Boolean] Whether to repeat last cell
+      # @!attribute [r] colrowattr
+      #   @return [String] Legacy combined colspan.rowspan string (for serialization)
+      # @!attribute [r] alignattr
+      #   @return [String] Legacy alignment string (for serialization)
+      #
+      # @example Cell spanning 2 columns
+      #   cell = TableCell.new(content: "text", colspan: 2)
+      #
+      # @example Centered cell with emphasis style
+      #   cell = TableCell.new(content: "text", halign: "^", style: "e")
+      #
+      class TableCell < Base
+        include Coradoc::AsciiDoc::Model::Anchorable
+
+        # Core attributes
+        attribute :id, :string
+        attribute :content, Coradoc::AsciiDoc::Model::TextElement, collection: true, initialize_empty: true
+
+        # Cell format specification attributes
+        attribute :colspan, :integer
+        attribute :rowspan, :integer
+        attribute :halign, :string  # "<" left, "^" center, ">" right
+        attribute :valign, :string  # "<" top, "^" middle, ">" bottom
+        attribute :style, :string   # d/s/e/m/a/l/v
+        attribute :repeat, :boolean, default: -> { false }
+
+        # Legacy attributes for backward compatibility with serializer
+        attribute :colrowattr, :string, default: -> { '' }
+        attribute :alignattr, :string, default: -> { '' }
+
+        # Check if this cell contains AsciiDoc content
+        def asciidoc?
+          style == 'a'
+        end
+
+        # Check if this cell has literal content
+        def literal?
+          style == 'l'
+        end
+
+        # Check if this cell has verse style
+        def verse?
+          style == 'v'
+        end
+
+        # Get horizontal alignment as CSS value
+        # @return [String, nil] "left", "center", or "right"
+        def horizontal_alignment
+          case halign
+          when '<' then 'left'
+          when '^' then 'center'
+          when '>' then 'right'
+          end
+        end
+
+        # Get vertical alignment as CSS value
+        # @return [String, nil] "top", "middle", or "bottom"
+        def vertical_alignment
+          case valign
+          when '<' then 'top'
+          when '^' then 'middle'
+          when '>' then 'bottom'
+          end
+        end
+
+        # Get style name as human-readable string
+        # @return [String, nil] Style name
+        def style_name
+          case style
+          when 'd' then 'default'
+          when 's' then 'strong'
+          when 'e' then 'emphasis'
+          when 'm' then 'monospace'
+          when 'a' then 'asciidoc'
+          when 'l' then 'literal'
+          when 'v' then 'verse'
+          end
+        end
+
+        # Generate colrowattr for serialization (e.g., "2.3" for colspan=2, rowspan=3)
+        # @return [String] Combined colspan.rowspan string
+        def generate_colrowattr
+          result = ''
+          result += colspan.to_s if colspan && colspan > 1
+          result += ".#{rowspan}" if rowspan && rowspan > 1
+          result
+        end
+
+        # Generate alignattr for serialization (e.g., "^" for center)
+        # @return [String] Combined alignment string
+        def generate_alignattr
+          (halign || '') + (valign || '')
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/model/table_row.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Model
+      class TableRow < Base
+        attribute :columns, Coradoc::AsciiDoc::Model::TableCell, collection: true
+        attribute :header, :boolean, default: -> { false }
+
+        def table_header_row?
+          header
+        end
+
+        def asciidoc?
+          columns&.any? { |c| c.is_a?(Coradoc::AsciiDoc::Model::TableCell) && c.asciidoc? } || false
+        end
+
+        # NOTE: underline_for provides trailing newline for table row serialization.
+        # The method name follows AsciiDoc table formatting conventions.
+        def underline_for
+          "\n"
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/model/tag.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Model
+      # Tag element for AsciiDoc documents.
+      #
+      # Tags are metadata markers that can be associated with document elements.
+      #
+      # @!attribute [r] name
+      #   @return [String] The tag name
+      #
+      # @!attribute [r] prefix
+      #   @return [String] Tag prefix (default: "tag")
+      #
+      # @!attribute [r] attrs
+      #   @return [Coradoc::AsciiDoc::Model::AttributeList] Tag attributes
+      #
+      # @!attribute [r] line_break
+      #   @return [String] Line break character (default: "\n")
+      #
+      # @example Create a tag
+      #   tag = Coradoc::AsciiDoc::Model::Tag.new
+      #   tag.name = "important"
+      #
+      class Tag < Base
+        attribute :name, :string
+        attribute :prefix, :string, default: 'tag'
+        attribute :attrs, Coradoc::AsciiDoc::Model::AttributeList, default: lambda {
+          Coradoc::AsciiDoc::Model::AttributeList.new
+        }
+        attribute :line_break, :string, default: -> { "\n" }
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/model/term.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Model
+      # Term element for AsciiDoc definition lists.
+      #
+      # Terms are the items being defined in definition lists.
+      # Each term has a text value and can have an optional type.
+      #
+      # @!attribute [r] term
+      #   @return [String] The term text being defined
+      #
+      # @!attribute [r] type
+      #   @return [String] The term type/category
+      #
+      # @!attribute [r] lang
+      #   @return [String] Language code (default: "en")
+      #
+      # @!attribute [r] line_break
+      #   @return [String] Line break character (default: "")
+      #
+      # @example Create a term
+      #   term = Coradoc::AsciiDoc::Model::Term.new
+      #   term.term = "ASCII"
+      #   term.type = "acronym"
+      #
+      # @see Coradoc::AsciiDoc::Model::List::Definition Definition lists
+      #
+      class Term < Base
+        attribute :term, :string
+        attribute :type, :string
+        attribute :lang, :string, default: -> { 'en' }
+        attribute :line_break, :string, default: -> { '' }
+
+        def validate
+          errors = super
+
+          errors << Lutaml::Model::Error.new('Term cannot be nil or empty') if term.nil? || term.empty?
+
+          errors << Lutaml::Model::Error.new('Type cannot be nil or empty') if type.nil? || type.empty?
+
+          errors
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/model/text_element.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Model
+      class TextElement < Base
+        def inline?
+          true
+        end
+
+        attribute :id, :string
+        attribute :content,
+                  Lutaml::Model::Serializable,
+                  default: -> { '' },
+                  polymorphic: [
+                    Lutaml::Model::Type::String,
+                    :array
+                  ]
+        attribute :line_break, :string, default: -> { '' }
+
+        def self.escape_keychars(string)
+          subs = { '*' => '\*', '_' => '\_' }
+          string
+            .gsub(/((?<=\s)[*_]+)|[*_]+(?=\s)/) do |n|
+            n.chars.map do |char|
+              subs[char]
+            end.join
+          end
+        end
+
+        # Get text content as string
+        #
+        # @return [String] The text content
+        #
+        def to_s
+          case content
+          when String
+            content
+          when Array
+            content.map(&:to_s).join
+          when Coradoc::AsciiDoc::Model::Base
+            content.to_adoc
+          when Lutaml::Model::Serializable
+            if content.class.attributes.key?(:content)
+              content.content.to_s
+            else
+              ''
+            end
+          when nil
+            ''
+          else
+            content.is_a?(String) ? content.to_s : ''
+          end
+        end
+
+        # Alias for text to work with ContentList
+        #
+        # @return [String] The text content
+        #
+        def text
+          to_s
+        end
+      end
+    end
+  end
+end