yard 0.8.7.6 → 0.9.0

data/spec/handlers/c/alias_handler_spec.rb

@@ -1,7 +1,7 @@
 require File.dirname(__FILE__) + "/spec_helper"
 
 describe YARD::Handlers::C::AliasHandler do
-  it "should allow defining of aliases (rb_define_alias)" do
+  it "allows defining of aliases (rb_define_alias)" do
     parse <<-eof
       /* FOO */
       VALUE foo(VALUE x) { int value = x; }
@@ -12,11 +12,11 @@ describe YARD::Handlers::C::AliasHandler do
       }
     eof
 
-    Registry.at('Foo#bar').should be_is_alias
-    Registry.at('Foo#bar').docstring.should == 'FOO'
+    expect(Registry.at('Foo#bar')).to be_is_alias
+    expect(Registry.at('Foo#bar').docstring).to eq 'FOO'
   end
 
-  it "should allow defining of aliases (rb_define_alias) of attributes" do
+  it "allows defining of aliases (rb_define_alias) of attributes" do
     parse <<-eof
       /* FOO */
       VALUE foo(VALUE x) { int value = x; }
@@ -27,7 +27,7 @@ describe YARD::Handlers::C::AliasHandler do
       }
     eof
 
-    Registry.at('Foo#foo').should be_reader
-    Registry.at('Foo#foo?').should be_is_alias
+    expect(Registry.at('Foo#foo')).to be_reader
+    expect(Registry.at('Foo#foo?')).to be_is_alias
   end
 end

data/spec/handlers/c/attribute_handler_spec.rb

@@ -14,27 +14,27 @@ describe YARD::Handlers::C::AttributeHandler do
     eof
   end
 
-  it "should handle readonly attribute (rb_define_attr)" do
+  it "handles readonly attribute (rb_define_attr)" do
     run(1, 0)
-    Registry.at('Foo#foo').should be_reader
-    Registry.at('Foo#foo=').should be_nil
+    expect(Registry.at('Foo#foo')).to be_reader
+    expect(Registry.at('Foo#foo=')).to be nil
   end
 
-  it "should handle writeonly attribute (rb_define_attr)" do
+  it "handles writeonly attribute (rb_define_attr)" do
     run(0, 1)
-    Registry.at('Foo#foo').should be_nil
-    Registry.at('Foo#foo=').should be_writer
+    expect(Registry.at('Foo#foo')).to be nil
+    expect(Registry.at('Foo#foo=')).to be_writer
   end
 
-  it "should handle readwrite attribute (rb_define_attr)" do
+  it "handles readwrite attribute (rb_define_attr)" do
     run(1, 1)
-    Registry.at('Foo#foo').should be_reader
-    Registry.at('Foo#foo=').should be_writer
+    expect(Registry.at('Foo#foo')).to be_reader
+    expect(Registry.at('Foo#foo=')).to be_writer
   end
 
-  it "should handle commented writeonly attribute (/* rb_define_attr */)" do
+  it "handles commented writeonly attribute (/* rb_define_attr */)" do
     run(1, 1, true)
-    Registry.at('Foo#foo').should be_reader
-    Registry.at('Foo#foo=').should be_writer
+    expect(Registry.at('Foo#foo')).to be_reader
+    expect(Registry.at('Foo#foo=')).to be_writer
   end
 end

data/spec/handlers/c/class_handler_spec.rb

@@ -1,63 +1,76 @@
 require File.dirname(__FILE__) + "/spec_helper"
 
 describe YARD::Handlers::C::ClassHandler do
-  it "should register classes" do
+  it "registers classes" do
     parse_init 'cFoo = rb_define_class("Foo", rb_cObject);'
-    Registry.at('Foo').type.should == :class
+    expect(Registry.at('Foo').type).to eq :class
   end
 
-  it "should register classes under namespaces" do
-    parse_init 'cFoo = rb_define_class_under(cBar, "Foo", rb_cObject);'
-    Registry.at('Bar::Foo').type.should == :class
+  it "registers classes under namespaces" do
+    parse_init <<-EOF
+      cBar = rb_define_class("Bar", rb_cObject);
+      cFoo = rb_define_class_under(cBar, "Foo", rb_cObject);
+    EOF
+    expect(Registry.at('Bar::Foo').type).to eq :class
   end
 
