yard 0.7.5 → 0.8.0

data/spec/code_objects/class_object_spec.rb

@@ -35,7 +35,7 @@ describe YARD::CodeObjects::ClassObject do
       @class2.inheritance_tree(true)
       @class2.mixins.should == []
     end
-    
+
     it "should list class mixins in inheritance tree" do
       mod = ModuleObject.new(:root, :ClassMethods)
       klass = ClassObject.new(:root, :ReceivingClass)
@@ -47,7 +47,7 @@ describe YARD::CodeObjects::ClassObject do
   describe "#meths / #inherited_meths" do
     before(:all) do
       Registry.clear
-    
+
       YARD.parse_string <<-eof
         class SuperYard < String
           def foo; end
@@ -58,26 +58,26 @@ describe YARD::CodeObjects::ClassObject do
           private
           def self.bar; end
         end
-      
+
         class MiddleYard < SuperYard
           def middle; end
         end
-      
+
         class YARD < MiddleYard
           def mymethod; end
           def bar; end
         end
-        
+
         module IncludedYard
           def foo; end
         end
-        
+
         class FinalYard < SuperYard
           include IncludedYard
         end
       eof
     end
-  
+
     it "should show inherited methods by default" do
       meths = P(:YARD).meths
       meths.should include(P("YARD#mymethod"))
@@ -85,7 +85,7 @@ describe YARD::CodeObjects::ClassObject do
       meths.should include(P("SuperYard#foo2"))
       meths.should include(P("SuperYard.bar"))
     end
-  
+
     it "should allow :inherited to be set to false" do
       meths = P(:YARD).meths(:inherited => false)
       meths.should include(P("YARD#mymethod"))
@@ -93,12 +93,12 @@ describe YARD::CodeObjects::ClassObject do
       meths.should_not include(P("SuperYard#foo2"))
       meths.should_not include(P("SuperYard.bar"))
     end
-  
-    it "should not show overridden methods" do 
+
+    it "should not show overridden methods" do
       meths = P(:YARD).meths
       meths.should include(P("YARD#bar"))
       meths.should_not include(P("SuperYard#bar"))
-    
+
       meths = P(:YARD).inherited_meths
       meths.should_not include(P("YARD#bar"))
       meths.should_not include(P("YARD#mymethod"))
@@ -106,13 +106,13 @@ describe YARD::CodeObjects::ClassObject do
       meths.should include(P("SuperYard#foo2"))
       meths.should include(P("SuperYard.bar"))
     end
-  
+
     it "should not show inherited methods overridden by other subclasses" do
       meths = P(:YARD).inherited_meths
       meths.should include(P('MiddleYard#middle'))
       meths.should_not include(P('SuperYard#middle'))
     end
-    
+
     it "should show mixed in methods before superclass method" do
       meths = P(:FinalYard).meths
       meths.should include(P('IncludedYard#foo'))
@@ -121,67 +121,67 @@ describe YARD::CodeObjects::ClassObject do
   end
 
   describe "#constants / #inherited_constants" do
-    before(:all) do 
-      Registry.clear 
-    
+    before(:all) do
+      Registry.clear
+
       Parser::SourceParser.parse_string <<-eof
         class YARD
           CONST1 = 1
           CONST2 = "hello"
           CONST4 = 0
         end
-      
+
         class SUPERYARD < YARD
           CONST4 = 5
         end
-      
+
         class SubYard < SUPERYARD
           CONST2 = "hi"
           CONST3 = "foo"
         end
       eof
     end
-  
+
     it "should list inherited constants by default" do
       consts = P(:SubYard).constants
       consts.should include(P("YARD::CONST1"))
       consts.should include(P("SubYard::CONST3"))
-    
+
       consts = P(:SubYard).inherited_constants
       consts.should include(P("YARD::CONST1"))
       consts.should_not include(P("YARD::CONST2"))
       consts.should_not include(P("SubYard::CONST2"))
       consts.should_not include(P("SubYard::CONST3"))
     end
-  
+
     it "should not list inherited constants if turned off" do
       consts = P(:SubYard).constants(:inherited => false)
       consts.should_not include(P("YARD::CONST1"))
       consts.should include(P("SubYard::CONST3"))
     end
-  
+
     it "should not include an inherited constant if it is overridden by the object" do
       consts = P(:SubYard).constants
       consts.should include(P("SubYard::CONST2"))
       consts.should_not include(P("YARD::CONST2"))
     end
-  
+
     it "should not include an inherited constant if it is overridden by another subclass" do
       consts = P(:SubYard).inherited_constants
       consts.should include(P("SUPERYARD::CONST4"))
       consts.should_not include(P("YARD::CONST4"))
     end
