Allow rb_path2class in rb_define_class_under. Allows rdoc to find OpenSSL::Digest

Author: drbrain

History.txt

@@ -1,8 +1,10 @@
-=== 3.6.1
+=== 3.6.1 / 2011-05-15
 
 * Bug fixes
   * Fix infinite loop created when re-encountering BasicObject.
   * RDoc::Context#each_ancestor is now provided for duck-typing.
+  * rb_path2class() can now be used to discover the parent class in
+    rb_define_class_under.
 
 === 3.6 / 2011-05-13
 

lib/rdoc/parser/c.rb

@@ -218,13 +218,22 @@ def do_classes
       handle_class_module(var_name, "module", class_name, nil, in_module)
     end
 
-    @content.scan(/([\w\.]+)\s* = \s*rb_define_class_under\s*
-                  \(
-                     \s*(\w+),
-                     \s*"(\w+)",
-                     \s*([\w\*\s\(\)\.\->]+)\s*  # for SWIG
-                  \s*\)/mx) do |var_name, in_module, class_name, parent|
-      handle_class_module(var_name, "class", class_name, parent, in_module)
+    @content.scan(/([\w\.]+)\s* =                  # var_name
+                   \s*rb_define_class_under\s*
+                   \(
+                     \s* (\w+),                    # under
+                     \s* "(\w+)",                  # class_name
+                     \s*
+                     (?:
+                       ([\w\*\s\(\)\.\->]+) |      # parent_name
+                       rb_path2class\("([\w:]+)"\) # path
+                     )
+                     \s*
+                   \)
+                  /mx) do |var_name, under, class_name, parent_name, path|
+      parent = path || parent_name
+
+      handle_class_module var_name, 'class', class_name, parent, under
     end
 
     @content.scan(/([\w\.]+)\s* = \s*rb_singleton_class\s*
@@ -650,8 +659,8 @@ def handle_class_module(var_name, type, class_name, parent, in_module)
       enclosure = @classes[in_module] || @@enclosure_classes[in_module]
 
       if enclosure.nil? and enclosure = @known_classes[in_module] then
-        type = /^rb_m/ =~ in_module ? "module" : "class"
-        handle_class_module in_module, type, enclosure, nil, nil
+        enc_type = /^rb_m/ =~ in_module ? "module" : "class"
+        handle_class_module in_module, enc_type, enclosure, nil, nil
         enclosure = @classes[in_module]
       end
 
@@ -675,17 +684,21 @@ def handle_class_module(var_name, type, class_name, parent, in_module)
       end
 
       cm = enclosure.add_class RDoc::NormalClass, class_name, parent_name
-
-      @stats.add_class cm
     else
       cm = enclosure.add_module RDoc::NormalModule, class_name
-      @stats.add_module cm
     end
 
     cm.record_location enclosure.top_level
 
     find_class_comment cm.full_name, cm
 
+    case cm
+    when RDoc::NormalClass
+      @stats.add_class cm
+    when RDoc::NormalModule
+      @stats.add_module cm
+    end
+
     @classes[var_name] = cm
     @@enclosure_classes[var_name] = cm
     @known_classes[var_name] = cm.full_name

test/test_rdoc_parser_c.rb

@@ -236,27 +236,43 @@ def test_do_classes_class
     assert_equal "this is the Foo class", klass.comment
   end
 
-  def test_do_classes_singleton
+  def test_do_classes_class_under
     content = <<-EOF
-VALUE cFoo = rb_define_class("Foo", rb_cObject);
-VALUE cFooS = rb_singleton_class(cFoo);
+/* Document-class: Kernel::Foo
+ * this is the Foo class under Kernel
+ */
+VALUE cFoo = rb_define_class_under(rb_mKernel, "Foo", rb_cObject);
     EOF
 
-    util_get_class content, 'cFooS'
-
-    assert_equal 'Foo', @parser.singleton_classes['cFooS']
+    klass = util_get_class content, 'cFoo'
+    assert_equal 'Kernel::Foo', klass.full_name
+    assert_equal "this is the Foo class under Kernel", klass.comment
   end
 
-  def test_do_classes_class_under
+  def test_do_classes_class_under_rb_path2class
     content = <<-EOF
 /* Document-class: Kernel::Foo
- * this is the Foo class under Kernel
+ * this is Kernel::Foo < A::B
  */
-VALUE cFoo = rb_define_class_under(rb_mKernel, "Foo", rb_cObject);
+VALUE cFoo = rb_define_class_under(rb_mKernel, "Foo", rb_path2class("A::B"));
     EOF
 
     klass = util_get_class content, 'cFoo'
-    assert_equal "this is the Foo class under Kernel", klass.comment
+
+    assert_equal 'Kernel::Foo', klass.full_name
+    assert_equal 'A::B', klass.superclass
+    assert_equal 'this is Kernel::Foo < A::B', klass.comment
+  end
+
+  def test_do_classes_singleton
+    content = <<-EOF
+VALUE cFoo = rb_define_class("Foo", rb_cObject);
+VALUE cFooS = rb_singleton_class(cFoo);
+    EOF
+
+    util_get_class content, 'cFooS'
+
+    assert_equal 'Foo', @parser.singleton_classes['cFooS']
   end
 
   def test_do_classes_module