-  it "should remember symbol defined with class" do
+  it "remembers symbol defined with class" do
     parse_init(<<-eof)
       cXYZ = rb_define_class("Foo", rb_cObject);
       rb_define_method(cXYZ, "bar", bar, 0);
     eof
-    Registry.at('Foo').type.should == :class
-    Registry.at('Foo#bar').should_not be_nil
+    expect(Registry.at('Foo').type).to eq :class
+    expect(Registry.at('Foo#bar')).not_to be nil
   end
 
-  it "should lookup superclass symbol name" do
+  it "looks up superclass symbol name" do
     parse_init(<<-eof)
       cXYZ = rb_define_class("Foo", rb_cObject);
       cBar = rb_define_class("Bar", cXYZ);
     eof
-    Registry.at('Bar').superclass.should == Registry.at('Foo')
+    expect(Registry.at('Bar').superclass).to eq Registry.at('Foo')
   end
 
-  it "should user superclass symbol name as proxy if not found" do
+  it "uses superclass symbol name as proxy if not found" do
     parse_init(<<-eof)
       // cXYZ = rb_define_class("Foo", rb_cObject);
       cBar = rb_define_class("Bar", cXYZ);
     eof
-    Registry.at('Bar').superclass.should == P('XYZ')
+    expect(Registry.at('Bar').superclass).to eq P('XYZ')
   end
 
-  it "should not associate declaration comments as class docstring" do
+  it "does not associate declaration comments as class docstring" do
     parse_init(<<-eof)
       /* Docstring! */
       cFoo = rb_define_class("Foo", cObject);
     eof
-    Registry.at('Foo').docstring.should be_blank
+    expect(Registry.at('Foo').docstring).to be_blank
   end
 
-  it "should associate a file with the declaration" do
+  it "associates a file with the declaration" do
     parse_init(<<-eof)
       cFoo = rb_define_class("Foo", cObject);
     eof
-    Registry.at('Foo').file.should == '(stdin)'
-    Registry.at('Foo').line.should == 2
+    expect(Registry.at('Foo').file).to eq '(stdin)'
+    expect(Registry.at('Foo').line).to eq 2
   end
 
-  it "should properly handle Proxy superclasses" do
+  it "properly handles Proxy superclasses" do
     parse_init <<-eof
-      cFoo = rb_define_class_under(mFoo, "Bar", rb_cBar);
+      mFoo = rb_define_module("Foo");
+      cBar = rb_define_class_under(mFoo, "Bar", rb_cBar);
     eof
-    Registry.at('Foo::Bar').type.should == :class
-    Registry.at('Foo::Bar').superclass.should == P('Bar')
-    Registry.at('Foo::Bar').superclass.type.should == :class
+    expect(Registry.at('Foo::Bar').type).to eq :class
+    expect(Registry.at('Foo::Bar').superclass).to eq P('Bar')
+    expect(Registry.at('Foo::Bar').superclass.type).to eq :class
+  end
+
+  it "resolves namespace variable names across multiple files" do
+    parse_multi_file_init(
+      'cBar = rb_define_class_under(cFoo, "Bar", rb_cObject);',
+      'cFoo = rb_define_class("Foo", rb_cObject);'
+    )
+
+    expect(Registry.at('Foo::Bar').type).to eq :class
   end
 end

data/spec/handlers/c/constant_handler_spec.rb

@@ -1,15 +1,17 @@
 require File.dirname(__FILE__) + "/spec_helper"
 
 describe YARD::Handlers::C::ConstantHandler do
-  it "should register constants" do
+  it "registers constants" do
     parse_init <<-eof
       mFoo = rb_define_module("Foo");
       rb_define_const(mFoo, "FOO", ID2SYM(100));
+      rb_define_global_const("BAR", ID2SYM(100));
     eof
-    Registry.at('Foo::FOO').type.should == :constant
+   expect( Registry.at('Foo::FOO').type).to eq :constant
+   expect( Registry.at('BAR').type).to eq :constant
   end
 
