yard 0.5.8 → 0.6.0

data/spec/cli/yri_spec.rb

@@ -7,7 +7,7 @@ end
 describe YARD::CLI::Yardoc do
   before do
     @yri = YARD::CLI::YRI.new
-    Registry.instance.stub!(:load)
+    Registry.stub!(:load)
   end
   
   describe '#find_object' do
@@ -50,5 +50,17 @@ describe YARD::CLI::Yardoc do
       spaths.should include('line1')
       spaths.should include('line2')
     end
+    
+    it "should use DEFAULT_SEARCH_PATHS prior to other paths" do
+      YARD::CLI::YRI::DEFAULT_SEARCH_PATHS.push('foo', 'bar')
+      path = %r{/\.yard/yri_search_paths$}
+      File.should_receive(:file?).with(%r{/\.yard/yri_cache$}).and_return(false)
+      File.should_receive(:file?).with(path).and_return(true)
+      File.should_receive(:readlines).with(path).and_return(%w(line1 line2))
+      @yri = YARD::CLI::YRI.new
+      spaths = @yri.instance_variable_get("@search_paths")
+      spaths[0,4].should == %w(foo bar line1 line2)
+      YARD::CLI::YRI::DEFAULT_SEARCH_PATHS.replace([])
+    end
   end
 end

data/spec/code_objects/base_spec.rb

@@ -42,12 +42,6 @@ describe YARD::CodeObjects::Base do
     o2.docstring.should == "NOT_DOCSTRING"
   end
   
-  it "should convert string into Docstring when #docstring= is set" do
-    o = ClassObject.new(:root, :Me) 
-    o.docstring = "DOCSTRING"
-    o.docstring.should be_instance_of(Docstring)
-  end
-
   it "should allow complex name and convert that to namespace" do
     obj = CodeObjects::Base.new(nil, "A::B")
     obj.namespace.path.should == "A"
@@ -252,4 +246,55 @@ describe YARD::CodeObjects::Base do
       Registry.at('A#b').relative_path('A#c').should == '#c'
     end
   end
+  
+  describe '#docstring=' do
+    it "should convert string into Docstring when #docstring= is set" do
+      o = ClassObject.new(:root, :Me) 
+      o.docstring = "DOCSTRING"
+      o.docstring.should be_instance_of(Docstring)
+    end
+    
+    it "should set docstring to docstring of other object if docstring is '(see Path)'" do
+      ClassObject.new(:root, :AnotherObject) {|x| x.docstring = "FOO" }
+      o = ClassObject.new(:root, :Me)
+      o.docstring = '(see AnotherObject)'
+      o.docstring.should == "FOO"
+    end
+    
+    it "should allow extra docstring after (see Path)" do
+      ClassObject.new(:root, :AnotherObject) {|x| x.docstring = "FOO" }
+      o = ClassObject.new(:root, :Me)
+      o.docstring = "(see AnotherObject)\n\nEXTRA\n@api private"
+      o.docstring.should == "FOO\n\nEXTRA"
+      o.docstring.should have_tag(:api)
+    end
+  end
+  
+  describe '#docstring' do
+    it "should return empty string if docstring was '(see Path)' and Path is not resolved" do
+      o = ClassObject.new(:root, :Me)
+      o.docstring = '(see AnotherObject)'
+      o.docstring.should == ""
+    end
+    
+    it "should return docstring when object is resolved" do
+      o = ClassObject.new(:root, :Me)
+      o.docstring = '(see AnotherObject)'
+      o.docstring.should == ""
+      ClassObject.new(:root, :AnotherObject) {|x| x.docstring = "FOO" }
+      o.docstring.should == "FOO"
+    end
+  end
+  
+  describe '#add_file' do
+    it "should only add a file/line combination once" do
+      o = ClassObject.new(:root, :Me)
+      o.add_file('filename', 12)
+      o.files.should == [['filename', 12]]
+      o.add_file('filename', 12)
+      o.files.should == [['filename', 12]]
+      o.add_file('filename', 40) # different line
+      o.files.should == [['filename', 12], ['filename', 40]]
+    end
+  end
 end

data/spec/code_objects/class_object_spec.rb

@@ -48,7 +48,7 @@ describe YARD::CodeObjects::ClassObject do
     before(:all) do
       Registry.clear
     
