coradoc 2.0.1 → 2.0.3

data/lib/coradoc/coradoc.rb

@@ -67,6 +67,7 @@ module Coradoc
     # @param options [Hash] optional configuration (e.g., extensions: [])
     # @return [void]
     def register_format(format_name, format_module, **options)
+      format_module.extend(FormatModule::Interface) unless format_module.is_a?(FormatModule::Interface)
       registry.register(format_name, format_module, options)
       FormatModule.validate!(format_module, format_name)
     end
@@ -148,7 +149,7 @@ module Coradoc
       return model if model.is_a?(CoreModel::Base)
 
       registry.each_value do |format_module|
-        next unless format_module.respond_to?(:handles_model?) && format_module.handles_model?(model)
+        next unless format_module.handles_model?(model)
 
         return format_module.to_core(model)
       end
@@ -195,7 +196,7 @@ module Coradoc
     #   Coradoc.detect_format("file.md")        # => :markdown
     def detect_format(filename)
       ext = File.extname(filename).downcase
-      registry.each do |name, _mod|
+      registry.each_key do |name|
         opts = registry.options_for(name)
         return name if opts[:extensions]&.include?(ext)
       end
@@ -243,7 +244,7 @@ module Coradoc
     # @example
     #   html = Coradoc.convert_file("document.adoc", to: :html)
     #   adoc = Coradoc.convert_file("report.docx", to: :asciidoc)
-    def convert_file(path, from: nil, to:, **options)
+    def convert_file(path, to:, from: nil, **options)
       source_format = from || detect_format(path)
       raise UnsupportedFormatError, "Could not detect format for: #{path}" unless source_format
 
@@ -270,7 +271,7 @@ module Coradoc
       return nil unless name
 
       key = name.to_s.downcase
-      registry.each do |fmt_name, _mod|
+      registry.each_key do |fmt_name|
         opts = registry.options_for(fmt_name)
         return fmt_name if opts[:aliases]&.include?(key)
       end
@@ -285,9 +286,7 @@ module Coradoc
       mod = get_format(format)
       return false unless mod
 
-      return mod.serialize? if mod.respond_to?(:serialize?)
-
-      true
+      mod.serialize?
     end
 
     # Check if a format supports parsing (reading input)
@@ -296,7 +295,9 @@ module Coradoc
     # @return [Boolean] true if the format can parse
     def parse_format?(format)
       mod = get_format(format)
-      mod&.respond_to?(:parse_to_core) || mod&.respond_to?(:parse) || false
+      return false unless mod
+
+      mod.public_methods.include?(:parse_to_core) || mod.public_methods.include?(:parse)
     end
 
     # Get capability summary for all registered formats
@@ -361,9 +362,9 @@ module Coradoc
     def document_stats(doc)
       stats = {}
 
-      stats[:title] = doc.title if doc.respond_to?(:title) && doc.title
+      stats[:title] = doc.title if doc.title
 
-      if doc.respond_to?(:children)
+      if doc.is_a?(CoreModel::StructuralElement)
         stats[:child_count] = count_elements(doc)
         stats[:element_counts] = count_element_types(doc)
       end
@@ -379,9 +380,9 @@ module Coradoc
       return elem.to_s unless elem.is_a?(CoreModel::Base)
 
       type = elem.class.name.split('::').last
-      if elem.respond_to?(:title) && elem.title
+      if elem.title
         "#{type}: #{elem.title}"
-      elsif elem.respond_to?(:content) && elem.content
+      elsif elem.is_a?(CoreModel::Block) && elem.content
         preview = elem.content.to_s[0..50]
         preview += '...' if elem.content.to_s.length > 50
         "#{type}: #{preview}"
@@ -411,10 +412,10 @@ module Coradoc
     private
 
     def count_elements(doc)
-      return 0 unless doc.respond_to?(:children)
+      return 0 unless doc.is_a?(CoreModel::StructuralElement)
 
       doc.children.sum do |child|
-        1 + (child.respond_to?(:children) ? count_elements(child) : 0)
+        1 + (child.is_a?(CoreModel::StructuralElement) ? count_elements(child) : 0)
       end
     end
 
@@ -423,11 +424,12 @@ module Coradoc
       visitor = Class.new(Visitor::Base) do
         define_method(:visit) do |element|
           if element.is_a?(CoreModel::Base)
-            type_key = if element.respond_to?(:element_type) && element.element_type
+            has_element_type = element.is_a?(CoreModel::StructuralElement) || element.is_a?(CoreModel::Block)
+            type_key = if has_element_type && element.element_type
                          element.element_type
                        else
                          element.class.name.split('::').last
-                                   .gsub(/([A-Z])/, '_\1').downcase.sub(/^_/, '')
+                                .gsub(/([A-Z])/, '_\1').downcase.sub(/^_/, '')
                        end
             counts[type_key] += 1
           end

data/lib/coradoc/core_model/base.rb

@@ -136,7 +136,7 @@ module Coradoc
         children_arr.map do |child|
           if child.is_a?(String)
             child
-          elsif child.respond_to?(:to_hash)
+          elsif child.is_a?(Lutaml::Model::Serializable)
             child.to_hash
           else
             child.to_s
@@ -156,8 +156,8 @@ module Coradoc
 
       # Compare a single attribute between this model and another
       def compare_attribute(attr, other)
-        self_value = send(attr)
-        other_value = other.send(attr)
+        self_value = public_send(attr)
+        other_value = other.public_send(attr)
 
         case self_value
         when Array

data/lib/coradoc/core_model/list_item.rb

@@ -45,13 +45,13 @@ module Coradoc
 
       # Delegate nested to nested_list (lutaml attribute added by list_block.rb)
       def nested
