yard 0.7.5 → 0.8.0

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

@@ -1,41 +1,41 @@
 class Testing
   # Ignore yields outside methods
   raise NoMethodError, "reason"
-  
+
   # Should document this
   def mymethod
     raise ArgumentError, "Argument is missing"
   end
-  
+
   # Don't document this
   def mymethod2
-    raise(a) 
+    raise(a)
   end
-  
+
   # Don't document this (docstring takes precedence)
   # @raise [A]
-  def mymethod3 
+  def mymethod3
     raise SomethingElse
   end
-  
+
   # Only document the first one (limitation of exc handler)
-  def mymethod4 
+  def mymethod4
     raise(A)
     raise B, "Argument", somethingelse
   end
-  
+
   def mymethod5
     raise YARD::Parser::UndocumentableError
   end
-  
+
   def mymethod6
     raise YARD::Handlers.constants("test")
   end
-  
+
   def mymethod7
     raise MethodCall('argument')
   end
-  
+
   def mymethod8
     raise ExceptionClass.new('blah')
   end
@@ -44,15 +44,15 @@ class Testing
     obj.raise IgnoreMe
 	obj.raise(IgnoreMe)
   end
-  
+
   def mymethod10
     raise ArgumentError 'Message' # actually a method call
   end
-  
+
   def mymethod11
     raise foo('bar')
   end
-  
+
   def mymethod12
     raise
   end

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

@@ -3,8 +3,8 @@ def a
     # ignore this
     def b; end
   end
-  
+
   # don't ignore these even though we know they're not executed
   def c; end if false
   def d; end unless true
-end 
+end

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

@@ -13,7 +13,7 @@ class Foo
   def initialize; end
 
   def ==(other)
-    'hello' 
+    'hello'
   end
   def /(other) 'hi' end
 
@@ -22,24 +22,24 @@ class Foo
   def method1
     def dynamic; end
   end
- 
+
   def self.method2; end
 
   # Docstring
   def String :: hello; "" end
-  
+
   def self.new() end
 
   def [](key = 'default') puts key end
   def []=(key, value) end
