yard 0.2.3 → 0.2.3.2

data/spec/handlers/ruby/legacy/base_spec.rb

@@ -50,4 +50,29 @@ describe YARD::Handlers::Ruby::Legacy::Base, "#handles and inheritance" do
     TestTokenHandler.handles?(stmt("module")).should be_true
     TestTokenHandler.handles?(stmt("if")).should be_false
   end
+  
+  it "should parse a do/end or { } block with #parse_block" do
+    class MyBlockHandler < Handlers::Ruby::Legacy::Base
+      handles /\AmyMethod\b/
+      def process
+        parse_block(:owner => "test")
+      end
+    end
+    
+    class MyBlockInnerHandler < Handlers::Ruby::Legacy::Base
+      handles "inner"
+      def self.reset; @@reached = false end
+      def self.reached?; @@reached ||= false end
+      def process; @@reached = true end
+    end
+    
+    Handlers::Base.stub!(:subclasses).and_return [MyBlockHandler, MyBlockInnerHandler]
+    Parser::SourceParser.parser_type = :ruby18
+    Parser::SourceParser.parse_string "myMethod do inner end"
+    MyBlockInnerHandler.should be_reached
+    MyBlockInnerHandler.reset
+    Parser::SourceParser.parse_string "myMethod { inner }"
+    MyBlockInnerHandler.should be_reached
+    Parser::SourceParser.parser_type = :ruby
+  end
 end

data/spec/parser/examples/parse_in_order_001.rb.txt

@@ -0,0 +1,2 @@
+class MyModule::MyClass
+end

data/spec/parser/examples/parse_in_order_002.rb.txt

@@ -0,0 +1,2 @@
+module MyModule
+end

data/spec/parser/ruby/ast_node_spec.rb

@@ -2,14 +2,18 @@ require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
 
 include YARD::Parser::Ruby
 
-describe YARD::Parser::Ruby::AstNode, "#jump" do
-  it "should jump to the first specific inner node if found" do
-    ast = s(:paren, s(:paren, s(:params, s(s(:ident, "hi"), s(:ident, "bye")))))
-    ast.jump(:params)[0][0].type.should equal(:ident)
-  end
+if RUBY19
+  describe YARD::Parser::Ruby::AstNode do
+    describe "#jump" do
+      it "should jump to the first specific inner node if found" do
+        ast = s(:paren, s(:paren, s(:params, s(s(:ident, "hi"), s(:ident, "bye")))))
+        ast.jump(:params)[0][0].type.should equal(:ident)
+      end
   
-  it "should return the original ast if no inner node is found" do
-    ast = s(:paren, s(:list, s(:list, s(s(:ident, "hi"), s(:ident, "bye")))))
-    ast.jump(:params).object_id.should == ast.object_id
+      it "should return the original ast if no inner node is found" do
+        ast = s(:paren, s(:list, s(:list, s(s(:ident, "hi"), s(:ident, "bye")))))
+        ast.jump(:params).object_id.should == ast.object_id
+      end
+    end
   end
-end if RUBY19
+end

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

@@ -1,7 +1,8 @@
 require File.join(File.dirname(__FILE__), '..', '..', '..', 'spec_helper')
 
 describe YARD::Parser::Ruby::Legacy::StatementList do
-  def stmt(code) YARD::Parser::Ruby::Legacy::StatementList.new(code).first end
+  def stmts(code) YARD::Parser::Ruby::Legacy::StatementList.new(code) end
+  def stmt(code) stmts(code).first end
 
   it "should parse dangling block expressions" do
     s = stmt <<-eof
@@ -11,8 +12,9 @@ describe YARD::Parser::Ruby::Legacy::StatementList do
       end
 eof
 
-    s.tokens.to_s.should == "if          foo"
-    s.block.to_s.should == "\n        puts 'hi'\n      end\n"
+    s.tokens.to_s(true).should == "if\n          foo\n        ...\n      end"
+    s.tokens.to_s.should == "if\n          foo"
+    s.block.to_s.should == "puts 'hi'"
 
     s = stmt <<-eof
       if foo ||
@@ -21,64 +23,72 @@ eof
       end
 eof
 
-    s.tokens.to_s.should == "if foo ||          bar"
-    s.block.to_s.should == "\n        puts 'hi'\n      end\n"
+    s.tokens.to_s(true).should == "if foo ||\n          bar\n        ...\n      end"
+    s.tokens.to_s.should == "if foo ||\n          bar"
+    s.block.to_s.should == "puts 'hi'"
   end
 
   it "should allow semicolons within parentheses" do
     s = stmt "(foo; bar)"
 
-    s.tokens.to_s.should == "(foo; bar)"
-    s.block.to_s.should == ""
+    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)"
+    s.block.should be_nil
   end
 
   it "should allow block statements to be used as part of other block statements" do
-    s = stmt "while (foo; bar); foo = 12; end"
+    s = stmt "while (foo; bar); foo = 12; end; while"
 
+    s.tokens.to_s(true).should == "while (foo; bar); ... end"
     s.tokens.to_s.should == "while (foo; bar)"