-  
+
     it "should not set a superclass on BasicObject class" do
       o = ClassObject.new(:root, :Object)
       o.superclass.should == P(:BasicObject)
     end
-    
+
     it "should set superclass of Object to BasicObject" do
       o = ClassObject.new(:root, :BasicObject)
       o.superclass.should be_nil
     end
-  
+
     it "should raise ArgumentError if superclass == self" do
       lambda do
         o = ClassObject.new(:root, :Object) do |o|
@@ -189,9 +189,9 @@ describe YARD::CodeObjects::ClassObject do
         end
       end.should raise_error(ArgumentError)
     end
-  
+
     it "should tell the world if it is an exception class" do
-      o = ClassObject.new(:root, :MyClass) 
+      o = ClassObject.new(:root, :MyClass)
       o2 = ClassObject.new(:root, :OtherClass)
       o2.superclass = :SystemCallError
       o3 = ClassObject.new(:root, :StandardError)
@@ -200,20 +200,20 @@ describe YARD::CodeObjects::ClassObject do
 
       o.superclass = :Object
       o.is_exception?.should == false
-    
+
       o.superclass = :Exception
       o.is_exception?.should == true
-    
+
       o.superclass = :NoMethodError
       o.is_exception?.should == true
-    
+
       o.superclass = o2
       o.is_exception?.should == true
-    
+
       o.superclass = o3
       o.is_exception?.should == true
     end
-  
+
     it "should not raise ArgumentError if superclass is proxy in different namespace" do
       lambda do
         o = ClassObject.new(:root, :X) do |o|

data/spec/code_objects/code_object_list_spec.rb

@@ -2,7 +2,7 @@ require File.dirname(__FILE__) + '/spec_helper'
 
 describe YARD::CodeObjects::CodeObjectList do
   before { Registry.clear }
-  
+
   it "pushing a value should only allow CodeObjects::Base, String or Symbol" do
     list = CodeObjectList.new(nil)
     lambda { list.push(:hash => 1) }.should raise_error(ArgumentError)
@@ -11,21 +11,21 @@ describe YARD::CodeObjects::CodeObjectList do
     list << ModuleObject.new(nil, :YARD)
     list.size.should == 3
   end
-  
+
   it "added value should be a proxy if parameter was String or Symbol" do
     list = CodeObjectList.new(nil)
     list << "Test"
     list.first.class.should == Proxy
   end
-  
+
   it "should contain a unique list of objects" do
     obj = ModuleObject.new(nil, :YARD)
     list = CodeObjectList.new(nil)
-    
+
     list << P(:YARD)
     list << obj
     list.size.should == 1
-    
+
     list << :Test
     list << "Test"
     list.size.should == 2

data/spec/code_objects/constants_spec.rb

@@ -32,7 +32,7 @@ describe YARD::CodeObjects, "METHODMATCH" do
     "A::B::C :: method"[CodeObjects::METHODMATCH].should == "A::B::C :: method"
     "SomeClass . method"[CodeObjects::METHODMATCH].should == "SomeClass . method"
   end
-  
+
   it "should match self.method" do
     "self :: method!"[CodeObjects::METHODMATCH].should == "self :: method!"
     "self.is_a?"[CodeObjects::METHODMATCH].should == "self.is_a?"
@@ -51,10 +51,11 @@ describe YARD::CodeObjects, "BUILTIN_CLASSES" do
   it "should include all base classes" do
     YARD::CodeObjects::BUILTIN_CLASSES.each do |name|
       next if name == "MatchingData" && !defined?(::MatchingData)
+      next if name == "Continuation"
       eval(name).should be_instance_of(Class)
     end
   end
-  
+
   it "should include all exceptions" do
     YARD::CodeObjects::BUILTIN_EXCEPTIONS.each do |name|
       YARD::CodeObjects::BUILTIN_CLASSES.should include(name)
@@ -64,7 +65,7 @@ end
 
 describe YARD::CodeObjects, "BUILTIN_ALL" do
   it "should include classes modules and exceptions" do
-    a = YARD::CodeObjects::BUILTIN_ALL 
+    a = YARD::CodeObjects::BUILTIN_ALL
     b = YARD::CodeObjects::BUILTIN_CLASSES
     c = YARD::CodeObjects::BUILTIN_MODULES
     a.should == b+c

data/spec/code_objects/extra_file_object_spec.rb

@@ -6,65 +6,65 @@ describe YARD::CodeObjects::ExtraFileObject do
       File.should_receive(:read).with('file.txt').and_return('')
       ExtraFileObject.new('file.txt')
     end
