yard 0.2.2 → 0.2.3

data/spec/code_objects/class_object_spec.rb

@@ -5,12 +5,16 @@ describe YARD::CodeObjects::ClassObject do
     Registry.clear 
     @mixin = ModuleObject.new(:root, :SomeMixin)
     @mixin2 = ModuleObject.new(:root, :SomeMixin2)
+    @mixin3 = ModuleObject.new(:root, :SomeMixin3)
+    @mixin4 = ModuleObject.new(:root, :SomeMixin4)
+    @mixin2.instance_mixins << @mixin3
     @superyard = ClassObject.new(:root, :SuperYard)
     @superyard.superclass = P("String")
-    @superyard.mixins << @mixin2
+    @superyard.instance_mixins << @mixin2
+    @superyard.class_mixins << @mixin4
     @yard = ClassObject.new(:root, :YARD)
     @yard.superclass = @superyard
-    @yard.mixins << @mixin
+    @yard.instance_mixins << @mixin
   end
   
   it "should show the proper inheritance tree" do
@@ -18,7 +22,7 @@ describe YARD::CodeObjects::ClassObject do
   end
   
   it "should show proper inheritance tree when mixins are included" do
-    @yard.inheritance_tree(true).should == [@yard, @mixin, @superyard, P(:String)]
+    @yard.inheritance_tree(true).should == [@yard, @mixin, @superyard, @mixin2, @mixin3, P(:String)]
   end
 end
 
@@ -53,7 +57,7 @@ describe YARD::CodeObjects::ClassObject, "#meths / #inherited_meths" do
     meths.should include(P("YARD#mymethod"))
     meths.should include(P("SuperYard#foo"))
     meths.should include(P("SuperYard#foo2"))
-    meths.should include(P("SuperYard::bar"))
+    meths.should include(P("SuperYard.bar"))
   end
   
   it "should allow :inherited to be set to false" do
@@ -61,7 +65,7 @@ describe YARD::CodeObjects::ClassObject, "#meths / #inherited_meths" do
     meths.should include(P("YARD#mymethod"))
     meths.should_not include(P("SuperYard#foo"))
     meths.should_not include(P("SuperYard#foo2"))
-    meths.should_not include(P("SuperYard::bar"))
+    meths.should_not include(P("SuperYard.bar"))
   end
   
   it "should not show overridden methods" do 
@@ -74,7 +78,7 @@ describe YARD::CodeObjects::ClassObject, "#meths / #inherited_meths" do
     meths.should_not include(P("YARD#mymethod"))
     meths.should include(P("SuperYard#foo"))
     meths.should include(P("SuperYard#foo2"))
-    meths.should include(P("SuperYard::bar"))
+    meths.should include(P("SuperYard.bar"))
   end
   
   it "should not show inherited methods overridden by other subclasses" do
@@ -172,5 +176,13 @@ describe YARD::CodeObjects::ClassObject, "#constants / #inherited_constants" do
     o.superclass = o3
     o.is_exception?.should == true
   end
+  
+  it "should not raise ArgumentError if superclass is proxy in different namespace" do
+    lambda do
+      o = ClassObject.new(:root, :X) do |o|
+        o.superclass = P('OTHER::X')
+      end
+    end.should_not raise_error(ArgumentError)
+  end
 end
   

data/spec/code_objects/constants_spec.rb

@@ -50,6 +50,7 @@ end
 describe YARD::CodeObjects, "BUILTIN_CLASSES" do
   it "should include all base classes" do
     YARD::CodeObjects::BUILTIN_CLASSES.each do |name|
+      next if RUBY19 && ["MatchingData"].include?(name)
       eval(name).should be_instance_of(Class)
     end
   end
@@ -73,6 +74,7 @@ end
 describe YARD::CodeObjects, "BUILTIN_MODULES" do
   it "should include all base modules" do
     YARD::CodeObjects::BUILTIN_MODULES.each do |name|
+      next if RUBY19 && ["Precision"].include?(name)
       eval(name).should be_instance_of(Module)
     end
   end

data/spec/code_objects/method_object_spec.rb

@@ -16,15 +16,43 @@ describe YARD::CodeObjects::MethodObject do
     meth.path.should == "YARD#testing"
   end
   
-  it "should have a path of YARD::testing for a class method in YARD" do
+  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"
+    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 == nil
+    Registry.at("YARD.something").should_not be_nil
+    Registry.at("YARD#something").should be_nil
+    Registry.at("YARD::something").should be_nil
     obj = MethodObject.new(@yard, :somethingelse)
