yard 0.5.2 → 0.5.3

data/lib/yard/templates/template.rb

@@ -99,7 +99,12 @@ module YARD
           pc = path.to_s.split('/')
           if pc.size > 1
             pc.pop
-            include Engine.template!(pc.join('/'), full_path.gsub(%r{/[^/]+$}, ''))
+            pc = pc.join('/')
+            begin
+              include Engine.template(pc)
+            rescue ArgumentError
+              include Engine.template!(pc, full_path.gsub(%r{/[^/]+$}, ''))
+            end
           end
         end
         

data/spec/cli/yardoc_spec.rb

@@ -6,6 +6,8 @@ describe YARD::CLI::Yardoc do
   before do
     @yardoc = YARD::CLI::Yardoc.new
     @yardoc.stub!(:generate).and_return(false)
+    Templates::Engine.stub!(:render)
+    Templates::Engine.stub!(:generate)
     YARD.stub!(:parse)
   end
   
@@ -129,4 +131,24 @@ describe YARD::CLI::Yardoc do
     @yardoc.optparse *%w( --hide-void-return )
     @yardoc.options[:hide_void_return].should be_true
   end
+  
+  it "should generate all objects with --use-cache" do
+    YARD.should_receive(:parse)
+    Registry.should_receive(:load)
+    Registry.should_receive(:load_all)
+    @yardoc.stub!(:generate).and_return(true)
+    @yardoc.run *%w( --use-cache )
+  end
+  
+  it "should only generate changed objects with --incremental" do
+    YARD.should_receive(:parse)
+    Registry.should_receive(:load)
+    Registry.should_not_receive(:load_all)
+    @yardoc.stub!(:generate).and_return(true)
+    @yardoc.should_receive(:generate_with_cache)
+    @yardoc.run *%w( --incremental )
+    @yardoc.incremental.should == true
+    @yardoc.use_cache.should == true
+    @yardoc.generate.should == true
+  end
 end

data/spec/code_objects/base_spec.rb

@@ -2,6 +2,11 @@ require File.dirname(__FILE__) + '/spec_helper'
 
 describe YARD::CodeObjects::Base do
   before { Registry.clear }
+
+  # Fix this
+  # 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)
@@ -183,7 +188,7 @@ describe YARD::CodeObjects::Base do
 
   it "should maintain all file associations when objects are defined multiple times in multiple files" do
     3.times do |i|
-      IO.stub!(:read).and_return("class X; end")
+      File.stub!(:read_binary).and_return("class X; end")
       Parser::SourceParser.new.parse("file#{i+1}.rb")
     end
     
@@ -219,4 +224,32 @@ describe YARD::CodeObjects::Base do
       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('A::C')
+    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'
+    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'
+    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'
+    end
+
+    it "should return a relative path for instance methods" do
+      YARD.parse_string "module A; def b; end; def c; end; end"
+      Registry.at('A#b').relative_path('A#c').should == '#c'
+    end
+  end
 end

data/spec/code_objects/method_object_spec.rb

@@ -65,6 +65,41 @@ describe YARD::CodeObjects::MethodObject do
     end
   end
   
+  describe '#attr_info' do
+    it "should return attribute info if namespace is available" do
+      obj = MethodObject.new(@yard, :foo)
+      @yard.attributes[:instance][:foo] = {:read => obj, :write => nil}
+      obj.attr_info.should == @yard.attributes[:instance][:foo]
+    end
+    
+    it "should return nil if namespace is proxy" do
+      obj = MethodObject.new(P(:ProxyClass), :foo)
+      MethodObject.new(@yard, :foo).attr_info.should == nil
+    end
+    
+    it "should return nil if meth is not an attribute" do
+      MethodObject.new(@yard, :notanattribute).attr_info.should == nil
+    end
+  end
+  
+  describe '#writer?' do
+    it "should return true if method is a writer attribute" do
+      obj = MethodObject.new(@yard, :foo=)
+      @yard.attributes[:instance][:foo] = {:read => nil, :write => obj}
+      obj.writer?.should == true
+      MethodObject.new(@yard, :NOTfoo=).writer?.should == false
+    end
+  end
+
+  describe '#reader?' do
+    it "should return true if method is a reader attribute" do
+      obj = MethodObject.new(@yard, :foo)
+      @yard.attributes[:instance][:foo] = {:read => obj, :write => nil}
+      obj.reader?.should == true
+      MethodObject.new(@yard, :NOTfoo).reader?.should == false
+    end
+  end
+  
   describe '#constructor?' do
     before { @class = ClassObject.new(:root, :MyClass) }
 

