yard 0.7.5 → 0.8.0

data/spec/code_objects/method_object_spec.rb

@@ -1,31 +1,31 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
 describe YARD::CodeObjects::MethodObject do
-  before do 
-    Registry.clear 
+  before do
+    Registry.clear
     @yard = ModuleObject.new(:root, :YARD)
   end
-  
+
   it "should have a path of testing for an instance method in the root" do
     meth = MethodObject.new(:root, :testing)
     meth.path.should == "#testing"
   end
-  
+
   it "should have a path of YARD#testing for an instance method in YARD" do
     meth = MethodObject.new(@yard, :testing)
     meth.path.should == "YARD#testing"
   end
-  
+
   it "should have a path of YARD.testing for a class method in YARD" do
     meth = MethodObject.new(@yard, :testing, :class)
     meth.path.should == "YARD.testing"
   end
-  
+
   it "should have a path of ::testing (note the ::) for a class method added to root namespace" do
     meth = MethodObject.new(:root, :testing, :class)
     meth.path.should == "::testing"
   end
-  
+
   it "should exist in the registry after successful creation" do
     obj = MethodObject.new(@yard, :something, :class)
     Registry.at("YARD.something").should_not be_nil
@@ -34,7 +34,7 @@ describe YARD::CodeObjects::MethodObject do
     obj = MethodObject.new(@yard, :somethingelse)
     Registry.at("YARD#somethingelse").should_not be_nil
   end
-  
+
   it "should allow #scope to be changed after creation" do
     obj = MethodObject.new(@yard, :something, :class)
     Registry.at("YARD.something").should_not be_nil
@@ -42,20 +42,43 @@ describe YARD::CodeObjects::MethodObject do
     Registry.at("YARD.something").should be_nil
     Registry.at("YARD#something").should_not be_nil
   end
-  
+
+  it "should create object in :class scope if scope is :module" do
+    obj = MethodObject.new(@yard, :module_func, :module)
+    obj.scope.should == :class
+    obj.visibility.should == :public
+    Registry.at('YARD.module_func').should_not be_nil
+  end
+
+  it "should create second private instance method if scope is :module" do
+    MethodObject.new(@yard, :module_func, :module)
+    obj = Registry.at('YARD#module_func')
+    obj.should_not be_nil
+    obj.visibility.should == :private
+    obj.scope.should == :instance
+  end
+
+  it "should yield block to second method if scope is :module" do
+    MethodObject.new(@yard, :module_func, :module) do |o|
+      o.docstring = 'foo'
+    end
+    Registry.at('YARD.module_func').docstring.should == 'foo'
+    Registry.at('YARD#module_func').docstring.should == 'foo'
+  end
+
   describe '#name' do
     it "should show a prefix for an instance method when prefix=true" do
       obj = MethodObject.new(nil, :something)
       obj.name(true).should == "#something"
     end
-    
+
     it "should never show a prefix for a class method" do
       obj = MethodObject.new(nil, :something, :class)
       obj.name.should == :"something"
       obj.name(true).should == "something"
     end
   end
-  
+
   describe '#is_attribute?' do
     it "should only return true if attribute is set in namespace for read/write" do
       obj = MethodObject.new(@yard, :foo)
@@ -64,24 +87,24 @@ describe YARD::CodeObjects::MethodObject do
       MethodObject.new(@yard, :foo=).is_attribute?.should be_false
     end
   end
-  
+
   describe '#attr_info' do
     it "should return attribute info if namespace is available" do
       obj = MethodObject.new(@yard, :foo)
       @yard.attributes[:instance][:foo] = {:read => obj, :write => nil}
       obj.attr_info.should == @yard.attributes[:instance][:foo]
     end
-    
+
     it "should return nil if namespace is proxy" do
       obj = MethodObject.new(P(:ProxyClass), :foo)
       MethodObject.new(@yard, :foo).attr_info.should == nil
     end
-    
+
     it "should return nil if meth is not an attribute" do
       MethodObject.new(@yard, :notanattribute).attr_info.should == nil
     end
   end
-  
+
   describe '#writer?' do
     it "should return true if method is a writer attribute" do
       obj = MethodObject.new(@yard, :foo=)
