yard 0.7.5 → 0.8.0

data/spec/parser/tag_parsing_spec.rb

@@ -2,17 +2,17 @@ require File.join(File.dirname(__FILE__), '..', 'spec_helper')
 
 describe YARD::Parser, "tag handling" do
   before { parse_file :tag_handler_001, __FILE__ }
-  
+
   it "should know the list of all available tags" do
     P("Foo#foo").tags.should include(P("Foo#foo").tag(:api))
   end
-  
+
   it "should know the text of tags on a method" do
     P("Foo#foo").tag(:api).text.should == "public"
   end
-  
+
   it "should return true when asked whether a tag exists" do
     P("Foo#foo").has_tag?(:api).should == true
   end
-  
+
 end

data/spec/rake/yardoc_task_spec.rb

@@ -10,21 +10,23 @@ describe YARD::Rake::YardocTask do
     Templates::Engine.stub!(:render)
     Templates::Engine.stub!(:generate)
     YARD.stub!(:parse)
+    Registry.stub!(:load)
+    Registry.stub!(:save)
     YARD::CLI::Yardoc.stub!(:new).and_return(@yardoc)
     ::Rake.application.clear
   end
-  
+
   def run
     ::Rake.application.tasks[0].invoke
   end
-  
+
   describe '#initialize' do
     it "should allow separate rake task name to be set" do
       YARD::Rake::YardocTask.new(:notyardoc)
       ::Rake.application.tasks[0].name.should == "notyardoc"
     end
   end
-  
+
   describe '#files' do
     it "should allow files to be set" do
       YARD::Rake::YardocTask.new do |t|
@@ -34,7 +36,7 @@ describe YARD::Rake::YardocTask do
       @yardoc.files.should == %w(a b c)
     end
   end
-  
+
   describe '#options' do
     it "should allow extra options to be set" do
       YARD::Rake::YardocTask.new do |t|
@@ -44,7 +46,7 @@ describe YARD::Rake::YardocTask do
       @yardoc.visibilities.should == [:public, :private, :protected]
     end
   end
-  
+
   describe '#before' do
     it "should allow before callback" do
       proc = lambda { }
@@ -54,7 +56,7 @@ describe YARD::Rake::YardocTask do
       run
     end
   end
-  
+
   describe '#after' do
     it "should allow after callback" do
       proc = lambda { }
@@ -63,7 +65,7 @@ describe YARD::Rake::YardocTask do
       YARD::Rake::YardocTask.new {|t| t.after = proc }
       run
     end
-    
+
     describe '#verifier' do
       it "should allow a verifier proc to be set" do
         verifier = Verifier.new
@@ -79,7 +81,7 @@ describe YARD::Rake::YardocTask do
         @yardoc.should_receive(:run) do
           @yardoc.options[:verifier].should == verifier
         end
-        YARD::Rake::YardocTask.new do |t| 
+        YARD::Rake::YardocTask.new do |t|
           t.options += ['--query', '@return']
           t.verifier = verifier
         end

data/spec/registry_spec.rb

@@ -5,7 +5,7 @@ require "thread"
 
 describe YARD::Registry do
   before { Registry.clear }
-  
+
   describe '.yardoc_file_for_gem' do
     before do
       @gem = mock('gem')
@@ -13,37 +13,37 @@ describe YARD::Registry do
       @gem.stub!(:full_name).and_return('foo-1.0')
       @gem.stub!(:full_gem_path).and_return('/path/to/foo')
     end
-    
+
     it "should return nil if gem isn't found" do
       Gem.source_index.should_receive(:find_name).with('foo', '>= 0').and_return([])
       Registry.yardoc_file_for_gem('foo').should == nil
     end
-    
+
     it "should allow version to be specified" do
       Gem.source_index.should_receive(:find_name).with('foo', '= 2').and_return([])
       Registry.yardoc_file_for_gem('foo', '= 2').should == nil
     end
-    
+
     it "should return existing .yardoc path for gem when for_writing=false" do
       File.should_receive(:exist?).and_return(false)
       File.should_receive(:exist?).with('/path/to/foo/.yardoc').and_return(true)
       Gem.source_index.should_receive(:find_name).with('foo', '>= 0').and_return([@gem])
       Registry.yardoc_file_for_gem('foo').should == '/path/to/foo/.yardoc'
     end