-  it "should look for override comments" do
+  it "looks for override comments" do
     parse <<-eof
       /* Document-const: FOO
        * Document-const: Foo::BAR
@@ -23,46 +25,46 @@ describe YARD::Handlers::C::ConstantHandler do
       }
     eof
     foo = Registry.at('Foo::FOO')
-    foo.type.should == :constant
-    foo.docstring.should == 'Foo bar!'
-    foo.value.should == 'ID2SYM(100)'
-    foo.file.should == '(stdin)'
-    foo.line.should == 8
+    expect(foo.type).to eq :constant
+    expect(foo.docstring).to eq 'Foo bar!'
+    expect(foo.value).to eq 'ID2SYM(100)'
+    expect(foo.file).to eq '(stdin)'
+    expect(foo.line).to eq 8
     bar = Registry.at('Foo::BAR')
-    bar.type.should == :constant
-    bar.docstring.should == 'Foo bar!'
-    bar.file.should == '(stdin)'
-    bar.line.should == 9
-    bar.value.should == 'ID2SYM(101)'
+    expect(bar.type).to eq :constant
+    expect(bar.docstring).to eq 'Foo bar!'
+    expect(bar.file).to eq '(stdin)'
+    expect(bar.line).to eq 9
+    expect(bar.value).to eq 'ID2SYM(101)'
   end
 
-  it "should use comment attached to declaration as fallback" do
+  it "uses comment attached to declaration as fallback" do
     parse_init <<-eof
       mFoo = rb_define_module("Foo");
       rb_define_const(mFoo, "FOO", ID2SYM(100)); // foobar!
     eof
     foo = Registry.at('Foo::FOO')
-    foo.value.should == 'ID2SYM(100)'
-    foo.docstring.should == 'foobar!'
+    expect(foo.value).to eq 'ID2SYM(100)'
+    expect(foo.docstring).to eq 'foobar!'
   end
 
-  it "should allow the form VALUE: DOCSTRING to document value" do
+  it "allows the form VALUE: DOCSTRING to document value" do
     parse_init <<-eof
       mFoo = rb_define_module("Foo");
       rb_define_const(mFoo, "FOO", ID2SYM(100)); // 100: foobar!
     eof
     foo = Registry.at('Foo::FOO')
-    foo.value.should == '100'
-    foo.docstring.should == 'foobar!'
+    expect(foo.value).to eq '100'
+    expect(foo.docstring).to eq 'foobar!'
   end
 
-  it "should allow escaping of backslashes in VALUE: DOCSTRING syntax" do
+  it "allows escaping of backslashes in VALUE: DOCSTRING syntax" do
     parse_init <<-eof
       mFoo = rb_define_module("Foo");
       rb_define_const(mFoo, "FOO", ID2SYM(100)); // 100\\:x\\:y: foobar:x!
     eof
     foo = Registry.at('Foo::FOO')
-    foo.value.should == '100:x:y'
-    foo.docstring.should == 'foobar:x!'
+    expect(foo.value).to eq '100:x:y'
+    expect(foo.docstring).to eq 'foobar:x!'
   end
 end

data/spec/handlers/c/init_handler_spec.rb

@@ -1,47 +1,47 @@
 require File.dirname(__FILE__) + "/spec_helper"
 
 describe YARD::Handlers::C::InitHandler do
-  it "should add documentation in Init_ClassName() to ClassName" do
+  it "adds documentation in Init_ClassName() to ClassName" do
     parse(<<-eof)
       // Bar!
       void Init_A() {
         rb_cA = rb_define_class("A", rb_cObject);
       }
     eof
-    Registry.at('A').docstring.should == 'Bar!'
+    expect(Registry.at('A').docstring).to eq 'Bar!'
   end
 
-  it "should not add documentation if ClassName is not created in Init" do
+  it "does not add documentation if ClassName is not created in Init" do
     parse(<<-eof)
       // Bar!
       void Init_A() {
       }
     eof
-    Registry.at('A').should be_nil
+    expect(Registry.at('A')).to be nil
   end
 
-  it "should not overwrite override comment" do
+  it "does not overwrite override comment" do
     parse(<<-eof)
       /* Document-class: A
        * Foo!
        */
 
       // Bar!