-      Parser::SourceParser.parse_string <<-eof
+      YARD.parse_string <<-eof
         class SuperYard < String
           def foo; end
           def foo2; end
@@ -67,6 +67,14 @@ describe YARD::CodeObjects::ClassObject do
           def mymethod; end
           def bar; end
         end
+        
+        module IncludedYard
+          def foo; end
+        end
+        
+        class FinalYard < SuperYard
+          include IncludedYard
+        end
       eof
     end
   
@@ -104,6 +112,12 @@ describe YARD::CodeObjects::ClassObject do
       meths.should include(P('MiddleYard#middle'))
       meths.should_not include(P('SuperYard#middle'))
     end
+    
+    it "should show mixed in methods before superclass method" do
+      meths = P(:FinalYard).meths
+      meths.should include(P('IncludedYard#foo'))
+      meths.should_not include(P('SuperYard#foo'))
+    end
   end
 
   describe "#constants / #inherited_constants" do

data/spec/code_objects/method_object_spec.rb

@@ -115,4 +115,33 @@ describe YARD::CodeObjects::MethodObject 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
+        class A; def foo; end end
+        class B < A; include C; def foo; end end
+      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
+        class B < A; def foo; end end
+      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
+        class B < A; def foo; end end
+      eof
+      Registry.at('B#foo').overridden_method.should be_nil
+    end
+  end
 end

data/spec/code_objects/namespace_object_spec.rb

@@ -3,147 +3,168 @@ require File.dirname(__FILE__) + '/spec_helper'
 describe YARD::CodeObjects::NamespaceObject do
   before { Registry.clear }
   
-  it "should respond to #child with the object name passed in" do
-    obj = NamespaceObject.new(nil, :YARD)
-    other = NamespaceObject.new(obj, :Other)
-    obj.child(:Other).should == other
-    obj.child('Other').should == other
-  end
-  
-  it "should respond to #child with hash of reader attributes with their response value" do
-    obj = NamespaceObject.new(nil, :YARD)
-    NamespaceObject.new(obj, :NotOther)
-    other = NamespaceObject.new(obj, :Other)
-    other.somevalue = 2
-    obj.child(:somevalue => 2).should == other
-  end
-  
-  it "should return #meths even if parent is a Proxy" do
-    obj = NamespaceObject.new(P(:String), :YARD)
-    obj.meths.should be_empty
-  end
-  
-  it "should not list included methods that are already defined in the namespace using #meths" do
-    a = ModuleObject.new(nil, :Mod1)
-    ameth = MethodObject.new(a, :testing)
-    b = ModuleObject.new(nil, :Mod2)
-    bmeth = MethodObject.new(b, :foo)
-    c = NamespaceObject.new(nil, :YARD)
-    cmeth = MethodObject.new(c, :testing)
-    cmeth2 = MethodObject.new(c, :foo)
-    c.instance_mixins << a
-    c.class_mixins << b
-    
-    meths = c.meths
-    meths.should include(bmeth)
-    meths.should include(cmeth)
-    meths.should include(cmeth2)
-    meths.should_not include(ameth)
-    
-    meths = c.included_meths
-    meths.should include(bmeth)
-    meths.should_not include(ameth)
-    meths.should_not include(cmeth)
-    meths.should_not include(cmeth2)
-  end
+  describe '#child' do
+    it "should return the object matching the name passed in if argument is a Symbol" do
+      obj = NamespaceObject.new(nil, :YARD)
+      other = NamespaceObject.new(obj, :Other)
+      obj.child(:Other).should == other
+      obj.child('Other').should == other
+    end
 
-  it "should list included_meths mixed into the class scope as class methods" do
-    b = ModuleObject.new(nil, :Mod2)
-    bmeth = MethodObject.new(b, :foo)
-    bmeth2 = MethodObject.new(b, :foo2)
-    c = NamespaceObject.new(nil, :YARD)
-    c.class_mixins << b
-    
-    [bmeth, bmeth2].each {|o| o.scope.should == :instance }
-    meths = c.included_meths(:scope => :class)
-    meths.each {|o| o.scope.should == :class }
+    it "should look for attributes matching the object if the argument is a Hash" do
+      obj = NamespaceObject.new(nil, :YARD)
+      NamespaceObject.new(obj, :NotOther)
+      other = NamespaceObject.new(obj, :Other)
+      other.somevalue = 2
+      obj.child(:somevalue => 2).should == other
+    end
   end
   
