yard 0.2.1 → 0.2.2

data/spec/code_objects/class_object_spec.rb

@@ -0,0 +1,176 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe YARD::CodeObjects::ClassObject do
+  before do 
+    Registry.clear 
+    @mixin = ModuleObject.new(:root, :SomeMixin)
+    @mixin2 = ModuleObject.new(:root, :SomeMixin2)
+    @superyard = ClassObject.new(:root, :SuperYard)
+    @superyard.superclass = P("String")
+    @superyard.mixins << @mixin2
+    @yard = ClassObject.new(:root, :YARD)
+    @yard.superclass = @superyard
+    @yard.mixins << @mixin
+  end
+  
+  it "should show the proper inheritance tree" do
+    @yard.inheritance_tree.should == [@yard, @superyard, P(:String)]
+  end
+  
+  it "should show proper inheritance tree when mixins are included" do
+    @yard.inheritance_tree(true).should == [@yard, @mixin, @superyard, P(:String)]
+  end
+end
+
+describe YARD::CodeObjects::ClassObject, "#meths / #inherited_meths" do
+  before do 
+    Registry.clear 
+    
+    Parser::SourceParser.parse_string <<-eof
+      class SuperYard < String
+        def foo; end
+        def foo2; end
+        def bar; end
+        def middle; end
+        protected :foo2
+        private
+        def self.bar; end
+      end
+      
+      class MiddleYard < SuperYard
+        def middle; end
+      end
+      
+      class YARD < MiddleYard
+        def mymethod; end
+        def bar; end
+      end
+    eof
+  end
+  
+  it "should show inherited methods by default" do
+    meths = P(:YARD).meths
+    meths.should include(P("YARD#mymethod"))
+    meths.should include(P("SuperYard#foo"))
+    meths.should include(P("SuperYard#foo2"))
+    meths.should include(P("SuperYard::bar"))
+  end
+  
+  it "should allow :inherited to be set to false" do
+    meths = P(:YARD).meths(:inherited => false)
+    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"))
+  end
+  
+  it "should not show overridden methods" do 
+    meths = P(:YARD).meths
+    meths.should include(P("YARD#bar"))
+    meths.should_not include(P("SuperYard#bar"))
+    
+    meths = P(:YARD).inherited_meths
+    meths.should_not include(P("YARD#bar"))
+    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"))
+  end
+  
+  it "should not show inherited methods overridden by other subclasses" do
+    meths = P(:YARD).inherited_meths
+    meths.should include(P('MiddleYard#middle'))
+    meths.should_not include(P('SuperYard#middle'))
+  end
+end
+
+describe YARD::CodeObjects::ClassObject, "#constants / #inherited_constants" do
+  before do 
+    Registry.clear 
+    
+    Parser::SourceParser.parse_string <<-eof
+      class YARD
+        CONST1 = 1
+        CONST2 = "hello"
+        CONST4 = 0
+      end
+      
+      class SUPERYARD < YARD
+        CONST4 = 5
+      end
+      
+      class SubYard < SUPERYARD
+        CONST2 = "hi"
+        CONST3 = "foo"
+      end
+    eof
+  end
+  
+  it "should list inherited constants by default" do
+    consts = P(:SubYard).constants
+    consts.should include(P("YARD::CONST1"))
+    consts.should include(P("SubYard::CONST3"))
+    
+    consts = P(:SubYard).inherited_constants
+    consts.should include(P("YARD::CONST1"))
+    consts.should_not include(P("YARD::CONST2"))
+    consts.should_not include(P("SubYard::CONST2"))
+    consts.should_not include(P("SubYard::CONST3"))
+  end
+  
+  it "should not list inherited constants if turned off" do
+    consts = P(:SubYard).constants(:inherited => false)
+    consts.should_not include(P("YARD::CONST1"))
+    consts.should include(P("SubYard::CONST3"))
+  end
+  
+  it "should not include an inherited constant if it is overridden by the object" do
+    consts = P(:SubYard).constants
+    consts.should include(P("SubYard::CONST2"))
+    consts.should_not include(P("YARD::CONST2"))
+  end
+  
+  it "should not include an inherited constant if it is overridden by another subclass" do
+    consts = P(:SubYard).inherited_constants
+    consts.should include(P("SUPERYARD::CONST4"))
+    consts.should_not include(P("YARD::CONST4"))
+  end
+  
+  it "should not set a superclass on Object class" do
+    o = ClassObject.new(:root, :Object)
+    o.superclass.should be_nil
+  end
+  
+  it "should raise ArgumentError if superclass == self" do
+    lambda do
+      o = ClassObject.new(:root, :Object) do |o|
+        o.superclass = :Object
+      end
+    end.should raise_error(ArgumentError)
+  end
+  
+  it "should tell the world if it is an exception class" do
+    o = ClassObject.new(:root, :MyClass) 
+    o2 = ClassObject.new(:root, :OtherClass)
+    o2.superclass = :SystemCallError
+    o3 = ClassObject.new(:root, :StandardError)
+    o3.superclass = :Object
+    o4 = ClassObject.new(:root, :Object)
+
+    o.superclass = :Object
+    o.is_exception?.should == false
+    
+    o.superclass = :Exception
+    o.is_exception?.should == true
+    
+    o.superclass = :NoMethodError
+    o.is_exception?.should == true
+    
+    o.superclass = o2
+    o.is_exception?.should == true
+    
+    o.superclass = o3
+    o.is_exception?.should == true
+  end
+end
+  

