yard 0.7.5 → 0.8.0

data/spec/parser/examples/extrafile.c.txt

@@ -1,4 +1,4 @@
-/* 
+/*
  * foo
  */
 VALUE

data/spec/parser/examples/override.c.txt

@@ -406,7 +406,7 @@ void init_gmpz()
   // Integer Arithmetic
   rb_define_method(cGMP_Z, "+",       r_gmpz_add, 1);
   rb_define_method(cGMP_Z, "add!",    r_gmpz_add_self, 1);
-  rb_define_method(cGMP_Z, "-",       r_gmpz_sub, 1);  
+  rb_define_method(cGMP_Z, "-",       r_gmpz_sub, 1);
   rb_define_method(cGMP_Z, "sub!",    r_gmpz_sub_self, 1);
   rb_define_method(cGMP_Z, "*",       r_gmpz_mul, 1);
   rb_define_method(cGMP_Z, "addmul!", r_gmpz_addmul_self, 2);

data/spec/parser/ruby/ast_node_spec.rb

@@ -16,7 +16,7 @@ describe YARD::Parser::Ruby::AstNode do
       ast.jump(:params).object_id.should == ast.object_id
     end
   end
-  
+
   describe '#pretty_print' do
     it "should show a list of nodes" do
       obj = YARD::Parser::Ruby::RubyParser.parse("# x\nbye", "x").ast

data/spec/parser/ruby/legacy/statement_list_spec.rb

@@ -34,7 +34,7 @@ eof
     s.tokens.to_s(true).should == "(foo; bar)"
     s.block.should be_nil
   end
-  
+
   it "should allow for non-block statements" do
     s = stmt "hello_world(1, 2, 3)"
     s.tokens.to_s.should == "hello_world(1, 2, 3)"
@@ -101,7 +101,7 @@ eof
     s.tokens.to_s(true).should == "foo do\n        ...\n      end"
     s.block.to_s.should == "puts 'hi'"
   end
-  
+
   it "should parse blocks with {}" do
     s = stmt "x { y }"
     s.tokens.to_s(true).should == "x { ... }"
@@ -111,16 +111,16 @@ eof
     s.tokens.to_s(true).should == "x() { ... }"
     s.block.to_s.should == "y"
   end
-  
+
   it "should parse blocks with begin/end" do
     s = stmt "begin xyz end"
     s.tokens.to_s(true).should == "begin ... end"
     s.block.to_s.should == "xyz"
   end
-  
+
   it "should parse nested blocks" do
     s = stmt "foo(:x) { baz(:y) { skippy } }"
-    
+
     s.tokens.to_s(true).should == "foo(:x) { ... }"
     s.block.to_s.should == "baz(:y) { skippy }"
   end
@@ -152,7 +152,7 @@ eof
     s.tokens.to_s(true).should == "[:foo, x {}]"
     s.block.to_s.should == ""
   end
-  
+
   it "should handle multiple methods" do
     s = stmt <<-eof
       def %; end
@@ -160,7 +160,7 @@ eof
     eof
     s.to_s.should == "def %; end"
   end
-  
+
   it "should handle nested methods" do
     s = stmt <<-eof
       def *(o) def +@; end
@@ -178,7 +178,7 @@ eof
     eof
     s[1].to_s.should == "def method1\n        def dynamic; end\n      end"
   end
-  
+
   it "should get comment line numbers" do
     s = stmt <<-eof
       # comment
@@ -220,68 +220,68 @@ eof
     s.comments.should == ["comment"]
     s.comments_range.should == (1..1)
   end
-  
+
   it "should only look up to two lines back for comments" do
     s = stmt <<-eof
       # comments
-      
+
       # comments
-      
+
       def method; end
     eof
     s.comments.should == ["comments"]
-    
+
     s = stmt <<-eof
       # comments
-      
-      
+
+
       def method; end
     eof
     s.comments.should == nil
 
     ss = stmts <<-eof
       # comments
-      
-      
+
+
       def method; end
