coradoc-adoc 2.0.0

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

@@ -0,0 +1,334 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Model
+      # A list of content elements that provides unified content handling
+      #
+      # ContentList handles mixed content types (strings, TextElements, model objects)
+      # and provides a consistent API for querying and manipulating content.
+      #
+      # @example Create from strings
+      #   content = ContentList.new("Hello", "World")
+      #   content.text # => "HelloWorld"
+      #
+      # @example Create from mixed types
+      #   content = ContentList.new([
+      #     "Hello ",
+      #     Bold.new("World"),
+      #     "!"
+      #   ])
+      #   content.text # => "Hello World!"
+      #
+      # @example Query by type
+      #   bold_items = content.find_type(Inline::Bold)
+      #
+      # @example Iterate elements
+      #   content.each do |element|
+      #     puts element.class
+      #   end
+      #
+      class ContentList
+        include Enumerable
+
+        # Get the raw items array
+        #
+        # @return [Array] The content items
+        attr_reader :items
+
+        # Create a new ContentList
+        #
+        # @param items [Array, String, Object] Content items to initialize with
+        #
+        # @example From strings
+        #   ContentList.new("Hello", "World")
+        #
+        # @example From array
+        #   ContentList.new(["Hello", Bold.new("World")])
+        #
+        # @example From nested array
+        #   ContentList.new([["Hello", " "], "World"])
+        #
+        def initialize(*items)
+          @items = normalize(items.flatten)
+          freeze
+        end
+
+        # Create a ContentList from a single value
+        #
+        # @param value [Object] The content value
+        # @return [ContentList] New ContentList
+        #
+        # @example From string
+        #   ContentList.from("Hello")
+        #
+        # @example From array
+        #   ContentList.from(["Hello", "World"])
+        #
+        def self.from(value)
+          case value
+          when ContentList
+            value
+          when Array
+            new(*value)
+          when nil
+            new
+          else
+            new(value)
+          end
+        end
+
+        # Iterate over content items
+        #
+        # @yield [Object] Each content item
+        # @return [Enumerator] If no block given
+        #
+        # @example Iterate
+        #   content.each { |item| puts item }
+        #
+        def each(&block)
+          @items.each(&block)
+        end
+
+        # Add an item to the content
+        #
+        # @param item [Object] Item to add
+        # @return [ContentList] Self for chaining
+        #
+        # @example Add item
+        #   content << "more text"
+        #
+        # Note: This returns a new ContentList since ContentList is immutable
+        #
+        def <<(item)
+          ContentList.new(*@items, coerce(item))
+        end
+
+        # Get all items as a plain string
+        #
+        # @return [String] All items joined as string
+        #
+        # @example Get text
+        #   content.text # => "Hello World"
+        #
+        def text
+          @items.map(&:to_s).join
+        end
+        alias to_str text
+        alias to_s text
+
+        # Find all items of a specific type
+        #
+        # @param type [Class, Module] Type to find
+        # @return [Array] Items of the specified type
+        #
+        # @example Find bold items
+        #   content.find_type(Inline::Bold)
+        #
+        def find_type(type)
+          @items.select { |item| item.is_a?(type) }
+        end
+
+        # Check if content is empty
+        #
+        # @return [Boolean] true if no items
+        #
+        def empty?
+          @items.empty?
+        end
+
+        # Get number of items
+        #
+        # @return [Integer] Number of items
+        #
+        def size
+          @items.size
+        end
+        alias length size
+
+        # Get item at index
+        #
+        # @param index [Integer] Index
+        # @return [Object, nil] Item at index or nil
+        #
+        def [](index)
+          @items[index]
+        end
+
+        # Get first item
+        #
+        # @return [Object, nil] First item or nil
+        #
+        def first
+          @items.first
+        end
+
+        # Get last item
+        #
+        # @return [Object, nil] Last item or nil
+        #
+        def last
+          @items.last
+        end
+
+        # Convert to array
+        #
+        # @return [Array] Items as array
+        #
+        def to_a
+          @items.dup
+        end
+
+        # Join items with a separator
+        #
+        # @param sep [String] Separator
+        # @return [String] Joined string
+        #
+        # @example Join with spaces
+        #   content.join(" ") # => "Hello World"
+        #
+        def join(sep = '')
+          @items.map(&:to_s).join(sep)
+        end
+
+        # Map over items
+        #
+        # @yield [Object] Each item
+        # @return [Array] Mapped items
+        #
+        # @example Map
+        #   content.map(&:class) # => [String, Bold, String]
+        #
+        def map(&block)
+          @items.map(&block)
+        end
+
+        # Select items matching predicate
+        #
+        # @yield [Object] Each item
+        # @return [Array] Selected items
+        #
+        # @example Select strings
+        #   content.select { |i| i.is_a?(String) }
+        #
+        def select(&block)
+          @items.select(&block)
+        end
+
+        # Reject items matching predicate
+        #
+        # @yield [Object] Each item
+        # @return [Array] Remaining items
+        #
+        def reject(&block)
+          @items.reject(&block)
+        end
+
+        # Check if content includes an item
+        #
+        # @param item [Object] Item to check
+        # @return [Boolean] true if item is in content
+        #
+        def include?(item)
+          @items.include?(item)
+        end
+
+        # Check if content includes an item of a type
+        #
+        # @param type [Class, Module] Type to check
+        # @return [Boolean] true if any item is of the type
+        #
+        # @example Check for bold
+        #   content.include_type?(Inline::Bold)
+        #
+        def include_type?(type)
+          @items.any? { |item| item.is_a?(type) }
+        end
+
+        # Concatenate another ContentList or array
+        #
+        # @param other [ContentList, Array] Other content to add
+        # @return [ContentList] New ContentList with combined items
+        #
+        # @example Concatenate
+        #   content + ContentList.new("more")
+        #
+        def +(other)
+          other_items = other.is_a?(ContentList) ? other.items : Array(other)
+          ContentList.new(*@items, *other_items)
+        end
+
+        # String representation for debugging
+        #
+        # @return [String] Debug string
+        #
+        def inspect
+          "#<#{self.class.name} size=#{@items.size} items=#{@items.inspect}>"
+        end
+
+        # Two ContentLists are equal if their items are equal
+        #
+        # @param other [Object] Object to compare
+        # @return [Boolean] true if equal
+        #
+        def ==(other)
+          return false unless other.is_a?(ContentList)
+
+          @items == other.items
+        end
+        alias eql? ==
+
+        # Hash code for use in Hash keys
+        #
+        # @return [Integer] Hash code
+        #
+        def hash
+          @items.hash
+        end
+
+        private
+
+        # Normalize items to appropriate content types
+        #
+        # @param items [Array] Raw items
+        # @return [Array] Normalized items
+        #
+        def normalize(items)
+          items.map { |item| coerce(item) }
+        end
+
+        # Coerce an item to appropriate content type
+        #
+        # @param item [Object] Item to coerce
+        # @return [Object] Coerced item
+        #
+        def coerce(item)
+          case item
+          when String
+            # Convert string to TextElement
+            TextElement.new(content: item)
+          when TextElement, Model::Base
+            # Already appropriate type
+            item
+          when nil
+            # Skip nil items
+            nil
+          when Hash
+            # Convert hash to TextElement if it has content key
+            if item[:content] || item['content']
+              TextElement.from_hash(item)
+            else
+              TextElement.new(content: item.inspect)
+            end
+          when Array
+            # Flatten nested arrays
+            normalize(item)
+          else
+            # Try to convert to string, then to TextElement
+            TextElement.new(content: item.to_s)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Model
+      autoload :Resolver, "#{__dir__}/resolver"
+
+      # Document model representing an AsciiDoc document.
+      #
+      # The Document class is the main container for parsed AsciiDoc content.
+      # It holds the document's header, attributes, and sections (blocks, lists, etc.).
+      #
+      # @!attribute [r] document_attributes
+      #   @return [DocumentAttributes] Document-level attributes like author, date, etc.
+      # @!attribute [r] header
+      #   @return [Header] Document header containing title and metadata
+      # @!attribute [r] sections
+      #   @return [Array<Base>] Document content blocks (sections, paragraphs, lists, etc.)
+      #
+      # @example Create a new document
+      #   doc = Coradoc::AsciiDoc::Model::Document.new(
+      #     header: Coradoc::AsciiDoc::Model::Header.new(title: "My Document"),
+      #     sections: [Coradoc::AsciiDoc::Model::Paragraph.new("Hello World")]
+      #   )
+      #
+      # @example Parse and serialize
+      #   doc = Coradoc.parse("= Title\n\nContent")
+      #   doc.to_adoc # => "= Title\n\nContent"
+      #
+      # @example Expand includes
+      #   doc = Coradoc.parse_file("main.adoc")
+      #   expanded = doc.expand_includes("/path/to/docs")
+      #
+      # @example Freeze document with unified resolution
+      #   frozen = doc.freeze(base_dir: "/path/to/docs", includes: true, images: :reference)
+      #
+      class Document < Base
+        attribute :document_attributes,
+                  Coradoc::AsciiDoc::Model::DocumentAttributes,
+                  default: lambda {
+                    Coradoc::AsciiDoc::Model::DocumentAttributes.new
+                  }
+        attribute :header,
+                  Coradoc::AsciiDoc::Model::Header,
+                  default: lambda {
+                    Coradoc::AsciiDoc::Model::Header.new(
+                      title: Coradoc::AsciiDoc::Model::Title.new(content: '')
+                    )
+                  }
+
+        attribute :sections,
+                  Coradoc::AsciiDoc::Model::Base,
+                  collection: true,
+                  initialize_empty: true,
+                  polymorphic: [
+                    Coradoc::AsciiDoc::Model::Admonition,
+                    Coradoc::AsciiDoc::Model::Audio,
+                    Coradoc::AsciiDoc::Model::BibliographyEntry,
+                    Coradoc::AsciiDoc::Model::Block::Core,
+                    Coradoc::AsciiDoc::Model::Image::BlockImage,
+                    Coradoc::AsciiDoc::Model::CommentBlock,
+                    Coradoc::AsciiDoc::Model::CommentLine,
+                    Coradoc::AsciiDoc::Model::Include,
+                    Coradoc::AsciiDoc::Model::LineBreak,
+                    Coradoc::AsciiDoc::Model::List::Core,
+                    Coradoc::AsciiDoc::Model::Paragraph,
+                    Coradoc::AsciiDoc::Model::Table,
+                    Coradoc::AsciiDoc::Model::Tag,
+                    Coradoc::AsciiDoc::Model::Video
+                  ]
+
+        # @param [Integer] index The index of the section to retrieve
+        # @return [Coradoc::AsciiDoc::Model::Base] The section at the specified index
+        def [](index)
+          sections[index]
+        end
+
+        # @param [Integer] index The index of the section to set
+        # @param [Coradoc::AsciiDoc::Model::Base] value The section to set at the specified index
+        # @return [Coradoc::AsciiDoc::Model::Base] The section that was set
+        def []=(index, value)
+          sections[index] = value
+        end
+
+        # Expand include directives in the document
+        # @param base_dir [String] Base directory for resolving relative includes
+        # @return [Coradoc::AsciiDoc::Model::Document] A new document with includes expanded
+        def expand_includes(base_dir = '.')
+          freeze(base_dir: base_dir, includes: true, images: :reference, media: :reference)
+        end
+
+        # Freeze the document by resolving external references.
+        #
+        # This method creates a NEW document with resolved references.
+        # The original document is never modified (immutable principle).
+        #
+        # @param options [Hash] Resolution options
+        # @option options [String] :base_dir Base directory for relative paths (default: ".")
+        # @option options [Boolean] :includes Resolve include:: directives (default: true)
+        # @option options [Symbol] :images Image resolution: :reference, :copy, :embed (default: :reference)
+        # @option options [Symbol] :media Media resolution: :reference, :copy (default: :reference)
+        # @option options [String] :output_dir Output directory for :copy mode
+        # @option options [Integer] :max_recursion Maximum recursion depth for includes (default: 10)
+        # @return [Document] NEW document with resolved references
+        #
+        # @example Resolve includes only
+        #   frozen = doc.freeze(base_dir: "/docs", includes: true)
+        #
+        # @example Create self-contained document
+        #   frozen = doc.freeze(
+        #     base_dir: "/docs",
+        #     includes: true,
+        #     images: :embed,
+        #     output_dir: "/output"
+        #   )
+        #
+        def freeze(options = {})
+          resolver = Resolver.new(options)
+          base_dir = options[:base_dir] || '.'
+          resolver.resolve_document(self, base_dir)
+        end
+
+        class << self
+          def from_ast(elements)
+            sections = []
+            document_attributes = nil
+            header = nil
+
+            elements.each do |element|
+              case element
+              when Coradoc::AsciiDoc::Model::DocumentAttributes
+                document_attributes = element
+
+              when Coradoc::AsciiDoc::Model::Header
+                header = element
+
+              when Coradoc::AsciiDoc::Model::Base
+                sections << element
+
+              else
+                warn "Unknown element type: #{element.class}"
+                warn "Element: #{element.inspect}"
+              end
+            end
+
+            # Merge standalone LineBreak elements into the previous element's line_break
+            merge_line_breaks(sections)
+
+            # Only pass non-nil values to preserve defaults
+            attrs = { sections: sections }
+            attrs[:document_attributes] = document_attributes if document_attributes
+            attrs[:header] = header if header
+
+            new(attrs)
+          end
+
+          private
+
+          def merge_line_breaks(sections)
+            return if sections.empty?
+
+            # Skip leading LineBreak elements
+            sections.shift while sections.first.is_a?(Coradoc::AsciiDoc::Model::LineBreak)
+
+            i = 0
+            while i < sections.length
+              # If current element is a LineBreak and there's a previous element
+              if sections[i].is_a?(Coradoc::AsciiDoc::Model::LineBreak) && i.positive?
+                prev = sections[i - 1]
+                line_break = sections[i]
+
+                # Skip consecutive LineBreaks
+                if prev.is_a?(Coradoc::AsciiDoc::Model::LineBreak)
+                  sections.delete_at(i)
+                  next
+                end
+
+                # Merge the line break into the previous element if it has a line_break attribute
+                if prev.is_a?(Coradoc::AsciiDoc::Model::Base) && prev.class.attributes.key?(:line_break)
+                  prev.line_break = prev.line_break.to_s + line_break.line_break.to_s
+                  sections.delete_at(i)
+                  # Don't increment i since we deleted an element
+                  next
+                else
+                  # Keep as standalone if no suitable previous element
+                  i += 1
+                end
+              else
+                i += 1
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Model
+      # Container for document-level attributes.
+      #
+      # DocumentAttributes holds key-value pairs that define document metadata
+      # and configuration options. These are the `:key: value` declarations at
+      # the top of an AsciiDoc file.
+      #
+      # @!attribute [r] data
+      #   @return [Array<Attribute>] Array of attribute key-value pairs
+      #
+      # @example Access attributes as hash
+      #   attrs = Coradoc::AsciiDoc::Model::DocumentAttributes.new
+      #   attrs.data << Coradoc::AsciiDoc::Model::Attribute.new("author", "John Doe")
+      #   attrs.to_hash # => {"author" => "John Doe"}
+      #
+      # @example Get specific attribute
+      #   value = attrs.get_attribute("author")
+      #
+      class DocumentAttributes < Base
+        attribute :data, Attribute, collection: true
+
+        def to_hash
+          return {} if data.nil?
+
+          data.each_with_object({}) do |attribute, hash|
+            hash[attribute.key.to_s] = attribute.value
+          end
+        end
+
+        def get_attribute(name)
+          return nil if data.nil?
+
+          attribute = data.find { |attr| attr.key.to_s == name.to_s }
+          attribute&.value
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Model
+      class Glossaries < Base
+        attribute :items, :string, collection: true
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Model
+      # Document header containing title and metadata.
+      #
+      # The Header represents the document-level metadata including the main title,
+      # author information, and revision details. This corresponds to the AsciiDoc
+      # header line (e.g., `= Document Title`) and associated metadata.
+      #
+      # @!attribute [r] title
+      #   @return [String] The main document title
+      # @!attribute [r] author
+      #   @return [Author, nil] Document author information
+      # @!attribute [r] revision
+      #   @return [Revision, nil] Document revision information (version, date)
+      #
+      # @example Create a simple header
+      #   header = Coradoc::AsciiDoc::Model::Header.new(title: "My Document")
+      #
+      # @example Create a header with author and revision
+      #   header = Coradoc::AsciiDoc::Model::Header.new(
+      #     title: "My Document",
+      #     author: Coradoc::AsciiDoc::Model::Author.new("John Doe"),
+      #     revision: Coradoc::AsciiDoc::Model::Revision.new("1.0", "2024-01-01")
+      #   )
+      #
+      class Header < Base
+        include Coradoc::AsciiDoc::Model::Anchorable
+
+        attribute :title, Coradoc::AsciiDoc::Model::Title
+        attribute :author, Coradoc::AsciiDoc::Model::Author
+        attribute :revision, Coradoc::AsciiDoc::Model::Revision
+
+        def validate
+          validate_author_type
+          validate_revision_type
+        end
+
+        private
+
+        def validate_author_type
+          return if author.nil? || author.is_a?(Coradoc::AsciiDoc::Model::Author)
+
+          raise TypeError, "author must be a Coradoc::AsciiDoc::Model::Author, got #{author.class}"
+        end
+
+        def validate_revision_type
+          return if revision.nil? || revision.is_a?(Coradoc::AsciiDoc::Model::Revision)
+
+          raise TypeError, "revision must be a Coradoc::AsciiDoc::Model::Revision, got #{revision.class}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Model
+      class Highlight < TextElement
+        attribute :unconstrained, :boolean, default: -> { false }
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/model/image/block_image/attribute_list.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Model
+      class BlockImage < Coradoc::AsciiDoc::Model::Image::Core
+        class AttributeList < Coradoc::AsciiDoc::Model::Image::Core::AttributeList
+          extend AttributeList::Matchers
+
+          def named_validators
+            super.merge(
+              {
+                caption: String,
+                align: one('left', 'center', 'right'),
+                float: one('left', 'right')
+              }
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/model/image/block_image.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Model
+      module Image
+        class BlockImage < Coradoc::AsciiDoc::Model::Image::Core
+          def block_level?
+            true
+          end
+
+          # Autoload nested AttributeList class
+          autoload :AttributeList, 'coradoc/asciidoc/model/image/block_image/attribute_list'
+
+          attribute :colons, :string, default: -> { '::' }
+          attribute :attributes,
+                    Coradoc::AsciiDoc::Model::Image::BlockImage::AttributeList,
+                    default: lambda {
+                      ::Coradoc::AsciiDoc::Model::AttributeList.new
+                    }
+        end
+      end
+    end
+  end
+end