-      void Init_A() {
+      static SWIGEXPORT void Init_A() {
         rb_cA = rb_define_class("A", rb_cObject);
       }
     eof
-    Registry.at('A').docstring.should == 'Foo!'
+    expect(Registry.at('A').docstring).to eq 'Foo!'
   end
 
-  it "should check non-Init methods for declarations too" do
+  it "checks non-Init methods for declarations too" do
     parse(<<-eof)
       void foo(int x, int y, char *name) {
         rb_cB = rb_define_class("B", rb_cObject);
         rb_define_method(rb_cB, "foo", foo_impl, 0);
       }
     eof
-    Registry.at('B').should be_a(CodeObjects::ClassObject)
-    Registry.at('B#foo').should be_a(CodeObjects::MethodObject)
+    expect(Registry.at('B')).to be_a(CodeObjects::ClassObject)
+    expect(Registry.at('B#foo')).to be_a(CodeObjects::MethodObject)
   end
 end

data/spec/handlers/c/method_handler_spec.rb

@@ -1,34 +1,34 @@
 require File.dirname(__FILE__) + "/spec_helper"
 
 describe YARD::Handlers::C::MethodHandler do
-  it "should register methods" do
+  it "registers methods" do
     parse_init <<-eof
       mFoo = rb_define_module("Foo");
       rb_define_method(mFoo, "bar", bar, 0);
     eof
-    Registry.at('Foo#bar').should_not be_nil
-    Registry.at('Foo#bar').visibility.should == :public
+    expect(Registry.at('Foo#bar')).not_to be nil
+    expect(Registry.at('Foo#bar').visibility).to eq :public
   end
 
-  it "should register private methods" do
+  it "registers private methods" do
     parse_init <<-eof
       mFoo = rb_define_module("Foo");
       rb_define_private_method(mFoo, "bar", bar, 0);
     eof
-    Registry.at('Foo#bar').should_not be_nil
-    Registry.at('Foo#bar').visibility.should == :private
+    expect(Registry.at('Foo#bar')).not_to be nil
+    expect(Registry.at('Foo#bar').visibility).to eq :private
   end
 
-  it "should register singleton methods" do
+  it "registers singleton methods" do
     parse_init <<-eof
       mFoo = rb_define_module("Foo");
       rb_define_singleton_method(mFoo, "bar", bar, 0);
     eof
-    Registry.at('Foo.bar').should_not be_nil
-    Registry.at('Foo.bar').visibility.should == :public
+    expect(Registry.at('Foo.bar')).not_to be nil
+    expect(Registry.at('Foo.bar').visibility).to eq :public
   end
 
-  it "should register module functions" do
+  it "registers module functions" do
     parse <<-eof
       /* DOCSTRING
        * @return [String] foo!
@@ -42,24 +42,24 @@ describe YARD::Handlers::C::MethodHandler do
     eof
     bar_c = Registry.at('Foo.bar')
     bar_i = Registry.at('Foo#bar')
-    bar_c.should be_module_function
-    bar_c.visibility.should == :public
-    bar_c.docstring.should == "DOCSTRING"
-    bar_c.tag(:return).object.should == bar_c
-    bar_c.source.should == "static VALUE bar(VALUE self) { x(); y(); z(); }"
-    bar_i.should_not be_module_function
-    bar_i.visibility.should == :private
-    bar_i.docstring.should == "DOCSTRING"
-    bar_i.tag(:return).object.should == bar_i
-    bar_i.source.should == bar_c.source
-  end
-
-  it "should register global functions into Kernel" do
+    expect(bar_c).to be_module_function
+    expect(bar_c.visibility).to eq :public
+    expect(bar_c.docstring).to eq "DOCSTRING"
+    expect(bar_c.tag(:return).object).to eq bar_c
+    expect(bar_c.source).to eq "static VALUE bar(VALUE self) { x(); y(); z(); }"
+    expect(bar_i).not_to be_module_function
+    expect(bar_i.visibility).to eq :private
+    expect(bar_i.docstring).to eq "DOCSTRING"
+    expect(bar_i.tag(:return).object).to eq bar_i
+    expect(bar_i.source).to eq bar_c.source
+  end
+
+  it "registers global functions into Kernel" do
     parse_init 'rb_define_global_function("bar", bar, 0);'
-    Registry.at('Kernel#bar').should_not be_nil
+    expect(Registry.at('Kernel#bar')).not_to be nil
   end
 
-  it "should look for symbol containing method source" do
+  it "looks for symbol containing method source" do
     parse <<-eof
       static VALUE foo(VALUE self) { x(); y(); z(); }
       VALUE bar() { a(); b(); c(); }
@@ -71,15 +71,15 @@ describe YARD::Handlers::C::MethodHandler do
     eof
     foo = Registry.at('Foo#foo')
     bar = Registry.at('Foo#bar')
-    foo.source.should == "static VALUE foo(VALUE self) { x(); y(); z(); }"
-    foo.file.should == '(stdin)'
-    foo.line.should == 1
-    bar.source.should == "VALUE bar() { a(); b(); c(); }"
-    bar.file.should == '(stdin)'
-    bar.line.should == 2
+    expect(foo.source).to eq "static VALUE foo(VALUE self) { x(); y(); z(); }"
+    expect(foo.file).to eq '(stdin)'
+    expect(foo.line).to eq 1
+    expect(bar.source).to eq "VALUE bar() { a(); b(); c(); }"
+    expect(bar.file).to eq '(stdin)'
+    expect(bar.line).to eq 2
   end
 
-  it "should find docstrings attached to method symbols" do
+  it "finds docstrings attached to method symbols" do
     parse <<-eof
       /* DOCSTRING */
       static VALUE foo(VALUE self) { x(); y(); z(); }
@@ -89,10 +89,10 @@ describe YARD::Handlers::C::MethodHandler do
       }
     eof
     foo = Registry.at('Foo#foo')