-  it "should not list methods overridden by another included module" do
-    a = ModuleObject.new(nil, :Mod)
-    ameth = MethodObject.new(a, :testing)
-    b = ModuleObject.new(nil, :Mod2)
-    bmeth = MethodObject.new(b, :testing)
-    c = NamespaceObject.new(nil, :YARD)
-    c.instance_mixins << a
-    c.instance_mixins << b
-    c.class_mixins << b
-    c.class_mixins << a
-    
-    meths = c.included_meths(:scope => :instance)
-    meths.should_not include(ameth)
-    meths.should include(bmeth)
-
-    meths = c.included_meths(:scope => :class)
-    meths.should include(ameth)
-    meths.should_not include(bmeth)
-  end
-  
-  it "should list class attributes using #class_attributes" do
-    a = NamespaceObject.new(nil, :Mod)
-    a.attributes[:instance][:a] = { :read => MethodObject.new(a, :a), :write => nil }
-    a.attributes[:instance][:b] = { :read => MethodObject.new(a, :b), :write => nil }
-    a.attributes[:class][:a] = { :read => MethodObject.new(a, :a, :class), :write => nil }
-    a.class_attributes.keys.should include(:a)
-    a.class_attributes.keys.should_not include(:b)
-  end
-  
-  it "should list instance attributes using #instance attributes" do
-    a = NamespaceObject.new(nil, :Mod)
-    a.attributes[:instance][:a] = { :read => MethodObject.new(a, :a), :write => nil }
-    a.attributes[:instance][:b] = { :read => MethodObject.new(a, :b), :write => nil }
-    a.attributes[:class][:a] = { :read => MethodObject.new(a, :a, :class), :write => nil }
-    a.instance_attributes.keys.should include(:a)
-    a.instance_attributes.keys.should include(:b)
+  describe '#meths' do
+    it "should return #meths even if parent is a Proxy" do
+      obj = NamespaceObject.new(P(:String), :YARD)
+      obj.meths.should be_empty
+    end
+
+    it "should not list included methods that are already defined in the namespace using #meths" do
+      a = ModuleObject.new(nil, :Mod1)
+      ameth = MethodObject.new(a, :testing)
+      b = ModuleObject.new(nil, :Mod2)
+      bmeth = MethodObject.new(b, :foo)
+      c = NamespaceObject.new(nil, :YARD)
+      cmeth = MethodObject.new(c, :testing)
+      cmeth2 = MethodObject.new(c, :foo)
+      c.instance_mixins << a
+      c.class_mixins << b
+
+      meths = c.meths
+      meths.should include(bmeth)
+      meths.should include(cmeth)
+      meths.should include(cmeth2)
+      meths.should_not include(ameth)
+
+      meths = c.included_meths
+      meths.should include(bmeth)
+      meths.should_not include(ameth)
+      meths.should_not include(cmeth)
+      meths.should_not include(cmeth2)
+    end
   end
-end
 
-describe YARD::CodeObjects::NamespaceObject, '#constants/#included_constants' do
-  before do
-    Registry.clear
-    
-    Parser::SourceParser.parse_string <<-eof
-      module A
-        CONST1 = 1
-        CONST2 = 2
-      end
-      
-      module B
-        CONST2 = -2
-        CONST3 = -3
-      end
-      
-      class C
-        CONST3 = 3
-        CONST4 = 4
-        
-        include A
-        include B
-      end
-    eof
+  describe '#included_meths' do
+    it "should list methods mixed into the class scope as class methods" do
+      b = ModuleObject.new(nil, :Mod2)
+      bmeth = MethodObject.new(b, :foo)
+      bmeth2 = MethodObject.new(b, :foo2)
+      c = NamespaceObject.new(nil, :YARD)
+      c.class_mixins << b
+
+      [bmeth, bmeth2].each {|o| o.scope.should == :instance }
+      meths = c.included_meths(:scope => :class)
+      meths.each {|o| o.scope.should == :class }
+    end
+
+    it "should not list methods overridden by another included module" do
+      a = ModuleObject.new(nil, :Mod)
+      ameth = MethodObject.new(a, :testing)
+      b = ModuleObject.new(nil, :Mod2)
+      bmeth = MethodObject.new(b, :testing)
+      c = NamespaceObject.new(nil, :YARD)
+      c.instance_mixins.unshift a
+      c.instance_mixins.unshift b
+      c.class_mixins.unshift b
+      c.class_mixins.unshift a
+
+      meths = c.included_meths(:scope => :instance)
+      meths.should_not include(ameth)
+      meths.should include(bmeth)
+
+      meths = c.included_meths(:scope => :class)
+      meths.should include(ameth)
+      meths.should_not include(bmeth)
+    end
   end
   