-    Registry.at("YARD#somethingelse").should_not == nil
+    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
+    obj.scope = :instance
+    Registry.at("YARD.something").should be_nil
+    Registry.at("YARD#something").should_not be_nil
+  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
-end
+end

data/spec/code_objects/module_object_spec.rb

@@ -10,7 +10,7 @@ describe YARD::CodeObjects::ModuleObject, "#meths" do
     #   YARD#foo:method
     #   YARD#foo2:method
     #   YARD#xyz:method
-    #   YARD::bar:method
+    #   YARD.bar:method
     #   SomeMod#mixmethod
     #   SomeMod#xyz:method
     # 
@@ -26,48 +26,106 @@ describe YARD::CodeObjects::ModuleObject, "#meths" do
     @other = ModuleObject.new(:root, :SomeMod)
     MethodObject.new(@other, :mixmethod)
     MethodObject.new(@other, :xyz)
+    MethodObject.new(@other, :baz, :class)
+    @another = ModuleObject.new(:root, :AnotherMod)
+    MethodObject.new(@another, :fizz)
+    MethodObject.new(@another, :bar)
+    MethodObject.new(@another, :fazz, :class)
     
-    @yard.mixins << @other
+    @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"))
     meths.should include(P("YARD#foo2"))
-    meths.should include(P("YARD::bar"))
+    meths.should include(P("YARD.bar"))
     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"))
+    meths.should_not include(P("YARD.bar"))
     meths = @yard.meths(:visibility => [:public, :private])
     meths.should include(P("YARD#foo"))
-    meths.should include(P("YARD::bar"))
+    meths.should include(P("YARD.bar"))
     meths.should_not include(P("YARD#foo2"))
   end
   
-  it "should allow :scope to be set" do
+  it "should only display class methods for :scope => :class" do
     meths = @yard.meths(:scope => :class)
     meths.should_not include(P("YARD#foo"))
     meths.should_not include(P("YARD#foo2"))
     meths.should_not include(P("SomeMod#mixmethod"))
+    meths.should_not include(P("SomeMod.baz"))
+    meths.should_not include(P("AnotherMod#fazz"))
+    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"))
+    meths.should include(P("YARD#foo2"))
+    meths.should include(P("SomeMod#mixmethod"))
+    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"))
+    meths.should_not include(P("AnotherMod#fizz"))
     meths.should include(P("YARD#foo"))
     meths.should include(P("YARD#foo2"))
-    meths.should include(P("YARD::bar"))
+    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"))
+
+    meths = @another.meths
+    meths.should include(P("AnotherMod#bar"))
+  end
+end
+
+describe YARD::CodeObjects::ModuleObject, "#inheritance_tree" do
+  before do
+    Registry.clear
+
+    @mod1 = ModuleObject.new(:root, :Mod1)
+    @mod2 = ModuleObject.new(:root, :Mod2)
+    @mod3 = ModuleObject.new(:root, :Mod3)
+    @mod4 = ModuleObject.new(:root, :Mod4)
+    @mod5 = ModuleObject.new(:root, :Mod5)
+
+    @mod1.instance_mixins << @mod2
+    @mod2.instance_mixins << @mod3
+    @mod1.instance_mixins << @mod4
+    
+    @proxy = P(:SomeProxyClass)
+    @mod5.instance_mixins << @proxy
+  end
+
+  it "should show only itself for an inheritance tree without included modules" do
+    @mod1.inheritance_tree.should == [@mod1]
+  end
+
+  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
-end
+end

data/spec/code_objects/namespace_object_spec.rb

@@ -24,25 +24,39 @@ describe YARD::CodeObjects::NamespaceObject do
   end
   
   it "should not list included methods that are already defined in the namespace using #meths" do
-    a = ModuleObject.new(nil, :Mod)
+    a = ModuleObject.new(nil, :Mod1)
     ameth = MethodObject.new(a, :testing)
-    ameth2 = MethodObject.new(a, :foo, :class)
-    b = NamespaceObject.new(nil, :YARD)
-    bmeth = MethodObject.new(b, :testing)
-    bmeth2 = MethodObject.new(b, :foo)
-    b.mixins << a
+    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 = b.meths
+    meths = c.meths
     meths.should include(bmeth)
-    meths.should include(bmeth2)
-    meths.should include(ameth2)
+    meths.should include(cmeth)
+    meths.should include(cmeth2)
     meths.should_not include(ameth)
     
-    meths = b.included_meths
-    meths.should include(ameth2)
+    meths = c.included_meths
+    meths.should include(bmeth)
     meths.should_not include(ameth)
-    meths.should_not include(bmeth)
-    meths.should_not include(bmeth2)
+    meths.should_not include(cmeth)
+    meths.should_not include(cmeth2)
+  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 }
   end
   
   it "should not list methods overridden by another included module" do