-      
+
       # hello
       def method2; end
     eof
     ss[0].comments.should == nil
     ss[1].comments.should == ['hello']
   end
-  
+
   it "should handle CRLF (Windows) newlines" do
     s = stmts("require 'foo'\r\n\r\n# Test Test\r\n# \r\n# Example:\r\n#   example code\r\ndef test\r\nend\r\n")
     s[1].comments.should == ['Test Test', '', 'Example:', '  example code']
   end
-  
+
   it "should handle elsif blocks" do
     s = stmts(stmt("if 0\n  foo\nelsif 2\n  bar\nend\nbaz").block)
     s.size.should == 2
     s[1].tokens.to_s.should == "elsif 2"
     s[1].block.to_s.should == "bar"
   end
-  
+
   it "should handle else blocks" do
     s = stmts(stmt("if 0\n  foo\nelse\n  bar\nend\nbaz").block)
     s.size.should == 2
     s[1].tokens.to_s.should == "else"
     s[1].block.to_s.should == "bar"
   end
-  
+
   it "should allow aliasing keywords" do
     ['do x', 'x do', 'end begin', 'begin end'].each do |a|
       s = stmt("alias #{a}\ndef foo; end")
       s.tokens.to_s.should == "alias #{a}"
       s.block.should be_nil
     end
-    
+
     s = stmt("alias do x if 2 ==\n 2")
     s.tokens.to_s.should == "alias do x if 2 ==\n 2"
   end
-  
+
   it "should not open a block on an aliased keyword block opener" do
     s = stmts(<<-eof)
       class A; alias x do end
@@ -290,7 +290,7 @@ eof
     s[0].block.to_s.should == 'alias x do'
     s.size.should > 1
   end
-  
+
   it "should convert heredoc to string" do
     src = "<<-XML\n  foo\n\nXML"
     s = stmt(src)

data/spec/parser/ruby/legacy/token_list_spec.rb

@@ -9,12 +9,12 @@ describe YARD::Parser::Ruby::Legacy::TokenList do
       lambda { TokenList.new(TokenList.new) }.should_not raise_error(ArgumentError)
       TokenList.new.push(TokenList.new("x = 2")).size.should == 6
     end
-  
+
     it "accept a token (via constructor or push)" do
       lambda { TokenList.new(Token.new(0, 0)) }.should_not raise_error(ArgumentError)
       TokenList.new.push(Token.new(0, 0), Token.new(1, 1)).size.should == 2
     end
-  
+
     it "should accept a string and parse it as code (via constructor or push)" do
       lambda { TokenList.new("x = 2") }.should_not raise_error(ArgumentError)
       x = TokenList.new
@@ -22,11 +22,11 @@ describe YARD::Parser::Ruby::Legacy::TokenList do
       x.size.should == 6
       x.to_s.should == "x\n=\n2\n"
     end
-  
+
     it "should not accept any other input" do
       lambda { TokenList.new(:notcode) }.should raise_error(ArgumentError)
     end
-  
+
     it "should not interpolate string data" do
       x = TokenList.new('x = "hello #{world}"')
       x.size.should == 6
@@ -34,7 +34,7 @@ describe YARD::Parser::Ruby::Legacy::TokenList do
       x.to_s.should == 'x = "hello #{world}"' + "\n"
     end
   end
-  
+
   describe '#to_s' do
     before do
       @t = TokenList.new
@@ -53,7 +53,7 @@ describe YARD::Parser::Ruby::Legacy::TokenList do
       @t[7].set_text " "
       @t[8].set_text "end"
     end
-    
+
     it "should only show the statement portion of the tokens by default" do
       @t.to_s.should == "def x"
     end
@@ -61,7 +61,7 @@ describe YARD::Parser::Ruby::Legacy::TokenList do
     it "should show ... for the block token if all of the tokens are shown" do
       @t.to_s(true).should == "def x; ... end"
     end
-    
+
     it "should ignore ... if show_block = false" do
       @t.to_s(true, false).should == "def x;  end"
     end