-    foo.docstring.should == 'DOCSTRING'
+    expect(foo.docstring).to eq 'DOCSTRING'
   end
 
-  it "should use declaration comments as docstring if there are no others" do
+  it "uses declaration comments as docstring if there are no others" do
     parse <<-eof
       static VALUE foo(VALUE self) { x(); y(); z(); }
       void Init_Foo() {
@@ -104,17 +104,17 @@ describe YARD::Handlers::C::MethodHandler do
       }
     eof
     foo = Registry.at('Foo#foo')
-    foo.docstring.should == 'DOCSTRING'
+    expect(foo.docstring).to eq 'DOCSTRING'
     bar = Registry.at('Foo#bar')
-    bar.docstring.should == 'DOCSTRING!'
+    expect(bar.docstring).to eq 'DOCSTRING!'
   end
 
-  it "should look for symbols in other file" do
+  it "looks for symbols in other file" do
     other = <<-eof
       /* DOCSTRING! */
       static VALUE foo() { x(); }
     eof
-    File.should_receive(:read).with('other.c').and_return(other)
+    expect(File).to receive(:read).with('other.c').and_return(other)
     parse <<-eof
       void Init_Foo() {
         mFoo = rb_define_module("Foo");
@@ -122,14 +122,14 @@ describe YARD::Handlers::C::MethodHandler do
       }
     eof
     foo = Registry.at('Foo#foo')
-    foo.docstring.should == 'DOCSTRING!'
-    foo.file.should == 'other.c'
-    foo.line.should == 2
-    foo.source.should == 'static VALUE foo() { x(); }'
+    expect(foo.docstring).to eq 'DOCSTRING!'
+    expect(foo.file).to eq 'other.c'
+    expect(foo.line).to eq 2
+    expect(foo.source).to eq 'static VALUE foo() { x(); }'
   end
 
-  it "should allow extra file to include /'s and other filename characters" do
-    File.should_receive(:read).at_least(1).times.with('ext/a-file.c').and_return(<<-eof)
+  it "allows extra file to include /'s and other filename characters" do
+    expect(File).to receive(:read).at_least(1).times.with('ext/a-file.c').and_return(<<-eof)
       /* FOO */
       VALUE foo(VALUE x) { int value = x; }
 
@@ -140,12 +140,12 @@ describe YARD::Handlers::C::MethodHandler do
       rb_define_method(rb_cFoo, "foo", foo, 1); /* in ext/a-file.c */
       rb_define_global_function("bar", bar, 1); /* in ext/a-file.c */
     eof
-    Registry.at('Foo#foo').docstring.should == 'FOO'
-    Registry.at('Kernel#bar').docstring.should == 'BAR'
+    expect(Registry.at('Foo#foo').docstring).to eq 'FOO'
+    expect(Registry.at('Kernel#bar').docstring).to eq 'BAR'
   end
 
