yard 0.7.5 → 0.8.0

data/spec/cli/yri_spec.rb

@@ -4,41 +4,43 @@ class YARD::CLI::YRI
   public :optparse, :find_object, :cache_object
 end
 
-describe YARD::CLI::Yardoc do
+describe YARD::CLI::YRI do
   before do
     @yri = YARD::CLI::YRI.new
     Registry.stub!(:load)
   end
-  
+
   describe '#find_object' do
     it "should use cache if available" do
       @yri.stub!(:cache_object)
       File.should_receive(:exist?).with('.yardoc').and_return(false)
       File.should_receive(:exist?).with('bar.yardoc').and_return(true)
       Registry.should_receive(:load).with('bar.yardoc')
-      Registry.should_receive(:at).with('Foo').and_return('OBJ')
+      Registry.should_receive(:at).ordered.with('Foo').and_return(nil)
+      Registry.should_receive(:at).ordered.with('Foo').and_return('OBJ')
       @yri.instance_variable_set("@cache", {'Foo' => 'bar.yardoc'})
       @yri.find_object('Foo').should == 'OBJ'
     end
-    
+
     it "should never use cache ahead of current directory's .yardoc" do
       @yri.stub!(:cache_object)
       File.should_receive(:exist?).with('.yardoc').and_return(true)
       Registry.should_receive(:load).with('.yardoc')
-      Registry.should_receive(:at).with('Foo').and_return('OBJ')
+      Registry.should_receive(:at).ordered.with('Foo').and_return(nil)
+      Registry.should_receive(:at).ordered.with('Foo').and_return('OBJ')
       @yri.instance_variable_set("@cache", {'Foo' => 'bar.yardoc'})
       @yri.find_object('Foo').should == 'OBJ'
       @yri.instance_variable_get("@search_paths")[0].should == '.yardoc'
     end
   end
-  
+
   describe '#cache_object' do
     it "should skip caching for Registry.yardoc_file" do
       File.should_not_receive(:open).with(CLI::YRI::CACHE_FILE, 'w')
       @yri.cache_object('Foo', Registry.yardoc_file)
     end
   end
-  
+
   describe '#initialize' do
     it "should load search paths" do
       path = %r{/\.yard/yri_search_paths$}
@@ -50,7 +52,7 @@ 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$}
@@ -63,21 +65,21 @@ describe YARD::CLI::Yardoc do
       YARD::CLI::YRI::DEFAULT_SEARCH_PATHS.replace([])
     end
   end
-  
+
   describe '#run' do
     it "should search for objects and print their documentation" do
       obj = YARD::CodeObjects::ClassObject.new(:root, 'Foo')
       @yri.should_receive(:print_object).with(obj)
       @yri.run('Foo')
       Registry.clear
-    end unless ENV['CI'] # FIXME make this work on Travis CI
-    
+    end
+
     it "should print usage if no object is provided" do
       @yri.should_receive(:print_usage)
       @yri.should_receive(:exit).with(1)
       @yri.run('')
     end
-    
+
     it "should print no documentation exists for object if object is not found" do
       STDERR.should_receive(:puts).with("No documentation for `Foo'")
       @yri.should_receive(:exit).with(1)

data/spec/code_objects/base_spec.rb

@@ -7,16 +7,16 @@ describe YARD::CodeObjects::Base do
   # it "should not allow empty object name" do
   #   lambda { Base.new(:root, '') }.should raise_error(ArgumentError)
   # end
-  
+
   it "should return a unique instance of any registered object" do
     obj = ClassObject.new(:root, :Me)
     obj2 = ClassObject.new(:root, :Me)
     obj.object_id.should == obj2.object_id
-    
+
     obj3 = ModuleObject.new(obj, :Too)
     obj4 = CodeObjects::Base.new(obj3, :Hello)
     obj4.parent = obj
-    
+
     obj5 = CodeObjects::Base.new(obj3, :hello)
     obj4.object_id.should_not == obj5.object_id
   end