-  it "should list all included constants by default" do
-    consts = P(:C).constants
-    consts.should include(P('A::CONST1'))
-    consts.should include(P('C::CONST4'))
+  describe '#class_attributes' do
+    it "should list class attributes" do
+      a = NamespaceObject.new(nil, :Mod)
+      a.attributes[:instance][:a] = { :read => MethodObject.new(a, :a), :write => nil }
+      a.attributes[:instance][:b] = { :read => MethodObject.new(a, :b), :write => nil }
+      a.attributes[:class][:a] = { :read => MethodObject.new(a, :a, :class), :write => nil }
+      a.class_attributes.keys.should include(:a)
+      a.class_attributes.keys.should_not include(:b)
+    end
   end
   
-  it "should allow :included to be set to false to ignore included constants" do
-    consts = P(:C).constants(:included => false)
-    consts.should_not include(P('A::CONST1'))
-    consts.should include(P('C::CONST4'))
+  describe '#instance_attributes' do
+    it "should list instance attributes" do
+      a = NamespaceObject.new(nil, :Mod)
+      a.attributes[:instance][:a] = { :read => MethodObject.new(a, :a), :write => nil }
+      a.attributes[:instance][:b] = { :read => MethodObject.new(a, :b), :write => nil }
+      a.attributes[:class][:a] = { :read => MethodObject.new(a, :a, :class), :write => nil }
+      a.instance_attributes.keys.should include(:a)
+      a.instance_attributes.keys.should include(:b)
+    end
   end
   
-  it "should not list an included constant if it is defined in the object" do
-    consts = P(:C).constants
-    consts.should include(P('C::CONST3'))
-    consts.should_not include(P('B::CONST3'))
+  describe '#constants/#included_constants' do
+    before do
+      Registry.clear
+
+      YARD.parse_string <<-eof
+        module A
+          CONST1 = 1
+          CONST2 = 2
+        end
+
+        module B
+          CONST2 = -2
+          CONST3 = -3
+        end
+
+        class C
+          CONST3 = 3
+          CONST4 = 4
+
+          include A
+          include B
+        end
+      eof
+    end
+
+    it "should list all included constants by default" do
+      consts = P(:C).constants
+      consts.should include(P('A::CONST1'))
+      consts.should include(P('C::CONST4'))
+    end
+
+    it "should allow :included to be set to false to ignore included constants" do
+      consts = P(:C).constants(:included => false)
+      consts.should_not include(P('A::CONST1'))
+      consts.should include(P('C::CONST4'))
+    end
+
+    it "should not list an included constant if it is defined in the object" do
+      consts = P(:C).constants
+      consts.should include(P('C::CONST3'))
+      consts.should_not include(P('B::CONST3'))
+    end
+
+    it "should not list an included constant if it is shadowed by another included constant" do
+      consts = P(:C).included_constants
+      consts.should include(P('B::CONST2'))
+      consts.should_not include(P('A::CONST2'))
+    end
   end
   
-  it "should not list an included constant if it is shadowed by another included constant" do
-    consts = P(:C).included_constants
-    consts.should include(P('B::CONST2'))
-    consts.should_not include(P('A::CONST2'))
+  describe '#included_meths' do
+    it "should return all included methods with :all = true" do
+      YARD.parse_string <<-eof
+        module B; def foo; end end
+        module C; def bar; end end
+        class A; include B; include C; def foo; end; def bar; end end
+      eof
+      Registry.at('A').included_meths(:all => true).should == [P('C#bar'), P('B#foo')]
+    end
   end
 end