-    
+
     it "should return nil if no .yardoc path exists in gem when for_writing=false" do
       File.should_receive(:exist?).and_return(false)
       File.should_receive(:exist?).with('/path/to/foo/.yardoc').and_return(false)
       Gem.source_index.should_receive(:find_name).with('foo', '>= 0').and_return([@gem])
       Registry.yardoc_file_for_gem('foo').should == nil
     end
-    
+
     it "should search local gem path first if for_writing=false" do
       File.should_receive(:exist?).and_return(true)
       Gem.source_index.should_receive(:find_name).with('foo', '>= 0').and_return([@gem])
       Registry.yardoc_file_for_gem('foo').should =~ %r{/.yard/gem_index/foo-1.0.yardoc$}
     end
-    
+
     it "should return global .yardoc path for gem if for_writing=true and dir is writable" do
       File.should_receive(:writable?).with(@gem.full_gem_path).and_return(true)
       Gem.source_index.should_receive(:find_name).with('foo', '>= 0').and_return([@gem])
@@ -55,7 +55,7 @@ describe YARD::Registry do
       Gem.source_index.should_receive(:find_name).with('foo', '>= 0').and_return([@gem])
       Registry.yardoc_file_for_gem('foo', '>= 0', true).should =~ %r{/.yard/gem_index/foo-1.0.yardoc$}
     end
-    
+
     it "should return gem path if gem starts with yard-doc- and for_writing=false" do
       @gem.stub!(:name).and_return('yard-doc-core')
       @gem.stub!(:full_name).and_return('yard-doc-core-1.0')
@@ -64,7 +64,7 @@ describe YARD::Registry do
       File.should_receive(:exist?).with('/path/to/yard-doc-core/.yardoc').and_return(true)
       Registry.yardoc_file_for_gem('yard-doc-core').should == '/path/to/yard-doc-core/.yardoc'
     end
-    
+
     it "should return nil if gem starts with yard-doc- and for_writing=true" do
       @gem.stub!(:name).and_return('yard-doc-core')
       @gem.stub!(:full_name).and_return('yard-doc-core-1.0')
@@ -74,13 +74,13 @@ describe YARD::Registry do
       Registry.yardoc_file_for_gem('yard-doc-core', '>= 0', true).should == nil
     end
   end
-  
+
   describe '.root' do
     it "should have an empty path for root" do
       Registry.root.path.should == ""
     end
   end
-  
+
   describe '.resolve' do
     it "should resolve any existing namespace" do
       o1 = ModuleObject.new(:root, :A)
@@ -89,16 +89,16 @@ describe YARD::Registry do
       Registry.resolve(o1, "B::C").should == o3
       Registry.resolve(:root, "A::B::C")
     end
-  
+
     it "should resolve an object in the root namespace when prefixed with ::" do
       o1 = ModuleObject.new(:root, :A)
       o2 = ModuleObject.new(o1, :B)
       o3 = ModuleObject.new(o2, :C)
       Registry.resolve(o3, "::A").should == o1
-    
+
       Registry.resolve(o3, "::String", false, true).should == P(:String)
     end
-  
+
     it "should resolve instance methods with # prefix" do
       o1 = ModuleObject.new(:root, :A)
       o2 = ModuleObject.new(o1, :B)
@@ -108,12 +108,12 @@ describe YARD::Registry do
       Registry.resolve(o2, "C#methname").should == o4
       Registry.resolve(o3, "#methname").should == o4
     end
-  
+
     it "should resolve instance methods in the root without # prefix" do
       o = MethodObject.new(:root, :methname)
       Registry.resolve(:root, 'methname').should == o
     end
-  
+
     it "should resolve superclass methods when inheritance = true" do
       superyard = ClassObject.new(:root, :SuperYard)
       yard = ClassObject.new(:root, :YARD)
@@ -139,19 +139,48 @@ describe YARD::Registry do
       Registry.resolve(yard, "class_hello", false).should be_nil
       Registry.resolve(yard, "class_hello", true).should == cmeth
     end
