coradoc 2.0.1 → 2.0.2

data/coradoc-adoc/lib/coradoc/asciidoc/serializer/serializers/base.rb

@@ -85,19 +85,12 @@ module Coradoc
             when Proc
               child.call
             else
-              # Handle objects that respond to to_adoc (like test doubles)
-              if child.respond_to?(:to_adoc)
-                # For non-Coradoc objects, call to_adoc without arguments
-                # Test doubles and external objects typically don't accept context
-                child.to_adoc
-              else
-                # This is a programming error - we received an unexpected type
-                raise ArgumentError,
-                      "Cannot serialize child of type #{child.class.name}. " \
-                      'Expected String, Coradoc::AsciiDoc::Model::Base, ' \
-                      'Lutaml::Model::Serializable, or Proc. ' \
-                      "Got: #{child.inspect[0..100]}"
-              end
+              # This is a programming error - we received an unexpected type
+              raise ArgumentError,
+                    "Cannot serialize child of type #{child.class.name}. " \
+                    'Expected String, Coradoc::AsciiDoc::Model::Base, ' \
+                    'Lutaml::Model::Serializable, or Proc. ' \
+                    "Got: #{child.inspect[0..100]}"
             end
           end
 
@@ -115,14 +108,10 @@ module Coradoc
             when nil
               ''
             else
-              # Try AdocSerializer first for Lutaml models
+              # Try AdocSerializer for Lutaml models
               if content.is_a?(Lutaml::Model::Serializable) || content.is_a?(Coradoc::AsciiDoc::Model::Base)
                 AdocSerializer.serialize(content)
-              # Fall back to to_adoc if available
-              elsif content.respond_to?(:to_adoc)
-                content.to_adoc
               else
-                # This is a programming error - we received an unexpected type
                 raise ArgumentError,
                       "Cannot serialize content of type #{content.class.name}. " \
                       'Expected String, nil, Array, or serializable object. ' \
@@ -163,8 +152,7 @@ module Coradoc
           # @param model [Coradoc::AsciiDoc::Model::Base] Model with attributes
           # @return [String] Formatted block attributes
           def format_block_attributes(model)
-            return '' unless model.respond_to?(:attributes) &&
-                             model.attributes
+            return '' unless model.is_a?(Lutaml::Model::Serializable) && model.attributes
 
             Formatter.block_attributes(model.attributes)
           end

data/coradoc-adoc/lib/coradoc/asciidoc/serializer/serializers/block/core.rb

@@ -52,7 +52,7 @@ module Coradoc
             def gen_anchor
               return '' unless @model.anchor
 
-              anchor_str = if @model.anchor.respond_to?(:to_adoc)
+              anchor_str = if @model.anchor.is_a?(Coradoc::AsciiDoc::Model::Base)
                              @model.anchor.to_adoc
                            else
                              @model.anchor.to_s

data/coradoc-adoc/lib/coradoc/asciidoc/serializer/serializers/document.rb

@@ -25,23 +25,20 @@ module Coradoc
             parts << "\n" if @model.sections && !@model.sections.empty? && !@model.header
 
             # Only serialize header if it has a non-empty title
-            if @model.header.respond_to?(:title) && !@model.header.title.to_s.empty?
+            if @model.header&.title && !@model.header.title.to_s.empty?
               parts << serialize_child(@model.header,
                                        @context)
             end
 
             # Only serialize document_attributes if it has data
-            if @model.document_attributes.respond_to?(:data) &&
-               @model.document_attributes.data && !@model.document_attributes.data.empty?
-              parts << serialize_child(@model.document_attributes, @context)
-            end
+            parts << serialize_child(@model.document_attributes, @context) if @model.document_attributes&.data && !@model.document_attributes.data.empty?
 
             # Serialize sections with last_element tracking
             parts << serialize_sections_with_last_element if @model.sections && !@model.sections.empty?
             result = parts.join
 
             # Clean up leading newlines when we have header
-            if @model.header.respond_to?(:title) && !@model.header.title.to_s.empty?
+            if @model.header&.title && !@model.header.title.to_s.empty?
               result = result.sub(LEADING_NEWLINES_REGEX,
                                   '')
             end

data/coradoc-adoc/lib/coradoc/asciidoc/serializer/serializers/inline/strikethrough.rb

@@ -12,7 +12,7 @@ module Coradoc
 
               return '' if content.empty?
 