data/spec/parser/ruby/ruby_parser_spec.rb

@@ -1,18 +1,18 @@
 require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
 
 describe YARD::Parser::Ruby::RubyParser do
-  def stmt(stmt) 
+  def stmt(stmt)
     YARD::Parser::Ruby::RubyParser.new(stmt, nil).parse.root.first
   end
-  
+
   def stmts(stmts)
     YARD::Parser::Ruby::RubyParser.new(stmts, nil).parse.root
   end
-  
+
   def tokenize(stmt)
     YARD::Parser::Ruby::RubyParser.new(stmt, nil).parse.tokens
   end
-  
+
   describe '#parse' do
     it "should get comment line numbers" do
       s = stmt <<-eof
@@ -55,24 +55,24 @@ describe YARD::Parser::Ruby::RubyParser do
       s.comments.should == "comment"
       s.comments_range.should == (1..1)
     end
-    
+
     it "should only look up to two lines back for comments" do
-      s = stmt <<-eof
+      s = stmts <<-eof
         # comments
 
         # comments
 
         def method; end
       eof
-      s.comments.should == "comments"
+      s[1].comments.should == "comments"
 
-      s = stmt <<-eof
+      s = stmts <<-eof
         # comments
 
 
         def method; end
       eof
-      s.comments.should == nil
+      s[1].comments.should == nil
 
       ss = stmts <<-eof
         # comments
@@ -83,52 +83,52 @@ describe YARD::Parser::Ruby::RubyParser do
         # hello
         def method2; end
       eof
-      ss[0].comments.should == nil
-      ss[1].comments.should == 'hello'
+      ss[1].comments.should == nil
+      ss[2].comments.should == 'hello'
     end
-    
+
     it "should handle 1.9 lambda syntax with args" do
       src = "->(a,b,c=1,*args,&block) { hello_world }"
       stmt(src).source.should == src
     end
-    
+
     it "should handle 1.9 lambda syntax" do
       src = "-> { hello_world }"
       stmt(src).source.should == src
     end
-        
+
     it "should handle standard lambda syntax" do
       src = "lambda { hello_world }"
       stmt(src).source.should == src
     end
-    
+
     it "should throw a ParserSyntaxError on invalid code" do
       lambda { stmt("Foo, bar.") }.should raise_error(YARD::Parser::ParserSyntaxError)
     end
-    
+
     it "should handle bare hashes as method parameters" do
       src = "command :a => 1, :b => 2, :c => 3"
       stmt(src).jump(:command)[1].source.should == ":a => 1, :b => 2, :c => 3"
-      
+
       src = "command a: 1, b: 2, c: 3"
       stmt(src).jump(:command)[1].source.should == "a: 1, b: 2, c: 3"
     end
-    
+
     it "should handle source for hash syntax" do
       src = "{ :a => 1, :b => 2, :c => 3 }"
       stmt(src).jump(:hash).source.should == "{ :a => 1, :b => 2, :c => 3 }"
     end
-    
+
     it "should handle an empty hash" do
       stmt("{}").jump(:hash).source.should == "{}"
     end
-    
+
     it "new hash label syntax should show label without colon" do
       ast = stmt("{ a: 1 }").jump(:label)
       ast[0].should == "a"
       ast.source.should == "a:"
     end
-    
+
     it "should handle begin/rescue blocks" do
       ast = stmt("begin; X; rescue => e; Y end").jump(:rescue)
       ast.source.should == "rescue => e; Y end"
@@ -139,19 +139,19 @@ describe YARD::Parser::Ruby::RubyParser do
       ast = stmt("begin; X; rescue A, B => e; Y end").jump(:rescue)
       ast.source.should == "rescue A, B => e; Y end"
     end
-    
+
     it "should handle method rescue blocks" do
       ast = stmt("def x; A; rescue Y; B end")
       ast.source.should == "def x; A; rescue Y; B end"
       ast.jump(:rescue).source.should == "rescue Y; B end"
     end