-    
+
+    it "should resolve methods in Object when inheritance = true" do
+      YARD.parse_string <<-eof
+        class Object; def foo; end end
+        class A; end
+        class MyObject < A; end
+      eof
+
+      Registry.resolve(P('MyObject'), '#foo', true).should == P('Object#foo')
+    end
+
+    it "should resolve methods in BasicObject when inheritance = true" do
+      YARD.parse_string <<-eof
+        class BasicObject; def foo; end end
+        class A; end
+        class MyObject < A; end
+      eof
+
+      Registry.resolve(P('MyObject'), '#foo', true).should == P('BasicObject#foo')
+    end
+
+    it "should not resolve methods in Object if inheriting BasicObject when inheritance = true" do
+      YARD.parse_string <<-eof
+        class Object; def foo; end end
+        class MyObject < BasicObject; end
+      eof
+
+      Registry.resolve(P('MyObject'), '#foo', true).should be_nil
+    end
+
     it "should only check 'Path' in lookup on root namespace" do
       Registry.should_receive(:at).once.with('Test').and_return(true)
       Registry.resolve(Registry.root, "Test")
     end
-    
+
     it "should not perform lookup by joining namespace and name without separator" do
       yard = ClassObject.new(:root, :YARD)
       Registry.should_not_receive(:at).with('YARDB')
       Registry.resolve(yard, 'B')
     end
   end
-  
+
   describe '.all' do
     it "should return objects of types specified by arguments" do
       ModuleObject.new(:root, :A)
@@ -160,15 +189,15 @@ describe YARD::Registry do
       r = Registry.all(:method, :class)
       r.should include(o1, o2)
     end
-  
+
     it "should return code objects" do
       o1 = ModuleObject.new(:root, :A)
       o2 = ClassObject.new(:root, :B)
       MethodObject.new(:root, :testing)
-      r = Registry.all(CodeObjects::NamespaceObject)
+      r = Registry.all.select {|t| NamespaceObject === t }
       r.should include(o1, o2)
     end
-  
+
     it "should allow .all to omit list" do
       o1 = ModuleObject.new(:root, :A)
       o2 = ClassObject.new(:root, :B)
@@ -176,7 +205,7 @@ describe YARD::Registry do
       r.should include(o1, o2)
     end
   end
-  
+
   describe '.paths' do
     it "should return all object paths" do
       o1 = ModuleObject.new(:root, :A)
@@ -184,7 +213,7 @@ describe YARD::Registry do
       Registry.paths.should include('A', 'B')
     end
   end
-  
+
   describe '.load_yardoc' do
     it "should delegate load to RegistryStore" do
       store = RegistryStore.new
@@ -193,11 +222,11 @@ describe YARD::Registry do
       Registry.yardoc_file = 'foo'
       Registry.load_yardoc
     end
-    
+
     it "should return itself" do
       Registry.load_yardoc.should == Registry
     end
-    
+
     it "should maintain hash key equality on loaded objects" do
       Registry.clear
       Registry.load!(File.dirname(__FILE__) + '/serializers/data/serialized_yardoc')
@@ -206,7 +235,7 @@ describe YARD::Registry do
       Registry.at('Foo').aliases.has_key?(baz).should == true
     end
   end
-  
+
   ['load', 'load_all', 'load!'].each do |meth|
     describe('.' + meth) do
       it "should return itself" do
@@ -214,38 +243,38 @@ describe YARD::Registry do
       end
     end
   end
-  
+
   describe '.each' do
-    before do 
+    before do
       YARD.parse_string "def a; end; def b; end; def c; end"
     end
-    
+
     after { Registry.clear }
-    
+
     it "should iterate over .all" do
       items = []
       Registry.each {|x| items << x.path }
       items.sort.should == ['#a', '#b', '#c']
     end
-    
+
     it "should include Enumerable and allow for find, select" do
       Registry.find {|x| x.path == "#a" }.should be_a(CodeObjects::MethodObject)
     end
   end
-  
+
   describe '.instance' do
     it "should return itself" do
       Registry.instance.should == Registry
     end
   end
