vim-jar 0.0.3 → 0.1.0

data/bundler/ruby/1.8/gems/gherkin-2.2.9/spec/gherkin/shared/py_string_group.rb

@@ -0,0 +1,153 @@
+# encoding: utf-8
+require 'spec_helper'
+
+module Gherkin
+  module Lexer
+    shared_examples_for "a Gherkin lexer lexing py_strings" do
+      def scan(gherkin)
+        @lexer.scan(gherkin)
+      end
+
+      def ps(content)
+        '"""%s"""' % ("\n" + content + "\n")
+      end
+      
+      it "should provide the amount of indentation of the triple quotes to the listener" do
+str = <<EOS
+Feature: some feature
+  Scenario: some scenario
+    Given foo
+    """
+      Hello
+    Goodbye
+    """
+    Then bar
+EOS
+        @listener.should_receive(:py_string).with("  Hello\nGoodbye", 4)
+        scan(str)
+      end
+
+      it "should parse a simple py_string" do
+        @listener.should_receive(:py_string).with("I am a py_string", 1)
+        scan ps("I am a py_string")
+      end
+
+      it "should parse an empty py_string" do
+        @listener.should_receive(:py_string).with("", 4)
+        scan("Feature: Hi\nScenario: Hi\nGiven a step\n\"\"\"\n\"\"\"")
+      end
+
+      it "should treat a string containing only newlines as only newlines" do
+py_string = <<EOS
+"""
+
+
+
+"""
+EOS
+        @listener.should_receive(:py_string).with("\n\n", 1)
+        scan(py_string)
+      end
+      
+      it "should parse content separated by two newlines" do
+        scan ps("A\n\nB")
+        @listener.to_sexp.should == [
+          [:py_string, "A\n\nB", 1],
+          [:eof]
+        ]
+      end
+      
+      it "should parse a multiline string" do
+        @listener.should_receive(:py_string).with("A\nB\nC\nD", 1)
+        scan ps("A\nB\nC\nD")
+      end
+            
+      it "should ignore unescaped quotes inside the string delimeters" do
+        @listener.should_receive(:py_string).with("What does \"this\" mean?", 1)
+        scan ps('What does "this" mean?')
+      end
+      
+      it "should preserve whitespace within the triple quotes" do
+str = <<EOS
+    """
+      Line one
+ Line two
+    """
+EOS
+        @listener.should_receive(:py_string).with("  Line one\nLine two", 1)
+        scan(str)
+      end
+            
+      it "should preserve tabs within the content" do
+        @listener.should_receive(:py_string).with("I have\tsome tabs\nInside\t\tthe content", 1)
+        scan ps("I have\tsome tabs\nInside\t\tthe content")
+      end
+  
+      it "should handle complex py_strings" do
+py_string = <<EOS
+# Feature comment
+@one
+Feature: Sample
+
+  @two @three
+  Scenario: Missing
+    Given missing
+
+1 scenario (1 passed)
+1 step (1 passed)
+
+EOS
+        
+        @listener.should_receive(:py_string).with(py_string, 1)
+        scan ps(py_string)
+      end
+ 
+      it "should allow whitespace after the closing py_string delimiter" do
+str = <<EOS
+    """
+      Line one
+    """           
+EOS
+        @listener.should_receive(:py_string).with("  Line one", 1)
+        scan(str)
+      end
+
+      it "should preserve the last newline(s) at the end of a py_string" do
+str = <<EOS
+     """
+     PyString text
+
+
+     """
+EOS
+        @listener.should_receive(:py_string).with("PyString text\n\n",1)
+        scan(str)
+      end        
+
+      it "should preserve CRLFs within py_strings" do
+        @listener.should_receive(:py_string).with("Line one\r\nLine two\r\n", 1)
+        scan("\"\"\"\r\nLine one\r\nLine two\r\n\r\n\"\"\"")
+      end
+
+      it "should unescape escaped triple quotes" do
+str = <<EOS
+    """
+    \\"\\"\\"
+    """
+EOS
+        @listener.should_receive(:py_string).with('"""', 1)
+        scan(str)
+      end
+
+      it "should not unescape escaped single quotes" do
+str = <<EOS
+    """
+    \\" \\"\\"
+    """
+EOS
+        @listener.should_receive(:py_string).with('\" \"\"', 1)
+        scan(str)
+      end
+    end
+  end
+end

data/bundler/ruby/1.8/gems/gherkin-2.2.9/spec/gherkin/shared/row_group.rb

