coradoc 2.0.23 → 2.0.24

data/lib/coradoc/document_builder.rb

@@ -1,184 +0,0 @@
-# frozen_string_literal: true
-
-module Coradoc
-  class DocumentBuilder
-    attr_reader :document
-
-    def self.build(&block)
-      builder = new
-      builder.instance_eval(&block) if block_given?
-      builder
-    end
-
-    def initialize
-      @document = CoreModel::DocumentElement.new(
-        children: []
-      )
-      @current_context = @document
-      @context_stack = []
-    end
-
-    def title(text)
-      @document.title = text
-      self
-    end
-
-    def section(title_text, level: 1, &block)
-      new_section = CoreModel::SectionElement.new(
-        level: level,
-        title: title_text,
-        children: []
-      )
-
-      @current_context.children << new_section
-
-      if block_given?
-        push_context(new_section)
-        instance_eval(&block)
-        pop_context
-      end
-
-      self
-    end
-
-    def paragraph(text)
-      @current_context.children << CoreModel::ParagraphBlock.new(
-        content: text
-      )
-      self
-    end
-
-    def code(code_text, language: nil)
-      @current_context.children << CoreModel::SourceBlock.new(
-        content: code_text,
-        language: language
-      )
-      self
-    end
-
-    def blockquote(text, attribution: nil)
-      block = CoreModel::QuoteBlock.new(
-        content: text,
-        attribution: attribution
-      )
-      @current_context.children << block
-      self
-    end
-
-    def list(type = :unordered, &block)
-      list_items = []
-      list_type = type
-
-      wrapper = Object.new
-      wrapper.define_singleton_method(:item) do |text|
-        marker = list_type == :ordered ? '1.' : '*'
-        list_items << CoreModel::ListItem.new(content: text, marker: marker)
-        wrapper
-      end
-
-      wrapper.instance_eval(&block) if block_given?
-
-      @current_context.children << CoreModel::ListBlock.new(
-        marker_type: type.to_s,
-        items: list_items
-      )
-      self
-    end
-
-    alias ordered_list list
-    alias unordered_list list
-
-    def bulleted_list(&block)
-      list(:unordered, &block)
-    end
-
-    def numbered_list(&block)
-      list(:ordered, &block)
-    end
-
-    def image(src, alt: '', title: nil)
-      img = CoreModel::Image.new(src: src, alt: alt)
-      img.title = title if title
-      @current_context.children << img
-      self
-    end
-
-    def table(headers = [], rows = [])
-      table_rows = []
-
-      if headers.any?
-        header_cells = headers.map { |h| CoreModel::TableCell.new(content: h, header: true) }
-        table_rows << CoreModel::TableRow.new(cells: header_cells)
-      end
-
-      rows.each do |row|
-        cells = row.map { |c| CoreModel::TableCell.new(content: c.to_s) }
-        table_rows << CoreModel::TableRow.new(cells: cells)
-      end
-
-      @current_context.children << CoreModel::Table.new(rows: table_rows)
-      self
-    end
-
-    def hr
-      @current_context.children << CoreModel::HorizontalRuleBlock.new
-      self
-    end
-
-    def text(text_content)
-      @current_context.children << CoreModel::Block.new(
-        content: text_content
-      )
-      self
-    end
-
-    def admonition(type, text)
-      @current_context.children << CoreModel::AnnotationBlock.new(
-        annotation_type: type.to_s,
-        content: text
-      )
-      self
-    end
-
-    %i[note warning tip important caution].each do |admonition_type|
-      define_method(admonition_type) do |text|
-        admonition(admonition_type, text)
-      end
-    end
-
-    def to_core
-      @document
-    end
-
-    def to(format, **options)
-      Coradoc.serialize(@document, to: format, **options)
-    end
-
-    def to_html(**options)
-      to(:html, **options)
-    end
-
-    def to_markdown(**options)
-      to(:markdown, **options)
-    end
-
-    def to_asciidoc(**options)
-      to(:asciidoc, **options)
-    end
-
-    private
-
-    def push_context(new_context)
-      @context_stack << @current_context
-      @current_context = new_context
-    end
-
-    def pop_context
-      @current_context = @context_stack.pop
-    end
-  end
-
-  def self.build(&block)
-    DocumentBuilder.build(&block)
-  end
-end