data/spec/core_ext/hash_spec.rb

@@ -6,5 +6,9 @@ describe Hash do
       list = [['foo', 'bar'], ['foo2', 'bar2']]
       Hash[list].should == {'foo' => 'bar', 'foo2' => 'bar2'}
     end
+    
+    it "should accept an array as a key" do
+      Hash[['a', 'b'], 1].should == {['a', 'b'] => 1}
+    end
   end
 end

data/spec/core_ext/string_spec.rb

@@ -20,7 +20,11 @@ describe String do
     end
 
     it "should turn hello/world into Hello::World" do
-      "Hello::World".underscore.should == "hello/world"
+      "hello/world".camelcase.should == "Hello::World"
+    end
+    
+    it "should not camelcase _foo" do
+      "_foo".camelcase.should == "_foo"
     end
   end
   

data/spec/handlers/attribute_handler_spec.rb

@@ -71,7 +71,7 @@ describe "YARD::Handlers::Ruby::#{RUBY18 ? "Legacy::" : ""}AttributeHandler" do
   end
   
   it "should not return true for #is_explicit? in created methods" do
-    Registry.all(:method).each do |meth|
+    Registry.at(:B).meths.each do |meth|
       meth.is_explicit?.should == false
     end
   end
@@ -79,4 +79,12 @@ describe "YARD::Handlers::Ruby::#{RUBY18 ? "Legacy::" : ""}AttributeHandler" do
   it "should handle attr call with no arguments" do
     lambda { StubbedSourceParser.parse_string "attr" }.should_not raise_error
   end
+  
+  it "should add existing reader method as part of attr_writer combo" do
+    Registry.at('C#foo=').attr_info[:read].should == Registry.at('C#foo')
+  end
+
+  it "should add existing writer method as part of attr_reader combo" do
+    Registry.at('C#foo').attr_info[:write].should == Registry.at('C#foo=')
+  end
 end

data/spec/handlers/examples/attribute_handler_001.rb.txt

@@ -16,4 +16,12 @@ class B
   attr_accessor 'f'
 
   attr_accessor :z
+end
+
+class C
+  def foo; end
+  attr_writer :foo
+
+  def bar=(value); end
+  attr_reader :bar
 end

data/spec/handlers/examples/method_handler_001.rb.txt

@@ -68,4 +68,10 @@ end
 
   # @return [NotBoolean, nil]
   def boolean3?; end
+
+  attr_writer :attr_name
+  def attr_name; end
+
+  attr_reader :attr_name2
+  def attr_name2=; end
 end

data/spec/handlers/method_handler_spec.rb

@@ -105,4 +105,14 @@ describe "YARD::Handlers::Ruby::#{RUBY18 ? "Legacy::" : ""}MethodHandler" do
     meth.should have_tag(:return)
     meth.tag(:return).types.should == ['NotBoolean', 'nil']
   end
+  
+  it "should add method writer to existing attribute" do
+    Registry.at('Foo#attr_name').should be_reader
+    Registry.at('Foo#attr_name=').should be_writer
+  end
+  
+  it "should add method reader to existing attribute" do
+    Registry.at('Foo#attr_name2').should be_reader
+    Registry.at('Foo#attr_name2=').should be_writer
+  end
 end

data/spec/parser/source_parser_spec.rb

