coradoc 2.0.2 → 2.0.4

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

@@ -18,7 +18,7 @@ module Coradoc
         # @param context [Context] transform context with registry
         # @return [Array] transformed content (Strings, InlineElements, etc.)
         def transform_paragraph_content(paragraph, context)
-          order = paragraph.respond_to?(:element_order) ? paragraph.element_order : nil
+          order = paragraph.is_a?(Uniword::Wordprocessingml::Paragraph) ? paragraph.element_order : nil
 
           if order && !order.empty?
             transform_ordered(paragraph, order, context)
@@ -49,7 +49,7 @@ module Coradoc
 
           result = []
           order.each do |entry|
-            name = entry.respond_to?(:name) ? entry.name : entry.to_s
+            name = entry.is_a?(String) ? entry : entry.name
             idx = counters[name]
             counters[name] = idx + 1
 

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

@@ -109,7 +109,10 @@ module Coradoc
           def extent_to_px(extent, dimension)
             return nil unless extent
 
-            value = extent.respond_to?(dimension) ? extent.send(dimension) : nil
+            value = case dimension
+                    when :cx then extent.cx
+                    when :cy then extent.cy
+                    end
             return nil unless value
 
             px = value.to_i / EMU_PER_PX

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

@@ -66,7 +66,8 @@ module Coradoc
           end
 
           def element_to_xml(element)
-            return '' unless element.respond_to?(:to_xml)
+            return '' unless element.is_a?(Uniword::Wordprocessingml::AlternateContent) ||
+                             element.is_a?(Uniword::Wordprocessingml::OMath)
 
             element.to_xml
           end

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,24 +78,18 @@ 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
-            if run.respond_to?(:alternate_content) && run.alternate_content
+            if run.alternate_content
               result << extract_alternate_content(run.alternate_content,
                                                   context)
             end
@@ -109,19 +98,17 @@ module Coradoc
           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
@@ -147,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,19 +62,17 @@ module Coradoc
           private
 
           def field_text(field)
-            # SimpleField may have runs with resolved text
-            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,15 +69,14 @@ 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

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-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

@@ -434,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
                    ''

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

@@ -11,7 +11,7 @@ module Coradoc
           attrs[:id] = model.id if model.id
 
           # Get title from metadata
-          if model.respond_to?(:metadata) && model.metadata && model.metadata[:title]
+          if model.metadata && model.metadata[:title]
             attrs[:title] =
               model.metadata[:title]
           end

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

@@ -50,18 +50,18 @@ module Coradoc
             parts = []
 
             # Convert main content - check children first (mixed content), then content
-            content_to_render = model.respond_to?(:children) && model.children&.any? ? model.children : model.content
+            content_to_render = model.children&.any? ? model.children : model.content
             parts << convert_content_to_html(content_to_render, state) if content_to_render
 
             # Convert attached content
-            if model.respond_to?(:attached) && model.attached && !model.attached.empty?
+            if model.attached && !model.attached.empty?
               model.attached.each do |attached_item|
                 parts << convert_content_to_html(attached_item, state)
               end
             end
 
             # Convert nested list
-            parts << convert_content_to_html(model.nested, state) if model.respond_to?(:nested) && model.nested
+            parts << convert_content_to_html(model.nested, state) if model.nested
 
             attrs = {}
             attrs[:id] = model.id if model.id

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

@@ -42,7 +42,7 @@ module Coradoc
             attrs[:id] = model.id if model.id
 
             # Add start attribute if not starting from 1
-            attrs[:start] = model.start if model.respond_to?(:start) && model.start && model.start != 1
+            attrs[:start] = model.start if model.start && model.start != 1
 
             build_element('ol', "\n#{items_html}\n", attrs)
           end

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

@@ -39,7 +39,7 @@ module Coradoc
           # @return [String] HTML string
           def to_html(model, state = {})
             # Prefer children for mixed content, fall back to content
-            content = if model.respond_to?(:children) && model.children&.any?
+            content = if model.children&.any?
                         model.children.map { |c| convert_content_to_html(c, state) }.join
                       else
                         escape_html(model.content || '')
@@ -47,7 +47,7 @@ module Coradoc
 
             # Build attributes from metadata
             attrs = {}
-            if model.respond_to?(:metadata) && model.metadata && model.metadata[:class]
+            if model.metadata && model.metadata[:class]
               attrs[:class] =
                 model.metadata[:class]
             end

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

@@ -48,16 +48,16 @@ module Coradoc
           attrs = []
 
           # Add ID if present
-          attrs << %( id="#{escape_attribute(table.id)}") if table.respond_to?(:id) && table.id
+          attrs << %( id="#{escape_attribute(table.id)}") if table.id
 
           # CoreModel::Table with frame attribute
-          attrs << %( class="frame-#{escape_attribute(table.frame)}") if table.respond_to?(:frame) && table.frame
+          attrs << %( class="frame-#{escape_attribute(table.frame)}") if table.frame
 
           attrs.join
         end
 
         def self.build_caption(table)
-          return nil unless table.respond_to?(:title) && table.title
+          return nil unless table.title
 
           caption_text = table.title.to_s
           return nil if caption_text.empty?