-  it "should warn if other file can't be found" do
-    log.should_receive(:warn).with(/Missing source file `other.c' when parsing Foo#foo/)
+  it "warns if other file can't be found" do
+    expect(log).to receive(:warn).with(/Missing source file `other.c' when parsing Foo#foo/)
     parse <<-eof
       void Init_Foo() {
         mFoo = rb_define_module("Foo");
@@ -154,7 +154,7 @@ describe YARD::Handlers::C::MethodHandler do
     eof
   end
 
-  it "should look at override comments for docstring" do
+  it "looks at override comments for docstring" do
     parse <<-eof
       /* Document-method: Foo::foo
        * Document-method: new
@@ -171,12 +171,12 @@ describe YARD::Handlers::C::MethodHandler do
         rb_define_method(mBar, "baz", foo, 0);
       }
     eof
-    Registry.at('Foo#foo').docstring.should == 'Foo bar!'
-    Registry.at('Foo#initialize').docstring.should == 'Foo bar!'
-    Registry.at('Foo::Bar#baz').docstring.should == 'Foo bar!'
+    expect(Registry.at('Foo#foo').docstring).to eq 'Foo bar!'
+    expect(Registry.at('Foo#initialize').docstring).to eq 'Foo bar!'
+    expect(Registry.at('Foo::Bar#baz').docstring).to eq 'Foo bar!'
   end
 
-  it "should look at overrides in other files" do
+  it "looks at overrides in other files" do
     other = <<-eof
       /* Document-method: Foo::foo
        * Document-method: new
@@ -184,7 +184,7 @@ describe YARD::Handlers::C::MethodHandler do
        * Foo bar!
        */
     eof
-    File.should_receive(:read).with('foo/bar/other.c').and_return(other)
+    expect(File).to receive(:read).with('foo/bar/other.c').and_return(other)
     src = <<-eof
       void Init_Foo() {
         mFoo = rb_define_module("Foo");
@@ -195,12 +195,12 @@ describe YARD::Handlers::C::MethodHandler do
       }
     eof
     parse(src, 'foo/bar/baz/init.c')
-    Registry.at('Foo#foo').docstring.should == 'Foo bar!'
-    Registry.at('Foo#initialize').docstring.should == 'Foo bar!'
-    Registry.at('Foo::Bar#baz').docstring.should == 'Foo bar!'
+    expect(Registry.at('Foo#foo').docstring).to eq 'Foo bar!'
+    expect(Registry.at('Foo#initialize').docstring).to eq 'Foo bar!'
+    expect(Registry.at('Foo::Bar#baz').docstring).to eq 'Foo bar!'
   end
 
-  it "should add return tag on methods ending in '?'" do
+  it "adds return tag on methods ending in '?'" do
     parse <<-eof
       /* DOCSTRING */
       static VALUE foo(VALUE self) { x(); y(); z(); }
@@ -210,11 +210,11 @@ describe YARD::Handlers::C::MethodHandler do
       }
     eof
     foo = Registry.at('Foo#foo?')
-    foo.docstring.should == 'DOCSTRING'
-    foo.tag(:return).types.should == ['Boolean']
+    expect(foo.docstring).to eq 'DOCSTRING'
+    expect(foo.tag(:return).types).to eq ['Boolean']
   end
 
-  it "should not add return tag if return tags exist" do
+  it "does not add return tag if return tags exist" do
     parse <<-eof
       // @return [String] foo
       static VALUE foo(VALUE self) { x(); y(); z(); }
@@ -224,16 +224,101 @@ describe YARD::Handlers::C::MethodHandler do
       }
     eof
     foo = Registry.at('Foo#foo?')
-    foo.tag(:return).types.should == ['String']
+    expect(foo.tag(:return).types).to eq ['String']
   end
 
-  it "should handle casted method names" do
+  it "handles casted method names" do
     parse_init <<-eof
       mFoo = rb_define_module("Foo");
       rb_define_method(mFoo, "bar", (METHOD)bar, 0);
       rb_define_global_function("baz", (METHOD)baz, 0);
     eof