-  
+
   describe '.single_object_db' do
     it "should default to nil" do
       Registry.single_object_db.should == nil
       Thread.new { Registry.single_object_db.should == nil }.join
     end
   end
-  
+
   describe 'Thread local' do
     it "should maintain two Registries in separate threads" do
       barrier = 0
@@ -296,7 +325,7 @@ describe YARD::Registry do
       threads.each {|t| t.join }
       Registry.yardoc_file = Registry::DEFAULT_YARDOC_FILE
     end
-    
+
     it "should automatically clear in new threads" do
       Thread.new { Registry.all.should be_empty }.join
     end

data/spec/registry_store_spec.rb

@@ -5,20 +5,23 @@ describe YARD::RegistryStore do
     FileUtils.rm_rf("foo")
     @store = RegistryStore.new
     @serializer = Serializers::YardocSerializer.new('foo')
+    @foo = CodeObjects::MethodObject.new(nil, :foo)
+    @bar = CodeObjects::ClassObject.new(nil, :Bar)
     Serializers::YardocSerializer.stub!(:new).and_return(@serializer)
   end
-  
+
   describe '#load' do
     it "should load root.dat as full object list if it is a Hash" do
       File.should_receive(:directory?).with('foo').and_return(true)
       File.should_receive(:file?).with('foo/checksums').and_return(false)
       File.should_receive(:file?).with('foo/proxy_types').and_return(false)
-      @serializer.should_receive(:deserialize).with('root').and_return({:root => 'foo', :A => 'bar'})
+      File.should_receive(:file?).with('foo/object_types').and_return(false)
+      @serializer.should_receive(:deserialize).with('root').and_return({:root => @foo, :A => @bar})
       @store.load('foo').should == true
-      @store.root.should == 'foo'
-      @store.get('A').should == 'bar'
+      @store.root.should == @foo
+      @store.get('A').should == @bar
     end
-    
+
     it "should load old yardoc format if .yardoc is a file" do
       File.should_receive(:directory?).with('foo').and_return(false)
       File.should_receive(:file?).with('foo').and_return(true)
@@ -27,16 +30,17 @@ describe YARD::RegistryStore do
 
       @store.load('foo')
     end
-    
+
     it "should load new yardoc format if .yardoc is a directory" do
       File.should_receive(:directory?).with('foo').and_return(true)
       File.should_receive(:file?).with('foo/checksums').and_return(false)
       File.should_receive(:file?).with('foo/proxy_types').and_return(false)
+      File.should_receive(:file?).with('foo/object_types').and_return(false)
       File.should_receive(:file?).with('foo/objects/root.dat').and_return(false)
 
       @store.load('foo').should == true
     end
-    
+
     it "should return true if .yardoc is loaded (file)" do
       File.should_receive(:directory?).with('myyardoc').and_return(false)
       File.should_receive(:file?).with('myyardoc').and_return(true)
@@ -48,6 +52,7 @@ describe YARD::RegistryStore do
       File.should_receive(:directory?).with('foo').and_return(true)
       File.should_receive(:file?).with('foo/checksums').and_return(false)
       File.should_receive(:file?).with('foo/proxy_types').and_return(false)
+      File.should_receive(:file?).with('foo/object_types').and_return(false)
       File.should_receive(:file?).with('foo/objects/root.dat').and_return(false)
       @store.load('foo').should == true
     end
@@ -55,27 +60,29 @@ describe YARD::RegistryStore do
     it "should return false if .yardoc does not exist" do
       @store.load('NONEXIST').should == false
     end
-    
+
     it "should return false if there is no file to load" do
       @store.load(nil).should == false
     end
-    
+
     it "should load checksums if they exist" do
       File.should_receive(:directory?).with('foo').and_return(true)
       File.should_receive(:file?).with('foo/checksums').and_return(true)
       File.should_receive(:file?).with('foo/proxy_types').and_return(false)
       File.should_receive(:file?).with('foo/objects/root.dat').and_return(false)