@@ -99,26 +122,26 @@ describe YARD::CodeObjects::MethodObject do
       MethodObject.new(@yard, :NOTfoo).reader?.should == false
     end
   end
-  
+
   describe '#constructor?' do
     before { @class = ClassObject.new(:root, :MyClass) }
 
     it "should mark the #initialize method as constructor" do
       MethodObject.new(@class, :initialize)
     end
-    
+
     it "should not mark Klass.initialize as constructor" do
       MethodObject.new(@class, :initialize, :class).constructor?.should be_false
     end
-    
+
     it "should not mark module method #initialize as constructor" do
       MethodObject.new(@yard, :initialize).constructor?.should be_false
     end
   end
-  
+
   describe '#overridden_method' do
     before { Registry.clear }
-    
+
     it "should return overridden method from mixin first" do
       YARD.parse_string(<<-eof)
         module C; def foo; end end
@@ -127,7 +150,7 @@ describe YARD::CodeObjects::MethodObject do
       eof
       Registry.at('B#foo').overridden_method.should == Registry.at('C#foo')
     end
-    
+
     it "should return overridden method from superclass" do
       YARD.parse_string(<<-eof)
         class A; def foo; end end
@@ -135,7 +158,7 @@ describe YARD::CodeObjects::MethodObject do
       eof
       Registry.at('B#foo').overridden_method.should == Registry.at('A#foo')
     end
-    
+
     it "should return nil if none is found" do
       YARD.parse_string(<<-eof)
         class A; end
@@ -143,7 +166,7 @@ describe YARD::CodeObjects::MethodObject do
       eof
       Registry.at('B#foo').overridden_method.should be_nil
     end
-    
+
     it "should return nil if namespace is a proxy" do
       YARD.parse_string "def ARGV.foo; end"
       Registry.at('ARGV.foo').overridden_method.should be_nil

data/spec/code_objects/module_object_spec.rb

@@ -2,11 +2,11 @@ require File.dirname(__FILE__) + '/spec_helper'
 
 describe YARD::CodeObjects::ModuleObject do
   describe "#meths" do
-    before do 
-      Registry.clear 
-    
+    before do
+      Registry.clear
+
       # setup the object space:
-      # 
+      #
       #   YARD:module
       #   YARD#foo:method
       #   YARD#foo2:method
@@ -14,7 +14,7 @@ describe YARD::CodeObjects::ModuleObject do
       #   YARD.bar:method
       #   SomeMod#mixmethod
       #   SomeMod#xyz:method
-      # 
+      #
       @yard = ModuleObject.new(:root, :YARD)
       MethodObject.new(@yard, :foo)
       MethodObject.new(@yard, :xyz)
@@ -32,11 +32,11 @@ describe YARD::CodeObjects::ModuleObject do
       MethodObject.new(@another, :fizz)
       MethodObject.new(@another, :bar)
       MethodObject.new(@another, :fazz, :class)
-    
+
       @yard.instance_mixins << @other
       @yard.class_mixins << @another
     end
-  
+
     it "should list all methods (including mixin methods) via #meths" do
       meths = @yard.meths
       meths.should include(P("YARD#foo"))
@@ -45,7 +45,7 @@ describe YARD::CodeObjects::ModuleObject do
       meths.should include(P("SomeMod#mixmethod"))
       meths.should include(P("AnotherMod#fizz"))
     end
-  
+
     it "should allow :visibility to be set" do
       meths = @yard.meths(:visibility => :public)
       meths.should_not include(P("YARD.bar"))
@@ -54,7 +54,7 @@ describe YARD::CodeObjects::ModuleObject do
       meths.should include(P("YARD.bar"))
       meths.should_not include(P("YARD#foo2"))
     end
-  
+
     it "should only display class methods for :scope => :class" do
       meths = @yard.meths(:scope => :class)
       meths.should_not include(P("YARD#foo"))
@@ -65,7 +65,7 @@ describe YARD::CodeObjects::ModuleObject do
       meths.should include(P("YARD.bar"))
       meths.should include(P("AnotherMod#fizz"))
     end
