yard 0.2.2 → 0.2.3

data/spec/parser/{token_list_spec.rb → ruby/legacy/token_list_spec.rb}

@@ -1,9 +1,9 @@
-require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'spec_helper')
 
-include YARD::Parser
-include YARD::Parser::RubyToken
+include YARD::Parser::Ruby::Legacy
+include YARD::Parser::Ruby::Legacy::RubyToken
 
-describe YARD::Parser::TokenList, "#initialize / #push" do
+describe YARD::Parser::Ruby::Legacy::TokenList, "#initialize / #push" do
   it "should accept a tokenlist (via constructor or push)" do
     lambda { TokenList.new(TokenList.new) }.should_not raise_error(ArgumentError)
     TokenList.new.push(TokenList.new("x = 2")).size.should == 6

data/spec/parser/source_parser_spec.rb

@@ -25,19 +25,4 @@ describe YARD::Parser::SourceParser do
     Registry.at("Hello::Hi#me").should_not == nil
     Registry.at("Hello::Hi#me").docstring.should == "Docstring"
   end
-  
-  it "should start with public visibility" do
-    p = Parser::SourceParser.new
-    p.visibility.should == :public
-  end
-  
-  it "should start in instance scope" do
-    p = Parser::SourceParser.new
-    p.scope.should == :instance
-  end
-  
-  it "should start in root namespace" do
-    p = Parser::SourceParser.new
-    p.namespace.should == Registry.root
-  end
 end

data/spec/rake/yardoc_task_spec.rb

@@ -0,0 +1,48 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe YARD::Rake::YardocTask do
+  before do
+    Rake.application.clear
+  end
+  
+  def run
+    Rake.application.tasks[0].invoke
+  end
+  
+  it "should allow separate rake task name to be set" do
+    YARD::Rake::YardocTask.new(:notyardoc)
+    Rake.application.tasks[0].name.should == "notyardoc"
+  end
+  
+  it "should allow files to be set" do
+    YARD::CLI::Yardoc.should_receive(:run).with('a', 'b', 'c')
+    YARD::Rake::YardocTask.new do |t|
+      t.files = ['a', 'b', 'c']
+    end
+    run
+  end
+  
+  it "should allow extra options to be set" do
+    YARD::CLI::Yardoc.should_receive(:run).with('--extra', '--opts')
+    YARD::Rake::YardocTask.new do |t|
+      t.options = ['--extra', '--opts']
+    end
+    run
+  end
+  
+  it "should allow before callback" do
+    proc = lambda { }
+    proc.should_receive(:call)
+    YARD::CLI::Yardoc.should_receive(:run)
+    YARD::Rake::YardocTask.new {|t| t.before = proc }
+    run
+  end
+  
+  it "should allow after callback" do
+    proc = lambda { }
+    proc.should_receive(:call)
+    YARD::CLI::Yardoc.should_receive(:run)
+    YARD::Rake::YardocTask.new {|t| t.after = proc }
+    run
+  end
+end

data/spec/registry_spec.rb

@@ -21,7 +21,7 @@ describe YARD::Registry do
     o3 = ModuleObject.new(o2, :C)
     Registry.resolve(o3, "::A").should == o1
     
-    Registry.resolve(o3, "::String", true).should == P(:String)
+    Registry.resolve(o3, "::String", false, true).should == P(:String)
   end
   
   it "should resolve instance methods with # prefix" do
@@ -39,6 +39,32 @@ describe YARD::Registry do
     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)
+    yard.superclass = superyard
+    imeth = MethodObject.new(superyard, :hello)
+    cmeth = MethodObject.new(superyard, :class_hello, :class)
+
+    Registry.resolve(yard, "#hello", false).should be_nil
+    Registry.resolve(yard, "#hello", true).should == imeth
+    Registry.resolve(yard, "class_hello", false).should be_nil
+    Registry.resolve(yard, "class_hello", true).should == cmeth
+  end
+
+  it "should resolve mixin methods when inheritance = true" do
+    yard = ClassObject.new(:root, :YARD)
+    mixin = ModuleObject.new(:root, :Mixin)
+    yard.mixins(:instance) << mixin
+    imeth = MethodObject.new(mixin, :hello)
+    cmeth = MethodObject.new(mixin, :class_hello, :class)
+
+    Registry.resolve(yard, "#hello", false).should be_nil
+    Registry.resolve(yard, "#hello", true).should == imeth
+    Registry.resolve(yard, "class_hello", false).should be_nil
+    Registry.resolve(yard, "class_hello", true).should == cmeth
+  end
+  
   it "should allow symbols as object type in #all" do
     ModuleObject.new(:root, :A)
     o1 = ClassObject.new(:root, :B)