+      File.should_receive(:file?).with('foo/object_types').and_return(false)
       File.should_receive(:readlines).with('foo/checksums').and_return([
         'file1 CHECKSUM1', '  file2 CHECKSUM2 '
       ])
       @store.load('foo').should == true
       @store.checksums.should == {'file1' => 'CHECKSUM1', 'file2' => 'CHECKSUM2'}
     end
-    
+
     it "should load proxy_types if they exist" do
       File.should_receive(:directory?).with('foo').and_return(true)
       File.should_receive(:file?).with('foo/checksums').and_return(false)
       File.should_receive(:file?).with('foo/proxy_types').and_return(true)
+      File.should_receive(:file?).with('foo/object_types').and_return(false)
       File.should_receive(:file?).with('foo/objects/root.dat').and_return(false)
       File.should_receive(:read_binary).with('foo/proxy_types').and_return(Marshal.dump({'a' => 'b'}))
       @store.load('foo').should == true
@@ -86,52 +93,53 @@ describe YARD::RegistryStore do
       File.should_receive(:directory?).with('foo').and_return(true)
       File.should_receive(:file?).with('foo/checksums').and_return(false)
       File.should_receive(:file?).with('foo/proxy_types').and_return(false)
+      File.should_receive(:file?).with('foo/object_types').and_return(false)
       File.should_receive(:file?).with('foo/objects/root.dat').and_return(true)
-      File.should_receive(:read_binary).with('foo/objects/root.dat').and_return(Marshal.dump('foo'))
+      File.should_receive(:read_binary).with('foo/objects/root.dat').and_return(Marshal.dump(@foo))
       @store.load('foo').should == true
-      @store.root.should == 'foo'
+      @store.root.should == @foo
     end
   end
-  
+
   describe '#save' do
     before do
       @store.stub!(:write_proxy_types)
       @store.stub!(:write_checksums)
       @store.stub!(:destroy)
     end
-    
+
     after do
       Registry.single_object_db = nil
     end
-    
+
     def saves_to_singledb
       @serializer.should_receive(:serialize).once.with(instance_of(Hash))
       @store.save(true, 'foo')
     end
-    
+
     def add_items(n)
-      n.times {|i| @store[i.to_s] = 'foo' }
+      n.times {|i| @store[i.to_s] = @foo }
     end
-    
+
     def saves_to_multidb
       times = @store.keys.size
       @serializer.should_receive(:serialize).exactly(times).times
       @store.save(true, 'foo')
       @last = times
     end
-    
+
     it "should save as single object db if single_object_db is nil and there are less than 3000 objects" do
       Registry.single_object_db = nil
       add_items(100)
       saves_to_singledb
     end
-    
+
     it "should save as single object db if single_object_db is nil and there are more than 3000 objects" do
       Registry.single_object_db = nil
       add_items(5000)
       saves_to_singledb
     end
-    
+
     it "should save as single object db if single_object_db is true (and any amount of objects)" do
       Registry.single_object_db = true
       add_items(100)
@@ -139,7 +147,7 @@ describe YARD::RegistryStore do
       add_items(5000)
       saves_to_singledb
     end
-    
+
     it "should never save as single object db if single_object_db is false" do
       Registry.single_object_db = false
       add_items(100)
@@ -148,38 +156,38 @@ describe YARD::RegistryStore do
       saves_to_multidb
     end
   end
-  
+
   describe '#put' do
     it "should assign values" do
-      @store.put(:YARD, true)
-      @store.get(:YARD).should == true
+      @store.put(:YARD, @foo)
+      @store.get(:YARD).should == @foo
     end
-    
+
     it "should treat '' as root" do
-      @store.put('', 'value')
-      @store.get(:root).should == 'value'
+      @store.put('', @foo)
+      @store.get(:root).should == @foo
     end
   end
-  
+
   describe '#get' do
     it "should hit cache if object exists" do
-      @store.put(:YARD, true)
-      @store.get(:YARD).should == true
+      @store.put(:YARD, @foo)
+      @store.get(:YARD).should == @foo
     end
-    
+
     it "should hit backstore on cache miss and cache is not fully loaded" do
       serializer = mock(:serializer)