-        nested_list if respond_to?(:nested_list)
+        nested_list
       end
 
       # Set nested list
       # @param value [ListBlock, nil] nested list block
       def nested=(value)
-        self.nested_list = value if respond_to?(:nested_list=)
+        self.nested_list = value
       end
 
       # Convert to hash representation
@@ -62,7 +62,7 @@ module Coradoc
           marker: marker,
           content: content,
           nested_list: nested&.to_h,
-          children: children&.map { |child| child.respond_to?(:to_h) ? child.to_h : child }
+          children: children&.map { |child| child.is_a?(CoreModel::Base) ? child.to_h : child }
         }.compact
       end
 

data/lib/coradoc/core_model/toc_generator.rb

@@ -71,7 +71,7 @@ module Coradoc
         # Find all sections in the document within level range
         def find_sections(element, min_level, max_level)
           sections = []
-          return sections unless element.respond_to?(:children)
+          return sections unless element.is_a?(CoreModel::StructuralElement)
 
           Array(element.children).each do |child|
             next unless child.is_a?(CoreModel::StructuralElement)

data/lib/coradoc/document_manipulator.rb

@@ -22,7 +22,7 @@ module Coradoc
       DocumentManipulator.new(filtered)
     end
 
-    def transform_text(&block)
+    def transform_text
       return self unless block_given?
 
       Visitor::Transformer.new do |element|
@@ -36,13 +36,11 @@ module Coradoc
       self
     end
 
-    def transform_headings(&block)
+    def transform_headings
       return self unless block_given?
 
       Visitor::Transformer.new do |element|
-        if element.is_a?(CoreModel::StructuralElement) && element.title.is_a?(String)
-          element.title = yield(element.title)
-        end
+        element.title = yield(element.title) if element.is_a?(CoreModel::StructuralElement) && element.title.is_a?(String)
       end.visit(@document)
       self
     end
@@ -64,7 +62,7 @@ module Coradoc
 
     def remove_elements(element_type)
       Visitor::Transformer.new do |element|
-        next unless element.respond_to?(:children) && element.children
+        next unless element.is_a?(CoreModel::StructuralElement) && element.children
 
         element.children.reject! do |child|
           match_element_type?(child, element_type)
@@ -128,15 +126,13 @@ module Coradoc
     end
 
     def filter_sections(element, level: nil, title: nil)
-      if element.respond_to?(:children) && element.children
+      if element.is_a?(CoreModel::StructuralElement) && element.children
         element.children = element.children
                                   .map { |child| filter_sections(child, level: level, title: title) }
                                   .compact
       end
 
-      if element.is_a?(CoreModel::StructuralElement) && element.section? && !element.document?
-        return nil unless section_matches?(element, level: level, title: title)
-      end
+      return nil if element.is_a?(CoreModel::StructuralElement) && element.section? && !element.document? && !section_matches?(element, level: level, title: title)
 
       element
     end
@@ -154,7 +150,7 @@ module Coradoc
         element_title = section.title || ''
         case title
         when String then return false unless element_title.include?(title)
-        when Regexp then return false unless element_title =~ title
+        when Regexp then return false unless element_title&.match?(title)
         end
       end
 
@@ -163,7 +159,7 @@ module Coradoc
 
     def collect_sections(element, max_level: 3, current_level: 1)
       sections = []
-      return sections unless element.respond_to?(:children)
+      return sections unless element.is_a?(CoreModel::StructuralElement)
 
       element.children.each do |child|
         next unless child.is_a?(CoreModel::StructuralElement) &&
@@ -186,7 +182,7 @@ module Coradoc
       when CoreModel::Base
         cloned = element.class.new
         element.class.attributes.each_key do |name|
-          cloned.send("#{name}=", deep_clone(element.send(name)))
+          cloned.public_send("#{name}=", deep_clone(element.public_send(name)))
         end
         cloned
       when Array

data/lib/coradoc/format_module.rb

@@ -19,17 +19,29 @@ module Coradoc
     MINIMUM_PARSE_METHODS = %i[parse_to_core parse].freeze
     REQUIRED_METHODS = %i[serialize].freeze
 
+    # Default implementations for optional format module methods.
+    # Format modules are auto-extended with this during registration.
+    module Interface
+      def handles_model?(_model)
+        false
+      end
+
+      def serialize?
+        true
+      end
+    end
+
     # Validate that a format module implements the minimum interface.
     # Warns to $stderr if methods are missing. Returns true if valid.
     def self.validate!(format_module, format_name)
-      has_parse = MINIMUM_PARSE_METHODS.any? { |m| format_module.respond_to?(m) }
-      has_serialize = REQUIRED_METHODS.all? { |m| format_module.respond_to?(m) }
+      has_parse = MINIMUM_PARSE_METHODS.any? { |m| format_module.public_methods.include?(m) }
+      has_serialize = REQUIRED_METHODS.all? { |m| format_module.public_methods.include?(m) }
 
       return true if has_parse && has_serialize
 
       missing = []
-      missing << "parse_to_core or parse" unless has_parse
-      missing << "serialize" unless has_serialize
+      missing << 'parse_to_core or parse' unless has_parse
+      missing << 'serialize' unless has_serialize
       warn "Coradoc: format :#{format_name} (#{format_module}) missing: #{missing.join(', ')}"
       false
     end

data/lib/coradoc/input.rb

@@ -17,6 +17,6 @@ module Coradoc
   #
   module Input
     extend ProcessorRegistry
-    self.error_label = "input processor"
+    self.error_label = 'input processor'
   end
 end

data/lib/coradoc/output.rb

@@ -17,6 +17,6 @@ module Coradoc
   #
   module Output
     extend ProcessorRegistry
-    self.error_label = "output processor"
+    self.error_label = 'output processor'
   end
 end