data/lib/coradoc/document_manipulator.rb

@@ -1,203 +0,0 @@
-# frozen_string_literal: true
-
-module Coradoc
-  class DocumentManipulator
-    attr_reader :document
-
-    def initialize(document)
-      unless document.is_a?(Coradoc::CoreModel::Base)
-        raise ArgumentError,
-              "Expected CoreModel::Base, got #{document.class}"
-      end
-
-      @document = document
-    end
-
-    def query(selector)
-      Coradoc::Query.query(@document, selector).to_a
-    end
-
-    def select_sections(level: nil, title: nil)
-      filtered = filter_sections(@document, level: level, title: title)
-      DocumentManipulator.new(filtered)
-    end
-
-    def transform_text
-      return self unless block_given?
-
-      Visitor::Transformer.new do |element|
-        case element
-        when CoreModel::InlineElement
-          element.content = yield(element.content) if element.content.is_a?(String)
-        when CoreModel::Block
-          element.content = yield(element.content) if element.content.is_a?(String)
-        end
-      end.visit(@document)
-      self
-    end
-
-    def transform_headings
-      return self unless block_given?
-
-      Visitor::Transformer.new do |element|
-        element.title = yield(element.title) if element.is_a?(CoreModel::StructuralElement) && element.title.is_a?(String)
-      end.visit(@document)
-      self
-    end
-
-    def add_toc(levels: 3, position: :top)
-      sections = collect_sections(@document, max_level: levels)
-      toc = CoreModel::TocGenerator.generate(sections)
-
-      toc_element = CoreModel::Block.new(block_semantic_type: 'toc', content: toc)
-      case position
-      when :top
-        @document.children = [toc_element] + @document.children
-      when :bottom
-        @document.children = @document.children + [toc_element]
-      end
-
-      self
-    end
-
-    def remove_elements(element_type)
-      Visitor::Transformer.new do |element|
-        next unless element.is_a?(CoreModel::StructuralElement) && element.children
-
-        element.children.reject! do |child|
-          match_element_type?(child, element_type)
-        end
-      end.visit(@document)
-      self
-    end
-
-    def add_metadata(metadata)
-      metadata.each do |key, value|
-        @document.set_metadata(key.to_s, value.to_s)
-      end
-      self
-    end
-
-    def set_title(title)
-      @document.title = title
-      self
-    end
-
-    def set_id(id)
-      @document.id = id
-      self
-    end
-
-    def to_html(**options)
-      Coradoc.serialize(@document, to: :html, **options)
-    end
-
-    def to_markdown(**options)
-      Coradoc.serialize(@document, to: :markdown, **options)
-    end
-
-    def to_asciidoc(**options)
-      Coradoc.serialize(@document, to: :asciidoc, **options)
-    end
-
-    def to(format, **options)
-      Coradoc.serialize(@document, to: format, **options)
-    end
-
-    def to_core
-      @document
-    end
-
-    def clone
-      DocumentManipulator.new(deep_clone(@document))
-    end
-
-    private
-
-    def match_element_type?(child, element_type)
-      return false unless child.is_a?(CoreModel::Block)
-
-      case element_type
-      when :comment_line, :comment_block
-        child.is_a?(CoreModel::CommentBlock)
-      else
-        child.resolve_semantic_type == element_type.to_sym
-      end
-    end
-
-    def filter_sections(element, level: nil, title: nil)
-      if element.is_a?(CoreModel::StructuralElement) && element.children
-        element.children = element.children
-                                  .map { |child| filter_sections(child, level: level, title: title) }
-                                  .compact
-      end
-
-      return nil if element.is_a?(CoreModel::StructuralElement) && element.section? && !element.document? && !section_matches?(
-        element, level: level, title: title
-      )
-
-      element
-    end
-
-    def section_matches?(section, level: nil, title: nil)
-      if level
-        element_level = section.heading_level
-        case level
-        when Range then return false unless level.include?(element_level)
-        when Integer then return false unless element_level == level
-        end
-      end
-
-      if title
-        element_title = section.title || ''
-        case title
-        when String then return false unless element_title.include?(title)
-        when Regexp then return false unless element_title&.match?(title)
-        end
-      end
-
-      true
-    end
-
-    def collect_sections(element, max_level: 3, current_level: 1)
-      sections = []
-      return sections unless element.is_a?(CoreModel::StructuralElement)
-
-      element.children.each do |child|
-        next unless child.is_a?(CoreModel::StructuralElement) &&
-                    child.section? && (current_level <= max_level)
-
-        sections << {
-          id: child.id,
-          title: child.title,
-          level: child.level || current_level,
-          children: collect_sections(child, max_level: max_level,
-                                            current_level: current_level + 1)
-        }
-      end
-
-      sections
-    end
-
-    def deep_clone(element)
-      case element
-      when CoreModel::Base
-        cloned = element.class.new
-        element.class.attributes.each_key do |name|
-          cloned.public_send("#{name}=", deep_clone(element.public_send(name)))
-        end
-        cloned
-      when Array
-        element.map { |item| deep_clone(item) }
-      when Hash
-        element.transform_values { |v| deep_clone(v) }
-      else
-        begin
-          element.dup
-        rescue StandardError
-          element
-        end
-      end
-    end
-  end
-end