@@ -51,12 +65,18 @@ describe YARD::CodeObjects::NamespaceObject do
     b = ModuleObject.new(nil, :Mod2)
     bmeth = MethodObject.new(b, :testing)
     c = NamespaceObject.new(nil, :YARD)
-    c.mixins << a
-    c.mixins << b
+    c.instance_mixins << a
+    c.instance_mixins << b
+    c.class_mixins << b
+    c.class_mixins << a
     
-    meths = c.included_meths
+    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
@@ -126,4 +146,4 @@ describe YARD::CodeObjects::NamespaceObject, '#constants/#included_constants' do
     consts.should include(P('B::CONST2'))
     consts.should_not include(P('A::CONST2'))
   end
-end
+end

data/spec/code_objects/proxy_spec.rb

@@ -28,7 +28,7 @@ describe YARD::CodeObjects::Proxy do
   it "should return the object if it's an included Module" do
     yardobj = ModuleObject.new(:root, :YARD)
     pathobj = ClassObject.new(:root, :TestClass)
-    pathobj.mixins << yardobj
+    pathobj.instance_mixins << yardobj
     P(P(nil, :TestClass), :YARD).should be_instance_of(ModuleObject)
   end
   
@@ -37,6 +37,12 @@ describe YARD::CodeObjects::Proxy do
     yardobj = ModuleObject.new(:root, :YARD)
     P(:YARD).respond_to?(:children).should == true
     P(:NOTYARD).respond_to?(:children).should == false
+
+    private_method = P(:instantiated).private_methods.first
+    P(:YARD).respond_to?(private_method).should == false
+    P(:YARD).respond_to?(private_method, true).should == true
+    P(:NOTYARD).respond_to?(private_method).should == false
+    P(:NOTYARD).respond_to?(private_method, true).should == true
   end
   
   it "should make itself obvious that it's a proxy" do
@@ -77,4 +83,9 @@ describe YARD::CodeObjects::Proxy do
     P("InvalidClass").type = :class
     P("InvalidClass").type.should == :class
   end
-end
+  
+  it "should never equal Registry.root" do
+    P("MYPROXY").should_not == Registry.root
+    P("X::A").should_not == Registry.root
+  end
+end

data/spec/core_ext/string_spec.rb

@@ -1,4 +1,16 @@
 require File.dirname(__FILE__) + '/../spec_helper'
 
-described_in_docs String, '#camelcase'
-described_in_docs String, '#underscore'
+#described_in_docs String, '#camelcase'
+#described_in_docs String, '#underscore'
+
+describe String, '#camelcase' do
+  it 'should turn HelloWorld into hello_world' do
+    "HelloWorld".underscore.should == "hello_world"
+  end
+end
+
+describe String, '#underscore' do
+  it 'should turn hello_world into HelloWorld' do
+    "hello_world".camelcase.should == "HelloWorld"
+  end
+end

data/spec/core_ext/symbol_hash_spec.rb

@@ -55,13 +55,19 @@ describe SymbolHash do
     h['test'].should == [1,2,3]
   end
   
-  it "should support symbolization using #update or #merge" do
+  it "should support symbolization using #update or #merge!" do
     h = SymbolHash.new
     h.update('test' => 'value')
     h[:test].should == :value
-    h.merge('test' => 'value2')
+    h.merge!('test' => 'value2')
     h[:test].should == :value2
   end
+
+  it "should support symbolization non-destructively using #merge" do
+    h = SymbolHash.new
+    h.merge('test' => 'value')[:test].should == :value
+    h.should == SymbolHash.new
+  end
   
   it "should support #initializing of a hash" do
     h = SymbolHash[:test => 1]
@@ -77,4 +83,4 @@ describe SymbolHash do
     opts.keys.should == [:default]
     opts[:default].should == 1
   end
-end
+end

data/spec/docstring_spec.rb