-  
+
     it "should only display instance methods for :scope => :class" do
       meths = @yard.meths(:scope => :instance)
       meths.should include(P("YARD#foo"))
@@ -74,7 +74,7 @@ describe YARD::CodeObjects::ModuleObject do
       meths.should_not include(P("YARD.bar"))
       meths.should_not include(P("AnotherMod#fizz"))
     end
-  
+
     it "should allow :included to be set" do
       meths = @yard.meths(:included => false)
       meths.should_not include(P("SomeMod#mixmethod"))
@@ -83,14 +83,14 @@ describe YARD::CodeObjects::ModuleObject do
       meths.should include(P("YARD#foo2"))
       meths.should include(P("YARD.bar"))
     end
-  
+
     it "should choose the method defined in the class over an included module" do
       meths = @yard.meths
       meths.should_not include(P("SomeMod#xyz"))
       meths.should include(P("YARD#xyz"))
       meths.should_not include(P("AnotherMod#bar"))
       meths.should include(P("YARD.bar"))
-    
+
       meths = @other.meths
       meths.should include(P("SomeMod#xyz"))
 
@@ -113,7 +113,7 @@ describe YARD::CodeObjects::ModuleObject do
       @mod2.instance_mixins << @mod3
       @mod3.instance_mixins << @mod4
       @mod1.instance_mixins << @mod4
-    
+
       @proxy = P(:SomeProxyClass)
       @mod5.instance_mixins << @proxy
     end
@@ -125,12 +125,12 @@ describe YARD::CodeObjects::ModuleObject do
     it "should show proper inheritance three when modules are included" do
       @mod1.inheritance_tree(true).should == [@mod1, @mod2, @mod3, @mod4]
     end
-  
+
     it "should not list inheritance tree of proxy objects in inheritance tree" do
       @proxy.should_not_receive(:inheritance_tree)
       @mod5.instance_mixins.should == [@proxy]
     end
-    
+
     it "should list class mixins in inheritance tree" do
       mod = ModuleObject.new(:root, :ClassMethods)
       recvmod = ModuleObject.new(:root, :ReceivingModule)

data/spec/code_objects/namespace_object_spec.rb

@@ -2,7 +2,7 @@ require File.dirname(__FILE__) + '/spec_helper'
 
 describe YARD::CodeObjects::NamespaceObject do
   before { Registry.clear }
-  
+
   describe '#child' do
     it "should return the object matching the name passed in if argument is a Symbol" do
       obj = NamespaceObject.new(nil, :YARD)
@@ -19,7 +19,7 @@ describe YARD::CodeObjects::NamespaceObject do
       obj.child(:somevalue => 2).should == other
     end
   end
-  
+
   describe '#meths' do
     it "should return #meths even if parent is a Proxy" do
       obj = NamespaceObject.new(P(:String), :YARD)
@@ -84,7 +84,7 @@ describe YARD::CodeObjects::NamespaceObject do
       meths.should_not include(bmeth)
     end
   end
-  
+
   describe '#class_attributes' do
     it "should list class attributes" do
       a = NamespaceObject.new(nil, :Mod)
@@ -95,7 +95,7 @@ describe YARD::CodeObjects::NamespaceObject do
       a.class_attributes.keys.should_not include(:b)
     end
   end
-  
+
   describe '#instance_attributes' do
     it "should list instance attributes" do
       a = NamespaceObject.new(nil, :Mod)
@@ -106,7 +106,7 @@ describe YARD::CodeObjects::NamespaceObject do
       a.instance_attributes.keys.should include(:b)
     end
   end
-  
+
   describe '#constants/#included_constants' do
     before do
       Registry.clear
@@ -156,7 +156,7 @@ describe YARD::CodeObjects::NamespaceObject do
       consts.should_not include(P('A::CONST2'))
     end
   end
-  
+
   describe '#included_meths' do
     it "should return all included methods with :all = true" do
       YARD.parse_string <<-eof

data/spec/code_objects/proxy_spec.rb

@@ -2,20 +2,20 @@ require File.dirname(__FILE__) + '/spec_helper'
 
 describe YARD::CodeObjects::Proxy do
   before { Registry.clear }
