nutshell-crm 0.0.1 → 0.0.2

data/vendor/bundle/gems/yard-0.7.4/spec/parser/examples/parse_in_order_002.rb.txt

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

data/vendor/bundle/gems/yard-0.7.4/spec/parser/examples/tag_handler_001.rb.txt

@@ -0,0 +1,8 @@
+class Foo
+
+  # @api public
+  # @return nil
+  def foo
+  end
+
+end

data/vendor/bundle/gems/yard-0.7.4/spec/parser/ruby/ast_node_spec.rb

@@ -0,0 +1,33 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
+require 'pp'
+require 'stringio'
+
+include YARD::Parser::Ruby
+
+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
+  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)
+      vcall = RUBY_VERSION >= '1.9.3' ? 'vcall' : 'var_ref'
+      out.string.should == "s(s(:#{vcall},\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 if HAVE_RIPPER

data/vendor/bundle/gems/yard-0.7.4/spec/parser/ruby/legacy/statement_list_spec.rb

@@ -0,0 +1,299 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'spec_helper')
+
+describe YARD::Parser::Ruby::Legacy::StatementList do
+  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
+      if
+          foo
+        puts 'hi'
+      end
+eof
+
+    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 ||
+          bar
+        puts 'hi'
+      end
+eof
+
+    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(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; 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
+
+  it "should allow continued processing after a block" do
+    s = stmt "if foo; end.stuff"
+    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(true).should == "if foo; end[stuff]"
+    s.block.to_s.should == ""
+
+    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(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(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(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(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(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(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
+    s = stmt <<-eof
+      foo do
+        puts 'hi'
+      end
+    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 { ... }"
+    s.block.to_s.should == "y"
+
+    s = stmt "x() { y }"
+    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
+
+  it "should not parse hashes as blocks" do
+    s = stmt "x({})"
+    s.tokens.to_s(true).should == "x({})"
+    s.block.to_s.should == ""
+
+    s = stmt "x = {}"
+    s.tokens.to_s(true).should == "x = {}"
+    s.block.to_s.should == ""
+
+    s = stmt "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(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(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
+  
+  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
+      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)
+    s.source.should == '"foo\n\n"'
+  end
+end

data/vendor/bundle/gems/yard-0.7.4/spec/parser/ruby/legacy/token_list_spec.rb

@@ -0,0 +1,69 @@
+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 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 "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)
+    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
+  
+  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/vendor/bundle/gems/yard-0.7.4/spec/parser/ruby/ruby_parser_spec.rb

@@ -0,0 +1,257 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
+
+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
+
+        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 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"
+
+      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("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]
+    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)
+      t = tokenize(src)
+      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)
+      t = tokenize(src)
+      s.source.should == src
+      t.map {|x| x[1] }.join.should == src
+    end
+
+    it "should show proper source for heredoc with comment" do
+      src = "def foo\n  x = <<-XML # HI!\n  Hello \#{name}!\n  Bye!\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)
+        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
+    end
+
+    it "should parse %w() array in constant declaration" do
+      s = stmt(<<-eof)
+        class Foo
+          FOO = %w( foo bar )
+        end
+      eof
+      s.jump(:qwords_literal).source.should == '%w( foo bar )'
+      if RUBY_VERSION >= '1.9.3' # ripper fix: array node encapsulates qwords
+        s.jump(:array).source.should == '%w( foo bar )'
+      end
+    end
+    
+    it "should parse [] as array" do
+      s = stmt(<<-eof)
+        class Foo
+          FOO = ['foo', 'bar']
+        end
+      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
+
+    it "should show source for unary exclamation" do
+      stmt("X = !1").jump(:unary).source.should == '!1'
+    end
+  end
+end if HAVE_RIPPER