data/lib/coradoc/input.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'processor_registry'
-
-module Coradoc
-  # Input module for document ingestion
-  #
-  # Provides a unified interface for document input processing.
-  # Format-specific input processors register themselves with this module.
-  #
-  # @example Registering an input processor
-  #   Coradoc::Input.define(MyHtmlProcessor)
-  #
-  # @example Using a registered processor
-  #   processor = Coradoc::Input.for(:html)
-  #   document = processor.convert(html_content)
-  #
-  module Input
-    extend ProcessorRegistry
-    self.error_label = 'input processor'
-  end
-end

data/lib/coradoc/output.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'processor_registry'
-
-module Coradoc
-  # Output module for document serialization
-  #
-  # Provides a unified interface for document output processing.
-  # Format-specific output processors register themselves with this module.
-  #
-  # @example Registering an output processor
-  #   Coradoc::Output.define(MyHtmlProcessor)
-  #
-  # @example Using a registered processor
-  #   processor = Coradoc::Output.get(:html_static)
-  #   html = processor.processor_execute(document, {})
-  #
-  module Output
-    extend ProcessorRegistry
-    self.error_label = 'output processor'
-  end
-end

data/lib/coradoc/processor_registry.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-module Coradoc
-  # Module adapter that gives a module Registry-backed processor methods.
-  #
-  # Both Input and Output extend this module to get processor registration,
-  # lookup, and dispatch methods. All state is stored in a Registry instance.
-  #
-  # @api private
-  #
-  # @example
-  #   module Input
-  #     extend ProcessorRegistry
-  #     self.error_label = "input processor"
-  #   end
-  module ProcessorRegistry
-    def error_label=(label)
-      @error_label = label
-    end
-
-    def registry
-      @registry ||= Registry.new(error_label: @error_label)
-    end
-
-    def define(processor, **options)
-      registry.define(processor, **options)
-    end
-
-    def get(id)
-      registry.get(id)
-    end
-    alias [] get
-
-    def registered?(id)
-      registry.registered?(id)
-    end
-
-    def processors
-      registry.items
-    end
-
-    def for_file(filename)
-      registry.for_file(filename)
-    end
-
-    def process(content, options = {})
-      registry.process(content, options)
-    end
-  end
-end

data/lib/coradoc/serializer/registry.rb