@@ -33,33 +33,29 @@ describe YARD::Parser::SourceParser do
       Registry.at(:Hello).docstring.should == "PASS"
     end
     
+    it "should not add comments appended to last line of block" do
+      YARD.parse_string <<-eof
+        module Hello2
+        end # FAIL
+      eof
+      Registry.at(:Hello2).docstring.should be_blank
+    end
+    
     it "should add comments appended to an object's first line" do
       YARD.parse_string <<-eof
         module Hello # PASS
           HELLO
         end
-        module Hello2
-        end # FAIL
-
 
-        module Hello3 # PASS
-          # CANNOT DIFFERENTIATE
+        module Hello2 # PASS
+          # ANOTHER PASS
           def x; end
         end
       eof
 
-      # TODO: unify behaviour
-      if RUBY18
-        Registry.at(:Hello).docstring.should == ""
-        Registry.at(:Hello2).docstring.should == "FAIL"
-        Registry.at(:Hello3).docstring.should == ""
-        Registry.at('Hello3#x').docstring.should == "CANNOT DIFFERENTIATE"
-      else
-        Registry.at(:Hello).docstring.should == "PASS"
-        Registry.at(:Hello2).docstring.should == ""
-        Registry.at(:Hello3).docstring.should == ""
-        Registry.at('Hello3#x').docstring.should == "PASS\nCANNOT DIFFERENTIATE"
-      end
+      Registry.at(:Hello).docstring.should == "PASS"
+      Registry.at(:Hello2).docstring.should == "PASS"
+      Registry.at('Hello2#x').docstring.should == "ANOTHER PASS"
     end
   end
 
@@ -79,7 +75,7 @@ describe YARD::Parser::SourceParser do
     it "should parse a set of absolute paths" do
       Dir.should_not_receive(:[]).and_return([])
       File.should_receive(:file?).with('/path/to/file').and_return(true)
-      IO.should_receive(:read).with('/path/to/file').and_return("")
+      File.should_receive(:read_binary).with('/path/to/file').and_return("")
       YARD.parse('/path/to/file')
     end
 
@@ -88,9 +84,9 @@ describe YARD::Parser::SourceParser do
       File.should_receive(:file?).with('/path/to/file').and_return(true)
       File.should_receive(:file?).with('a.rb').and_return(true)
       File.should_receive(:file?).with('b.rb').and_return(true)
-      IO.should_receive(:read).with('/path/to/file').and_return("")
-      IO.should_receive(:read).with('a.rb').and_return("")
-      IO.should_receive(:read).with('b.rb').and_return("")
+      File.should_receive(:read_binary).with('/path/to/file').and_return("")
+      File.should_receive(:read_binary).with('a.rb').and_return("")
+      File.should_receive(:read_binary).with('b.rb').and_return("")
       YARD.parse ['/path/to/file', '*.rb']
     end
     
@@ -99,8 +95,8 @@ describe YARD::Parser::SourceParser do
       File.should_receive(:directory?).with('foo').and_return(true)
       File.should_receive(:file?).with('foo/a.rb').and_return(true)
       File.should_receive(:file?).with('foo/bar/b.rb').and_return(true)
-      IO.should_receive(:read).with('foo/a.rb').and_return("")
-      IO.should_receive(:read).with('foo/bar/b.rb').and_return("")
+      File.should_receive(:read_binary).with('foo/a.rb').and_return("")
+      File.should_receive(:read_binary).with('foo/bar/b.rb').and_return("")
       YARD.parse ['foo']
     end
     
@@ -111,15 +107,22 @@ describe YARD::Parser::SourceParser do
       cmock.should_receive(:[]).with('foo/bar').and_return(hash)
       Registry.should_receive(:checksums).and_return(cmock)
       File.should_receive(:file?).with('foo/bar').and_return(true)
-      IO.should_receive(:read).with('foo/bar').and_return(data)
+      File.should_receive(:read_binary).with('foo/bar').and_return(data)
       YARD.parse('foo/bar')
     end
