coradoc-adoc 2.0.0

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Model
+      # Title element for sections and document headers.
+      #
+      # Represents a title with optional level information. Titles are used by
+      # sections to define their heading level and text content.
+      #
+      # @!attribute [r] id
+      #   @return [String, nil] Optional identifier for the title
+      # @!attribute [r] content
+      #   @return [Array<TextElement>] Title text content (can include inline formatting)
+      # @!attribute [r] level_int
+      #   @return [Integer, nil] Heading level (0-5 for standard, 6+ uses style attribute)
+      # @!attribute [r] line_break
+      #   @return [String] Line break character after title (default: newline)
+      # @!attribute [r] style
+      #   @return [String, nil] Optional style attribute for title formatting
+      #
+      # @example Create a level 1 title
+      #   title = Coradoc::AsciiDoc::Model::Title.new(
+      #     content: [Coradoc::AsciiDoc::Model::TextElement.new("Chapter 1")],
+      #     level_int: 0
+      #   )
+      #   title.to_adoc # => "= Chapter 1\n"
+      #
+      # @example Create a level 2 title
+      #   title = Coradoc::AsciiDoc::Model::Title.new(
+      #     content: [Coradoc::AsciiDoc::Model::TextElement.new("Section 1.1")],
+      #     level_int: 1
+      #   )
+      #   title.to_adoc # => "== Section 1.1\n"
+      #
+      class Title < Base
+        include Coradoc::AsciiDoc::Model::Anchorable
+
+        attribute :id, :string
+        attribute :content, Coradoc::AsciiDoc::Model::TextElement, collection: true
+        # attribute :level, :string
+        attribute :level_int, :integer
+        attribute :line_break, :string, default: -> { "\n" }
+        attribute :style, :string
+
+        alias text content
+
+        # Convert title content to string
+        # @return [String] The title text
+        def to_s
+          case content
+          when String
+            content
+          when Array
+            content.map do |item|
+              item.is_a?(Coradoc::AsciiDoc::Model::TextElement) ? item.content.to_s : item.to_s
+            end.join
+          else
+            content.to_s
+          end
+        end
+
+        def level_str
+          return '' if level_int.nil?
+
+          if level_int <= 5
+            '=' * (level_int + 1)
+          else
+            '======'
+          end
+        end
+
+        def style_str
+          return '' if level_int.nil?
+
+          _style = [style]
+          _style << "level=#{level_int}" if level_int > 5
+          _style = _style.compact.join(',')
+
+          _style.empty? ? '' : "[#{_style}]\n"
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/model/video/attribute_list.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Model
+      class Video < Base
+        class AttributeList < Coradoc::AsciiDoc::Model::AttributeList
+          extend AttributeList::Matchers
+          def positional_validators
+            [
+              [:alt, String],
+              [:width, Integer],
+              [:height, Integer]
+            ]
+          end
+
+          def named_validators
+            {
+              title: String,
+              poster: String,
+              width: Integer,
+              height: Integer,
+              start: Integer,
+              end: Integer,
+              theme: one('dark', 'light'),
+              lang: /[a-z]{2,3}(?:-[A-Z]{2})?/,
+              list: String,
+              playlist: String,
+              options: many(
+                'autoplay',
+                'loop',
+                'modest',
+                'nocontrols',
+                'nofullscreen',
+                'muted'
+              )
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Model
+      # Video block element for AsciiDoc documents.
+      #
+      # Videos are embedded multimedia content with support for various
+      # video platforms and custom attributes.
+      #
+      # @!attribute [r] id
+      #   @return [String, nil] Optional identifier for the video
+      #
+      # @!attribute [r] title
+      #   @return [String, nil] Optional video title
+      #
+      # @!attribute [r] src
+      #   @return [String] The video source URL or path
+      #
+      # @!attribute [r] attributes
+      #   @return [Coradoc::AsciiDoc::Model::Video::AttributeList] Video-specific attributes
+      #
+      # @!attribute [r] line_break
+      #   @return [String] Line break character (default: "\n")
+      #
+      # @example Create a video block
+      #   video = Coradoc::AsciiDoc::Model::Video.new
+      #   video.src = "https://example.com/video.mp4"
+      #   video.title = "Demo Video"
+      #
+      class Video < Base
+        # Autoload nested AttributeList class
+        autoload :AttributeList, 'coradoc/asciidoc/model/video/attribute_list'
+
+        include Coradoc::AsciiDoc::Model::Anchorable
+
+        attribute :id, :string
+        attribute :title, :string
+        attribute :src, :string, default: -> { '' }
+        attribute :attributes,
+                  Video::AttributeList,
+                  default: lambda {
+                    Coradoc::AsciiDoc::Model::AttributeList.new
+                  }
+        attribute :line_break, :string, default: -> { "\n" }
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/model.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+# IMPORTANT: Load Serialization module eagerly — it registers the asciidoc
+# format with Lutaml::Model, which is needed before any model class can
+# use the asciidoc DSL.
+require_relative 'model/serialization'
+
+module Coradoc
+  module AsciiDoc
+    module Model
+      # Base class for all AsciiDoc model classes (no side effects)
+      autoload :Base, "#{__dir__}/model/base"
+
+      # Layer 0: Mixins (no dependencies)
+      autoload :Anchorable, "#{__dir__}/model/anchorable"
+      autoload :Attached, "#{__dir__}/model/attached"
+      autoload :Spacing, "#{__dir__}/model/spacing"
+
+      # Layer 1: Simple types (only depend on Layer 0)
+      autoload :Attribute, "#{__dir__}/model/attribute"
+      autoload :AttributeListAttribute, "#{__dir__}/model/attribute_list_attribute"
+      autoload :NamedAttribute, "#{__dir__}/model/named_attribute"
+      autoload :RejectedPositionalAttribute, "#{__dir__}/model/rejected_positional_attribute"
+      autoload :AttributeList, "#{__dir__}/model/attribute_list"
+      autoload :Author, "#{__dir__}/model/author"
+      autoload :Revision, "#{__dir__}/model/revision"
+      autoload :Break, "#{__dir__}/model/break"
+      autoload :CommentBlock, "#{__dir__}/model/comment_block"
+      autoload :CommentLine, "#{__dir__}/model/comment_line"
+      autoload :Glossaries, "#{__dir__}/model/glossaries"
+      autoload :Include, "#{__dir__}/model/include"
+      autoload :Tag, "#{__dir__}/model/tag"
+
+      # Layer 2-3: Text types
+      autoload :TextElement, "#{__dir__}/model/text_element"
+      autoload :Admonition, "#{__dir__}/model/admonition"
+      autoload :Highlight, "#{__dir__}/model/highlight"
+      autoload :LineBreak, "#{__dir__}/model/line_break"
+      autoload :Title, "#{__dir__}/model/title"
+      autoload :Paragraph, "#{__dir__}/model/paragraph"
+
+      # Layer 4-5: Block and List types
+      autoload :Block, "#{__dir__}/model/block"
+      autoload :ContentList, "#{__dir__}/model/content_list"
+      autoload :Term, "#{__dir__}/model/term"
+      autoload :List, "#{__dir__}/model/list"
+
+      # Layer 6: Structural types
+      autoload :DocumentAttributes, "#{__dir__}/model/document_attributes"
+      autoload :Header, "#{__dir__}/model/header"
+      autoload :Section, "#{__dir__}/model/section"
+
+      # Layer 7-8: Content types
+      autoload :Audio, "#{__dir__}/model/audio"
+      autoload :BibliographyEntry, "#{__dir__}/model/bibliography_entry"
+      autoload :Bibliography, "#{__dir__}/model/bibliography"
+      autoload :Video, "#{__dir__}/model/video"
+      autoload :Image, "#{__dir__}/model/image"
+
+      # Layer 9: Table types
+      autoload :TableCell, "#{__dir__}/model/table_cell"
+      autoload :TableRow, "#{__dir__}/model/table_row"
+      autoload :Table, "#{__dir__}/model/table"
+
+      # Layer 10: Inline types
+      autoload :Inline, "#{__dir__}/model/inline"
+
+      # Layer 11: Complex types
+      autoload :ReviewerNote, "#{__dir__}/model/reviewer_note"
+
+      # Layer 12: Document
+      autoload :Document, "#{__dir__}/model/document"
+    end
+  end
+end

data/lib/coradoc/asciidoc/parse_error.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    # Custom error class for parsing failures
+    #
+    # Provides detailed context about where parsing failed, including
+    # line number, column position, and source snippet.
+    #
+    # @example Raising a parse error
+    #   raise Coradoc::AsciiDoc::ParseError.new(
+    #     "Unexpected token",
+    #     line: 42,
+    #     column: 10,
+    #     source: "line with error",
+    #     suggestion: "Did you mean X?"
+    #   )
+    #
+    class ParseError < Error
+      # @return [Integer, nil] Line number where error occurred
+      attr_reader :line
+
+      # @return [Integer, nil] Column position where error occurred
+      attr_reader :column
+
+      # @return [String, nil] Source line containing the error
+      attr_reader :source_line
+
+      # @return [String, nil] Helpful suggestion for fixing the error
+      attr_reader :suggestion
+
+      # @return [String, nil] Full source content (for multi-line context)
+      attr_reader :source
+
+      # @return [Exception, nil] Original exception that caused this error
+      attr_reader :cause
+
+      # Create a new ParseError
+      #
+      # @param message [String] Error description
+      # @param line [Integer, nil] Line number (1-indexed)
+      # @param column [Integer, nil] Column position (1-indexed)
+      # @param source_line [String, nil] The source line containing the error
+      # @param source [String, nil] Full source content
+      # @param suggestion [String, nil] Suggestion for fixing the error
+      # @param cause [Exception, nil] Original exception that caused this error
+      def initialize(message, line: nil, column: nil, source_line: nil, source: nil, suggestion: nil, cause: nil)
+        @line = line
+        @column = column
+        @source_line = source_line
+        @source = source
+        @suggestion = suggestion
+        @cause = cause
+
+        full_message = build_full_message(message)
+        super(full_message)
+
+        set_backtrace(cause.backtrace) if cause&.backtrace
+      end
+
+      # Build a formatted error message with context
+      #
+      # @param base_message [String] The base error message
+      # @return [String] Formatted error message with location context
+      def build_full_message(base_message)
+        parts = [base_message]
+
+        if line && column
+          parts << "at line #{line}, column #{column}"
+        elsif line
+          parts << "at line #{line}"
+        end
+
+        if source_line
+          parts << "\n  > #{source_line}"
+          parts << "  > #{' ' * (column - 1)}^" if column&.positive?
+        end
+
+        parts << "\n  Suggestion: #{suggestion}" if suggestion
+
+        parts.join("\n")
+      end
+
+      # Create a ParseError from a Parslet exception
+      #
+      # @param exception [Parslet::ParseFailed] The Parslet exception
+      # @param source [String] The original source text
+      # @return [ParseError] A new ParseError with extracted context
+      def self.from_parslet(exception, source = nil)
+        return exception if exception.is_a?(ParseError)
+
+        line, column = extract_location(exception)
+        source_line = extract_source_line(source, line)
+        suggestion = generate_suggestion(exception)
+
+        new(
+          exception.message,
+          line: line,
+          column: column,
+          source_line: source_line,
+          source: source,
+          suggestion: suggestion,
+          cause: exception
+        )
+      rescue StandardError
+        # If we can't extract details, wrap the original exception
+        new(exception.message, cause: exception)
+      end
+
+      # Extract line and column from Parslet error
+      #
+      # @param exception [Parslet::ParseFailed] The Parslet exception
+      # @return [Array<Integer, Integer>] Line and column numbers
+      def self.extract_location(exception)
+        return [nil, nil] unless exception.is_a?(Parslet::ParseFailed)
+
+        cause = exception.cause
+        return [nil, nil] unless cause
+
+        [cause.source_line, cause.source_column]
+      rescue NoMethodError
+        [nil, nil]
+      end
+
+      # Extract the relevant source line
+      #
+      # @param source [String, nil] Full source text
+      # @param line [Integer, nil] Line number
+      # @return [String, nil] The source line
+      def self.extract_source_line(source, line)
+        return nil if source.nil? || line.nil?
+
+        lines = source.split("\n")
+        lines[line - 1] if line.positive? && line <= lines.length
+      end
+
+      # Generate a helpful suggestion based on the error
+      #
+      # @param exception [Exception] The parsing exception
+      # @return [String, nil] A suggestion string
+      def self.generate_suggestion(exception)
+        message = exception.message.to_s.downcase
+
+        case message
+        when /expected.*heading/
+          "Make sure headings start with '=' followed by a space"
+        when /expected.*list/
+          "List items should start with '*', '.', or a term followed by '::'"
+        when /expected.*table/
+          "Tables require '|===' delimiters and '|' for cell separators"
+        when /expected.*block/
+          'Block delimiters should be 4 identical characters (----, ====, etc.)'
+        when /expected.*attribute/
+          "Attributes should be in the format ':name: value'"
+        when /unexpected.*end/
+          'Check for missing closing delimiters or incomplete syntax'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Parser
+      module Admonition
+        def admonition_type
+          str('NOTE') | str('TIP') | str('EDITOR') |
+            str('IMPORTANT') | str('WARNING') | str('CAUTION') |
+            str('TODO')
+          # requires atypical syntax for access?
+          # | str('DANGER')
+          # | str('SAFETY PRECAUTION')
+        end
+
+        def admonition_line
+          admonition_type.as(:admonition_type) >> str(': ') >>
+            (text.as(:text) >>
+            line_ending.as(:line_break)
+            ).repeat(1)
+            .as(:content)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Parser
+      module AttributeList
+        def named_attribute_name
+          attribute_name
+        end
+
+        def named_value_noquote
+          match('[^\],]').repeat(1)
+        end
+
+        def named_value_single_quote
+          str("'") >>
+            match("[^']").repeat(1) >>
+            str("'")
+        end
+
+        def named_value_double_quote
+          str('"') >>
+            match('[^"]').repeat(1) >>
+            str('"')
+        end
+
+        def named_value
+          (named_value_single_quote |
+            named_value_double_quote |
+            named_value_noquote
+          ).as(:named_value)
+        end
+
+        def named_key
+          match('[a-zA-Z0-9_-]').repeat(1).as(:named_key)
+        end
+
+        def named_attribute
+          (named_key >>
+            str(' ').maybe >> str('=') >> str(' ').maybe >>
+              named_value >>
+              str(' ').maybe
+          ).as(:named)
+        end
+
+        def positional_value_unquoted
+          match['a-zA-Z0-9_\-%.'].repeat(1)
+        end
+
+        def positional_value_single_quote
+          str("'") >>
+            match("[^']").repeat(1) >>
+            str("'")
+        end
+
+        def positional_value_double_quote
+          str('"') >>
+            match('[^"]').repeat(1) >>
+            str('"')
+        end
+
+        def positional_attribute
+          ((positional_value_single_quote |
+              positional_value_double_quote |
+              positional_value_unquoted
+           ) >>
+            str('=').absent?
+          ).as(:positional)
+        end
+
+        def named_many
+          (named_attribute.repeat(1, 1) >>
+              (str(',') >> space.maybe >> named_attribute).repeat(0))
+        end
+
+        def positional_one_named_many
+          (positional_attribute.repeat(1, 1) >>
+            (str(',') >> space.maybe >> named_attribute).repeat(1))
+        end
+
+        def positional_many_named_many
+          (positional_attribute.repeat(1, 1) >>
+            (str(',') >> space.maybe >> positional_attribute).repeat(1) >>
+            (str(',') >> space.maybe >> named_attribute).repeat(1))
+        end
+
+        def positional_many
+          (positional_attribute.repeat(1, 1) >>
+            (str(',') >> space.maybe >> positional_attribute).repeat(0))
+        end
+
+        def positional_zero_or_one
+          positional_attribute.repeat(0, 1)
+        end
+
+        def attribute_list(name = :attribute_list)
+          str('[').present? >>
+            str('[') >> str('[').absent? >>
+            (named_many |
+              positional_one_named_many |
+              positional_many_named_many |
+              positional_many |
+              positional_zero_or_one
+            ).as(:attribute_array).as(name) >>
+            str(']')
+        end
+      end
+    end
+  end
+end