-    
+
     it "should raise Errno::ENOENT if contents=nil and file does not exist" do
       lambda { ExtraFileObject.new('file.txt') }.should raise_error(Errno::ENOENT)
     end
-    
+
     it "should not attempt to read from disk if contents are provided" do
       ExtraFileObject.new('file.txt', 'CONTENTS')
     end
-    
+
     it "should set filename to filename" do
       file = ExtraFileObject.new('a/b/c/file.txt', 'CONTENTS')
       file.filename.should == "a/b/c/file.txt"
     end
-    
+
     it "should parse out attributes at top of the file" do
       file = ExtraFileObject.new('file.txt', "# @title X\n# @some_attribute Y\nFOO BAR")
       file.attributes[:title].should == "X"
       file.attributes[:some_attribute].should == "Y"
       file.contents.should == "FOO BAR"
     end
-    
+
     it "should allow whitespace prior to '#' marker when parsing attributes" do
       file = ExtraFileObject.new('file.txt', " \t # @title X\nFOO BAR")
       file.attributes[:title].should == "X"
       file.contents.should == "FOO BAR"
     end
-    
+
     it "should parse out old-style #!markup shebang format" do
       file = ExtraFileObject.new('file.txt', "#!foobar\nHello")
       file.attributes[:markup].should == "foobar"
     end
-    
+
     it "should not parse old-style #!markup if any whitespace is found" do
       file = ExtraFileObject.new('file.txt', " #!foobar\nHello")
       file.attributes[:markup].should be_nil
       file.contents.should == " #!foobar\nHello"
     end
-    
+
     it "should not parse out attributes if there are newlines prior to attributes" do
       file = ExtraFileObject.new('file.txt', "\n# @title\nFOO BAR")
       file.attributes.should be_empty
       file.contents.should == "\n# @title\nFOO BAR"
     end
-    
+
     it "should set contents to data after attributes" do
       file = ExtraFileObject.new('file.txt', "# @title\nFOO BAR")
       file.contents.should == "FOO BAR"
     end
-    
+
     it "should preserve newlines" do
       file = ExtraFileObject.new('file.txt', "FOO\r\nBAR\nBAZ")
       file.contents.should == "FOO\r\nBAR\nBAZ"
     end
-    
+
     it "should not include newlines in attribute data" do
       file = ExtraFileObject.new('file.txt', "# @title FooBar\r\nHello world")
       file.attributes[:title].should == "FooBar"
     end
-    
+
     it "should force encoding to @encoding attribute if present" do
       log.should_not_receive(:warn)
       data = "# @encoding sjis\nFOO"
@@ -80,12 +80,12 @@ describe YARD::CodeObjects::ExtraFileObject do
       file = ExtraFileObject.new('file.txt', data)
       file.contents.encoding.should == encoding
     end if RUBY19
-    
+
     it "should ignore encoding in 1.8.x (or encoding-unaware platforms)" do
       log.should_not_receive(:warn)
       file = ExtraFileObject.new('file.txt', "# @encoding INVALID\nFOO")
     end if RUBY18
-    
+
     it "should attempt to re-parse data as 8bit ascii if parsing fails" do
       log.should_not_receive(:warn)
       str = "\xB0"
@@ -94,26 +94,26 @@ describe YARD::CodeObjects::ExtraFileObject do
       file.contents.should == "\xB0"
     end
   end
-  
+
   describe '#name' do
     it "should be set to basename (not extension) of filename" do
       file = ExtraFileObject.new('file.txt', '')
       file.name.should == 'file'
     end
   end
-  
+
   describe '#title' do
     it "should return @title attribute if present" do
       file = ExtraFileObject.new('file.txt', '# @title FOO')
       file.title.should == 'FOO'
     end
-    
+
     it "should return #name if no @title attribute exists" do
       file = ExtraFileObject.new('file.txt', '')
       file.title.should == 'file'
     end
   end
-  
+
   describe '#==' do
     it "should define equality on filename alone" do
       file1 = ExtraFileObject.new('file.txt', 'A')
@@ -127,6 +127,6 @@ describe YARD::CodeObjects::ExtraFileObject do
       a |= [file2]
       a.size.should == 1
     end
-    
+
   end
 end

data/spec/code_objects/macro_object_spec.rb

@@ -1,10 +1,10 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
 describe YARD::CodeObjects::MacroObject do
-  before do 
-    Registry.clear 
+  before do
+    Registry.clear
   end
-  
+
   describe '.create' do
     def create(*args) MacroObject.create(*args) end
 
@@ -13,60 +13,55 @@ describe YARD::CodeObjects::MacroObject do
       obj = Registry.at('.macro.foo')
       obj.should_not be_nil
     end
