Separate C call-seq for "copied" methods

If the same C function is used to implement two methods typically the
call-seq in the comment describes both methods together.

This leads to confusing duplication in generated HTML as identical
content is show twice.

Now when such a method is encountered the call-seq is de-duplicated to
avoid this confusion.

Author: drbrain

History.rdoc

@@ -25,6 +25,8 @@
   * Code objects with nodoc are no longer included in the ri store.  Bug #177
     by Thomas Leitner.
   * Text#snippet now creates a RDoc::Markup::ToHtmlSnippet correctly.
+  * The C parser now de-duplicates call-seq if the same C function is used for
+    multiple method names.  Bug #203 by Pete Higgins
 
 === 4.0.0 / 2013-02-24
 

lib/rdoc/parser/c.rb

@@ -173,6 +173,9 @@ def initialize top_level, file_name, content, options, stats
     @classes           = load_variable_map :c_class_variables
     @singleton_classes = load_variable_map :c_singleton_class_variables
 
+    # class_variable => { function => [method, ...] }
+    @methods = Hash.new { |h, f| h[f] = Hash.new { |h, m| h[m] = [] } }
+
     # missing variable => [handle_class_module arguments]
     @missing_dependencies = {}
 
@@ -206,6 +209,41 @@ def @enclosure_dependencies.tsort_each_child node, &block
     end
   end
 
+  ##
+  # Removes duplicate call-seq entries for methods using the same
+  # implementation.
+
+  def deduplicate_call_seq
+    @methods.each do |var_name, functions|
+      class_name = @known_classes[var_name]
+      class_obj  = find_class var_name, class_name
+
+      functions.each_value do |method_names|
+        next if method_names.length == 1
+
+        method_names.each do |method_name|
+          deduplicate_method_name class_obj, method_name
+        end
+      end
+    end
+  end
+
+  def deduplicate_method_name class_obj, method_name
+    return unless
+      method = class_obj.method_list.find { |m| m.name == method_name }
+    return unless call_seq = method.call_seq
+
+    method_name = method_name[0] unless method_name =~ /\A\w/
+
+      entries = call_seq.split "\n"
+
+    matching = entries.select do |entry|
+      entry =~ /^\w*\.?#{Regexp.escape method_name}/
+    end
+
+    method.call_seq = matching.join "\n"
+  end
+
   ##
   # Scans #content for rb_define_alias
 
@@ -938,6 +976,8 @@ def handle_method(type, var_name, meth_name, function, param_count,
     class_name = @known_classes[var_name]
     singleton  = @singleton_classes.key? var_name
 
+    @methods[var_name][function] << meth_name
+
     return unless class_name
 
     class_obj = find_class var_name, class_name
@@ -1172,6 +1212,8 @@ def scan
     do_aliases
     do_attrs
 
+    deduplicate_call_seq
+
     @store.add_c_variables self
 
     @top_level

test/test_rdoc_parser_c.rb

@@ -1699,6 +1699,80 @@ def test_scan
     assert_equal expected, @store.c_singleton_class_variables
   end
 
+  def test_scan_method_copy
+    parser = util_parser <<-C
+/*
+ *  call-seq:
+ *    pathname.to_s    -> string
+ *    pathname.to_path -> string
+ *
+ *  Return the path as a String.
+ *
+ *  to_path is implemented so Pathname objects are usable with File.open, etc.
+ */
+static VALUE
+path_to_s(VALUE self) { }
+
+/*
+ *  call-seq:
+ *     str[index]               -> new_str or nil
+ *     str[start, length]       -> new_str or nil
+ *     str.slice(index)         -> new_str or nil
+ *     str.slice(start, length) -> new_str or nil
+ */
+static VALUE
+path_aref_m(int argc, VALUE *argv, VALUE str) { }
+ 
+/*
+ *  call-seq:
+ *     string <=> other_string   -> -1, 0, +1 or nil
+ */
+static VALUE
+path_cmp_m(VALUE str1, VALUE str2) { }
+
+Init_pathname()
+{
+    rb_cPathname = rb_define_class("Pathname", rb_cObject);
+
+    rb_define_method(rb_cPathname, "to_s",    path_to_s, 0);
+    rb_define_method(rb_cPathname, "to_path", path_to_s, 0);
+    rb_define_method(rb_cPathname, "[]",      path_aref_m, -1);
+    rb_define_method(rb_cPathname, "slice",   path_aref_m, -1);
+    rb_define_method(rb_cPathname, "<=>",     path_cmp_m, 1);
+}
+    C
+
+    parser.scan
+
+    pathname = @store.classes_hash['Pathname']
+
+    to_path = pathname.method_list.find { |m| m.name == 'to_path' }
+    assert_equal "pathname.to_path -> string", to_path.call_seq
+
+    to_s = pathname.method_list.find { |m| m.name == 'to_s' }
+    assert_equal "pathname.to_s    -> string", to_s.call_seq
+
+    index_expected = <<-EXPECTED.chomp
+str[index]               -> new_str or nil
+str[start, length]       -> new_str or nil
+    EXPECTED
+
+    index = pathname.method_list.find { |m| m.name == '[]' }
+    assert_equal index_expected, index.call_seq, '[]'
+
+    slice_expected = <<-EXPECTED.chomp
+str.slice(index)         -> new_str or nil
+str.slice(start, length) -> new_str or nil
+    EXPECTED
+
+    slice = pathname.method_list.find { |m| m.name == 'slice' }
+    assert_equal slice_expected, slice.call_seq
+
+    spaceship = pathname.method_list.find { |m| m.name == '<=>' }
+    assert_equal "string <=> other_string   -> -1, 0, +1 or nil",
+                 spaceship.call_seq
+  end
+
   def test_scan_order_dependent
     parser = util_parser <<-C
 void a(void) {