coradoc-adoc 2.0.7 → 2.0.8

data/lib/coradoc/asciidoc/transform/to_core_model_registrations.rb

@@ -3,8 +3,14 @@
 module Coradoc
   module AsciiDoc
     module Transform
-      # Registers all default AsciiDoc -> CoreModel transformers
       module ToCoreModelRegistrations
+        Doc = ElementTransformers::DocumentTransformer
+        Blk = ElementTransformers::BlockTransformer
+        Lst = ElementTransformers::ListTransformer
+        Inl = ElementTransformers::InlineTransformer
+        Tbl = ElementTransformers::TableTransformer
+        Oth = ElementTransformers::OtherTransformer
+
         class << self
           def register_all!
             register_document_transformers!
@@ -20,24 +26,24 @@ module Coradoc
           def register_document_transformers!
             Registry.register(
               Coradoc::AsciiDoc::Model::Document,
-              method_wrapper(:transform_document)
+              ->(model) { Doc.transform_document(model) }
             )
 
             Registry.register(
               Coradoc::AsciiDoc::Model::Section,
-              method_wrapper(:transform_section)
+              ->(model) { Doc.transform_section(model) }
             )
 
             Registry.register(
               Coradoc::AsciiDoc::Model::Paragraph,
-              method_wrapper(:transform_paragraph)
+              ->(model) { Blk.transform_paragraph(model) }
             )
           end
 
           def register_block_transformers!
             Registry.register_with_priority(
               Coradoc::AsciiDoc::Model::Block::SourceCode,
-              METHOD_DISPATCH[:transform_source_block],
+              ->(model) { Blk.transform_source_block(model) },
               priority: 10
             )
 