-              if model.respond_to?(:unconstrained) && model.unconstrained
+              if model.unconstrained
                 "[.line-through]#[.line-through]##{content}[.line-through]#[.line-through]#"
               else
                 "[.line-through]##{content}#"

data/coradoc-adoc/lib/coradoc/asciidoc/serializer/serializers/list/item.rb

@@ -31,14 +31,10 @@ module Coradoc
                              when Coradoc::AsciiDoc::Model::Base, Lutaml::Model::Serializable
                                subitem.to_adoc
                              else
-                               if subitem.respond_to?(:to_adoc)
-                                 subitem.to_adoc
-                               else
-                                 raise ArgumentError,
-                                       "Cannot serialize list item content of type #{subitem.class.name}. " \
-                                       'Expected String, Coradoc::AsciiDoc::Model::Base, or ' \
-                                       "Lutaml::Model::Serializable. Got: #{subitem.inspect[0..100]}"
-                               end
+                               raise ArgumentError,
+                                     "Cannot serialize list item content of type #{subitem.class.name}. " \
+                                     'Expected String, Coradoc::AsciiDoc::Model::Base, or ' \
+                                     "Lutaml::Model::Serializable. Got: #{subitem.inspect[0..100]}"
                              end
 
                 inline = inline?(subitem)
@@ -90,7 +86,7 @@ module Coradoc
               attach = model.attached.map do |elem|
                 "+\n#{elem.to_adoc}"
               end.join
-              nest = model.nested.nil? || (model.nested.respond_to?(:empty?) && model.nested.empty?) ? '' : model.nested.to_adoc
+              nest = model.nested.nil? || (model.nested.is_a?(Array) && model.nested.empty?) ? '' : model.nested.to_adoc
               out = " #{_anchor}#{out}#{model.line_break}"
               out + attach + nest
             end

data/coradoc-adoc/lib/coradoc/asciidoc/transform/from_core_model.rb

@@ -65,8 +65,6 @@ module Coradoc
             end
           end
 
-          private
-
           def transform_structural_element(element)
             case element.element_type
             when 'document'
@@ -173,29 +171,6 @@ module Coradoc
             end
           end
 
-          def safe_content_to_string(content)
-            case content
-            when String
-              content
-            when Array
-              content.map { |item| safe_content_to_string(item) }.join
-            when Lutaml::Model::Serializable
-              if content.respond_to?(:to_adoc)
-                content.to_adoc
-              elsif content.respond_to?(:text)
-                content.text.to_s
-              elsif content.respond_to?(:content)
-                safe_content_to_string(content.content)
-              else
-                ''
-              end
-            when nil
-              ''
-            else
-              content.respond_to?(:to_str) ? content.to_s : ''
-            end
-          end
-
           def transform_table(table)
             rows = Array(table.rows).map do |row|
               columns = Array(row.cells).map do |cell|
@@ -373,6 +348,29 @@ module Coradoc
             )
           end
 
+          private
+
+          def safe_content_to_string(content)
+            case content
+            when String
+              content
+            when Array
+              content.map { |item| safe_content_to_string(item) }.join
+            when Lutaml::Model::Serializable
+              if content.is_a?(Coradoc::AsciiDoc::Model::Base)
+                content.to_adoc
+              elsif content.class.attributes.key?(:text)
+                content.text.to_s
+              else
+                ''
+              end
+            when nil
+              ''
+            else
+              content.is_a?(String) ? content : ''
+            end
+          end
+
           def create_title(text, level)
             return nil if text.nil?
 
@@ -391,12 +389,10 @@ module Coradoc
             when Coradoc::AsciiDoc::Model::Base
               content
             when Lutaml::Model::Serializable
-              text = if content.respond_to?(:to_adoc)
+              text = if content.is_a?(Coradoc::AsciiDoc::Model::Base)
                        content.to_adoc
-                     elsif content.respond_to?(:text)
+                     elsif content.class.attributes.key?(:text)
                        content.text.to_s
-                     elsif content.respond_to?(:content)
-                       content.content.to_s
                      else
                        ''
                      end
@@ -404,11 +400,7 @@ module Coradoc
             when String
               Coradoc::AsciiDoc::Model::TextElement.new(content: content)
             else
-              text = if content.respond_to?(:to_str)
-                       content.to_s
-                     else
-                       ''
-                     end
+              text = content.is_a?(String) ? content : ''
               Coradoc::AsciiDoc::Model::TextElement.new(content: text)
             end
           end

