coradoc 2.0.1 → 2.0.3

data/coradoc-docx/lib/coradoc/docx/transform/rules/run_rule.rb

@@ -45,10 +45,8 @@ module Coradoc
           private
 
           def effective_props(run)
-            if run.respond_to?(:effective_run_properties)
-              ep = run.effective_run_properties
-              return ep if ep
-            end
+            ep = run.effective_run_properties
+            return ep if ep
 
             run.properties
           end
@@ -66,15 +64,12 @@ module Coradoc
               result << context.transform(drawing)
             end
 
-            # Tab character
-            result << "\t" if run.respond_to?(:tab) && run.tab
+            result << "\t" if run.tab
 
-            # Inline math (m:oMath within a run)
-            result << context.transform(run.o_math) if run.respond_to?(:o_math) && run.o_math
+            result << context.transform(run.o_math) if run.class.attributes.key?(:o_math) && run.o_math
 
-            # Deleted text (tracked changes)
-            if run.respond_to?(:del_text) && run.del_text
-              text = run.del_text.respond_to?(:content) ? run.del_text.content.to_s : run.del_text.to_s
+            if run.del_text
+              text = run.del_text.is_a?(Uniword::Wordprocessingml::DeletedText) ? run.del_text.content.to_s : run.del_text.to_s
               unless text.empty?
                 result << CoreModel::InlineElement.new(
                   format_type: 'strikethrough',
@@ -83,42 +78,37 @@ module Coradoc
               end
             end
 
-            # Symbol (w:sym)
-            if run.respond_to?(:sym) && run.sym
-              sym = run.sym
-              char = sym.respond_to?(:char) ? sym.char : nil
+            if run.sym
+              char = run.sym.char
               result << char.to_s if char && !char.empty?
             end
 
-            # No-break hyphen (U+2011)
-            result << "\u2011" if run.respond_to?(:no_break_hyphen) && run.no_break_hyphen
+            result << "\u2011" if run.no_break_hyphen
 
-            # Soft hyphen (U+00AD)
-            result << "\u00AD" if run.respond_to?(:soft_hyphen) && run.soft_hyphen
+            result << "\u00AD" if run.class.attributes.key?(:soft_hyphen) && run.soft_hyphen
 
-            # Carriage return (w:cr) — treat as line break
-            result << CoreModel::InlineElement.new(format_type: 'hard_line_break') if run.respond_to?(:carriage_return) && run.carriage_return
+            result << CoreModel::InlineElement.new(format_type: 'hard_line_break') if run.class.attributes.key?(:carriage_return) && run.carriage_return
 
-            # Alternate content — extract preferred/fallback content
-            result << extract_alternate_content(run.alternate_content, context) if run.respond_to?(:alternate_content) && run.alternate_content
+            if run.alternate_content
+              result << extract_alternate_content(run.alternate_content,
+                                                  context)
+            end
 
             result.compact
           end
 
           def extract_alternate_content(ac, context)
-            # Prefer the fallback content (wc:w:bdoContent or mc:Fallback)
-            content = if ac.respond_to?(:fallback) && ac.fallback
+            content = if ac.fallback
                         ac.fallback
-                      elsif ac.respond_to?(:choice) && ac.choice
+                      elsif ac.choice
                         ac.choice
                       end
 
             return nil unless content
 
-            # If the fallback/choice has paragraphs or runs, transform them
-            if content.respond_to?(:runs)
+            if content.is_a?(Uniword::Wordprocessingml::Run)
               content.runs&.each { |r| context.transform(r) }
-            elsif content.respond_to?(:paragraphs)
+            elsif content.is_a?(Uniword::Wordprocessingml::Paragraph)
               content.paragraphs&.flat_map { |p| context.transform(p) }
             end
           end
@@ -144,7 +134,7 @@ module Coradoc
             return nil unless props
 
             # Check rStyle for semantic role
-            if context.style_resolver.respond_to?(:run_semantic_role)
+            if context.style_resolver.is_a?(Coradoc::Docx::Transform::StyleResolver)
               role = context.style_resolver.run_semantic_role(run)
               case role
               when :monospace then return 'monospace'

data/coradoc-docx/lib/coradoc/docx/transform/rules/simple_field_rule.rb

@@ -62,15 +62,17 @@ module Coradoc
           private
 
           def field_text(field)
-            # SimpleField may have runs with resolved text
-            return field.runs.map { |r| r.text&.content.to_s }.join if field.respond_to?(:runs) && field.runs && !field.runs.empty?
+            if field.runs && !field.runs.empty?
+              return field.runs.map do |r|
+                r.text&.content.to_s
+              end.join
+            end
 
-            # Fall back to text attribute
-            field.respond_to?(:text) ? field.text.to_s : nil
+            nil
           end
 
           def field_instruction(field)
-            instr = field.respond_to?(:instr) ? field.instr : nil
+            instr = field.instr
             instr.to_s
           end
 

data/coradoc-docx/lib/coradoc/docx/transform/rules/table_rule.rb

@@ -32,7 +32,7 @@ module Coradoc
           def transform_row(row, context)
             CoreModel::TableRow.new(
               cells: row.cells.map { |c| transform_cell(c, context) },
-              header: row.respond_to?(:header?) ? row.header? : false
+              header: row.header?
             )
           end
 
@@ -69,17 +69,15 @@ module Coradoc
           end
 
           def cell_paragraphs(cell)
-            cell.respond_to?(:paragraphs) ? (cell.paragraphs || []) : []
+            cell.paragraphs || []
           end
 
           def header_cell?(cell)
             return false unless cell.properties
-            return false unless cell.properties.respond_to?(:v_merge)
 
             vm = cell.properties.v_merge
-            vm.respond_to?(:value) ? vm.value.to_s == 'restart' : false
+            vm&.value.to_s == 'restart'
           end
-
         end
       end
     end

data/coradoc-docx/lib/coradoc/docx/transform/style_resolver.rb

@@ -51,18 +51,16 @@ module Coradoc
           style_name = resolve_style_name(paragraph)
           return true if style_name && HEADING_PATTERN.match?(style_name)
 
-          # Check outline_level on paragraph properties
           ol = paragraph.properties.outline_level
           if ol
-            ol_level = ol.respond_to?(:value) ? ol.value.to_i : ol.to_i
+            ol_level = ol.is_a?(Uniword::Wordprocessingml::OutlineLevel) ? ol.value.to_i : ol.to_i
             return true if ol_level.positive?
           end
 
-          # Check outline_level from style definition
           style = find_style_for_paragraph(paragraph)
-          if style.respond_to?(:outline_level) && style.outline_level
+          if style&.outline_level
             ol_val = style.outline_level
-            ol_val = ol_val.respond_to?(:value) ? ol_val.value.to_i : ol_val.to_i
+            ol_val = ol_val.is_a?(Uniword::Wordprocessingml::OutlineLevel) ? ol_val.value.to_i : ol_val.to_i
             return true if ol_val.positive?
           end
 
@@ -82,7 +80,7 @@ module Coradoc
           # Check outline_level on paragraph properties
           ol = paragraph.properties&.outline_level
           if ol
-            level = ol.respond_to?(:value) ? ol.value.to_i : ol.to_i
+            level = ol.is_a?(Uniword::Wordprocessingml::OutlineLevel) ? ol.value.to_i : ol.to_i
             return level if level.positive?
           end
 
@@ -138,10 +136,9 @@ module Coradoc
           style_ref = paragraph.properties&.style
           return nil unless style_ref
 
-          value = style_ref.respond_to?(:value) ? style_ref.value : style_ref.to_s
+          value = style_ref.is_a?(Uniword::Wordprocessingml::PStyle) ? style_ref.val : style_ref.to_s
           return nil unless value
 
-          # Check local style map first (for custom style aliases)
           mapped = @style_map[value]
           return mapped if mapped
 
@@ -152,7 +149,7 @@ module Coradoc
           style_ref = run.properties.style
           return nil unless style_ref
 
-          value = style_ref.respond_to?(:value) ? style_ref.value : style_ref.to_s
+          value = style_ref.is_a?(Uniword::Wordprocessingml::PStyle) ? style_ref.val : style_ref.to_s
           return nil unless value
 
           mapped = @style_map[value]
@@ -165,23 +162,21 @@ module Coradoc
           style_id = style_id_from_paragraph(paragraph)
           return nil unless style_id
 
-          if @config.respond_to?(:style_by_id)
-            @config.style_by_id(style_id)
-          elsif @config.respond_to?(:styles)
-            @config.styles.find { |s| s.styleId == style_id }
-          end
+          return unless @config.is_a?(Uniword::Wordprocessingml::StylesConfiguration)
+
+          @config.style_by_id(style_id)
         end
 
         def style_id_from_paragraph(paragraph)
           style_ref = paragraph.properties&.style
           return nil unless style_ref
 
-          style_ref.respond_to?(:value) ? style_ref.value : style_ref.to_s
+          style_ref.is_a?(Uniword::Wordprocessingml::PStyle) ? style_ref.val : style_ref.to_s
         end
 
         def build_style_map(config)
           return {} unless config
-          return {} unless config.respond_to?(:styles)
+          return {} unless config.is_a?(Uniword::Wordprocessingml::StylesConfiguration)
 
           map = {}
           config.styles.each do |style|
@@ -191,7 +186,6 @@ module Coradoc
 
             map[id] = name
 
-            # Detect custom heading styles by basedOn chain
             if heading_by_based_on?(config, style)
               level = heading_level_from_chain(config, style)
               map[id] = "Heading#{level}"
@@ -202,26 +196,27 @@ module Coradoc
         end
 
         def extract_style_name(style)
-          return style.style_name if style.respond_to?(:style_name)
+          sn = style.style_name
+          return sn if sn
 
           name = style.name
           return nil unless name
 
-          name.respond_to?(:val) ? name.val.to_s : name.to_s
+          name.is_a?(Uniword::Wordprocessingml::StyleName) ? name.val.to_s : name.to_s
         end
 
         def heading_by_based_on?(config, style)
-          based_on = style.respond_to?(:based_on) ? style.based_on : nil
+          based_on = style.based_on
           return false unless based_on
 
           visited = Set.new
           current = style
           while current && !visited.include?(current.styleId)
             visited << current.styleId
-            parent_id = current.respond_to?(:based_on) ? current.based_on : nil
+            parent_id = current.based_on
             return true if parent_id && HEADING_PATTERN.match?(parent_id)
 
-            break unless parent_id && config.respond_to?(:styles)
+            break unless parent_id
 
             current = config.styles.find { |s| s.styleId == parent_id }
           end
@@ -240,8 +235,8 @@ module Coradoc
               return match[2].to_i if match
             end
 
-            parent_id = current.respond_to?(:based_on) ? current.based_on : nil
-            break unless parent_id && config.respond_to?(:styles)
+            parent_id = current.based_on
+            break unless parent_id
 
             current = config.styles.find { |s| s.styleId == parent_id }
           end

data/coradoc-docx/lib/coradoc/docx/transform/to_core_model.rb

@@ -129,14 +129,13 @@ module Coradoc
         end
 
         def section_break?(paragraph)
-          return false unless paragraph.respond_to?(:properties)
+          return false unless paragraph.is_a?(Uniword::Wordprocessingml::Paragraph)
           return false unless paragraph.properties
 
           sect_pr = paragraph.properties.section_properties
           return false unless sect_pr
 
-          # A section break exists if sectPr has a type (nextPage, continuous, etc.)
-          sect_pr.respond_to?(:type) && sect_pr.type
+          sect_pr.type ? true : false
         end
 
         def section_break_element(paragraph, context)
@@ -182,12 +181,12 @@ module Coradoc
         end
 
         def body_ordered_elements(body)
-          order = body.respond_to?(:element_order) ? body.element_order : nil
+          order = body.is_a?(Uniword::Wordprocessingml::Body) ? body.element_order : nil
           return body.elements if order.nil? || order.empty?
 
           p_idx = tbl_idx = sdt_idx = 0
           order.filter_map do |entry|
-            name = entry.respond_to?(:name) ? entry.name : entry.to_s
+            name = entry.is_a?(String) ? entry : entry.name
             case name
             when 'p'
               para = body.paragraphs[p_idx]
@@ -216,7 +215,7 @@ module Coradoc
           doc_footnotes = document.footnotes
           if doc_footnotes.is_a?(Hash)
             doc_footnotes.each do |id, fn|
-              paragraphs = fn.respond_to?(:content) ? fn.content : []
+              paragraphs = fn.is_a?(Uniword::Wordprocessingml::Footnote) ? fn.paragraphs : fn[:content]
               footnotes[id.to_s] = Array(paragraphs)
             end
           end
@@ -280,7 +279,10 @@ module Coradoc
         end
 
         def extract_from_parts(document, method, prefix, core_doc)
-          parts = document.respond_to?(method) ? document.send(method) : nil
+          parts = case method
+                  when :headers then document.headers
+                  when :footers then document.footers
+                  end
           return unless parts
 
           Array(parts).each_with_index do |part, idx|
@@ -288,13 +290,18 @@ module Coradoc
             next if text.nil? || text.strip.empty?
             next if layout_only_text?(text)
 
-            core_doc.set_metadata("docx.#{prefix}.#{part.respond_to?(:type) ? part.type : idx}",
-                                  text.strip)
+            part_type = if part.is_a?(Uniword::Wordprocessingml::Header) ||
+                           part.is_a?(Uniword::Wordprocessingml::Footer)
+                          part.type
+                        else
+                          idx
+                        end
+            core_doc.set_metadata("docx.#{prefix}.#{part_type}", text.strip)
           end
         end
 
         def extract_part_text(part)
-          paragraphs = part.respond_to?(:paragraphs) ? part.paragraphs : []
+          paragraphs = part.paragraphs || []
           return nil unless paragraphs
 
           paragraphs.map do |para|
@@ -303,7 +310,7 @@ module Coradoc
         end
 
         def extract_paragraph_text_content(para)
-          runs = para.respond_to?(:runs) ? para.runs : []
+          runs = para.runs || []
           return nil unless runs
 
           runs.map { |r| r.text&.content.to_s }.join

data/coradoc-docx/lib/coradoc/docx.rb

@@ -91,7 +91,9 @@ module Coradoc
 end
 
 # Auto-register :docx format with Coradoc when both gems are loaded
-Coradoc.register_format(:docx, Coradoc::Docx,
-                        aliases: %w[docx],
-                        extensions: %w[.docx],
-                        binary: true) unless Coradoc.registered_formats.include?(:docx)
+unless Coradoc.registered_formats.include?(:docx)
+  Coradoc.register_format(:docx, Coradoc::Docx,
+                          aliases: %w[docx],
+                          extensions: %w[.docx],
+                          binary: true)
+end

data/coradoc-docx/spec/coradoc/docx/transform/from_core_model_spec.rb

@@ -120,7 +120,9 @@ RSpec.describe Coradoc::Docx::Transform::FromCoreModel do
     end
 
     context 'with Abbreviation' do
-      let(:core_model) { Coradoc::CoreModel::Abbreviation.new(term: 'API', definition: 'Application Programming Interface') }
+      let(:core_model) do
+        Coradoc::CoreModel::Abbreviation.new(term: 'API', definition: 'Application Programming Interface')
+      end
 
       it 'produces a Paragraph with term and definition' do
         expect(result).to be_a(Uniword::Wordprocessingml::Paragraph)
@@ -245,7 +247,8 @@ RSpec.describe Coradoc::Docx::Transform::FromCoreModel do
         @tmpdir = Dir.mktmpdir
         img_path = File.join(@tmpdir, 'test.png')
         # Minimal 1x1 PNG
-        File.binwrite(img_path, "\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x01\x00\x00\x00\x01\x08\x02\x00\x00\x00\x90wS\xde\x00\x00\x00\x0cIDATx\x9cc\xf8\x0f\x00\x00\x01\x01\x00\x05\x18\xd8N\x00\x00\x00\x00IEND\xAEB`\x82".b)
+        File.binwrite(img_path,
+                      "\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x01\x00\x00\x00\x01\x08\x02\x00\x00\x00\x90wS\xde\x00\x00\x00\x0cIDATx\x9cc\xf8\x0f\x00\x00\x01\x01\x00\x05\x18\xd8N\x00\x00\x00\x00IEND\xAEB`\x82".b)
         Coradoc::CoreModel::Image.new(src: img_path, alt: 'Test image')
       end
 

data/coradoc-docx/spec/coradoc/docx/transform/rules/rule_unit_spec.rb

@@ -148,7 +148,10 @@ RSpec.describe Coradoc::Docx::Transform::Rules::ParagraphRule do
   end
 
   describe '#apply' do
-    let(:context) { build_context(registry: build_registry_with(described_class.new, Coradoc::Docx::Transform::Rules::RunRule.new, Coradoc::Docx::Transform::Rules::TextRule.new)) }
+    let(:context) do
+      build_context(registry: build_registry_with(described_class.new, Coradoc::Docx::Transform::Rules::RunRule.new,
+                                                  Coradoc::Docx::Transform::Rules::TextRule.new))
+    end
 
     it 'produces a Block paragraph with text content' do
       para = build_paragraph('Hello')
@@ -188,7 +191,10 @@ RSpec.describe Coradoc::Docx::Transform::Rules::TableRule do
   end
 
   describe '#apply' do
-    let(:context) { build_context(registry: build_registry_with(described_class.new, Coradoc::Docx::Transform::Rules::ParagraphRule.new, Coradoc::Docx::Transform::Rules::RunRule.new, Coradoc::Docx::Transform::Rules::TextRule.new)) }
+    let(:context) do
+      build_context(registry: build_registry_with(described_class.new, Coradoc::Docx::Transform::Rules::ParagraphRule.new,
+                                                  Coradoc::Docx::Transform::Rules::RunRule.new, Coradoc::Docx::Transform::Rules::TextRule.new))
+    end
 
     it 'produces a CoreModel::Table with rows and cells' do
       table = build_table([%w[A B], %w[C D]])
@@ -213,7 +219,10 @@ RSpec.describe Coradoc::Docx::Transform::Rules::ListItemRule do
   end
 
   describe '#apply' do
-    let(:context) { build_context(registry: build_registry_with(Coradoc::Docx::Transform::Rules::RunRule.new, Coradoc::Docx::Transform::Rules::TextRule.new)) }
+    let(:context) do
+      build_context(registry: build_registry_with(Coradoc::Docx::Transform::Rules::RunRule.new,
+                                                  Coradoc::Docx::Transform::Rules::TextRule.new))
+    end
 
     it 'produces a ListItem with content' do
       para = build_list_paragraph('Item 1', num_id: 1)
@@ -242,7 +251,10 @@ RSpec.describe Coradoc::Docx::Transform::Rules::HeadingRule do
   end
 
   describe '#apply' do
-    let(:context) { build_context(registry: build_registry_with(Coradoc::Docx::Transform::Rules::RunRule.new, Coradoc::Docx::Transform::Rules::TextRule.new)) }
+    let(:context) do
+      build_context(registry: build_registry_with(Coradoc::Docx::Transform::Rules::RunRule.new,
+                                                  Coradoc::Docx::Transform::Rules::TextRule.new))
+    end
 
     it 'produces a StructuralElement section with title and level' do
       para = build_heading('My Title', level: 2)
@@ -363,7 +375,9 @@ RSpec.describe Coradoc::Docx::Transform::Rules::HyperlinkRule do
 
   describe '#apply' do
     let(:run_rule) { Coradoc::Docx::Transform::Rules::RunRule.new }
-    let(:context) { build_context(registry: build_registry_with(run_rule, Coradoc::Docx::Transform::Rules::TextRule.new)) }
+    let(:context) do
+      build_context(registry: build_registry_with(run_rule, Coradoc::Docx::Transform::Rules::TextRule.new))
+    end
 
     it 'produces InlineElement link with external URL' do
       hl = build_hyperlink(
@@ -419,7 +433,10 @@ RSpec.describe Coradoc::Docx::Transform::Rules::SimpleFieldRule do
   end
 
   describe '#apply' do
-    let(:context) { build_context(registry: build_registry_with(Coradoc::Docx::Transform::Rules::RunRule.new, Coradoc::Docx::Transform::Rules::TextRule.new)) }
+    let(:context) do
+      build_context(registry: build_registry_with(Coradoc::Docx::Transform::Rules::RunRule.new,
+                                                  Coradoc::Docx::Transform::Rules::TextRule.new))
+    end
 
     it 'returns nil for PAGE field (print layout)' do
       field = Uniword::Wordprocessingml::SimpleField.new
@@ -449,7 +466,10 @@ RSpec.describe Coradoc::Docx::Transform::Rules::StructuredDocumentTagRule do
   end
 
   describe '#apply' do
-    let(:context) { build_context(registry: build_registry_with(Coradoc::Docx::Transform::Rules::ParagraphRule.new, Coradoc::Docx::Transform::Rules::RunRule.new, Coradoc::Docx::Transform::Rules::TextRule.new)) }
+    let(:context) do
+      build_context(registry: build_registry_with(Coradoc::Docx::Transform::Rules::ParagraphRule.new,
+                                                  Coradoc::Docx::Transform::Rules::RunRule.new, Coradoc::Docx::Transform::Rules::TextRule.new))
+    end
 
     it 'unwraps SDT content and delegates to paragraph rules' do
       sdt = Uniword::Wordprocessingml::StructuredDocumentTag.new

data/coradoc-docx/spec/coradoc/docx/transform/to_core_model_spec.rb

@@ -221,7 +221,9 @@ RSpec.describe Coradoc::Docx::Transform::ToCoreModel do
         core = transform_to_core(doc)
 
         blocks = core.children.select { |c| c.is_a?(Coradoc::CoreModel::Block) }
-        inline = blocks.first.children.find { |c| c.is_a?(Coradoc::CoreModel::InlineElement) && c.format_type == 'subscript' }
+        inline = blocks.first.children.find do |c|
+          c.is_a?(Coradoc::CoreModel::InlineElement) && c.format_type == 'subscript'
+        end
         expect(inline).not_to be_nil
         expect(inline.content).to eq('2')
       end
@@ -241,7 +243,9 @@ RSpec.describe Coradoc::Docx::Transform::ToCoreModel do
         core = transform_to_core(doc)
 
         blocks = core.children.select { |c| c.is_a?(Coradoc::CoreModel::Block) }
-        inline = blocks.first.children.find { |c| c.is_a?(Coradoc::CoreModel::InlineElement) && c.format_type == 'superscript' }
+        inline = blocks.first.children.find do |c|
+          c.is_a?(Coradoc::CoreModel::InlineElement) && c.format_type == 'superscript'
+        end
         expect(inline).not_to be_nil
         expect(inline.content).to eq('2')
       end

data/coradoc-html/lib/coradoc/html/base.rb

@@ -125,14 +125,10 @@ module Coradoc
         def extract_attributes(model)
           attrs = {}
 
-          # Extract ID if available
-          attrs[:id] = model.id if model.respond_to?(:id) && model.id
+          attrs[:id] = model.id if model.id
+          attrs[:title] = model.title if model.title
 
-          # Extract title if available
-          attrs[:title] = model.title if model.respond_to?(:title) && model.title
-
-          # Extract class/role if available
-          if model.respond_to?(:metadata) && model.metadata
+          if model.is_a?(Coradoc::CoreModel::StructuralElement) && model.metadata
             attrs[:class] = model.metadata[:class] || model.metadata[:role]
             attrs.merge!(model.metadata.except(:class, :role))
           end

data/coradoc-html/lib/coradoc/html/converter_base.rb

@@ -118,25 +118,19 @@ module Coradoc
       # @param config [Hash, Object] Configuration options or object
       # @return [Object] Built configuration object
       def build_config(config)
-        # If config is already a Configuration object, validate and return it
-        if config.respond_to?(:validate!)
-          config.validate! if config.respond_to?(:validate!)
+        if config.public_methods.include?(:validate!)
+          config.validate!
           return config
         end
 
-        # Otherwise, build from hash (subclasses should override this)
         config
       end
 
-      # Extract document title
-      #
-      # @return [String] Document title
       def extract_document_title
-        # Handle CoreModel::StructuralElement (has title directly)
-        if @document.respond_to?(:title) && @document.title
+        if @document.is_a?(Coradoc::CoreModel::StructuralElement) && @document.title
           title = @document.title
           return title if title.is_a?(String)
-          return title.text if title.respond_to?(:text)
+          return title.text if title.is_a?(Coradoc::CoreModel::Base) && title.text
 
           return title.to_s
         end
@@ -144,10 +138,6 @@ module Coradoc
         'Untitled Document'
       end
 
-      # Extract text from content (array of inline elements)
-      #
-      # @param content [Array] Content elements
-      # @return [String] Extracted text
       def extract_text_from_content(content)
         case content
         when Array
@@ -157,7 +147,7 @@ module Coradoc
         when Coradoc::CoreModel::InlineElement
           content.content.to_s
         when Coradoc::CoreModel::Base
-          if content.respond_to?(:content)
+          if content.content
             extract_text_from_content(content.content)
           else
             content.to_s

data/coradoc-html/lib/coradoc/html/converters/base.rb

@@ -96,7 +96,10 @@ module Coradoc
 
             return render_core_bibliography(content, state) if content.is_a?(Coradoc::CoreModel::Bibliography)
 
-            return render_core_bibliography_entry(content, state) if content.is_a?(Coradoc::CoreModel::BibliographyEntry)
+            if content.is_a?(Coradoc::CoreModel::BibliographyEntry)
+              return render_core_bibliography_entry(content,
+                                                    state)
+            end
 
             # Handle unknown types gracefully
             handle_unknown_content(content, state)
@@ -431,37 +434,28 @@ module Coradoc
 
           # Extract text from unknown model types as a fallback
           def extract_text_fallback(content)
-            # Try text attribute first
-            if content.respond_to?(:text) && content.text
-              text_val = content.text
-              return text_val if text_val.is_a?(String)
-              return text_val.to_s if text_val.respond_to?(:to_s)
-            end
+            if content.is_a?(Coradoc::CoreModel::Base)
+              if content.class.attributes.key?(:text) && content.text
+                text_val = content.text
+                return text_val if text_val.is_a?(String)
 
-            # Try content attribute
-            if content.respond_to?(:content) && content.content
-              content_val = content.content
-              if content_val.is_a?(String)
-                return content_val
-              elsif content_val.is_a?(Array)
-                return content_val.map { |item| convert_content_to_html(item, {}) }.join
+                return text_val.to_s
               end
-            end
 
-            # Try href attribute (for cross-references)
-            return content.href.to_s if content.respond_to?(:href) && content.href
-
-            # Try term attribute (for term references)
-            return content.term.to_s if content.respond_to?(:term) && content.term
-
-            # Try id attribute (for references with IDs)
-            return content.id.to_s if content.respond_to?(:id) && content.id
-
-            # Try name attribute
-            return content.name.to_s if content.respond_to?(:name) && content.name
+              if content.class.attributes.key?(:content) && content.content
+                content_val = content.content
+                if content_val.is_a?(String)
+                  return content_val
+                elsif content_val.is_a?(Array)
+                  return content_val.map { |item| convert_content_to_html(item, {}) }.join
+                end
+              end
 
-            # Try to_adoc if available (for AsciiDoc models)
-            return content.to_adoc.to_s if content.respond_to?(:to_adoc)
+              return content.href.to_s if content.class.attributes.key?(:href) && content.href
+              return content.term.to_s if content.class.attributes.key?(:term) && content.term
+              return content.id.to_s if content.class.attributes.key?(:id) && content.id
+              return content.name.to_s if content.class.attributes.key?(:name) && content.name
+            end
 
             ''
           end

data/coradoc-html/lib/coradoc/html/converters/comment_line.rb

@@ -12,9 +12,9 @@ module Coradoc
           return '' unless options[:preserve_comments]
 
           # Get comment text - check for content or text attribute
-          text = if comment.respond_to?(:content) && comment.content
+          text = if comment.content
                    comment.content
-                 elsif comment.respond_to?(:text) && comment.text
+                 elsif comment.text
                    comment.text
                  else
                    ''