-  
+
   it "should return the object if it's in the Registry" do
     pathobj = ModuleObject.new(:root, :YARD)
     proxyobj = P(:root, :YARD)
     proxyobj.type.should == :module
     Proxy.should_not === proxyobj
   end
-  
+
   it "should handle complex string namespaces" do
     ModuleObject.new(:root, :A)
     pathobj = ModuleObject.new(P(nil, :A), :B)
     P(:root, "A::B").should be_instance_of(ModuleObject)
   end
-  
+
   it "should not return true to Proxy === obj if obj is a Proxy class holding a resolved object" do
     Proxy.should === P(:root, 'a')
     Proxy.should_not === P(:root)
@@ -24,14 +24,14 @@ describe YARD::CodeObjects::Proxy do
     x = Proxy.new(:root, 'a')
     Proxy.should_not === x
   end
-  
+
   it "should return the object if it's an included Module" do
     yardobj = ModuleObject.new(:root, :YARD)
     pathobj = ClassObject.new(:root, :TestClass)
     pathobj.instance_mixins << yardobj
     P(P(nil, :TestClass), :YARD).should be_instance_of(ModuleObject)
   end
-  
+
   it "should respond_to respond_to?" do
     obj = ClassObject.new(:root, :Object)
     yardobj = ModuleObject.new(:root, :YARD)
@@ -43,33 +43,33 @@ describe YARD::CodeObjects::Proxy do
     P(:NOTYARD).respond_to?(:initialize).should == false
     P(:NOTYARD).respond_to?(:initialize, true).should == true
   end
-  
+
   it "should make itself obvious that it's a proxy" do
     pathobj = P(:root, :YARD)
     pathobj.class.should == Proxy
     (Proxy === pathobj).should == true
-  end    
+  end
 
   it "should pretend it's the object's type if it can resolve" do
     pathobj = ModuleObject.new(:root, :YARD)
     proxyobj = P(:root, :YARD)
     proxyobj.should be_instance_of(ModuleObject)
   end
-  
+
   it "should handle instance method names" do
     obj = P(nil, '#test')
     obj.name.should == :test
     obj.path.should == "#test"
     obj.namespace.should == Registry.root
   end
-  
+
   it "should handle instance method names under a namespace" do
     pathobj = ModuleObject.new(:root, :YARD)
     obj = P(pathobj, "A::B#test")
     obj.name.should == :test
     obj.path.should == "A::B#test"
   end
-  
+
   it "should allow type to be changed" do
     obj = P("InvalidClass")
     obj.type.should == :proxy
@@ -77,17 +77,17 @@ describe YARD::CodeObjects::Proxy do
     obj.type = :class
     obj.type.should == :class
   end
-  
+
   it "should retain a type change between Proxy objects" do
     P("InvalidClass").type = :class
     P("InvalidClass").type.should == :class
   end
-  
+
   it "should never equal Registry.root" do
     P("MYPROXY").should_not == Registry.root
     P("X::A").should_not == Registry.root
   end
-  
+
   it "should reset namespace and name when object is resolved" do
     obj1 = ModuleObject.new(:root, :YARD)
     obj2 = ModuleObject.new(:root, :NOTYARD)
@@ -96,24 +96,24 @@ describe YARD::CodeObjects::Proxy do
     resolved.namespace.should == Registry.root
     resolved.name.should == :YARD
   end
-  
+
   it "should ensure that the correct object was resolved" do
     foo = ModuleObject.new(:root, :Foo)
     foobar = ModuleObject.new(foo, :Bar)
     foobaz = ClassObject.new(foo, :Baz)
-    
+
     # Remember, we're looking for Qux::Bar, not just 'Bar'
     proxy = Proxy.new(foobar, 'Foo::Qux::Bar')
     proxy.type.should == :proxy
-    
+
     qux = ModuleObject.new(foo, :Qux)
     quxbar = ModuleObject.new(qux, :Bar)
-    
+
     # Now it should resolve
     proxy.type.should == :module
   end
-  
-  
+
+
   it "should handle constant names in namespaces" do
     YARD.parse_string <<-eof
       module A; end; B = A