@@ -27,62 +27,62 @@ describe YARD::CodeObjects::Base do
     ClassObject.new(:root, "MYMODULE").should be_instance_of(ClassObject)
     YARD::Registry.at("MYMODULE").should be_instance_of(ClassObject)
   end
-  
+
   it "should recall the block if #new is called on an existing object" do
     o1 = ClassObject.new(:root, :Me) do |o|
       o.docstring = "DOCSTRING"
     end
-    
+
     o2 = ClassObject.new(:root, :Me) do |o|
       o.docstring = "NOT_DOCSTRING"
     end
-    
+
     o1.object_id.should == o2.object_id
     o1.docstring.should == "NOT_DOCSTRING"
     o2.docstring.should == "NOT_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"
     obj.name.should == :B
   end
-  
+
   it "should allow namespace to be nil and not register in the Registry" do
     obj = CodeObjects::Base.new(nil, :Me)
     obj.namespace.should == nil
     Registry.at(:Me).should == nil
   end
-  
+
   it "should allow namespace to be a NamespaceObject" do
     ns = ModuleObject.new(:root, :Name)
     obj = CodeObjects::Base.new(ns, :Me)
     obj.namespace.should == ns
   end
-  
+
   it "should allow :root to be the shorthand namespace of `Registry.root`" do
     obj = CodeObjects::Base.new(:root, :Me)
     obj.namespace.should == Registry.root
   end
-  
+
   it "should not allow any other types as namespace" do
     lambda { CodeObjects::Base.new("ROOT!", :Me) }.should raise_error(ArgumentError)
   end
-  
+
   it "should register itself in the registry if namespace is supplied" do
     obj = ModuleObject.new(:root, :Me)
     Registry.at(:Me).should == obj
-    
+
     obj2 = ModuleObject.new(obj, :Too)
     Registry.at(:"Me::Too").should == obj2
   end
-  
+
   it "should set any attribute using #[]=" do
     obj = ModuleObject.new(:root, :YARD)
     obj[:some_attr] = "hello"
     obj[:some_attr].should == "hello"
   end
-  
+
   it "#[]= should use the accessor method if available" do
     obj = CodeObjects::Base.new(:root, :YARD)
     obj[:source] = "hello"
@@ -90,34 +90,34 @@ describe YARD::CodeObjects::Base do
     obj.source = "unhello"
     obj[:source].should == "unhello"
   end
-  
+
   it "should set attributes via attr= through method_missing" do
     obj = CodeObjects::Base.new(:root, :YARD)
     obj.something = 2
     obj.something.should == 2
     obj[:something].should == 2
   end
-  
+
   it "should exist in the parent's #children after creation" do
     obj = ModuleObject.new(:root, :YARD)
     obj2 = MethodObject.new(obj, :testing)
     obj.children.should include(obj2)
   end
-  
+
   it "should properly re-indent source starting from 0 indentation" do
     obj = CodeObjects::Base.new(nil, :test)
     obj.source = <<-eof
       def mymethod
         if x == 2 &&
             5 == 5
-          3 
+          3
         else
           1
         end
       end
     eof
-    obj.source.should == "def mymethod\n  if x == 2 &&\n      5 == 5\n    3 \n  else\n    1\n  end\nend"
-    
+    obj.source.should == "def mymethod\n  if x == 2 &&\n      5 == 5\n    3\n  else\n    1\n  end\nend"
+
     Registry.clear
     Parser::SourceParser.parse_string <<-eof
       def key?(key)
@@ -138,7 +138,7 @@ describe YARD::CodeObjects::Base do
     eof
     Registry.at('#key?').source.should == "def key?(key)\n  if x == 2\n    puts key\n  else\n    exit\n  end\nend"
   end
-  
+
   it "should not add newlines to source when parsing sub blocks" do
     Parser::SourceParser.parse_string <<-eof
       module XYZ
@@ -151,15 +151,15 @@ describe YARD::CodeObjects::Base do
         end
       end
     eof
