yard 0.6.4 → 0.6.5

data/spec/handlers/private_constant_handler_spec.rb

@@ -0,0 +1,24 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}PrivateConstantHandler" do
+  before(:all) { parse_file :private_constant_handler_001, __FILE__ }
+
+  it "should handle private_constant statement" do
+    Registry.at('A::Foo').visibility.should == :private
+    Registry.at('A::B').visibility.should == :private
+    Registry.at('A::C').visibility.should == :private
+  end
+  
+  it "should make all other constants public" do
+    Registry.at('A::D').visibility.should == :public
+  end
+  
+  it "should fail if parameter is not String, Symbol or Constant" do
+    undoc_error 'class Foo; private_constant x; end'
+    undoc_error 'class Foo; X = 1; private_constant X.new("hi"); end'
+  end unless LEGACY_PARSER
+  
+  it "should fail if constant can't be recognized" do
+    undoc_error 'class Foo2; private_constant :X end'
+  end
+end

data/spec/handlers/process_handler_spec.rb

@@ -1,6 +1,6 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
-describe "YARD::Handlers::Ruby::#{RUBY18 ? "Legacy::" : ""}ProcessHandler" do
+describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ProcessHandler" do
   before(:all) { parse_file :process_handler_001, __FILE__ }
 
   it "should only work for classes that extend YARD::Handlers::*" do

data/spec/handlers/ruby/base_spec.rb

@@ -32,7 +32,7 @@ describe YARD::Handlers::Ruby::Base, '#valid_handler?' do
       handles "x"
     end
     Handlers::Base.stub!(:subclasses).and_return [StringHandler]
-    ast = RubyParser.parse("if x == 2 then true end").ast
+    ast = Parser::Ruby::RubyParser.parse("if x == 2 then true end").ast
     valid StringHandler, ast[0][0][0]
     invalid StringHandler, ast[0][1]
   end
@@ -51,7 +51,7 @@ describe YARD::Handlers::Ruby::Base, '#valid_handler?' do
       handles %r{^if x ==}
     end
     Handlers::Base.stub!(:subclasses).and_return [RegexHandler]
-    ast = RubyParser.parse("if x == 2 then true end").ast
+    ast = Parser::Ruby::RubyParser.parse("if x == 2 then true end").ast
     valid RegexHandler, ast
     invalid RegexHandler, ast[0][1]
   end
@@ -70,7 +70,7 @@ describe YARD::Handlers::Ruby::Base, '#valid_handler?' do
       handles method_call(:meth)
     end
     Handlers::Base.stub!(:subclasses).and_return [MethCallHandler]
-    ast = RubyParser.parse(<<-"eof").ast
+    ast = Parser::Ruby::RubyParser.parse(<<-"eof").ast
       meth                   # 0
       meth()                 # 1
       meth(1,2,3)            # 2
@@ -87,4 +87,4 @@ describe YARD::Handlers::Ruby::Base, '#valid_handler?' do
     end
     invalid MethCallHandler, ast[9]
   end
-end if RUBY19
+end if HAVE_RIPPER

data/spec/handlers/visibility_handler_spec.rb

@@ -1,6 +1,6 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
-describe "YARD::Handlers::Ruby::#{RUBY18 ? "Legacy::" : ""}VisibilityHandler" do
+describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}VisibilityHandler" do
   before(:all) { parse_file :visibility_handler_001, __FILE__ }
   
   it "should be able to set visibility to public" do

data/spec/handlers/yield_handler_spec.rb

@@ -1,6 +1,6 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
-describe "YARD::Handlers::Ruby::#{RUBY18 ? "Legacy::" : ""}YieldHandler" do
+describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}YieldHandler" do
   before(:all) { parse_file :yield_handler_001, __FILE__ }
   
   it "should only parse yield blocks in methods" do

data/spec/parser/base_spec.rb

@@ -2,16 +2,14 @@ require File.join(File.dirname(__FILE__), '..', 'spec_helper')
 
 describe YARD::Parser::Base do
   describe '#initialize' do
-    before do
-      class MyParser < Parser::Base; def initialize(a, b) end end
-    end
+    class MyParser < Parser::Base; def initialize(a, b) end end
     
     it "should take 2 arguments" do