-  def 
+  def
 allowed?
 end
 
   def ` param; end
   def /(x = File.new('x', 'w'), y = 2) end
   def |; end; def =~ ()
-  def -@; end; 
+  def -@; end;
 end
   def *(o) def +@; end
     def ~@
@@ -47,7 +47,7 @@ end
   def &(o) end
   def %(o) end
   def ^(o) end
-  
+
   def optsmeth(x, opts = {}) end
   def blockmeth(x, &block) end
 
@@ -91,35 +91,35 @@ def CONST2.meth2_on_const; end
 
 class D
   alias b a
-  
+
   # foo bar
   def a; end
 end
 
 class E
-  # @macro prop
-  #   @method $1(value)
+  # @!macro prop
+  #   @!method $1(value)
   #   $3
   #   @return [$2]
   def self.property(name, ret_type, docstring)
   end
-  
+
   property :foo, String, "create a foo"
-  
-  # @macro xyz
-  #   @method $1
+
+  # @!macro xyz
+  #   @!method $1
   def xyz; end
-  
+
   xyz :a
 end
 
 module F
   class A
     def foo; end
-    
+
     def end
     end
-    
+
     # PASS
     def bar; end
   end

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

@@ -1,6 +1,6 @@
 module A; end
-module B; 
-  module C; end 
+module B;
+  module C; end
   module D; end
 end
 
@@ -19,15 +19,19 @@ module Y
   class << self; include A; end
 end
 
+module Z
+  include A, B
+end
+
 module ABC
   module FOO; end
   module DEF
     module FOO
       include ABC::FOO
     end
-    
+
     module BAR
       include ABC::BAR
     end
   end
-end  
+end

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

@@ -3,6 +3,6 @@ module A
   class B; end
   module C; end
   module D; end
-  
+
   private_constant :Foo, 'B', C
 end

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

@@ -1,6 +1,6 @@
 class Testing
   def pub; end
-  
+
   private
 
   def priv; end
@@ -17,11 +17,11 @@ class Testing
   def pub2; end
 
   protected :notpriv, 'notpriv2', :notpriv?
-  
+
   private name
   private *argument
   private *(method_call)
-  
+
   def Foo; end
   private :Foo
 end

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

@@ -1,12 +1,12 @@
 class Testing
   # Ignore yields outside methods
-  yield x, y, z 
-  
+  yield x, y, z
+
   # Should document this
   def mymethod
     yield
   end
-  
+
   # Has yield and yieldparam documentation
   # @yield [a, b] Blah
   # @yieldparam a Blah
@@ -14,42 +14,41 @@ class Testing
   def mymethod2
     yield(b, a) # Yield something else
   end
-  
+
   # Has yield documentation only
   # @yield [a, b]
-  def mymethod3 
+  def mymethod3
     yield self # Should not be changed
   end
-  
+
   # Has yieldparam documentation only
   # @yieldparam _self BLAH
   def mymethod4
     yield self
   end
-  
+
   # Some weird possibilities..
   # Document it all.
-  
-  
+
+
   def mymethod5
     yield :a, b, self, File.read('file', 'w'), CONSTANT if x == 2
   end
-  
+
   def mymethod6
     yield(b, a)
   end
-  
+
   def mymethod7
     yield a
     yield b
   end
-  
+
   def mymethod8
     yield self
   end
-  
+
   def mymethod9
     yield super
   end
 end
-  

data/spec/handlers/exception_handler_spec.rb

@@ -2,25 +2,25 @@ require File.dirname(__FILE__) + '/spec_helper'
 
 describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ExceptionHandler" do
   before(:all) { parse_file :exception_handler_001, __FILE__ }
-  
+
   it "should not document an exception outside of a method" do
     P('Testing').has_tag?(:raise).should == false
   end
-  
+
   it "should document a valid raise" do
     P('Testing#mymethod').tag(:raise).types.should == ['ArgumentError']
   end
-  
+
   it "should only document non-dynamic raises" do
     P('Testing#mymethod2').tag(:raise).should be_nil
     P('Testing#mymethod6').tag(:raise).should be_nil
     P('Testing#mymethod7').tag(:raise).should be_nil
   end
-  
+
   it "should treat ConstantName.new as a valid exception class" do
     P('Testing#mymethod8').tag(:raise).types.should == ['ExceptionClass']
   end
-  
+
   it "should not document a method with an existing @raise tag" do
     P('Testing#mymethod3').tag(:raise).types.should == ['A']
   end
@@ -28,20 +28,20 @@ describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ExceptionHandl
   it "should only document the first raise message of a method (limitation of exception handler)" do
     P('Testing#mymethod4').tag(:raise).types.should == ['A']
   end
-  
+
   it "should handle complex class names" do
     P('Testing#mymethod5').tag(:raise).types.should == ['YARD::Parser::UndocumentableError']
   end
-  
+
   it "should ignore any raise calls on a receiver" do
     P('Testing#mymethod9').tag(:raise).should be_nil
   end
-  
+
   it "should handle raise expressions that are method calls" do
     P('Testing#mymethod10').tag(:raise).should be_nil
     P('Testing#mymethod11').tag(:raise).should be_nil
   end
-  
+
   it "should ignore empty raise call" do
     P('Testing#mymethod12').tag(:raise).should be_nil
   end

data/spec/handlers/extend_handler_spec.rb

@@ -12,11 +12,11 @@ describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ExtendHandler"
     Registry.at(:C).class_mixins.should == [P(:C)]
     Registry.at(:C).instance_mixins.should be_empty
   end
-  
+
   it "should extend module with correct namespace" do
     Registry.at('Q::R::S').class_mixins.first.path.should == 'A'
   end
-  
+
   it "should not allow extending self if object is a class" do
     undoc_error "class Foo; extend self; end"
   end

data/spec/handlers/legacy_base_spec.rb

@@ -2,123 +2,123 @@ require File.dirname(__FILE__) + '/spec_helper'
 
 include Parser::Ruby::Legacy
 
-describe YARD::Handlers::Ruby::Legacy::Base, "#tokval" do 
-  
-  before { @handler = Handlers::Ruby::Legacy::Base.new(nil, nil) } 
-  
+describe YARD::Handlers::Ruby::Legacy::Base, "#tokval" do
+
+  before { @handler = Handlers::Ruby::Legacy::Base.new(nil, nil) }
+
   def tokval(code, *types)
     @handler.send(:tokval, TokenList.new(code).first, *types)
   end
-  
+
   it "should return the String's value without quotes" do
     tokval('"hello"').should == "hello"
   end
-  
+
   it "should not allow interpolated strings with TkSTRING" do
     tokval('"#{c}"', RubyToken::TkSTRING).should be_nil
   end
-  
+
   it "should return a Symbol's value as a String (as if it was done via :name.to_sym)" do
     tokval(':sym').should == :sym
   end
-  
+
   it "should return nil for any non accepted type" do
     tokval('identifier').should be_nil
     tokval(':sym', RubyToken::TkId).should be_nil
   end
-  
+
   it "should accept TkVal tokens by default" do
     tokval('2.5').should == 2.5
     tokval(':sym').should == :sym
   end
-  
+
   it "should accept any ID type if TkId is set" do
     tokval('variable', RubyToken::TkId).should == "variable"
     tokval('CONSTANT', RubyToken::TkId).should == "CONSTANT"
   end
-  
-  it "should allow extra token types to be accepted" do 
+
+  it "should allow extra token types to be accepted" do
     tokval('2.5', RubyToken::TkFLOAT).should == 2.5
     tokval('2', RubyToken::TkFLOAT).should be_nil
     tokval(':symbol', RubyToken::TkFLOAT).should be_nil
   end
-  
+
   it "should allow :string for any string type" do
     tokval('"hello"', :string).should == "hello"
     tokval('"#{c}"', :string).should == '#{c}'
   end
-  
+
   it "should not include interpolated strings when using :attr" do
     tokval('"#{c}"', :attr).should be_nil
   end
-  
+
   it "should allow any number type with :number" do
     tokval('2.5', :number).should == 2.5
     tokval('2', :number).should == 2
   end
-  
+
   it "should should allow method names with :identifier" do
     tokval('methodname?', :identifier).should == "methodname?"
   end
-  
+
   #it "should obey documentation expectations" do docspec end
 end
 
-describe YARD::Handlers::Base, "#tokval_list" do 
-  before { @handler = Handlers::Ruby::Legacy::Base.new(nil, nil) } 
-  
+describe YARD::Handlers::Base, "#tokval_list" do
+  before { @handler = Handlers::Ruby::Legacy::Base.new(nil, nil) }
+
   def tokval_list(code, *types)
     @handler.send(:tokval_list, TokenList.new(code), *types)
   end
-  
+
   it "should return the list of tokvalues" do
     tokval_list(":a, :b, \"\#{c}\", 'd'", :attr).should == [:a, :b, 'd']
-    tokval_list(":a, :b, File.read(\"\#{c}\", ['w']), :d", 
+    tokval_list(":a, :b, File.read(\"\#{c}\", ['w']), :d",
       RubyToken::Token).should  == [:a, :b, 'File.read("#{c}", [\'w\'])', :d]
   end
-  
+
   it "should try to skip any invalid tokens" do
     tokval_list(":a, :b, \"\#{c}\", :d", :attr).should  == [:a, :b, :d]
     tokval_list(":a, :b, File.read(\"\#{c}\", 'w', File.open { }), :d", :attr).should  == [:a, :b, :d]
-    tokval_list("CONST1, identifier, File.read(\"\#{c}\", 'w', File.open { }), CONST2", 
+    tokval_list("CONST1, identifier, File.read(\"\#{c}\", 'w', File.open { }), CONST2",
       RubyToken::TkId).should  == ['CONST1', 'identifier', 'CONST2']
   end
-  
+
   it "should ignore a token if another invalid token is read before a comma" do
     tokval_list(":a, :b XYZ, :c", RubyToken::TkSYMBOL).should == [:a, :c]
   end
-  
+
   it "should stop on most keywords" do
     tokval_list(':a rescue :x == 5', RubyToken::Token).should == [:a]
   end
-  
+
   it "should handle ignore parentheses that begin the token list" do
     tokval_list('(:a, :b, :c)', :attr).should == [:a, :b, :c]
   end
-  
+
   it "should end when a closing parenthesis was found" do
     tokval_list(':a, :b, :c), :d', :attr).should == [:a, :b, :c]
   end
-  
+
   it "should ignore parentheses around items in a list" do
     tokval_list(':a, (:b), :c, (:d TEST), :e, [:f], :g', :attr).should == [:a, :b, :c, :e, :g]
     tokval_list(':a, (((:f)))', :attr).should == [:a, :f]
     tokval_list(':a, ([:f]), :c)', RubyToken::Token).should == [:a, '[:f]', :c]
   end
-  
+
   it "should not stop on a true/false/self keyword (cannot handle nil)" do
-    tokval_list(':a, true, :b, self, false, :c, nil, File, super, if, XYZ', 
+    tokval_list(':a, true, :b, self, false, :c, nil, File, super, if, XYZ',
       RubyToken::Token).should == [:a, true, :b, 'self', false, :c, 'File', 'super']
   end
-  
+
   it "should ignore invalid commas" do
     tokval_list(":a, :b, , :d").should == [:a, :b, :d]
   end
-  
+
   it "should return an empty list if no matches were found" do
     tokval_list('attr_accessor :x').should == []
   end
-  
+
   it "should treat {} as a valid value" do
     # FIXME: tokval_list destroys extra spaces surrounding the '=' in
     #        this situation. This is technically a design flaw of the