-    s.block.to_s.should == " foo = 12; end\n"
+    s.block.to_s.should == "foo = 12"
   end
 
   it "should allow continued processing after a block" do
     s = stmt "if foo; end.stuff"
-    s.tokens.to_s.should == "if foo"
-    s.block.to_s.should == " end.stuff\n"
+    s.tokens.to_s(true).should == "if foo; end.stuff"
+    s.block.to_s.should == ""
 
     s = stmt "if foo; end[stuff]"
-    s.tokens.to_s.should == "if foo"
-    s.block.to_s.should == " end[stuff]\n"
+    s.tokens.to_s(true).should == "if foo; end[stuff]"
+    s.block.to_s.should == ""
 
-    s = stmt "if foo; end.map do; 123; end"
-    s.tokens.to_s.should == "if foo"
-    s.block.to_s.should == " end.map do; 123; end\n"
+    s = stmt "if foo; hi end.map do; 123; end"
+    s.tokens.to_s(true).should == "if foo; ... end.map do; 123; end"
+    s.block.to_s.should == "hi"
   end
 
   it "should parse default arguments" do
     s = stmt "def foo(bar, baz = 1, bang = 2); bar; end"
-    s.tokens.to_s.should == "def foo(bar, baz = 1, bang = 2)"
-    s.block.to_s.should == " bar; end\n"
+    s.tokens.to_s(true).should == "def foo(bar, baz = 1, bang = 2) ... end"
+    s.block.to_s.should == "bar"
 
     s = stmt "def foo bar, baz = 1, bang = 2; bar; end"
-    s.tokens.to_s.should == "def foo bar, baz = 1, bang = 2"
-    s.block.to_s.should == " bar; end\n"
+    s.tokens.to_s(true).should == "def foo bar, baz = 1, bang = 2; ... end"
+    s.block.to_s.should == "bar"
 
     s = stmt "def foo bar , baz = 1 , bang = 2; bar; end"
-    s.tokens.to_s.should == "def foo bar , baz = 1 , bang = 2"
-    s.block.to_s.should == " bar; end\n"
+    s.tokens.to_s(true).should == "def foo bar , baz = 1 , bang = 2; ... end"
+    s.block.to_s.should == "bar"
   end
 
   it "should parse complex default arguments" do
     s = stmt "def foo(bar, baz = File.new(1, 2), bang = 3); bar; end"
-    s.tokens.to_s.should == "def foo(bar, baz = File.new(1, 2), bang = 3)"
-    s.block.to_s.should == " bar; end\n"
+    s.tokens.to_s(true).should == "def foo(bar, baz = File.new(1, 2), bang = 3) ... end"
+    s.block.to_s.should == "bar"
 
     s = stmt "def foo bar, baz = File.new(1, 2), bang = 3; bar; end"
-    s.tokens.to_s.should == "def foo bar, baz = File.new(1, 2), bang = 3"
-    s.block.to_s.should == " bar; end\n"
+    s.tokens.to_s(true).should == "def foo bar, baz = File.new(1, 2), bang = 3; ... end"
+    s.block.to_s.should == "bar"
 
     s = stmt "def foo bar , baz = File.new(1, 2) , bang = 3; bar; end"
-    s.tokens.to_s.should == "def foo bar , baz = File.new(1, 2) , bang = 3"
-    s.block.to_s.should == " bar; end\n"
+    s.tokens.to_s(true).should == "def foo bar , baz = File.new(1, 2) , bang = 3; ... end"
+    s.block.to_s.should == "bar"
   end
 
   it "should parse blocks with do/end" do
@@ -88,58 +98,126 @@ eof
       end
     eof
 
-    s.tokens.to_s.should == "foo "
-    s.block.to_s.should == "do\n        puts 'hi'\n      end\n"
+    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.should == "x "
-    s.block.to_s.should == "{ y }\n"
+    s.tokens.to_s(true).should == "x { ... }"
+    s.block.to_s.should == "y"
 
     s = stmt "x() { y }"
-    s.tokens.to_s.should == "x() "
-    s.block.to_s.should == "{ y }\n"
+    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.should == ""
-    s.block.to_s.should == "begin xyz end\n"
+    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.should == "foo(:x) "
-    s.block.to_s.should == "{ baz(:y) { skippy } }\n"
+    s.tokens.to_s(true).should == "foo(:x) { ... }"
+    s.block.to_s.should == "baz(:y) { skippy }"
   end
 
   it "should not parse hashes as blocks" do
     s = stmt "x({})"
-    s.tokens.to_s.should == "x({})"
+    s.tokens.to_s(true).should == "x({})"
     s.block.to_s.should == ""
 
     s = stmt "x = {}"
-    s.tokens.to_s.should == "x = {}"
+    s.tokens.to_s(true).should == "x = {}"
     s.block.to_s.should == ""
 
     s = stmt "x(y, {})"