-    
+
     it "should handle defs with keywords as method name" do
       ast = stmt("# docstring\nclass A;\ndef class; end\nend")
       ast.jump(:class).docstring.should == "docstring"
       ast.jump(:class).line_range.should == (2..4)
     end
-    
+
     it "should end source properly on array reference" do
       ast = stmt("AS[0, 1 ]   ")
       ast.source.should == 'AS[0, 1 ]'
@@ -159,17 +159,17 @@ describe YARD::Parser::Ruby::RubyParser do
       ast = stmt("def x(a = S[1]) end").jump(:default_arg)
       ast.source.should == 'a = S[1]'
     end
-    
+
     it "should end source properly on if/unless mod" do
       %w(if unless while).each do |mod|
         stmt("A=1 #{mod} true").source.should == "A=1 #{mod} true"
       end
     end
-    
+
     it "should show proper source for assignment" do
       stmt("A=1").jump(:assign).source.should == "A=1"
     end
-    
+
     it "should show proper source for a top_const_ref" do
       s = stmt("::\nFoo::Bar")
       s.jump(:top_const_ref).source.should == "::\nFoo"
@@ -178,7 +178,7 @@ describe YARD::Parser::Ruby::RubyParser do
       s.source.should == "::\nFoo::Bar"
       s.line_range.to_a.should == [1, 2]
     end
-    
+
     it "should show proper source for inline heredoc" do
       src = "def foo\n  foo(<<-XML, 1, 2)\n    bar\n\n  XML\nend"
       s = stmt(src)
@@ -186,7 +186,7 @@ describe YARD::Parser::Ruby::RubyParser do
       s.source.should == src
       t.map {|x| x[1] }.join.should == src
     end
-    
+
     it "should show proper source for regular heredoc" do
       src = "def foo\n  x = <<-XML\n  Hello \#{name}!\n  Bye!\n  XML\nend"
       s = stmt(src)
@@ -202,7 +202,7 @@ describe YARD::Parser::Ruby::RubyParser do
       s.source.should == src
       t.map {|x| x[1] }.join.should == src
     end
-    
+
     it "should show proper source for string" do
       ["'", '"'].each do |q|
         src = "#{q}hello\n\nworld#{q}"
@@ -210,16 +210,16 @@ describe YARD::Parser::Ruby::RubyParser do
         s.jump(:string_content).source.should == "hello\n\nworld"
         s.source.should == src
       end
-      
+
       src = '("this is a string")'
       stmt(src).jump(:string_literal).source.should == '"this is a string"'
     end
-    
+
     it "should show proper source for %w() array" do
       src = "%w(\na b c\n d e f\n)"
       stmt(src).jump(:qwords_literal).source.should == src
     end
-    
+
     it "should show proper source for %w{} array" do
       src = "%w{\na b c\n d e f\n}"
       stmt(src).jump(:array).source.should == src
@@ -261,7 +261,7 @@ describe YARD::Parser::Ruby::RubyParser do
       eof
       s.jump(:array).source.should == "['foo', 'bar']"
     end
-    
+
     it "should show source for unary minus" do
       stmt("X = - 1").jump(:unary).source.should == '- 1'
     end
@@ -269,5 +269,27 @@ describe YARD::Parser::Ruby::RubyParser do
     it "should show source for unary exclamation" do
       stmt("X = !1").jump(:unary).source.should == '!1'
     end
+
+    it "should find lone comments" do
+      Registry.clear
+      ast = YARD.parse_string(<<-eof).enumerator
+        class Foo
+          ##
+          # comment here
+
+
+          def foo; end
+
+          # end comment
+        end
+      eof
+      comment = ast.first.last.first
+      comment.type.should == :comment
+      comment.docstring_hash_flag.should be_true
+      comment.docstring.strip.should == "comment here"
+
+      ast.first.last.last.type.should == :comment
+      ast.first.last.last.docstring.should == "end comment"
+    end
   end
 end if HAVE_RIPPER