-      serializer.should_receive(:deserialize).once.with(:YARD).and_return('foo')
+      serializer.should_receive(:deserialize).once.with(:YARD).and_return(@foo)
       @store.load('foo')
       @store.instance_variable_set("@loaded_objects", 0)
       @store.instance_variable_set("@available_objects", 100)
       @store.instance_variable_set("@serializer", serializer)
-      @store.get(:YARD).should == 'foo'
-      @store.get(:YARD).should == 'foo'
+      @store.get(:YARD).should == @foo
+      @store.get(:YARD).should == @foo
       @store.instance_variable_get("@loaded_objects").should == 1
     end
   end
-  
+
   [:keys, :values].each do |item|
     describe "##{item}" do
       it "should load entire database if reload=true" do
@@ -188,7 +196,7 @@ describe YARD::RegistryStore do
         @store.should_receive(:load_all)
         @store.send(item, true)
       end
-    
+
       it "should not load entire database if reload=false" do
         File.should_receive(:directory?).with('foo').and_return(true)
         @store.load('foo')
@@ -197,15 +205,57 @@ describe YARD::RegistryStore do
       end
     end
   end
-  
+
+  describe '#paths_for_type' do
+    after { Registry.clear }
+
+    it "should set all object types if not set by object_types" do
+      File.should_receive(:directory?).with('foo').and_return(true)
+      File.should_receive(:file?).with('foo/checksums').and_return(false)
+      File.should_receive(:file?).with('foo/proxy_types').and_return(false)
+      File.should_receive(:file?).with('foo/object_types').and_return(false)
+      @serializer.should_receive(:deserialize).with('root').and_return({:'A#foo' => @foo, :A => @bar})
+      @store.load('foo')
+      @store.paths_for_type(:method).should == ['#foo']
+      @store.paths_for_type(:class).should == ['Bar']
+    end
+
+    it "should keep track of types when assigning values" do
+      @store.put(:abc, @foo)
+      @store.paths_for_type(@foo.type).should == ['abc']
+    end
+
+    it "should reassign path if type changes" do
+      foo = CodeObjects::ClassObject.new(:root, :Foo)
+      @store.put('Foo', foo)
+      @store.get('Foo').type.should == :class
+      @store.paths_for_type(:class).should == ["Foo"]
+      foo = CodeObjects::ModuleObject.new(:root, :Foo)
+      @store.put('Foo', foo)
+      @store.get('Foo').type.should == :module
+      @store.paths_for_type(:class).should == []
+      @store.paths_for_type(:module).should == ["Foo"]
+    end
+  end
+
+  describe '#values_for_type' do
+    it "should return all objects with type" do
+      @store.put(:abc, @foo)
+      @store.values_for_type(@foo.type).should == [@foo]
+    end
+  end
+
   describe '#load_all' do
     it "should load the entire database" do
       foomock = mock(:Foo)
       barmock = mock(:Bar)
+      foomock.stub!(:type).and_return(:class)
+      barmock.stub!(:type).and_return(:class)
       foomock.should_receive(:path).and_return('Foo')
       barmock.should_receive(:path).and_return('Bar')
       File.should_receive(:directory?).with('foo').and_return(true)
       File.should_receive(:file?).with('foo/proxy_types').and_return(false)
+      File.should_receive(:file?).with('foo/object_types').and_return(false)
       File.should_receive(:file?).with('foo/checksums').and_return(false)
       File.should_receive(:file?).with('foo/objects/root.dat').and_return(false)
       @store.should_receive(:all_disk_objects).at_least(1).times.and_return(['foo/objects/foo', 'foo/objects/bar'])
@@ -220,7 +270,7 @@ describe YARD::RegistryStore do
       @store[:Bar].should == barmock
     end
   end
-  
+
   describe '#destroy' do
     it "should destroy file ending in .yardoc when force=false" do
       File.should_receive(:file?).with('foo.yardoc').and_return(true)
@@ -244,7 +294,7 @@ describe YARD::RegistryStore do
       @store.instance_variable_set("@file", 'foo')
       @store.destroy.should == false
     end
-    
+
     it "should destroy any file/dir when force=true" do
       File.should_receive(:file?).with('foo').and_return(true)
       File.should_receive(:unlink).with('foo')