-    s.tokens.to_s.should == "x(y, {})"
+    s.tokens.to_s(true).should == "x(y, {})"
     s.block.to_s.should == ""
   end
 
   it "should parse hashes in blocks with {}" do
     s = stmt "x {x = {}}"
 
-    s.tokens.to_s.should == "x "
-    s.block.to_s.should == "{x = {}}\n"
+    s.tokens.to_s(true).should == "x {...}"
+    s.block.to_s.should == "x = {}"
   end
 
   it "should parse blocks with {} in hashes" do
     s = stmt "[:foo, x {}]"
 
-    s.tokens.to_s.should == "[:foo, x {}]"
+    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
+      def b; end
+    eof
+    s.to_s.should == "def %; end"
+  end
+  
+  it "should handle nested methods" do
+    s = stmt <<-eof
+      def *(o) def +@; end
+        def ~@
+        end end
+    eof
+    s.tokens.to_s(true).should == "def *(o) ... end"
+    s.block.to_s.should == "def +@; end\n        def ~@\n        end"
+
+    s = stmts(<<-eof)
+      def /(other) 'hi' end
+      def method1
+        def dynamic; end
+      end
+    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
+      # comment
+      # comment
+      def method; end
+    eof
+    s.comments.should == ["comment", "comment", "comment"]
+    s.comments_range.should == (1..3)
+
+    s = stmt <<-eof
+
+      # comment
+      # comment
+      def method; end
+    eof
+    s.comments.should == ["comment", "comment"]
+    s.comments_range.should == (2..3)
+
+    s = stmt <<-eof
+      # comment
+      # comment
+
+      def method; end
+    eof
+    s.comments.should == ["comment", "comment"]
+    s.comments_range.should == (1..2)
+
+    s = stmt <<-eof
+      # comment
+      def method; end
+    eof
+    s.comments.should == ["comment"]
+    s.comments_range.should == (1..1)
+
+    s = stmt <<-eof
+      def method; end # comment
+    eof
+    s.comments.should == ["comment"]
+    s.comments_range.should == (1..1)
+  end
 end

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

@@ -3,33 +3,67 @@ require File.join(File.dirname(__FILE__), '..', '..', '..', 'spec_helper')
 include YARD::Parser::Ruby::Legacy
 include YARD::Parser::Ruby::Legacy::RubyToken
 
-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
-  end
+describe YARD::Parser::Ruby::Legacy::TokenList do
+  describe  "#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
+    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 "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
-    x.push("x", "=", "2")
-    x.size.should == 6
-    x.to_s.should == "x\n=\n2\n"
-  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
+      x.push("x", "=", "2")
+      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)
+    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
+      x[4].class.should == TkDSTRING
+      x.to_s.should == 'x = "hello #{world}"' + "\n"
+    end
   end
   
-  it "should not interpolate string data" do
-    x = TokenList.new('x = "hello #{world}"')
-    x.size.should == 6
-    x[4].class.should == TkDSTRING
-    x.to_s.should == 'x = "hello #{world}"' + "\n"
+  describe '#to_s' do
+    before do
+      @t = TokenList.new
+      @t << TkDEF.new(1, 1, "def")
+      @t << TkSPACE.new(1, 1)
+      @t << TkIDENTIFIER.new(1, 1, "x")
+      @t << TkStatementEnd.new(1, 1)
+      @t << TkSEMICOLON.new(1, 1) << TkSPACE.new(1, 1)
+      @t << TkBlockContents.new(1, 1)
+      @t << TkSPACE.new(1, 1) << TkEND.new(1, 1, "end")
+      @t[0].set_text "def"
+      @t[1].set_text " "
+      @t[2].set_text "x"
+      @t[4].set_text ";"
+      @t[5].set_text " "
+      @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
+
+    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
   end
 end

data/spec/parser/ruby/ruby_parser_spec.rb

@@ -0,0 +1,53 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
+
+if RUBY19
+  describe YARD::Parser::Ruby::RubyParser do
+    def stmt(stmt) 
+      YARD::Parser::Ruby::RubyParser.new(stmt, nil).parse.root.first
+    end
+    
+    describe '#parse' do
+      it "should get comment line numbers" do
+        s = stmt <<-eof
+          # comment
+          # comment
+          # comment
+          def method; end
+        eof
+        s.comments.should == "comment\ncomment\ncomment"
+        s.comments_range.should == (1..3)
+
+        s = stmt <<-eof
+
+          # comment
+          # comment
+          def method; end
+        eof
+        s.comments.should == "comment\ncomment"
+        s.comments_range.should == (2..3)
+
+        s = stmt <<-eof
+          # comment
+          # comment
+
+          def method; end
+        eof
+        s.comments.should == "comment\ncomment"
+        s.comments_range.should == (1..2)
+
+        s = stmt <<-eof
+          # comment
+          def method; end
+        eof
+        s.comments.should == "comment"
+        s.comments_range.should == (1..1)
+
+        s = stmt <<-eof
+          def method; end # comment
+        eof
+        s.comments.should == "comment"
+        s.comments_range.should == (1..1)
+      end
+    end
+  end
+end