-    Registry.at('XYZ::ZYX::ABC#msg').source.should == "def msg\n  hello_world\nend"    
+    Registry.at('XYZ::ZYX::ABC#msg').source.should == "def msg\n  hello_world\nend"
   end
-  
+
   it "should handle source for 'def x; end'" do
     Registry.clear
     Parser::SourceParser.parse_string "def x; 2 end"
     Registry.at('#x').source.should == "def x; 2 end"
   end
-  
+
   it "should set file and line information" do
     Parser::SourceParser.parse_string <<-eof
       class X; end
@@ -167,14 +167,14 @@ describe YARD::CodeObjects::Base do
     Registry.at(:X).file.should == '(stdin)'
     Registry.at(:X).line.should == 1
   end
-  
+
   it "should maintain all file associations when objects are defined multiple times in one file" do
     Parser::SourceParser.parse_string <<-eof
       class X; end
       class X; end
       class X; end
     eof
-    
+
     Registry.at(:X).file.should == '(stdin)'
     Registry.at(:X).line.should == 1
     Registry.at(:X).files.should == [['(stdin)', 1], ['(stdin)', 2], ['(stdin)', 3]]
@@ -185,7 +185,7 @@ describe YARD::CodeObjects::Base do
       File.stub!(:read_binary).and_return("class X; end")
       Parser::SourceParser.new.parse("file#{i+1}.rb")
     end
-    
+
     Registry.at(:X).file.should == 'file1.rb'
     Registry.at(:X).line.should == 1
     Registry.at(:X).files.should == [['file1.rb', 1], ['file2.rb', 1], ['file3.rb', 1]]
@@ -198,12 +198,12 @@ describe YARD::CodeObjects::Base do
       # docstring
       class X; end
     eof
-    
+
     Registry.at(:X).file.should == '(stdin)'
     Registry.at(:X).line.should == 4
     Registry.at(:X).files.should == [['(stdin)', 4], ['(stdin)', 1], ['(stdin)', 2]]
   end
-  
+
   describe '#format' do
     it "should send to Templates.render" do
       object = MethodObject.new(:root, :method)
@@ -211,34 +211,34 @@ describe YARD::CodeObjects::Base do
       object.format :x => 1
     end
   end
-  
+
   describe '#source_type' do
     it "should default source_type to :ruby" do
       object = MethodObject.new(:root, :method)
       object.source_type.should == :ruby
     end
   end
-  
+
   describe '#relative_path' do
     it "should accept a string" do
       YARD.parse_string "module A; class B; end; class C; end; end"
-      Registry.at('A::B').relative_path(Registry.at('A::C')).should == 
+      Registry.at('A::B').relative_path(Registry.at('A::C')).should ==
         Registry.at('A::B').relative_path('A::C')
     end
-    
+
     it "should return full class name when objects share a common class prefix" do
       YARD.parse_string "module User; end; module UserManager; end"
       Registry.at('User').relative_path('UserManager').should == 'UserManager'
       Registry.at('User').relative_path(Registry.at('UserManager')).should == 'UserManager'
     end
-    
+
     it "should return the relative path when they share a common namespace" do
       YARD.parse_string "module A; class B; end; class C; end; end"
       Registry.at('A::B').relative_path(Registry.at('A::C')).should == 'C'
       YARD.parse_string "module Foo; module A; end; module B; def foo; end end end"
       Registry.at('Foo::A').relative_path(Registry.at('Foo::B#foo')).should == 'B#foo'
     end
-    
+
     it "should return the full path if they don't have a common namespace" do
       YARD.parse_string "module A; class B; end; end; module D; class C; end; end"
       Registry.at('A::B').relative_path('D::C').should == 'D::C'
@@ -249,7 +249,7 @@ describe YARD::CodeObjects::Base do
       YARD.parse_string("class YARD::Config; MYCONST = 1; end")
       Registry.at('YARD::Config').relative_path('YARD::Config::MYCONST').should == "MYCONST"
     end
-    
+
     it "should return a relative path for class methods" do
       YARD.parse_string "module A; def self.b; end; def self.c; end; end"
       Registry.at('A.b').relative_path('A.c').should == 'c'