data/spec/code_objects/code_object_list_spec.rb

@@ -0,0 +1,33 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe YARD::CodeObjects::CodeObjectList do
+  before { Registry.clear }
+  
+  it "pushing a value should only allow CodeObjects::Base, String or Symbol" do
+    list = CodeObjectList.new(nil)
+    lambda { list.push(:hash => 1) }.should raise_error(ArgumentError)
+    list << "Test"
+    list << :Test2
+    list << ModuleObject.new(nil, :YARD)
+    list.size.should == 3
+  end
+  
+  it "added value should be a proxy if parameter was String or Symbol" do
+    list = CodeObjectList.new(nil)
+    list << "Test"
+    list.first.class.should == Proxy
+  end
+  
+  it "should contain a unique list of objects" do
+    obj = ModuleObject.new(nil, :YARD)
+    list = CodeObjectList.new(nil)
+    
+    list << P(:YARD)
+    list << obj
+    list.size.should == 1
+    
+    list << :Test
+    list << "Test"
+    list.size.should == 2
+  end
+end

data/spec/code_objects/constants_spec.rb

@@ -0,0 +1,79 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe YARD::CodeObjects, "CONSTANTMATCH" do
+  it "should match a constant" do
+    "Constant"[CodeObjects::CONSTANTMATCH].should == "Constant"
+    "identifier"[CodeObjects::CONSTANTMATCH].should be_nil
+    "File.new"[CodeObjects::CONSTANTMATCH].should == "File"
+  end
+end
+
+describe YARD::CodeObjects, "NAMESPACEMATCH" do
+  it "should match a namespace (multiple constants with ::)" do
+    "Constant"[CodeObjects::NAMESPACEMATCH].should == "Constant"
+    "A::B::C.new"[CodeObjects::NAMESPACEMATCH].should == "A::B::C"
+  end
+end
+
+describe YARD::CodeObjects, "METHODNAMEMATCH" do
+  it "should match a method name" do
+    "method"[CodeObjects::METHODNAMEMATCH].should == "method"
+    "[]()"[CodeObjects::METHODNAMEMATCH].should == "[]"
+    "-@"[CodeObjects::METHODNAMEMATCH].should == "-@"
+    "method?"[CodeObjects::METHODNAMEMATCH].should == "method?"
+    "method!!"[CodeObjects::METHODNAMEMATCH].should == "method!"
+  end
+end
+
+describe YARD::CodeObjects, "METHODMATCH" do
+  it "should match a full class method path" do
+    "method"[CodeObjects::METHODMATCH].should == "method"
+    "A::B::C.method?"[CodeObjects::METHODMATCH].should == "A::B::C.method?"
+    "A::B::C :: method"[CodeObjects::METHODMATCH].should == "A::B::C :: method"
+    "SomeClass . method"[CodeObjects::METHODMATCH].should == "SomeClass . method"
+  end
+  
+  it "should match self.method" do
+    "self :: method!"[CodeObjects::METHODMATCH].should == "self :: method!"
+    "self.is_a?"[CodeObjects::METHODMATCH].should == "self.is_a?"
+  end
+end
+
+describe YARD::CodeObjects, "BUILTIN_EXCEPTIONS" do
+  it "should include all base exceptions" do
+    YARD::CodeObjects::BUILTIN_EXCEPTIONS.each do |name|
+      eval(name).should <= Exception
+    end
+  end
+end
+
+describe YARD::CodeObjects, "BUILTIN_CLASSES" do
+  it "should include all base classes" do
+    YARD::CodeObjects::BUILTIN_CLASSES.each do |name|
+      eval(name).should be_instance_of(Class)
+    end
+  end
+  
+  it "should include all exceptions" do
+    YARD::CodeObjects::BUILTIN_EXCEPTIONS.each do |name|
+      YARD::CodeObjects::BUILTIN_CLASSES.should include(name)
+    end
+  end
+end
+
+describe YARD::CodeObjects, "BUILTIN_ALL" do
+  it "should include classes modules and exceptions" do
+    a = YARD::CodeObjects::BUILTIN_ALL 
+    b = YARD::CodeObjects::BUILTIN_CLASSES
+    c = YARD::CodeObjects::BUILTIN_MODULES
+    a.should == b+c
+  end
+end
+
+describe YARD::CodeObjects, "BUILTIN_MODULES" do
+  it "should include all base modules" do
+    YARD::CodeObjects::BUILTIN_MODULES.each do |name|
+      eval(name).should be_instance_of(Module)
+    end
+  end
+end