-    
+
     it "should use identity map" do
       obj1 = create('foo', '')
       obj2 = create('foo', '')
       obj1.object_id.should == obj2.object_id
     end
-    
+
     it "should allow specifying of macro data" do
       obj = create('foo', 'MACRODATA')
       obj.macro_data.should == 'MACRODATA'
     end
-    
+
     it "should attach if a method object is provided" do
       obj = create('foo', 'MACRODATA', P('Foo.property'))
       obj.method_object.should == P('Foo.property')
       obj.should be_attached
     end
   end
-  
+
   describe '.find' do
     before { MacroObject.create('foo', 'DATA') }
-    
+
     it "should search for an object by name" do
       MacroObject.find('foo').macro_data.should == 'DATA'
     end
-    
+
     it "should accept Symbol" do
       MacroObject.find(:foo).macro_data.should == 'DATA'
     end
   end
-  
+
   describe '.find_or_create' do
-    it "should look up name if @macro is present and find object" do
+    it "should look up name if @!macro is present and find object" do
       macro1 = MacroObject.create('foo', 'FOO')
-      macro2 = MacroObject.find_or_create("@macro foo\na b c")
+      macro2 = MacroObject.find_or_create('foo', "a b c")
       macro1.should == macro2
     end
-    
+
     it "should create new macro if macro by that name does not exist" do
-      MacroObject.find_or_create("@macro foo\n  @method $1\nEXTRA")
-      MacroObject.find('foo').macro_data.should == "@method $1"
-    end
-    
-    it "should use full docstring if no text block is present in @macro" do
-      MacroObject.find_or_create("@macro foo\n@method $1\nEXTRA")
-      MacroObject.find('foo').macro_data.should == "EXTRA\n@method $1"
+      MacroObject.find_or_create('foo', "@!method $1")
+      MacroObject.find('foo').macro_data.should == "@!method $1"
     end
   end
-  
+
   describe '.apply' do
     before do
       @args = %w(foo a b c)
     end
-    
+
     def apply(comments)
       MacroObject.apply(comments, @args)
     end
@@ -76,31 +71,30 @@ describe YARD::CodeObjects::MacroObject do
     end
 
     it "should handle macro text inside block" do
-      apply("@macro name\n  foo$1$2$3\nfoobaz").should == "fooabc\nfoobaz"
+      apply("@!macro\n  foo$1$2$3\nfoobaz").should == "fooabc\nfoobaz"
     end
-    
+
     it "should append docstring to existing macro" do
       macro = MacroObject.create('name', '$3$2$1')
-      result = MacroObject.apply("@macro name\nfoobar", @args)
+      result = MacroObject.apply("@!macro name\nfoobar", @args)
       result.should == "cba\nfoobar"
     end
-    
+
     it "should use only non macro data if docstring is an existing macro" do
-      data = "@macro name\n  $3$2$1\nEXTRA"
-      MacroObject.find_or_create(data)
-      result = MacroObject.apply(data, @args)
+      data = "@!macro name\n  $3$2$1\nEXTRA"
+      result = MacroObject.apply(data, @args, 'SOURCE')
       result.should == "cba\nEXTRA"
-      MacroObject.apply("@macro name\nFOO", @args).should == "cba\nFOO"
+      MacroObject.apply("@!macro name\nFOO", @args).should == "cba\nFOO"
     end
-    
+
     it "should create macros if they don't exist" do
-      result = MacroObject.apply("@macro name\n  foo!$1", @args)
+      result = MacroObject.apply("@!macro name\n  foo!$1", @args, 'SOURCE')
       result.should == "foo!a"
       MacroObject.find('name').macro_data.should == 'foo!$1'
     end
-    
+
     it "should keep other tags" do
-      apply("@macro name\n  foo$1$2$3\n@param name foo\nfoo").should == 
+      apply("@!macro\n  foo$1$2$3\n@param name foo\nfoo").should ==
         "fooabc\nfoo\n@param name\n  foo"
     end
   end
@@ -139,15 +133,15 @@ describe YARD::CodeObjects::MacroObject do
     it "should handle negative indexes ($-N)" do
       expand("$-1 ${-2-} ${-2--2}").should == "c b, c b"
     end
-    
+
     it "should accept Docstring objects" do
       expand(Docstring.new("$1\n@param name foo")).should == "a\n@param name foo"
     end
   end
-  
+
   describe '#expand' do
     it "should expand macro given its data" do
-      macro = MacroObject.create_docstring("@macro foo\n  $1 $2 THREE!")
+      macro = MacroObject.create_docstring('foo', '$1 $2 THREE!')
       macro.expand(['NAME', 'ONE', 'TWO']).should == "ONE TWO THREE!"
     end
   end