@@ -0,0 +1,139 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe YARD::Docstring do
+  before { YARD::Registry.clear }
+  
+  it "should parse comments into tags" do
+    doc = Docstring.new(<<-eof)
+      @param name Hello world
+        how are you?
+      @param name2 
+        this is a new line
+      @param name3 and this
+        is a new paragraph:
+
+        right here.
+    eof
+    doc.tags("param").each do |tag|
+      if tag.name == "name"
+        tag.text.should == "Hello world how are you?"
+      elsif tag.name == "name2"
+        tag.text.should == "this is a new line"
+      elsif tag.name == "name3"
+        tag.text.should == "and this is a new paragraph:\n\nright here."
+      end
+    end
+  end
+  
+  it "should handle empty docstrings with #summary" do
+    o1 = Docstring.new
+    o1.summary.should == ""
+  end
+
+  it "should return the first sentence with #summary" do
+    o = Docstring.new("DOCSTRING. Another sentence")
+    o.summary.should == "DOCSTRING."
+  end
+
+  it "should return the first paragraph with #summary" do
+    o = Docstring.new("DOCSTRING, and other stuff\n\nAnother sentence.")
+    o.summary.should == "DOCSTRING, and other stuff."
+  end
+
+  it "should return proper summary when docstring is changed" do
+    o = Docstring.new "DOCSTRING, and other stuff\n\nAnother sentence."
+    o.summary.should == "DOCSTRING, and other stuff."
+    o = Docstring.new "DOCSTRING."
+    o.summary.should == "DOCSTRING."
+  end
+
+  it "should not double the ending period in docstring.summary" do
+    o = Docstring.new("Returns a list of tags specified by +name+ or all tags if +name+ is not specified.\n\nTest")
+    o.summary.should == "Returns a list of tags specified by +name+ or all tags if +name+ is not specified."
+  
+    doc = Docstring.new(<<-eof)
+      
+      Returns a list of tags specified by +name+ or all tags if +name+ is not specified.
+      
+      @param name the tag name to return data for, or nil for all tags
+      @return [Array<Tags::Tag>] the list of tags by the specified tag name
+    eof
+    doc.summary.should == "Returns a list of tags specified by +name+ or all tags if +name+ is not specified."
+  end
+  
+  it "should parse reference tag into ref_tags" do
+    doc = Docstring.new("@return (see Foo#bar)")
+    doc.ref_tags.size.should == 1
+    doc.ref_tags.first.owner.should == P("Foo#bar")
+    doc.ref_tags.first.tag_name.should == "return"
+    doc.ref_tags.first.name.should be_nil
+  end
+
+  it "should parse named reference tag into ref_tags" do
+    doc = Docstring.new("@param blah \n   (see Foo#bar )")
+    doc.ref_tags.size.should == 1
+    doc.ref_tags.first.owner.should == P("Foo#bar")
+    doc.ref_tags.first.tag_name.should == "param"
+    doc.ref_tags.first.name.should == "blah"
+  end
+  
+  it "should fail to parse named reference tag into ref_tags" do
+    doc = Docstring.new("@param blah THIS_BREAKS_REFTAG (see Foo#bar)")
+    doc.ref_tags.size.should == 0
+  end
+  
+  it "should return all valid reference tags along with #tags" do
+    o = CodeObjects::MethodObject.new(:root, 'Foo#bar')
+    o.docstring.add_tag Tags::Tag.new('return', 'testing')
+    doc = Docstring.new("@return (see Foo#bar)")
+    tags = doc.tags
+    tags.size.should == 1
+    tags.first.text.should == 'testing'
+    tags.first.should be_kind_of(Tags::RefTag)
+    tags.first.owner.should == o
+  end
+  
+  it "should return all valid named reference tags along with #tags(name)" do
+    o = CodeObjects::MethodObject.new(:root, 'Foo#bar')
+    o.docstring.add_tag Tags::Tag.new('param', 'testing', nil, '*args')
+    o.docstring.add_tag Tags::Tag.new('param', 'NOTtesting', nil, 'notargs')
+    doc = Docstring.new("@param *args (see Foo#bar)")
+    tags = doc.tags('param')
+    tags.size.should == 1
+    tags.first.text.should == 'testing'
+    tags.first.should be_kind_of(Tags::RefTag)
+    tags.first.owner.should == o
+  end
+
+  it "should ignore invalid reference tags" do
+    doc = Docstring.new("@param *args (see INVALID::TAG#tag)")
+    tags = doc.tags('param')
+    tags.size.should == 0
+  end
+
+  it "should be blank and empty if it has no content and no tags" do
+    Docstring.new.should be_blank
+    Docstring.new.should be_empty
+  end
+
+  it "shouldn't be empty or blank if it has content" do
+    d = Docstring.new("foo bar")
+    d.should_not be_empty
+    d.should_not be_blank
+  end
+
+  it "should be empty but not blank if it has tags" do
+    d = Docstring.new("@param foo")
+    d.should be_empty
+    d.should_not be_blank
+  end
+
+  it "should be empty but not blank if it has ref tags" do
+    o = CodeObjects::MethodObject.new(:root, 'Foo#bar')
+    o.docstring.add_tag Tags::Tag.new('return', 'testing')
+    d = Docstring.new("@return (see Foo#bar)")
+    d.should be_empty
+    d.should_not be_blank
+  end
+  
+end