data/spec/code_objects/method_object_spec.rb

@@ -0,0 +1,30 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe YARD::CodeObjects::MethodObject do
+  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 exist in the registry after successful creation" do
+    obj = MethodObject.new(@yard, :something, :class)
+    Registry.at("YARD::something").should_not == nil
+    obj = MethodObject.new(@yard, :somethingelse)
+    Registry.at("YARD#somethingelse").should_not == nil
+  end
+end

data/spec/code_objects/module_object_spec.rb

@@ -0,0 +1,73 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe YARD::CodeObjects::ModuleObject, "#meths" do
+  before do 
+    Registry.clear 
+    
+    # setup the object space:
+    # 
+    #   YARD:module
+    #   YARD#foo:method
+    #   YARD#foo2:method
+    #   YARD#xyz:method
+    #   YARD::bar:method
+    #   SomeMod#mixmethod
+    #   SomeMod#xyz:method
+    # 
+    @yard = ModuleObject.new(:root, :YARD)
+    MethodObject.new(@yard, :foo)
+    MethodObject.new(@yard, :xyz)
+    MethodObject.new(@yard, :foo2) do |o|
+      o.visibility = :protected
+    end
+    MethodObject.new(@yard, :bar, :class) do |o|
+      o.visibility = :private
+    end
+    @other = ModuleObject.new(:root, :SomeMod)
+    MethodObject.new(@other, :mixmethod)
+    MethodObject.new(@other, :xyz)
+    
+    @yard.mixins << @other
+  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("SomeMod#mixmethod"))
+  end
+  
+  it "should allow :visibility to be set" do
+    meths = @yard.meths(:visibility => :public)
+    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_not include(P("YARD#foo2"))
+  end
+  
+  it "should allow :scope to be set" 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"))
+  end
+  
+  it "should allow :included to be set" do
+    meths = @yard.meths(:included => false)
+    meths.should_not include(P("SomeMod#mixmethod"))
+    meths.should include(P("YARD#foo"))
+    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 = @other.meths
+    meths.should include(P("SomeMod#xyz"))
+  end
+end

data/spec/code_objects/namespace_object_spec.rb

@@ -0,0 +1,129 @@
+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, :Mod)
+    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
+    
+    meths = b.meths
+    meths.should include(bmeth)
+    meths.should include(bmeth2)
+    meths.should include(ameth2)
+    meths.should_not include(ameth)
+    
+    meths = b.included_meths
+    meths.should include(ameth2)
+    meths.should_not include(ameth)
+    meths.should_not include(bmeth)
+    meths.should_not include(bmeth2)
+  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.mixins << a
+    c.mixins << b
+    
+    meths = c.included_meths
+    meths.should_not include(ameth)
+    meths.should 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)
+  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
+  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