@@ -51,14 +57,14 @@ module Coradoc
             }.each do |block_class, core_model_class|
               Registry.register_with_priority(
                 block_class,
-                typed_block_wrapper(core_model_class),
+                ->(model) { Blk.transform_typed_block(model, core_model_class) },
                 priority: 10
               )
             end
 
             Registry.register(
               Coradoc::AsciiDoc::Model::Block::Core,
-              block_model_wrapper
+              ->(model) { Blk.transform_block(model, model.delimiter.to_s) }
             )
 
             Registry.register(
@@ -74,17 +80,17 @@ module Coradoc
           def register_list_transformers!
             Registry.register(
               Coradoc::AsciiDoc::Model::List::Unordered,
-              list_wrapper('unordered')
+              ->(model) { Lst.transform_list(model, 'unordered') }
             )
 
             Registry.register(
               Coradoc::AsciiDoc::Model::List::Ordered,
-              list_wrapper('ordered')
+              ->(model) { Lst.transform_list(model, 'ordered') }
             )
 
             Registry.register(
               Coradoc::AsciiDoc::Model::List::Definition,
-              list_wrapper('definition')
+              ->(model) { Lst.transform_list(model, 'definition') }
             )
           end
 
@@ -100,33 +106,33 @@ module Coradoc
             ].each do |inline_class, format_type|
               Registry.register(
                 inline_class,
-                inline_wrapper(format_type)
+                ->(model) { Inl.transform_inline(model, format_type) }
               )
             end
 
             Registry.register(
               Coradoc::AsciiDoc::Model::Inline::Underline,
-              inline_text_wrapper('underline')
+              ->(model) { Inl.transform_inline_text(model, 'underline') }
             )
 
             Registry.register(
               Coradoc::AsciiDoc::Model::Inline::Link,
-              method_wrapper(:transform_link)
+              ->(model) { Inl.transform_link(model) }
             )
 
             Registry.register(
               Coradoc::AsciiDoc::Model::Inline::CrossReference,
-              method_wrapper(:transform_cross_reference)
+              ->(model) { Inl.transform_cross_reference(model) }
             )
 
             Registry.register(
               Coradoc::AsciiDoc::Model::Inline::Footnote,
-              method_wrapper(:transform_inline_footnote)
+              ->(model) { Inl.transform_inline_footnote(model) }
             )
 
             Registry.register(
               Coradoc::AsciiDoc::Model::Inline::Stem,
-              method_wrapper(:transform_stem)
+              ->(model) { Inl.transform_stem(model) }
             )
 
             Registry.register(
@@ -143,47 +149,46 @@ module Coradoc
           def register_table_transformers!
             Registry.register(
               Coradoc::AsciiDoc::Model::Table,
-              method_wrapper(:transform_table)
+              ->(model) { Tbl.transform_table(model) }
             )
 
             Registry.register(
               Coradoc::AsciiDoc::Model::TableRow,
-              method_wrapper(:transform_table_row)
+              ->(model) { Tbl.transform_table_row(model) }
             )
 
             Registry.register(
               Coradoc::AsciiDoc::Model::TableCell,
-              method_wrapper(:transform_table_cell)
+              ->(model) { Tbl.transform_table_cell(model) }
             )
           end
 
           def register_other_transformers!
             Registry.register(
               Coradoc::AsciiDoc::Model::Term,
-              method_wrapper(:transform_term)
+              ->(model) { Oth.transform_term(model) }
             )
 
             Registry.register(
               Coradoc::AsciiDoc::Model::Admonition,
-              method_wrapper(:transform_admonition)
+              ->(model) { Oth.transform_admonition(model) }
             )
 
             Registry.register(
               Coradoc::AsciiDoc::Model::Image::BlockImage,
-              method_wrapper(:transform_image)
+              ->(model) { Oth.transform_image(model) }
             )
 
             Registry.register(
               Coradoc::AsciiDoc::Model::Bibliography,
-              method_wrapper(:transform_bibliography)
+              ->(model) { Oth.transform_bibliography(model) }
             )
 
             Registry.register(
               Coradoc::AsciiDoc::Model::BibliographyEntry,
-              method_wrapper(:transform_bibliography_entry)
+              ->(model) { Oth.transform_bibliography_entry(model) }
             )
 
-            # Passthrough types (no CoreModel equivalent)
             [
               Coradoc::AsciiDoc::Model::TextElement,
               Coradoc::AsciiDoc::Model::Include,
@@ -195,57 +200,13 @@ module Coradoc
               Registry.register(klass, ->(model) { model })
             end
 
-            # Filtered types (layout-only, no CoreModel representation)
             [
               Coradoc::AsciiDoc::Model::LineBreak,
               Coradoc::AsciiDoc::Model::Break::PageBreak
             ].each do |klass|
-              Registry.register(klass, ->(_model) { nil })
+              Registry.register(klass, ->(_model) {})
             end
           end
-
-          METHOD_DISPATCH = {
-            transform_document: ->(model) { ToCoreModel.transform_document(model) },
-            transform_section: ->(model) { ToCoreModel.transform_section(model) },
-            transform_paragraph: ->(model) { ToCoreModel.transform_paragraph(model) },
-            transform_source_block: ->(model) { ToCoreModel.transform_source_block(model) },
-            transform_link: ->(model) { ToCoreModel.transform_link(model) },
-            transform_cross_reference: ->(model) { ToCoreModel.transform_cross_reference(model) },
-            transform_inline_footnote: ->(model) { ToCoreModel.transform_inline_footnote(model) },
-            transform_stem: ->(model) { ToCoreModel.transform_stem(model) },
-            transform_table: ->(model) { ToCoreModel.transform_table(model) },
-            transform_table_row: ->(model) { ToCoreModel.transform_table_row(model) },
-            transform_table_cell: ->(model) { ToCoreModel.transform_table_cell(model) },
-            transform_term: ->(model) { ToCoreModel.transform_term(model) },
-            transform_admonition: ->(model) { ToCoreModel.transform_admonition(model) },
-            transform_image: ->(model) { ToCoreModel.transform_image(model) },
-            transform_bibliography: ->(model) { ToCoreModel.transform_bibliography(model) },
-            transform_bibliography_entry: ->(model) { ToCoreModel.transform_bibliography_entry(model) }
-          }.freeze
-
-          def method_wrapper(method_name)
-            METHOD_DISPATCH.fetch(method_name)
-          end
-
-          def typed_block_wrapper(klass)
-            ->(model) { ToCoreModel.transform_typed_block(model, klass) }
-          end
-
-          def block_model_wrapper
-            ->(model) { ToCoreModel.transform_block(model, model.delimiter.to_s) }
-          end
-
-          def list_wrapper(marker_type)
-            ->(model) { ToCoreModel.transform_list(model, marker_type) }
-          end
-
-          def inline_wrapper(format_type)
-            ->(model) { ToCoreModel.transform_inline(model, format_type) }
-          end
-
-          def inline_text_wrapper(format_type)
-            ->(model) { ToCoreModel.transform_inline_text(model, format_type) }
-          end
         end
       end
     end

data/lib/coradoc/asciidoc/transform/transformer_registry.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Transform
+      class TransformerRegistry
+        class << self
+          def registry
+            @registry ||= {}
+          end
+
+          def register(source_class, transformer, target_class: nil)
+            registry[source_class] = transformer
+
+            return unless target_class
+
+            reverse_registry[target_class] = transformer
+          end
+
+          def register_with_priority(source_class, transformer, priority: 0)
+            @prioritized_registry ||= []
+            @prioritized_registry << {
+              class: source_class,
+              transformer: transformer,
+              priority: priority
+            }
+            @prioritized_registry.sort_by! { |e| -e[:priority] }
+          end
+
+          def lookup(model_class)
+            return registry[model_class] if registry.key?(model_class)
+
+            if @prioritized_registry
+              entry = @prioritized_registry.find { |e| model_class <= e[:class] }
+              return entry[:transformer] if entry
+            end
+
+            model_class.ancestors.each do |ancestor|
+              next if ancestor == model_class
+              next if [Object, BasicObject].include?(ancestor)
+
+              return registry[ancestor] if registry.key?(ancestor)
+            end
+
+            nil
+          end
+
+          def transform(model)
+            return model if model.nil?
+            return model.map { |item| transform(item) } if model.is_a?(Array)
+
+            transformer = lookup(model.class)
+            transformer ? transformer.call(model) : model
+          end
+
+          def registered?(model_class)
+            !lookup(model_class).nil?
+          end
+
+          def clear
+            registry.clear
+            @prioritized_registry = nil
+          end
+
+          def registered_classes
+            registry.keys
+          end
+
+          private
+
+          def reverse_registry
+            @reverse_registry ||= {}
+          end
+        end
+      end
+
+      Registry = TransformerRegistry
+    end
+  end
+end

data/lib/coradoc/asciidoc/transform.rb

@@ -3,11 +3,15 @@
 module Coradoc
   module AsciiDoc
     module Transform
-      autoload :Registry, "#{__dir__}/transform/registry"
+      autoload :TransformerRegistry, "#{__dir__}/transform/transformer_registry"
+      autoload :Registry, "#{__dir__}/transform/transformer_registry"
       autoload :ToCoreModel, "#{__dir__}/transform/to_core_model"
       autoload :ToCoreModelRegistrations, "#{__dir__}/transform/to_core_model_registrations"
       autoload :FromCoreModel, "#{__dir__}/transform/from_core_model"
       autoload :FromCoreModelRegistrations, "#{__dir__}/transform/from_core_model_registrations"
+      autoload :TextExtractVisitor, "#{__dir__}/transform/text_extract_visitor"
+      autoload :InlineTransformVisitor, "#{__dir__}/transform/inline_transform_visitor"
+      autoload :ElementTransformers, "#{__dir__}/transform/element_transformers"
     end
   end
 end

data/lib/coradoc/asciidoc/version.rb

@@ -2,6 +2,6 @@
 
 module Coradoc
   module AsciiDoc
-    VERSION = '2.0.7'
+    VERSION = '2.0.8'
   end
 end

data/lib/coradoc/asciidoc.rb

@@ -27,6 +27,7 @@ end
 # Autoload main components (lazy loading)
 module Coradoc
   module AsciiDoc
+    autoload :DelimiterMapping, "#{__dir__}/asciidoc/delimiter_mapping"
     autoload :Model, "#{__dir__}/asciidoc/model"
     autoload :Parser, "#{__dir__}/asciidoc/parser"
     autoload :Transformer, "#{__dir__}/asciidoc/transformer"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: coradoc-adoc
 version: !ruby/object:Gem::Version
-  version: 2.0.7
+  version: 2.0.8
 platform: ruby
 authors:
 - Ribose Inc.
@@ -111,6 +111,7 @@ files:
 - lib/coradoc/asciidoc/builder/element_builder.rb
 - lib/coradoc/asciidoc/builder/list_builder.rb
 - lib/coradoc/asciidoc/builder/text_builder.rb
+- lib/coradoc/asciidoc/delimiter_mapping.rb
 - lib/coradoc/asciidoc/model.rb
 - lib/coradoc/asciidoc/model/admonition.rb
 - lib/coradoc/asciidoc/model/anchorable.rb
@@ -308,11 +309,20 @@ files:
 - lib/coradoc/asciidoc/serializer/serializers/video.rb
 - lib/coradoc/asciidoc/serializer/spacing_strategy.rb
 - lib/coradoc/asciidoc/transform.rb
+- lib/coradoc/asciidoc/transform/element_transformers.rb
+- lib/coradoc/asciidoc/transform/element_transformers/block_transformer.rb
+- lib/coradoc/asciidoc/transform/element_transformers/document_transformer.rb
+- lib/coradoc/asciidoc/transform/element_transformers/inline_transformer.rb
+- lib/coradoc/asciidoc/transform/element_transformers/list_transformer.rb
+- lib/coradoc/asciidoc/transform/element_transformers/other_transformer.rb
+- lib/coradoc/asciidoc/transform/element_transformers/table_transformer.rb
 - lib/coradoc/asciidoc/transform/from_core_model.rb
 - lib/coradoc/asciidoc/transform/from_core_model_registrations.rb
-- lib/coradoc/asciidoc/transform/registry.rb
+- lib/coradoc/asciidoc/transform/inline_transform_visitor.rb
+- lib/coradoc/asciidoc/transform/text_extract_visitor.rb
 - lib/coradoc/asciidoc/transform/to_core_model.rb
 - lib/coradoc/asciidoc/transform/to_core_model_registrations.rb
+- lib/coradoc/asciidoc/transform/transformer_registry.rb
 - lib/coradoc/asciidoc/transformer.rb
 - lib/coradoc/asciidoc/transformer/block_rules.rb
 - lib/coradoc/asciidoc/transformer/header_rules.rb

data/lib/coradoc/asciidoc/transform/registry.rb

@@ -1,146 +0,0 @@
-# frozen_string_literal: true
-
-module Coradoc
-  module AsciiDoc
-    module Transform
-      # Registry for model transformers
-      #
-      # Provides a flexible, extensible way to register and lookup transformers
-      # that convert between different model types. This replaces case statements
-      # with a registry pattern, following the Open/Closed Principle.
-      #
-      # @example Register a transformer
-      #   Coradoc::AsciiDoc::Transform::Registry.register(
-      #     Coradoc::AsciiDoc::Model::Document,
-      #     ->(model) { transform_document(model) }
-      #   )
-      #
-      # @example Lookup and apply a transformer
-      #   transformer = Coradoc::AsciiDoc::Transform::Registry.lookup(model.class)
-      #   result = transformer.call(model) if transformer
-      #
-      class Registry
-        class << self
-          # Get the global registry instance
-          #
-          # @return [Hash] the registry hash
-          def registry
-            @registry ||= {}
-          end
-
-          # Register a transformer for a source class
-          #
-          # @param source_class [Class] the source model class
-          # @param transformer [#call] a callable that transforms the model
-          # @param target_class [Class, nil] optional target class for bidirectional lookup
-          # @return [void]
-          def register(source_class, transformer, target_class: nil)
-            registry[source_class] = transformer
-
-            # Store reverse mapping if target class specified
-            return unless target_class
-
-            reverse_registry[target_class] = transformer
-          end
-
-          # Register a transformer with a priority
-          #
-          # Higher priority transformers are checked first.
-          # This is useful for handling subclasses before parent classes.
-          #
-          # @param source_class [Class] the source model class
-          # @param transformer [#call] a callable that transforms the model
-          # @param priority [Integer] priority level (higher = checked first)
-          # @return [void]
-          def register_with_priority(source_class, transformer, priority: 0)
-            @prioritized_registry ||= []
-            @prioritized_registry << {
-              class: source_class,
-              transformer: transformer,
-              priority: priority
-            }
-            # Sort by priority descending
-            @prioritized_registry.sort_by! { |e| -e[:priority] }
-          end
-
-          # Lookup a transformer for a model
-          #
-          # First checks exact class match, then checks prioritized registry,
-          # then walks up the inheritance chain.
-          #
-          # @param model_class [Class] the model class to find a transformer for
-          # @return [#call, nil] the transformer or nil if not found
-          def lookup(model_class)
-            # 1. Check exact match in main registry
-            return registry[model_class] if registry.key?(model_class)
-
-            # 2. Check prioritized registry
-            if @prioritized_registry
-              entry = @prioritized_registry.find { |e| model_class <= e[:class] }
-              return entry[:transformer] if entry
-            end
-
-            # 3. Walk up inheritance chain
-            model_class.ancestors.each do |ancestor|
-              next if ancestor == model_class
-              next if [Object, BasicObject].include?(ancestor)
-
-              return registry[ancestor] if registry.key?(ancestor)
-            end
-
-            nil
-          end
-
-          # Transform a model using the registered transformer
-          #
-          # @param model [Object] the model to transform
-          # @return [Object] the transformed model
-          # @raise [ArgumentError] if no transformer is registered
-          def transform(model)
-            return model if model.nil?
-
-            # Handle arrays specially
-            return model.map { |item| transform(item) } if model.is_a?(Array)
-
-            transformer = lookup(model.class)
-            if transformer
-              transformer.call(model)
-            else
-              # Return unchanged if no transformer found
-              model
-            end
-          end
-
-          # Check if a transformer is registered for a class
-          #
-          # @param model_class [Class] the class to check
-          # @return [Boolean]
-          def registered?(model_class)
-            !lookup(model_class).nil?
-          end
-
-          # Clear all registrations (useful for testing)
-          #
-          # @return [void]
-          def clear
-            registry.clear
-            @prioritized_registry = nil
-          end
-
-          # Get all registered source classes
-          #
-          # @return [Array<Class>]
-          def registered_classes
-            registry.keys
-          end
-
-          private
-
-          def reverse_registry
-            @reverse_registry ||= {}
-          end
-        end
-      end
-    end
-  end
-end