coradoc-adoc 2.0.0

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

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Model
+      # Section element for organizing document content hierarchically.
+      #
+      # Sections represent the hierarchical structure of an AsciiDoc document.
+      # They can contain nested subsections, paragraphs, and other content.
+      #
+      # @!attribute [r] id
+      #   @return [String, nil] Optional identifier for the section
+      # @!attribute [r] content
+      #   @return [String, nil] Optional string content (typically unused, see contents)
+      # @!attribute [r] title
+      #   @return [Title] Section title
+      # @!attribute [r] attrs
+      #   @return [Array<NamedAttribute>] Additional named attributes
+      # @!attribute [r] contents
+      #   @return [Array<Paragraph>] Paragraph content within this section
+      # @!attribute [r] sections
+      #   @return [Array<Section>] Nested subsections
+      #
+      # @example Create a section
+      #   section = Coradoc::AsciiDoc::Model::Section.new(
+      #     title: Coradoc::AsciiDoc::Model::Title.new("Chapter 1"),
+      #     contents: [Coradoc::AsciiDoc::Model::Paragraph.new("Content here")]
+      #   )
+      #
+      # @example Create nested sections
+      #   parent = Coradoc::AsciiDoc::Model::Section.new(
+      #     title: Coradoc::AsciiDoc::Model::Title.new("Parent Section")
+      #   )
+      #   child = Coradoc::AsciiDoc::Model::Section.new(
+      #     title: Coradoc::AsciiDoc::Model::Title.new("Child Section")
+      #   )
+      #   parent.sections << child
+      #
+      class Section < Base
+        include Coradoc::AsciiDoc::Model::Anchorable
+
+        def block_level?
+          true
+        end
+
+        attribute :id, :string
+        attribute :content, :string
+        attribute :title, Coradoc::AsciiDoc::Model::Title
+        attribute :attrs,
+                  Coradoc::AsciiDoc::Model::NamedAttribute,
+                  collection: true,
+                  initialize_empty: true
+        attribute :contents,
+                  Coradoc::AsciiDoc::Model::Paragraph,
+                  collection: true,
+                  initialize_empty: true
+        attribute :sections,
+                  Coradoc::AsciiDoc::Model::Section,
+                  collection: true,
+                  initialize_empty: true
+        # attribute :anchor, Coradoc::AsciiDoc::Model::Inline::Anchor
+
+        # Allow setting level directly during initialization
+        def initialize(**attributes)
+          level_value = attributes.delete(:level)
+          super
+          if level_value && title
+            title.level_int = level_value
+          elsif level_value
+            self.title = Coradoc::AsciiDoc::Model::Title.new(content: '', level_int: level_value)
+          end
+        end
+
+        def validate
+          validate_title_type
+          super
+        end
+
+        # Get the section level from the title
+        # @return [Integer, nil] The section level (0-5 for standard sections)
+        def level
+          title&.level_int
+        end
+
+        # Set the section level on the title
+        # @param value [Integer] The section level
+        def level=(value)
+          if title
+            title.level_int = value
+          else
+            self.title = Coradoc::AsciiDoc::Model::Title.new(content: '', level_int: value)
+          end
+        end
+
+        def safe_to_collapse?
+          title.nil? && sections.empty?
+        end
+
+        private
+
+        def validate_title_type
+          return if title.nil? || title.is_a?(Coradoc::AsciiDoc::Model::Title)
+
+          raise TypeError, "title must be a Coradoc::AsciiDoc::Model::Title, got #{title.class}"
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/model/serialization/asciidoc_adapter.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Model
+      module Serialization
+        # Adapter for AsciiDoc serialization in Lutaml::Model format registry.
+        #
+        # This is a standalone adapter class that delegates to Coradoc's
+        # parsing infrastructure. It does NOT inherit from Base to avoid
+        # circular dependencies with the format registration system.
+        #
+        class AsciidocAdapter
+          # Delegate to Model::Document for AST creation
+          def self.from_ast(elements)
+            # Lazy reference to avoid loading Document before format is registered
+            Coradoc::AsciiDoc::Model::Document.from_ast(elements)
+          end
+
+          # Delegate to Coradoc.parse for parsing
+          def self.parse(string)
+            Coradoc.parse(string)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/model/serialization/asciidoc_mapping.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Model
+      module Serialization
+        # Define the DSL for defining mappings in Asciidoc format
+        class AsciidocMapping < Lutaml::Model::Mapping
+          attr_reader :mappings
+
+          def initialize
+            super
+            @mappings = []
+          end
+
+          def map_model(to:)
+            add_mapping('__element', to, field_type: :parsed_element)
+          end
+
+          def map_content(to:)
+            add_mapping('__content', to, field_type: :content)
+          end
+
+          def map_attribute(name, to:, render_nil: false)
+            add_mapping(
+              name,
+              to,
+              field_type: :attributes,
+              render_nil: render_nil
+            )
+          end
+
+          private
+
+          def add_mapping(name, to, **options)
+            @mappings << AsciidocMappingRule.new(name, to: to, **options)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/model/serialization/asciidoc_mapping_rule.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Model
+      module Serialization
+        class AsciidocMappingRule < Lutaml::Model::MappingRule
+          # Can be :parsed_element, :content, or :attributes
+          attr_reader :field_type
+
+          def initialize(
+            name,
+            to:,
+            render_nil: false,
+            field_type: :attributes
+          )
+            super(name, to:, render_nil:)
+            @field_type = field_type
+          end
+
+          def model_map?
+            field_type == :parsed_element
+          end
+
+          def content?
+            field_type == :content
+          end
+
+          def deep_dup
+            self.class.new(
+              name.dup,
+              to: to.dup,
+              render_nil: render_nil.dup,
+              field_type:
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/model/serialization/asciidoc_transform.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Model
+      module Serialization
+        # Transform class for converting between Coradoc::Element and Lutaml::Model objects
+        #
+        # This handles bidirectional transformation for AsciiDoc serialization:
+        # - data_to_model: Coradoc::Element -> Lutaml::Model::Serializable
+        # - model_to_data: Lutaml::Model::Serializable -> Coradoc::Element
+        #
+        class AsciidocTransform < Lutaml::Model::Transform
+          # Convert Coradoc::Element data to Lutaml::Model instance
+          #
+          # @param context [Context] The context with attribute and mapping management
+          # @param data [Coradoc::Element::Base] The Coradoc element to convert
+          # @param format [Symbol] The format type (:asciidoc)
+          # @param options [Hash] Additional options
+          # @return [Lutaml::Model::Serializable] The model instance
+          def self.data_to_model(context, data, _format, options = {})
+            new(context).data_to_model(data, options)
+          end
+
+          # Convert Lutaml::Model instance to Coradoc::Element data
+          #
+          # @param context [Context] The context with attribute and mapping management
+          # @param model [Lutaml::Model::Serializable] The model to convert
+          # @param format [Symbol] The format type (:asciidoc)
+          # @param options [Hash] Additional options
+          # @return [Coradoc::Element::Base] The Coradoc element
+          def self.model_to_data(context, model, _format, options = {})
+            new(context).model_to_data(model, options)
+          end
+
+          # Transform Coradoc::Element to model instance
+          def data_to_model(data, options = {})
+            return nil if data.nil?
+
+            # Get mappings for asciidoc format
+            mappings = context.mappings_for(:asciidoc)
+            return nil unless mappings
+
+            mapping_rules = mappings.mappings
+            return nil unless mapping_rules
+
+            # Find the parsed_element mapping to get target class
+            parsed_element_rule = mapping_rules.find { |m| m.field_type == :parsed_element }
+            return nil unless parsed_element_rule
+
+            target_class = parsed_element_rule.to
+            return nil unless target_class
+
+            # Validate data type if from is specified
+            return nil if parsed_element_rule.from && !data.is_a?(parsed_element_rule.from)
+
+            # Create instance and populate attributes
+            instance = target_class.new
+            attributes = target_class.attributes
+            defaults_used = []
+
+            mapping_rules.reject(&:model_map?).each do |rule|
+              attr = attributes[rule.to]
+              next if attr&.derived?
+
+              # Get value from source data
+              source_value = data.public_send(rule.name || rule.to)
+
+              # Transform the value
+              value = transform_value(source_value, attr, options)
+
+              # Handle defaults
+              if value.nil? && (instance.using_default?(rule.to) || rule.render_default)
+                defaults_used << rule.to
+                value = attr&.default || rule.to_value_for(instance)
+              end
+
+              # Apply value map if present
+              value = apply_value_map(value, rule.value_map(:from, options), attr)
+
+              # Set the value
+              instance.public_send(:"#{rule.to}=", value) if value
+            end
+
+            # Mark defaults as used
+            defaults_used.each { |attr_name| instance.using_default_for(attr_name) }
+
+            instance
+          end
+
+          # Transform model instance to Coradoc::Element
+          def model_to_data(model, options = {})
+            return nil if model.nil?
+
+            # Get mappings for asciidoc format
+            mappings = context.mappings_for(:asciidoc)
+            return nil unless mappings
+
+            mapping_rules = mappings.mappings
+            return nil unless mapping_rules
+
+            # Find the parsed_element mapping to get target class
+            parsed_element_rule = mapping_rules.find { |m| m.field_type == :parsed_element }
+            return nil unless parsed_element_rule
+
+            target_class = parsed_element_rule.from
+            return nil unless target_class
+
+            # Create instance and populate attributes
+            attributes = model.class.attributes
+            instance = target_class.new
+
+            mapping_rules.reject(&:model_map?).each do |rule|
+              attr = attributes[rule.to]
+              next if attr&.derived?
+
+              # Get value from model
+              model_value = model.public_send(rule.to)
+              next if model_value.nil?
+
+              # Transform the value back
+              value = transform_value_to_data(model_value, attr, options)
+
+              # Set on target instance
+              target_attr = rule.name || rule.to
+              instance.public_send(:"#{target_attr}=", value)
+            end
+
+            instance
+          end
+
+          protected
+
+          # Transform a value from data to model format
+          def transform_value(value, attr, options = {})
+            return nil if value.nil?
+
+            case value
+            when Array
+              value.map { |v| transform_single_value(v, attr, options) }
+            else
+              transform_single_value(value, attr, options)
+            end
+          end
+
+          # Transform a single value
+          def transform_single_value(value, attr, options = {})
+            case value
+            when Lutaml::Model::Type::Value
+              value.value
+            when Lutaml::Model::Serializable
+              # Recursively transform nested models
+              self.class.data_to_model(context, value, :asciidoc, options)
+            when Coradoc::Element::Base
+              # Already a Coradoc element, may need conversion
+              if attr&.type&.<(Lutaml::Model::Type::Value)
+                value.is_a?(Coradoc::AsciiDoc::Model::Base) && value.class.attributes.key?(:content) ? value.content : value.to_s
+              else
+                value
+              end
+            else
+              value
+            end
+          end
+
+          # Transform a value from model to data format
+          def transform_value_to_data(value, attr, options = {})
+            case value
+            when Array
+              value.map { |v| transform_single_value_to_data(v, attr, options) }
+            else
+              transform_single_value_to_data(value, attr, options)
+            end
+          end
+
+          # Transform a single value to data format
+          def transform_single_value_to_data(value, _attr, options = {})
+            case value
+            when Lutaml::Model::Serializable
+              # Recursively transform back to Coradoc element
+              self.class.model_to_data(context, value, :asciidoc, options)
+            when Lutaml::Model::Type::Value
+              value.value
+            else
+              value
+            end
+          end
+
+          # Apply value map transformation if present
+          def apply_value_map(value, value_map, _attr)
+            return value unless value_map
+
+            case value_map[:type]
+            when :symbolize_keys
+              value.transform_keys(&:to_sym) if value.is_a?(Hash)
+            when :stringify_keys
+              value.transform_keys(&:to_s) if value.is_a?(Hash)
+            else
+              value
+            end
+          end
+
+          # Get mappings for asciidoc format
+          def mappings
+            @mappings ||= context.mappings_for(:asciidoc)&.mappings || []
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/model/serialization/errors.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Model
+      module Serialization
+        module Errors
+          # Base class for all AsciiDoc serialization errors
+          # Inherits from Coradoc::Error for consistent error handling
+          class AsciidocError < Coradoc::Error; end
+
+          # Raised when parsing invalid AsciiDoc content
+          class ParseError < AsciidocError
+            attr_reader :input, :line_number
+
+            def initialize(message, input: nil, line_number: nil)
+              @input = input
+              @line_number = line_number
+              super(message)
+            end
+          end
+
+          # Raised when attribute mapping fails
+          class MappingError < AsciidocError
+            attr_reader :field_name, :value
+
+            def initialize(message, field_name: nil, value: nil)
+              @field_name = field_name
+              @value = value
+              super(message)
+            end
+          end
+
+          # Raised when required fields are missing
+          class ValidationError < AsciidocError
+            attr_reader :field_name
+
+            def initialize(message, field_name: nil)
+              @field_name = field_name
+              super(message)
+            end
+          end
+
+          # Raised when trying to serialize invalid model state
+          class SerializationError < AsciidocError
+            attr_reader :object
+
+            def initialize(message, object: nil)
+              @object = object
+              super(message)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Model
+      # Serialization support for AsciiDoc models.
+      #
+      # This module registers the `asciidoc` format with Lutaml::Model,
+      # enabling the `asciidoc do ... end` DSL in model classes.
+      #
+      # IMPORTANT: This module must be loaded BEFORE any model class
+      # that uses the `asciidoc` DSL. It is loaded eagerly by model.rb
+      # to ensure the format is registered early.
+      #
+      module Serialization
+        # Load all serialization components eagerly (they're small and interdependent)
+        require_relative 'serialization/errors'
+        require_relative 'serialization/asciidoc_adapter'
+        require_relative 'serialization/asciidoc_mapping_rule'
+        require_relative 'serialization/asciidoc_mapping'
+        require_relative 'serialization/asciidoc_transform'
+
+        # Register the asciidoc format with Lutaml::Model
+        # This enables the `asciidoc do ... end` DSL in model classes
+        def self.register_format!
+          Lutaml::Model::FormatRegistry.register(
+            :asciidoc,
+            mapping_class: AsciidocMapping,
+            adapter_class: AsciidocAdapter,
+            transformer: AsciidocTransform
+          )
+        end
+
+        # Register format when this module is loaded
+        register_format!
+      end
+    end
+  end
+end