@@ -67,4 +93,4 @@ describe YARD::Registry do
     o2 = ClassObject.new(:root, :B)
     Registry.paths.should include('A', 'B')
   end
-end
+end

data/spec/serializers/file_system_serializer_spec.rb

@@ -20,7 +20,13 @@ describe YARD::Serializers::FileSystemSerializer do
   
   it "should allow no extension to be used" do
     obj = Serializers::FileSystemSerializer.new :extension => nil
-    obj.serialized_path(Registry.root).should == 'root'
+    yard = CodeObjects::ClassObject.new(nil, :FooBar)
+    obj.serialized_path(yard).should == 'FooBar'
+  end
+  
+  it "should serialize to top-level-namespace for root" do
+    obj = Serializers::FileSystemSerializer.new :extension => nil
+    obj.serialized_path(Registry.root).should == "top-level-namespace"
   end
   
   it "should serialize to the correct path" do

data/spec/spec_helper.rb

@@ -1,7 +1,7 @@
 require "rubygems"
 require "spec"
 
-require File.join(File.dirname(__FILE__), '..', 'lib', 'yard')
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'yard'))
 
 def parse_file(file, thisfile = __FILE__)
   Registry.clear

data/spec/tags/default_factory_spec.rb

@@ -0,0 +1,135 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe YARD::Tags::DefaultFactory, "extract_types_and_name_from_text" do
+  before { @f = YARD::Tags::DefaultFactory.new }
+  
+  def parse_types(types)
+    @f.send(:extract_types_and_name_from_text, types)
+  end
+  
+  it "should handle one type" do
+    parse_types('[A]').should == [nil, ['A'], ""]
+  end
+
+  it "should handle a list of types" do
+    parse_types('[A, B, C]').should == [nil, ['A', 'B', 'C'], ""]
+  end
+  
+  it "should return the text before and after the type list" do
+    parse_types(' b <String> description').should == ['b', ['String'], 'description']
+  end
+  
+  it "should handle a complex list of types" do
+    v = parse_types(' [Test, Array<String, Hash, C>, String]')
+    v.should include(["Test", "Array<String, Hash, C>", "String"])
+  end
+  
+  it "should handle any of the following start/end delimiting chars: (), <>, {}, []" do
+    a = parse_types('[a,b,c]')
+    b = parse_types('<a,b,c>')
+    c = parse_types('(a,b,c)')
+    d = parse_types('{a,b,c}')
+    a.should == b
+    b.should == c
+    c.should == d
+    a.should include(['a','b','c'])
+  end
+  
+  it "should return the text before the type list as the last element" do
+    parse_types('b[x, y, z]').should == ['b', ['x', 'y', 'z'], '']
+    parse_types('  ! <x>').should == ["!", ['x'], '']
+  end
+  
+  it "should return text unparsed if there is no type list" do
+    parse_types('').should == [nil, nil, '']
+    parse_types('[]').should == [nil, nil, '[]']
+  end
+  
+  it "should allow A => B syntax" do
+    v = parse_types(' [Test, Array<String, Hash{A => {B => C}}, C>, String]')
+    v.should include(["Test", "Array<String, Hash{A => {B => C}}, C>", "String"])
+  end
+end
+
+describe YARD::Tags::DefaultFactory, '#parse_tag_with_types' do
+  before { @f = YARD::Tags::DefaultFactory.new }
+  
+  def parse_types(text)
+    @f.send(:parse_tag_with_types, 'test', text)
+  end
+  
+  it "should parse given types and description" do
+    YARD::Tags::Tag.should_receive(:new).with("test", "description", ["x", "y", "z"])
+    parse_types(' [x, y, z] description')
+  end
+  
+  it "should parse given types only" do
+    YARD::Tags::Tag.should_receive(:new).with("test", "", ["x", "y", "z"])
+    parse_types(' [x, y, z] ')
+  end
+  
+  it "should allow type list to be omitted" do
+    YARD::Tags::Tag.should_receive(:new).with('test', 'description', nil)
+    parse_types('  description    ')
+  end
+  
+  it "should raise an error if a name is specified before type list" do
+    lambda { parse_types('b<String> desc') }.should raise_error(YARD::Tags::TagFormatError, 'cannot specify a name before type list for \'@test\'')
+  end
+end
+
+describe YARD::Tags::DefaultFactory, '#parse_tag_with_types_name_and_default' do
+  before { @f = YARD::Tags::DefaultFactory.new }
+  
+  def parse_types(text)
+    @f.send(:parse_tag_with_types_name_and_default, 'test', text)
+  end
+  
+  it "should parse a standard type list with name before types (no default)" do
+    YARD::Tags::DefaultTag.should_receive(:new).with("test", "description", ["x", "y", "z"], 'NAME', nil)
+    parse_types('NAME [x, y, z] description')
+  end
+
+  it "should parse a standard type list with name after types (no default)" do
+    YARD::Tags::DefaultTag.should_receive(:new).with("test", "description", ["x", "y", "z"], 'NAME', nil)
+    parse_types('  [x, y, z] NAME description')
+  end
+  
+  it "should parse a tag definition with name, typelist and default" do
+    YARD::Tags::DefaultTag.should_receive(:new).with("test", "description", ["x", "y", "z"], 'NAME', ['default', 'values'])
+    parse_types('  [x, y, z] NAME (default, values) description')
+  end
+
+  it "should parse a tag definition with name, typelist and default when name is before type list" do
+    YARD::Tags::DefaultTag.should_receive(:new).with("test", "description", ["x", "y", "z"], 'NAME', ['default', 'values'])
+    parse_types(' NAME [x, y, z] (default, values) description')
+  end
+  
+  it "should allow typelist to be omitted" do
+    YARD::Tags::DefaultTag.should_receive(:new).with("test", "description", nil, 'NAME', ['default', 'values'])
+    parse_types('  NAME (default, values) description')
+  end
+end
+
+describe YARD::Tags::DefaultFactory, '#parse_tag_with_options' do
+  before { @f = YARD::Tags::DefaultFactory.new }
+  
+  def parse_options(text)
+    @f.parse_tag_with_options('option', text)
+  end
+  
+  it "should have a name before tag info" do
+    t = parse_options("xyz key [Types] (default) description")
+    t.tag_name.should == 'option'
+    t.name.should == 'xyz'
+  end
+  
+  it "should parse the rest of the tag like DefaultTag" do
+    t = parse_options("xyz key [Types] (default) description")
+    t.pair.should be_instance_of(Tags::DefaultTag)
+    t.pair.types.should == ["Types"]
+    t.pair.name.should == "key"
+    t.pair.defaults.should == ["default"]
+    t.pair.text.should == "description"
+  end
+end