@@ -261,26 +261,26 @@ describe YARD::CodeObjects::Base do
       Registry.at('A#b').relative_path('A#c').should == '#c'
       Registry.at('A').relative_path('A#c').should == '#c'
     end
-    
+
     it "should return full path if relative path is to parent namespace" do
       YARD.parse_string "module A; module B; end end"
       Registry.at('A::B').relative_path('A').should == 'A'
     end
-    
+
     it "should only return name for relative path to self" do
       YARD.parse_string("class A::B::C; def foo; end end")
       Registry.at('A::B::C').relative_path('A::B::C').should == 'C'
       Registry.at('A::B::C#foo').relative_path('A::B::C#foo').should == '#foo'
     end
   end
-  
+
   describe '#docstring=' do
     it "should convert string into Docstring when #docstring= is set" do
-      o = ClassObject.new(:root, :Me) 
+      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)
@@ -294,7 +294,7 @@ describe YARD::CodeObjects::Base do
       o.docstring = doc
       o.docstring.should == doc
     end
-    
+
     it "should allow extra docstring after (see Path)" do
       ClassObject.new(:root, :AnotherObject) {|x| x.docstring = "FOO" }
       o = ClassObject.new(:root, :Me)
@@ -303,14 +303,14 @@ describe YARD::CodeObjects::Base do
       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)'
@@ -319,7 +319,7 @@ describe YARD::CodeObjects::Base do
       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)
@@ -331,4 +331,62 @@ describe YARD::CodeObjects::Base do
       o.files.should == [['filename', 12], ['filename', 40]]
     end
   end
+
+  describe '#copy_to' do
+    it "should copy all data to new object" do
+      YARD.parse_string <<-eof
+        private
+        # A docstring
+        # @return [String] a tag
+        def foo(a, b, c)
+          source_code_here
+        end
+      eof
+      foo_c = MethodObject.new(:root, :foo, :class)
+      Registry.at('#foo').copy_to(foo_c)
+      foo_c.scope.should == :class
+      foo_c.visibility.should == :private
+      foo_c.type.should == :method
+      foo_c.class.should == MethodObject
+      foo_c.path.should == '::foo'
+      foo_c.docstring.should == "A docstring"
+      foo_c.tag(:return).types.should == ['String']
+      foo_c.file.should == '(stdin)'
+      foo_c.line.should == 4
+      foo_c.source.should =~ /source_code_here/
+      foo_c.signature.should == 'def foo(a, b, c)'
+      foo_c.parameters.should == [['a', nil], ['b', nil], ['c', nil]]
+    end
+
+    it "should return copied object" do
+      YARD.parse_string 'def foo; end'
+      foo_c = MethodObject.new(:root, :foo, :class)
+      Registry.at('#foo').copy_to(foo_c).should == foo_c
+    end
+
+    it "should copy docstring and rewrite tags for new object" do
+      YARD.parse_string <<-eof
+        # @return [String] a tag
+        def foo; end
+      eof
+      foo_c = MethodObject.new(:root, :foo, :class)
+      foo_i = Registry.at('#foo')
+      foo_i.copy_to(foo_c)
+      foo_i.tags.should_not == foo_c.tags
+      foo_c.tags.first.object.should == foo_c
+    end
+
+    it "should only copy #copyable_attributes" do
+      foo = MethodObject.new(:root, :foo)
+      foo.should_receive(:copyable_attributes).and_return %w(a b c)
+      foo.should_receive(:instance_variable_get).with('@a').and_return(1)
+      foo.should_receive(:instance_variable_get).with('@b').and_return(2)
+      foo.should_receive(:instance_variable_get).with('@c').and_return(3)
+      bar = MethodObject.new(:root, :bar)
+      bar.should_receive(:instance_variable_set).with('@a', 1)
+      bar.should_receive(:instance_variable_set).with('@b', 2)
+      bar.should_receive(:instance_variable_set).with('@c', 3)
+      foo.copy_to(bar)
+    end
+  end
 end