data/coradoc-adoc/lib/coradoc/asciidoc/transform/from_core_model_registrations.rb

@@ -19,101 +19,101 @@ module Coradoc
           def register_structural_transformers!
             Registry.register(
               Coradoc::CoreModel::StructuralElement,
-              ->(model) { FromCoreModel.send(:transform_structural_element, model) }
+              ->(model) { FromCoreModel.transform_structural_element(model) }
             )
           end
 
           def register_block_transformers!
             Registry.register_with_priority(
               Coradoc::CoreModel::AnnotationBlock,
-              ->(model) { FromCoreModel.send(:transform_annotation, model) },
+              ->(model) { FromCoreModel.transform_annotation(model) },
               priority: 10
             )
 
             Registry.register(
               Coradoc::CoreModel::Block,
-              ->(model) { FromCoreModel.send(:transform_block, model) }
+              ->(model) { FromCoreModel.transform_block(model) }
             )
           end
 
           def register_list_transformers!
             Registry.register(
               Coradoc::CoreModel::ListBlock,
-              ->(model) { FromCoreModel.send(:transform_list, model) }
+              ->(model) { FromCoreModel.transform_list(model) }
             )
 
             Registry.register(
               Coradoc::CoreModel::ListItem,
-              ->(model) { FromCoreModel.send(:transform_list_item, model) }
+              ->(model) { FromCoreModel.transform_list_item(model) }
             )
 
             Registry.register(
               Coradoc::CoreModel::DefinitionList,
-              ->(model) { FromCoreModel.send(:transform_definition_list, model) }
+              ->(model) { FromCoreModel.transform_definition_list(model) }
             )
 
             Registry.register(
               Coradoc::CoreModel::DefinitionItem,
-              ->(model) { FromCoreModel.send(:transform_definition_item, model) }
+              ->(model) { FromCoreModel.transform_definition_item(model) }
             )
           end
 
           def register_inline_transformers!
             Registry.register(
               Coradoc::CoreModel::InlineElement,
-              ->(model) { FromCoreModel.send(:transform_inline, model) }
+              ->(model) { FromCoreModel.transform_inline(model) }
             )
           end
 
           def register_other_transformers!
             Registry.register(
               Coradoc::CoreModel::Table,
-              ->(model) { FromCoreModel.send(:transform_table, model) }
+              ->(model) { FromCoreModel.transform_table(model) }
             )
 
             Registry.register(
               Coradoc::CoreModel::Term,
-              ->(model) { FromCoreModel.send(:transform_term, model) }
+              ->(model) { FromCoreModel.transform_term(model) }
             )
 
             Registry.register(
               Coradoc::CoreModel::Image,
-              ->(model) { FromCoreModel.send(:transform_image, model) }
+              ->(model) { FromCoreModel.transform_image(model) }
             )
 
             Registry.register(
               Coradoc::CoreModel::Footnote,
-              ->(model) { FromCoreModel.send(:transform_footnote, model) }
+              ->(model) { FromCoreModel.transform_footnote(model) }
             )
 
             Registry.register(
               Coradoc::CoreModel::FootnoteReference,
-              ->(model) { FromCoreModel.send(:transform_footnote_reference, model) }
+              ->(model) { FromCoreModel.transform_footnote_reference(model) }
             )
 
             Registry.register(
               Coradoc::CoreModel::Abbreviation,
-              ->(model) { FromCoreModel.send(:transform_abbreviation, model) }
+              ->(model) { FromCoreModel.transform_abbreviation(model) }
             )
 
             Registry.register(
               Coradoc::CoreModel::Toc,
-              ->(model) { FromCoreModel.send(:transform_toc, model) }
+              ->(model) { FromCoreModel.transform_toc(model) }
             )
 
             Registry.register(
               Coradoc::CoreModel::TocEntry,
-              ->(model) { FromCoreModel.send(:transform_toc_entry, model) }
+              ->(model) { FromCoreModel.transform_toc_entry(model) }
             )
 
             Registry.register(
               Coradoc::CoreModel::Bibliography,
-              ->(model) { FromCoreModel.send(:transform_bibliography, model) }
+              ->(model) { FromCoreModel.transform_bibliography(model) }
             )
 
             Registry.register(
               Coradoc::CoreModel::BibliographyEntry,
-              ->(model) { FromCoreModel.send(:transform_bibliography_entry, model) }
+              ->(model) { FromCoreModel.transform_bibliography_entry(model) }
             )
           end
         end