@@ -1,150 +0,0 @@
-# frozen_string_literal: true
-
-module Coradoc
-  module Serializer
-    # Registry for document element serializers
-    #
-    # Provides a registry-based pattern for looking up serializers
-    # for document element types. This allows users to register
-    # custom serializers for their own element types or override
-    # existing serializers.
-    #
-    # @example Registering a custom serializer
-    #   Coradoc::Serializer::Registry.register(MyCustomElement, MyCustomSerializer)
-    #
-    # @example Looking up a serializer
-    #   serializer = Coradoc::Serializer::Registry.lookup(element)
-    #   output = serializer.serialize(element) if serializer
-    #
-    class Registry
-      class << self
-        # Get the global registry instance
-        #
-        # @return [Hash] the registry hash
-        def registry
-          @registry ||= {}
-        end
-
-        # Register a serializer for a model class
-        #
-        # @param model_class [Class] The model class to serialize
-        # @param serializer_class [Class] The serializer class to use
-        # @return [Class, nil] The previous serializer class, if any
-        def register(model_class, serializer_class)
-          key = class_key(model_class)
-          previous = registry[key]
-          registry[key] = serializer_class
-          previous
-        end
-
-        # Unregister a serializer for a model class
-        #
-        # @param model_class [Class] The model class to unregister
-        # @return [Class, nil] The removed serializer class, if any
-        def unregister(model_class)
-          key = class_key(model_class)
-          registry.delete(key)
-        end
-
-        # Look up a serializer for a model instance or class
-        #
-        # @param model [Object, Class] The model instance or class
-        # @return [Class, nil] The serializer class, or nil if not found
-        def lookup(model)
-          model_class = model.is_a?(Class) ? model : model.class
-          key = class_key(model_class)
-
-          # Direct lookup
-          return registry[key] if registry.key?(key)
-
-          # Try parent classes
-          model_class.ancestors.each do |ancestor|
-            next if ancestor == model_class || ancestor == Object
-
-            ancestor_key = class_key(ancestor)
-            return registry[ancestor_key] if registry.key?(ancestor_key)
-          end
-
-          nil
-        end
-
-        # Check if a serializer is registered for a model
-        #
-        # @param model [Object, Class] The model instance or class
-        # @return [Boolean] true if a serializer is registered
-        def registered?(model)
-          !lookup(model).nil?
-        end
-
-        # Get all registered model classes
-        #
-        # @return [Array<Class>] Array of registered model classes
-        def registered_models
-          registry.keys
-        end
-
-        # Clear all registered serializers
-        #
-        # @return [Hash] Empty registry
-        def clear
-          @registry = {}
-        end
-
-        # Serialize a model using its registered serializer
-        #
-        # @param model [Object] The model to serialize
-        # @param format [Symbol] The output format (:adoc, :html, :md, etc.)
-        # @param options [Hash] Additional serialization options
-        # @return [String, nil] The serialized output, or nil if no serializer found
-        def serialize(model, format: :adoc, **options)
-          serializer_class = lookup(model)
-          return nil unless serializer_class
-
-          serializer = serializer_class.is_a?(Class) ? serializer_class.new : serializer_class
-
-          if serializer.is_a?(Base)
-            serializer.serialize(model, format: format, **options)
-          else
-            serializer.to_s
-          end
-        end
-
-        private
-
-        # Generate a registry key for a class
-        def class_key(klass)
-          klass.name.to_s
-        end
-      end
-    end
-
-    # Base class for element serializers
-    #
-    # Provides a common interface for all serializers.
-    # Subclasses should implement #serialize method.
-    #
-    # @example Creating a custom serializer
-    #   class MyElementSerializer < Coradoc::Serializer::Base
-    #     def serialize(element, format: :adoc, **options)
-    #       "Custom: #{element.text}"
-    #     end
-    #   end
-    #
-    class Base
-      # Serialize an element to the target format
-      #
-      # @param element [Object] The element to serialize
-      # @param format [Symbol] The output format
-      # @param options [Hash] Additional options
-      # @return [String] The serialized output
-      def serialize(element, format: :adoc, **_options)
-        element.to_s
-      end
-
-      # Class method for serialization
-      def self.serialize(element, **options)
-        new.serialize(element, **options)
-      end
-    end
-  end
-end

data/lib/coradoc/transform/base.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module Coradoc
-  module Transform
-    module Base
-      def self.included(base)
-        base.extend(ClassMethods)
-      end
-
-      module ClassMethods
-        def transform(model)
-          raise NotImplementedError, "#{name} must implement .transform"
-        end
-      end
-
-      def transform(model)
-        self.class.transform(model)
-      end
-    end
-  end
-end

data/lib/coradoc/transform.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-module Coradoc
-  module Transform
-    autoload :Base, "#{__dir__}/transform/base"
-  end
-end