-    Registry.at('Foo#bar').should_not be_nil
-    Registry.at('Kernel#baz').should_not be_nil
+    expect(Registry.at('Foo#bar')).not_to be nil
+    expect(Registry.at('Kernel#baz')).not_to be nil
+  end
+
+  it "extracts at regular method parameters from C function signatures" do
+    parse <<-eof
+      static VALUE noargs_func(VALUE self) { return Qnil; }
+      static VALUE twoargs_func(VALUE self, VALUE a, VALUE b) { return a; }
+      void Init_Foo() {
+        mFoo = rb_define_module("Foo");
+        rb_define_method(mFoo, "noargs", noargs_func, 0);
+        rb_define_method(mFoo, "twoargs", twoargs_func, 2);
+      }
+    eof
+    expect(Registry.at('Foo#noargs').parameters).to be_empty
+    expect(Registry.at('Foo#twoargs').parameters).to eq [['a', nil], ['b', nil]]
+  end
+
+  it "extracts at varargs method parameters from C function signatures" do
+    parse <<-eof
+      static VALUE varargs_func(int argc, VALUE *argv, VALUE self) { return self; }
+      /* let's see if parser is robust in the face of strange spacing */
+      static VALUE varargs_func2(	int 	argc ,	VALUE
+	* 	 argv  ,VALUE  self	)
+
+      {return self;}
+      void Init_Foo() {
+        mFoo = rb_define_module("Foo");
+        rb_define_method(mFoo, "varargs", varargs_func, -1);
+        rb_define_method(	mFoo	,"varargs2",varargs_func2		,-1);
+      }
+    eof
+    expect(Registry.at('Foo#varargs').parameters).to eq [['*args', nil]]
+    expect(Registry.at('Foo#varargs2').parameters).to eq [['*args', nil]]
+  end
+
+  it "is not too strict or too loose about matching override comments to methods" do
+    parse <<-eof
+      /* Document-method: Foo::foo
+       * Document-method: new
+       * Document-method: Foo::Bar#baz
+       * Foo bar!
+       */
+
+      void Init_Foo() {
+        mFoo = rb_define_module("Foo");
+        mBar = rb_define_module_under(mFoo, "Bar");
+
+        rb_define_method(mFoo, "foo", foo, 0);
+        rb_define_singleton_method(mFoo, "foo", foo, 0);
+        rb_define_method(mBar, "foo", foo, 0);
+        rb_define_singleton_method(mBar, "foo", foo, 0);
+
+        rb_define_method(mFoo, "initialize", foo, 0);
+        rb_define_method(mBar, "initialize", foo, 0);
+
+        rb_define_method(mFoo, "baz", foo, 0);
+        rb_define_singleton_method(mFoo, "baz", foo, 0);
+        rb_define_method(mBar, "baz", foo, 0);
+        rb_define_singleton_method(mBar, "baz", foo, 0);
+      }
+    eof
+    expect(Registry.at('Foo#foo').docstring).to eq 'Foo bar!'
+    expect(Registry.at('Foo.foo').docstring).to eq 'Foo bar!'
+    expect(Registry.at('Foo::Bar#foo').docstring).to be_empty
+    expect(Registry.at('Foo::Bar.foo').docstring).to be_empty
+    expect(Registry.at('Foo#initialize').docstring).to eq 'Foo bar!'
+    expect(Registry.at('Foo::Bar#initialize').docstring).to eq 'Foo bar!'
+    expect(Registry.at('Foo#baz').docstring).to be_empty
+    expect(Registry.at('Foo.baz').docstring).to be_empty
+    expect(Registry.at('Foo::Bar#baz').docstring).to eq 'Foo bar!'
+    expect(Registry.at('Foo::Bar.baz').docstring).to be_empty
+  end
+
+  it "recognizes core Ruby classes and modules provided by ruby.h" do
+    parse_init <<-eof
+      rb_define_method(rb_cFixnum, "popcount", fix_popcount, 0);
+      rb_define_private_method(rb_mKernel, "pp", obj_pp, 0);
+      rb_define_method(rb_mEnumerable, "to_hash", enum_to_hash, 0);
+    eof
+    expect(Registry.at('Fixnum').type).to eq :class
+    expect(Registry.at('Fixnum#popcount').type).to eq :method
+    expect(Registry.at('Object').type).to eq :class
+    # Methods defined on Kernel are treated as if they were defined on Object
+    expect(Registry.at('Object#pp').type).to eq :method
+    expect(Registry.at('Enumerable').type).to eq :module
+    expect(Registry.at('Enumerable#to_hash').type).to eq :method
   end
 end