-      lambda { Parser::Base.new }.should raise_error(ArgumentError, /wrong (number|#) of arguments/)
+      lambda { YARD::Parser::Base.new }.should raise_error(ArgumentError, /wrong (number|#) of arguments/)
     end
     
     it "should raise NotImplementedError on #initialize" do
-      lambda { Parser::Base.new('a', 'b') }.should raise_error(NotImplementedError)
+      lambda { YARD::Parser::Base.new('a', 'b') }.should raise_error(NotImplementedError)
     end
 
     it "should raise NotImplementedError on #parse" do

data/spec/parser/c_parser_spec.rb

@@ -1,5 +1,5 @@
 require File.join(File.dirname(__FILE__), '..', 'spec_helper')
-require 'continuation' unless RUBY18
+begin require 'continuation'; rescue LoadError; end unless RUBY18
 
 describe YARD::Parser::CParser do
   before(:all) do

data/spec/parser/ruby/ast_node_spec.rb

@@ -4,32 +4,29 @@ require 'stringio'
 
 include YARD::Parser::Ruby
 
-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
-      end
+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
     end
-    
-    describe '#pretty_print' do
-      it "should show a list of nodes" do
-        obj = YARD::Parser::Ruby::RubyParser.parse("# x\nbye", "x").ast
-        out = StringIO.new
-        PP.pp(obj, out)
-        out.rewind
-        out.read.should == "s(s(:var_ref,\n" +
-          "      s(:ident, \"bye\", line: 2..2, source: 4..6),\n" +
-          "      docstring: \"x\",\n" +
-          "      line: 2..2,\n" +
-          "      source: 4..6))\n"
-      end
+  end
+  
+  describe '#pretty_print' do
+    it "should show a list of nodes" do
+      obj = YARD::Parser::Ruby::RubyParser.parse("# x\nbye", "x").ast
+      out = StringIO.new
+      PP.pp(obj, out)
+      out.string.should == "s(s(:var_ref,\n" +
+        "      s(:ident, \"bye\", line: 2..2, source: 4..6),\n" +
+        "      docstring: \"x\",\n" +
+        "      line: 2..2,\n" +
+        "      source: 4..6))\n"
     end
   end
-end
+end if HAVE_RIPPER

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

@@ -282,6 +282,15 @@ eof
     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
+      class B; end
+    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/ruby_parser_spec.rb

@@ -1,200 +1,202 @@
 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
-    
-    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
-          # 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
-      
-      it "should only look up to two lines back for comments" do
-        s = stmt <<-eof
-          # comments
+describe YARD::Parser::Ruby::RubyParser do
+  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
+        # 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
+    
+    it "should only look up to two lines back for comments" do
+      s = stmt <<-eof
+        # comments
 
-          # comments
+        # comments
 
-          def method; end
-        eof
-        s.comments.should == "comments"
+        def method; end
+      eof
+      s.comments.should == "comments"
 
-        s = stmt <<-eof
-          # comments
+      s = stmt <<-eof
+        # comments
 
 
-          def method; end
-        eof
-        s.comments.should == nil
+        def method; end
+      eof
+      s.comments.should == nil
 
-        ss = stmts <<-eof
-          # comments
+      ss = stmts <<-eof
+        # comments
 
 
-          def method; end
+        def method; end
 
-          # hello
-          def method2; end
-        eof
-        ss[0].comments.should == nil
-        ss[1].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"
+        # hello
+        def method2; end
+      eof
+      ss[0].comments.should == nil
+      ss[1].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
         
-        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 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"
       
-      it "should handle begin/rescue blocks" do
-        ast = stmt("begin; X; rescue => e; Y end").jump(:rescue)
-        ast.source.should == "rescue => e; Y end"
+      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"
 
-        ast = stmt("begin; X; rescue A => e; Y end").jump(:rescue)
-        ast.source.should == "rescue A => e; Y end"
+      ast = stmt("begin; X; rescue A => e; Y end").jump(:rescue)
+      ast.source.should == "rescue A => e; Y end"
 
-        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 ]'
+      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 ]'
 
-        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"
-        s.should be_ref
-        s.jump(:top_const_ref).should be_ref
-        s.source.should == "::\nFoo::Bar"
-        s.line_range.to_a.should == [1, 2]
+      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
-      
-      it "should show proper source for heredoc" do
-        src = "def foo\n  foo(<<-XML, 1, 2)\n    bar\n\n  XML\nend"
+    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"
+      s.should be_ref
+      s.jump(:top_const_ref).should be_ref
+      s.source.should == "::\nFoo::Bar"
+      s.line_range.to_a.should == [1, 2]
+    end
+    
+    it "should show proper source for heredoc" do
+      src = "def foo\n  foo(<<-XML, 1, 2)\n    bar\n\n  XML\nend"
+      s = stmt(src)
+      t = tokenize(src)
+      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}"
         s = stmt(src)
-        t = tokenize(src)
+        s.jump(:string_content)[0].should == "hello\n\nworld"
         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}"
-          s = stmt(src)
-          s.source.should == src
-        end
-      end
+      src = '("this is a string")'
+      stmt(src).jump(:string_literal).source.should == '"this is a string"'
     end
   end
-end
+end if HAVE_RIPPER