+    
+    it "should support excluded paths" do
+      File.should_receive(:file?).with('foo/bar').and_return(true)
+      File.should_receive(:file?).with('foo/baz').and_return(true)
+      File.should_not_receive(:read_binary)
+      YARD.parse(["foo/bar", "foo/baz"], ["foo", /baz$/])
+    end
   end
   
   describe '#parse_in_order' do
     def in_order_parse(*files)
       paths = files.map {|f| File.join(File.dirname(__FILE__), 'examples', f.to_s + '.rb.txt') }
-      YARD::Parser::SourceParser.parse(paths, Logger::DEBUG)
+      YARD::Parser::SourceParser.parse(paths, [], Logger::DEBUG)
     end
     
     it "should attempt to parse files in order" do
@@ -135,7 +138,7 @@ describe YARD::Parser::SourceParser do
     it "should attempt to order files by length (process toplevel files first)" do
       %w(a a/b a/b/c).each do |file|
         File.should_receive(:file?).with(file).and_return(true)
-        IO.should_receive(:read).with(file).ordered.and_return('')
+        File.should_receive(:read_binary).with(file).ordered.and_return('')
       end
       YARD.parse %w(a/b/c a/b a)
     end

data/spec/spec_helper.rb

@@ -6,7 +6,7 @@ require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'yard'))
 def parse_file(file, thisfile = __FILE__, log_level = log.level, ext = '.rb.txt')
   Registry.clear
   path = File.join(File.dirname(thisfile), 'examples', file.to_s + ext)
-  YARD::Parser::SourceParser.parse(path, log_level)
+  YARD::Parser::SourceParser.parse(path, [], log_level)
 end
 
 def described_in_docs(klass, meth, file = nil)

data/spec/templates/engine_spec.rb

@@ -48,6 +48,7 @@ describe YARD::Templates::Engine do
 
     it "should create a Template including other matching templates in path" do
       paths = ['/full/path/template/name', '/full/path2/template/name']
+      Engine.should_receive(:find_template_paths).with(nil, 'template').at_least(1).times.and_return([])
       Engine.should_receive(:find_template_paths).with(nil, 'template/name').and_return(paths)
       ancestors = Engine.template('template/name').ancestors.map {|m| m.class_name }
       ancestors.should include("Template__full_path2_template_name")

data/spec/templates/examples/class001.html

@@ -83,8 +83,12 @@ Comments
   
 </ul>
 
+</div><div id="subclasses">
+  <h2>Direct Known Subclasses</h2>
+  <p class="children">C</p>
 </div>
 
+
   
 
   <h2>Instance Method Summary</h2>

data/spec/templates/examples/class001.txt

@@ -23,6 +23,11 @@ Version:
 
 ------------------------------------------------------------------------
 
+Direct Known Subclasses:
+------------------------
+
+    C
+
 Instance methods:
 -----------------
 

data/spec/templates/examples/module001.dot