data/spec/tags/default_tag_spec.rb

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe YARD::Tags::DefaultTag do
+  it "should create a tag with defaults" do
+    o = YARD::Tags::DefaultTag.new('tagname', 'desc', ['types'], 'name', ['defaults'])
+    o.defaults.should == ['defaults']
+    o.tag_name.should == 'tagname'
+    o.name.should == 'name'
+    o.types.should == ['types']
+  end
+end

data/spec/tags/overload_tag_spec.rb

@@ -0,0 +1,35 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe YARD::Tags::OverloadTag do
+  before do
+    @tag = Tags::OverloadTag.new(:overload, nil, <<-'eof')
+      def bar(a, b = 1, &block)
+        Hello world
+        @param a [String]
+        @return [String]
+    eof
+  end
+  
+  it "should parse the first line as a method signature" do
+    @tag.signature.should == "def bar(a, b = 1, &block)"
+    @tag.parameters.should == [[:a, nil], [:b, "1"], [:"&block", nil]]
+  end
+  
+  it "should parse the rest of the text as a new Docstring" do
+    @tag.docstring.should be_instance_of(Docstring)
+    @tag.docstring.should == "Hello world"
+  end
+  
+  it "should set Docstring's object after #object= is called" do
+    m = mock(:object)
+    @tag.object = m
+    @tag.docstring.object.should == m
+  end
+  
+  it "should respond to #tag, #tags and #has_tag?" do
+    @tag.object = mock(:object)
+    @tag.tags.size.should == 2
+    @tag.tag(:param).name.should == "a"
+    @tag.has_tag?(:return).should == true
+  end
+end

data/spec/tags/ref_tag_list_spec.rb