@@ -0,0 +1,120 @@
+# encoding: utf-8
+require 'spec_helper'
+
+module Gherkin
+  module Lexer
+    shared_examples_for "a Gherkin lexer lexing rows" do
+      def scan(gherkin)
+        @lexer.scan(gherkin)
+      end
+
+      rows = {
+        "|a|b|\n"        => %w{a b},
+        "|a|b|c|\n"      => %w{a b c},
+      }
+    
+      rows.each do |text, expected|
+        it "should parse #{text}" do
+          @listener.should_receive(:row).with(r(expected), 1)
+          scan(text.dup)
+        end
+      end
+
+      it "should parse a row with many cells" do
+        @listener.should_receive(:row).with(r(%w{a b c d e f g h i j k l m n o p}), 1)
+        scan("|a|b|c|d|e|f|g|h|i|j|k|l|m|n|o|p|\n")
+      end
+    
+      it "should parse multicharacter cell content" do
+        @listener.should_receive(:row).with(r(%w{foo bar}), 1)
+        scan("| foo | bar |\n")
+      end
+
+      it "should escape backslashed pipes" do
+        @listener.should_receive(:row).with(r(['|', 'the', '\a', '\\', '|\\|']), 1)
+        scan('| \| | the | \a | \\ |   \|\\\|    |' + "\n")
+      end
+    
+      it "should parse cells with spaces within the content" do
+        @listener.should_receive(:row).with(r(["Dill pickle", "Valencia orange"]), 1)
+        scan("| Dill pickle | Valencia orange |\n")
+      end
+      
+      it "should allow utf-8" do
+        scan(" | ůﻚ | 2 | \n")
+        @listener.to_sexp.should == [
+          [:row, ["ůﻚ", "2"], 1],
+          [:eof]
+        ]
+      end 
+
+      it "should allow utf-8 using should_receive" do
+        @listener.should_receive(:row).with(r(['繁體中文  而且','並且','繁體中文  而且','並且']), 1)
+        scan("| 繁體中文  而且|並且| 繁體中文  而且|並且|\n")
+      end
+
+      it "should parse a 2x2 table" do
+        @listener.should_receive(:row).with(r(%w{1 2}), 1)
+        @listener.should_receive(:row).with(r(%w{3 4}), 2)
+        scan("| 1 | 2 |\n| 3 | 4 |\n")
+      end
+
+      it "should parse a 2x2 table with empty cells" do
+        @listener.should_receive(:row).with(r(['1', '']), 1)
+        @listener.should_receive(:row).with(r(['', '4']), 2)
+        scan("| 1 |  |\n|| 4 |\n")
+      end
+
+      it "should parse a row with empty cells" do
+        @listener.should_receive(:row).with(r(['1', '']), 1).twice
+        scan("| 1 |  |\n")
+        scan("|1||\n")
+      end
+    
+      it "should parse a 1x2 table that does not end in a newline" do
+        @listener.should_receive(:row).with(r(%w{1 2}), 1)
+        scan("| 1 | 2 |")
+      end
+
+      it "should parse a row without spaces and with a newline" do
+        @listener.should_receive(:row).with(r(%w{1 2}), 1)
+        scan("|1|2|\n")
+      end
+      
+      it "should parse a row with whitespace after the rows" do
+        @listener.should_receive(:row).with(r(%w{1 2}), 1)
+        scan("| 1 | 2 | \n ")
+      end
+      
+      it "should parse a row with lots of whitespace" do
+        @listener.should_receive(:row).with(r(["abc", "123"]), 1)
+        scan("  \t| \t   abc\t| \t123\t \t\t| \t\t   \t \t\n  ")
+      end
+
+      it "should parse a table with a commented-out row" do
+        @listener.should_receive(:row).with(r(["abc"]), 1)
+        @listener.should_receive(:comment).with("#|123|", 2)
+        @listener.should_receive(:row).with(r(["def"]), 3)
+        scan("|abc|\n#|123|\n|def|\n") 
+      end
+      
+      it "should raise LexingError for rows that aren't closed" do
+        lambda { 
+          scan("|| oh hello \n") 
+        }.should raise_error(/Lexing error on line 1: '\|\| oh hello/)
+      end
+
+      it "should raise LexingError for rows that are followed by a comment" do
+        lambda { 
+          scan("|hi| # oh hello \n") 
+        }.should raise_error(/Lexing error on line 1: '\|hi\| # oh hello/)
+      end
+
+      it "should raise LexingError for rows that aren't closed" do
+        lambda { 
+          scan("|| oh hello \n  |Shoudn't Get|Here|") 
+        }.should raise_error(/Lexing error on line 1: '\|\| oh hello/)
+      end
+    end
+  end
+end

data/bundler/ruby/1.8/gems/gherkin-2.2.9/spec/gherkin/shared/tags_group.rb

@@ -0,0 +1,54 @@
+# encoding: utf-8
+require 'spec_helper'
+
+module Gherkin
+  module Lexer
+    shared_examples_for "a Gherkin lexer lexing tags" do
+      def scan(gherkin)
+        @lexer.scan(gherkin)
+      end
+
+      it "should lex a single tag" do
+        @listener.should_receive(:tag).with("@dog", 1)
+        scan("@dog\n")
+      end
+  
+      it "should lex multiple tags" do
+        @listener.should_receive(:tag).twice
+        scan("@dog @cat\n")
+      end
+  
+      it "should lex UTF-8 tags" do
+        @listener.should_receive(:tag).with("@シナリオテンプレート", 1)
+        scan("@シナリオテンプレート\n")
+      end
+        
+      it "should lex mixed tags" do
+        @listener.should_receive(:tag).with("@wip", 1).ordered
+        @listener.should_receive(:tag).with("@Значения", 1).ordered
+        scan("@wip @Значения\n")
+      end
+  
+      it "should lex wacky identifiers" do
+        @listener.should_receive(:tag).exactly(4).times
+        scan("@BJ-x98.77 @BJ-z12.33 @O_o" "@#not_a_comment\n")
+      end
+
+      # TODO: Ask on ML for opinions about this one
+      it "should lex tags without spaces between them?" do
+        @listener.should_receive(:tag).twice
+        scan("@one@two\n")
+      end
+    
+      it "should not lex tags beginning with two @@ signs" do
+        @listener.should_not_receive(:tag)
+        lambda { scan("@@test\n") }.should raise_error(/Lexing error on line 1/)
+      end
+    
+      it "should not lex a lone @ sign" do
+        @listener.should_not_receive(:tag)
+        lambda { scan("@\n") }.should raise_error(/Lexing error on line 1/)
+      end
+    end
+  end
+end

data/bundler/ruby/1.8/gems/gherkin-2.2.9/spec/gherkin/tag_expression_spec.rb

@@ -0,0 +1,137 @@
+require 'spec_helper'
+require 'gherkin/tag_expression'
+
+module Gherkin
+  describe TagExpression do
+    context "no tags" do
+      before(:each) do
+        @e = Gherkin::TagExpression.new([])
+      end
+
+      it "should match @foo" do
+        @e.eval(['@foo']).should == true
+      end
+
+      it "should match empty tags" do
+        @e.eval([]).should == true
+      end
+    end
+
+    context "@foo" do
+      before(:each) do
+        @e = Gherkin::TagExpression.new(['@foo'])
+      end
+
+      it "should match @foo" do
+        @e.eval(['@foo']).should == true
+      end
+
+      it "should not match @bar" do
+        @e.eval(['@bar']).should == false
+      end
+
+      it "should not match no tags" do
+        @e.eval([]).should == false
+      end
+    end
+
+    context "!@foo" do
+      before(:each) do
+        @e = Gherkin::TagExpression.new(['~@foo'])
+      end
+
+      it "should match @bar" do
+        @e.eval(['@bar']).should == true
+      end
+
+      it "should not match @foo" do
+        @e.eval(['@foo']).should == false
+      end
+    end
+
+    context "@foo || @bar" do
+      before(:each) do
+        @e = Gherkin::TagExpression.new(['@foo,@bar'])
+      end
+
+      it "should match @foo" do
+        @e.eval(['@foo']).should == true
+      end
+
+      it "should match @bar" do
+        @e.eval(['@bar']).should == true
+      end
+
+      it "should not match @zap" do
+        @e.eval(['@zap']).should == false
+      end
+    end
+
+    context "(@foo || @bar) && !@zap" do
+      before(:each) do
+        @e = Gherkin::TagExpression.new(['@foo,@bar', '~@zap'])
+      end
+
+      it "should match @foo" do
+        @e.eval(['@foo']).should == true
+      end
+
+      it "should not match @foo @zap" do
+        @e.eval(['@foo', '@zap']).should == false
+      end
+    end
+
+    context "(@foo:3 || !@bar:4) && @zap:5" do
+      before(:each) do
+        @e = Gherkin::TagExpression.new(['@foo:3,~@bar','@zap:5'])
+      end
+
+      it "should count tags for positive tags" do
+        rubify_hash(@e.limits).should == {'@foo' => 3, '@zap' => 5}
+      end
+
+      it "should match @foo @zap" do
+        @e.eval(['@foo', '@zap']).should == true
+      end
+    end
+
+    context "Parsing '@foo:3,~@bar', '@zap:5'" do
+      before(:each) do
+        @e = Gherkin::TagExpression.new([' @foo:3 , ~@bar ', ' @zap:5 '])
+      end
+
+      unless defined?(JRUBY_VERSION)
+        it "should split and trim (ruby implementation detail)" do
+          @e.__send__(:ruby_expression).should == "(!vars['@bar']||vars['@foo'])&&(vars['@zap'])"
+        end
+      end
+
+      it "should have limits" do
+        rubify_hash(@e.limits).should == {"@zap"=>5, "@foo"=>3}
+      end
+    end
+
+    context "Tag limits" do
+      it "should be counted for negative tags" do
+        @e = Gherkin::TagExpression.new(['~@todo:3'])
+        rubify_hash(@e.limits).should == {"@todo"=>3}
+      end
+
+      it "should be counted for positive tags" do
+        @e = Gherkin::TagExpression.new(['@todo:3'])
+        rubify_hash(@e.limits).should == {"@todo"=>3}
+      end
+
+      it "should raise an error for inconsistent limits" do
+        lambda do
+          @e = Gherkin::TagExpression.new(['@todo:3', '~@todo:4'])
+        end.should raise_error(/Inconsistent tag limits for @todo: 3 and 4/)
+      end
+
+      it "should allow duplicate consistent limits" do
+        @e = Gherkin::TagExpression.new(['@todo:3', '~@todo:3'])
+        rubify_hash(@e.limits).should == {"@todo"=>3}
+      end
+    end
+  end
+end

data/bundler/ruby/1.8/gems/gherkin-2.2.9/spec/spec_helper.rb

@@ -0,0 +1,69 @@
+require 'rubygems'
+require 'bundler'
+Bundler.setup
+
+require 'gherkin'
+require 'stringio'
+require 'gherkin/sexp_recorder'
+require 'gherkin/output_stream_string_io'
+require 'gherkin/java_libs'
+require 'gherkin/json'
+require 'gherkin/shared/lexer_group'
+require 'gherkin/shared/tags_group'
+require 'gherkin/shared/py_string_group'
+require 'gherkin/shared/row_group'
+
+module GherkinSpecHelper
+  def scan_file(file)
+    @lexer.scan(fixture(file))
+  end
+
+  def fixture(file)
+    File.new(File.dirname(__FILE__) + "/gherkin/fixtures/" + file).read
+  end
+
+  def rubify_hash(hash)
+    if defined?(JRUBY_VERSION)
+      h = {}
+      hash.keySet.each{|key| h[key] = hash[key]}
+      h
+    else
+      hash
+    end
+  end
+end
+
+RSpec.configure do |c|
+  c.include(GherkinSpecHelper)
+end
+
+# Allows comparison of Java List with Ruby Array (rows)
+RSpec::Matchers.define :r do |expected|
+  match do |row|
+    def row.inspect
+      "r " + self.map{|cell| cell}.inspect
+    end
+    row.map{|cell| cell}.should == expected
+  end
+end
+
+RSpec::Matchers.define :a do |expected|
+  match do |array|
+    def array.inspect
+      "a " + self.map{|e| e.to_sym}.inspect
+    end
+    array.map{|e| e.to_sym}.should == expected
+  end
+end
+
+RSpec::Matchers.define :sym do |expected|
+  match do |actual|
+    expected.to_s == actual.to_s
+  end
+end
+
+RSpec::Matchers.define :allow do |event|
+  match do |parser|
+    parser.expected.index(event)
+  end  
+end

data/bundler/ruby/1.8/gems/gherkin-2.2.9/tasks/bench/feature_builder.rb

@@ -0,0 +1,49 @@
+class StepsBuilder
+  def initialize
+    @steps = []
+  end
+
+  def step(content, generator)
+    @steps << "    Given #{content}"
+    if(rand(5) == 0)
+      cols = rand(8) + 1
+      rows = rand(10)
+      rows.times do
+        row = "      |"
+        cols.times do
+          row << generator.table_cell << "|"
+        end
+        @steps << row
+      end
+    end
+  end
+
+  def to_s
+    @steps.join("\n")
+  end
+end
+
+class FeatureBuilder
+  def initialize(name, &block)
+    @name = name
+    @scenarios = {}
+    block.call(self)
+  end
+
+  def scenario(name, &block)
+    @scenarios[name] = StepsBuilder.new
+    block.call(@scenarios[name])
+  end
+
+  def to_s
+    str = "Feature: #{@name}\n"
+    @scenarios.each do |scenario, steps|
+      str += "\n"
+      str += "  Scenario: #{scenario}\n"
+      str += steps.to_s
+      str += "\n"
+    end
+    str
+  end
+end
+

data/bundler/ruby/1.8/gems/gherkin-2.2.9/tasks/bench/generated/.gitignore

@@ -0,0 +1 @@
+*.feature

data/bundler/ruby/1.8/gems/gherkin-2.2.9/tasks/bench/null_listener.rb

@@ -0,0 +1,4 @@
+class NullListener
+  def method_missing(*args)
+  end
+end