@@ -1,4 +1,4 @@
-A [label="{module A|+ \#attr1 [RW]\l+ \#attr2 [R]\l+ \#attr3 [RW]\l|+ a\l+ \#a\l+ \#test_multi_overload\l+ \#test_overload\l+ \#void_meth\ \:\ void\l}" rank=sink];
+A [label="{module A|+ \#attr1 [RW]\l+ \#attr2 [R]\l+ \#attr3 [RW]\l+ \#attr4 [W]\l|+ a\l+ \#a\l+ \#test_multi_overload\l+ \#test_overload\l+ \#void_meth\ \:\ void\l}" rank=sink];
 A_Y [label="{class Y||}" rank=sink];
 subgraph cluster_A_Y {
   label = "Y"; labelloc=b;

data/spec/templates/examples/module001.html

@@ -46,12 +46,12 @@
   
     <dl class="constants">
       
-        <dt id="CONSTANT-constant ">CONSTANT =
+        <dt id="CONSTANT-constant" class="">CONSTANT =
             <span class="summary_desc"></span>
         </dt>
         <dd><pre class="code">'value'</pre></dd>
       
-        <dt id="cvar-classvariable ">@@cvar =
+        <dt id="cvar-classvariable" class="deprecated">@@cvar =
             <span class="summary_desc"></span>
         </dt>
         <dd><pre class="code">'value'</pre></dd>
@@ -136,6 +136,29 @@
 </li>
 
     
+      <li class="public ">
+  <span class="summary_signature">
+    
+      <a  title="#attr4= (instance method)">- <strong>attr4</strong> </a>
+    
+
+    
+  </span>
+  
+  
+    
+    <span class="note title writeonly">writeonly</span>
+  
+  
+  
+  
+
+  
+    <span class="summary_desc">Sets the attribute attr4.</span>
+  
+</li>
+
+    
   </ul>
 
 
@@ -452,6 +475,63 @@ end</pre>
 </table>
 </div>
     
+      
+      <span id="attr4=-instance_method"></span>
+      <span id=""></span>
+      <div class="method_details ">
+  <p class="signature " id="attr4=-instance_method">
+  
+    - <strong>attr4=</strong>(value)  <span class="extras">(writeonly)</span>
+  
+
+  
+</p><div class="docstring">
+  <div class="discussion">
+    Sets the attribute attr4
+
+  </div>
+</div>
+<div class="tags">
+  <h3>Parameters:</h3>
+<ul class="param">
+  
+    <li>
+      
+        <span class='type'></span>
+      
+      
+        <span class='name'>value</span>
+      
+      
+      
+        &mdash;
+        the value to set the attribute attr4 to.
+      
+    </li>
+  
+</ul>
+
+</div><table class="source_code">
+  <tr>
+    <td>
+      <pre class="lines">
+
+
+20
+21
+22</pre>
+    </td>
+    <td>
+      <pre class="code"><span class="info file"># File '(stdin)', line 20</span>
+
+def attr4=(value)
+  @attr4 = value
+end</pre>
+    </td>
+  </tr>
+</table>
+</div>
+    
   </div>
 
 
@@ -472,10 +552,10 @@ end</pre>
       <pre class="lines">
 
 
-20</pre>
+22</pre>
     </td>
     <td>
-      <pre class="code"><span class="info file"># File '(stdin)', line 20</span>
+      <pre class="code"><span class="info file"># File '(stdin)', line 22</span>
 
 def self.a; end</pre>
     </td>
@@ -506,10 +586,10 @@ def self.a; end</pre>
       <pre class="lines">
 
 
-21</pre>
+23</pre>
     </td>
     <td>
-      <pre class="code"><span class="info file"># File '(stdin)', line 21</span>
+      <pre class="code"><span class="info file"># File '(stdin)', line 23</span>
 
 def a; end</pre>
     </td>
@@ -542,10 +622,10 @@ def a; end</pre>
       <pre class="lines">
 
 
-31</pre>
+33</pre>
     </td>
     <td>
-      <pre class="code"><span class="info file"># File '(stdin)', line 31</span>
+      <pre class="code"><span class="info file"># File '(stdin)', line 33</span>
 
 def test_multi_overload(*args) end</pre>
     </td>
@@ -602,10 +682,10 @@ def test_multi_overload(*args) end</pre>
       <pre class="lines">
 
 
-27</pre>
+29</pre>
     </td>
     <td>
-      <pre class="code"><span class="info file"># File '(stdin)', line 27</span>
+      <pre class="code"><span class="info file"># File '(stdin)', line 29</span>
 
 def test_overload(*args) end</pre>
     </td>
@@ -634,10 +714,10 @@ def test_overload(*args) end</pre>
       <pre class="lines">
 
 
-34</pre>
+36</pre>
     </td>
     <td>
-      <pre class="code"><span class="info file"># File '(stdin)', line 34</span>
+      <pre class="code"><span class="info file"># File '(stdin)', line 36</span>
 
 def void_meth; end</pre>
     </td>