@@ -0,0 +1,53 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe YARD::Tags::RefTagList do
+  before { YARD::Registry.clear }
+  
+  it "should accept symbol or string as owner's path and convert it into a proxy" do
+    t = Tags::RefTagList.new('author', :String)
+    t.owner.should == P(:String)
+  end
+  
+  it "should accept proxy object as owner" do
+    t = Tags::RefTagList.new('author', P(:String))
+    t.owner.should == P(:String)
+  end
+  
+  it "should return tags from a proxy object" do
+    o = CodeObjects::ClassObject.new(:root, :String)
+    t = Tags::Tag.new(:author, 'foo')
+    o.docstring.add_tag(t)
+  
+    ref = Tags::RefTagList.new('author', :String)
+    ref.tags.should == [t]
+    ref.tags.first.text.should == 'foo'
+  end
+  
+  it "should return named tags from a proxy object" do
+    o = CodeObjects::ClassObject.new(:root, :String)
+    p1 = Tags::Tag.new(:param, 'bar1', nil, 'foo')
+    p2 = Tags::Tag.new(:param, 'bar2', nil, 'foo')
+    p3 = Tags::Tag.new(:param, 'bar3', nil, 'bar')
+    t1 = Tags::Tag.new(:return, 'blah')
+    o.docstring.add_tag(p1, t1, p2, p3)
+  
+    ref = Tags::RefTagList.new('param', :String, 'foo')
+    ref.tags.should == [p1, p2]
+    ref.tags.first.text.should == 'bar1'
+  end
+  
+  it "all tags should respond to #owner and be a RefTag" do
+    o = CodeObjects::ClassObject.new(:root, :String)
+    p1 = Tags::Tag.new(:param, 'bar1', nil, 'foo')
+    p2 = Tags::Tag.new(:param, 'bar2', nil, 'foo')
+    p3 = Tags::Tag.new(:param, 'bar3', nil, 'bar')
+    t1 = Tags::Tag.new(:return, 'blah')
+    o.docstring.add_tag(p1, t1, p2, p3)
+  
+    ref = Tags::RefTagList.new('param', :String)
+    ref.tags.each do |t|
+      t.should be_kind_of(Tags::RefTag)
+      t.owner.should == o
+    end
+  end
+end

data/templates/default/attributes/html/header.erb

@@ -6,18 +6,21 @@
       <h2><%= scope.capitalize %> Attributes</h2>
       <table>
       <% object.attributes[scope].sort_by {|o| o.to_s.downcase }.each do |name, rw| %>
-        <tr>
-          <th class="name"><%= h name %></td>
+        <% aliases = (rw[:read] || rw[:write]).aliases %>
+        <tr class="<%= 'hasaliases' if aliases.length > 0 %>">
+          <th class='signature'>
+            <span class='name'><%= h name %></span>
+          </td>
           <td class="readwrite">
             [<%= ['read', 'write'].map {|t| 
-                rw[t] && !rw[t].is_explicit? ? "<span id='#{anchor_for rw[t]}'>#{t[0,1].upcase}</span>" : t[0,1].upcase
+                rw[t] && (rw[t].is_explicit? ? t[0,1].upcase : "<span id='#{anchor_for rw[t]}'>#{t[0,1].upcase}</span>")
               }.compact.join %>] 
           </td>
           <td class="visibility">
             <%= rw.values.compact.first.visibility %>
           </td>
           <td class="docstring">
-            <%= htmlify rw.values.compact.first.short_docstring %>
+            <%= htmlify rw.values.compact.first.docstring.summary %>
             <% if rw[:read] && rw[:read].tag(:return) && rw[:read].tag(:return).types %>
               <p class='returns'>
                 Returns: 
@@ -28,8 +31,17 @@
             <% end %>
           </td>
         </tr>
+        <% if aliases.length > 0 %>
+          <tr>
+            <td colspan='4' class='aliases'><span class='text'>Also known as:</span>
+              <% aliases.each_with_index do |obj, i| %>
+                <span class='alias'><%= h obj.name.to_s.sub(/=$/, '') %></span><%= "," if i < aliases.length - 1 %>
+              <% end %>
+            </td>
+          </tr>
+        <% end %>
       <% end %>
       </table>
     </div>
   <% end %>
-</div>
+</div>

data/templates/default/attributes/text/header.erb

@@ -4,7 +4,7 @@
 -------------
 <% ['class', 'instance'].select {|s| object.attributes[s].length > 0 }.each do |scope| %>
 <% object.attributes[scope].sort_by {|o| o.to_s.downcase }.each do |name, rw| %>
-<%= uml_visibility rw.values.compact.first %> <%= rw.values.compact.first.name(true) %><%= " " if scope == 'class' %>	[<%= ['read', 'write'].map {|t| rw[t] ? t[0,1].upcase : ' ' }.compact.join %>]	(<%= rw.values.compact.first.visibility %>)
+<%= uml_visibility rw.values.compact.first %> <%= name %><%= " " if scope == 'class' %>	[<%= ['read', 'write'].map {|t| rw[t] ? t[0,1].upcase : ' ' }.compact.join %>]	(<%= rw.values.compact.first.visibility %>)
 <% end %>
 <% end %>