gherkin 1.0.30-java → 2.0.0-java

data/spec/gherkin/shared/{py_string_spec.rb → py_string_group.rb}

@@ -1,10 +1,13 @@
 # encoding: utf-8
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+require 'spec_helper'
 
 module Gherkin
   module Lexer
     shared_examples_for "a Gherkin lexer lexing py_strings" do
-            
+      def scan(gherkin)
+        @lexer.scan(gherkin, "test.feature", 0)
+      end
+
       def ps(content)
         '"""%s"""' % ("\n" + content + "\n")
       end
@@ -21,17 +24,17 @@ Feature: some feature
     Then bar
 EOS
         @listener.should_receive(:py_string).with("  Hello\nGoodbye", 4)
-        @lexer.scan(str)
+        scan(str)
       end
 
       it "should parse a simple py_string" do
         @listener.should_receive(:py_string).with("I am a py_string", 1)
-        @lexer.scan ps("I am a py_string")
+        scan ps("I am a py_string")
       end
 
       it "should parse an empty py_string" do
         @listener.should_receive(:py_string).with("", 4)
-        @lexer.scan("Feature: Hi\nScenario: Hi\nGiven a step\n\"\"\"\n\"\"\"")
+        scan("Feature: Hi\nScenario: Hi\nGiven a step\n\"\"\"\n\"\"\"")
       end
 
       it "should treat a string containing only newlines as only newlines" do
@@ -43,12 +46,13 @@ py_string = <<EOS
 """
 EOS
         @listener.should_receive(:py_string).with("\n\n", 1)
-        @lexer.scan(py_string)
+        scan(py_string)
       end
       
       it "should parse content separated by two newlines" do
-        @lexer.scan ps("A\n\nB")
+        scan ps("A\n\nB")
         @listener.to_sexp.should == [
+          [:location, 'test.feature', 0],
           [:py_string, "A\n\nB", 1],
           [:eof]
         ]
@@ -56,12 +60,12 @@ EOS
       
       it "should parse a multiline string" do
         @listener.should_receive(:py_string).with("A\nB\nC\nD", 1)
-        @lexer.scan ps("A\nB\nC\nD")
+        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)
-        @lexer.scan ps('What does "this" mean?')
+        scan ps('What does "this" mean?')
       end
       
       it "should preserve whitespace within the triple quotes" do
@@ -72,12 +76,12 @@ str = <<EOS
     """
 EOS
         @listener.should_receive(:py_string).with("  Line one\nLine two", 1)
-        @lexer.scan(str)
+        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)
-        @lexer.scan ps("I have\tsome tabs\nInside\t\tthe content")
+        scan ps("I have\tsome tabs\nInside\t\tthe content")
       end
   
       it "should handle complex py_strings" do
@@ -96,7 +100,7 @@ Feature: Sample
 EOS
         
         @listener.should_receive(:py_string).with(py_string, 1)
-        @lexer.scan ps(py_string)
+        scan ps(py_string)
       end
  
       it "should allow whitespace after the closing py_string delimiter" do
@@ -106,7 +110,7 @@ str = <<EOS
     """           
 EOS
         @listener.should_receive(:py_string).with("  Line one", 1)
-        @lexer.scan(str)
+        scan(str)
       end
 
       it "should preserve the last newline(s) at the end of a py_string" do
@@ -118,12 +122,12 @@ str = <<EOS
      """
 EOS
         @listener.should_receive(:py_string).with("PyString text\n\n",1)
-        @lexer.scan(str)
+        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)
-        @lexer.scan("\"\"\"\r\nLine one\r\nLine two\r\n\r\n\"\"\"")
+        scan("\"\"\"\r\nLine one\r\nLine two\r\n\r\n\"\"\"")
       end
 
       it "should unescape escaped triple quotes" do
@@ -133,7 +137,7 @@ str = <<EOS
     """
 EOS
         @listener.should_receive(:py_string).with('"""', 1)
-        @lexer.scan(str)
+        scan(str)
       end
 
       it "should not unescape escaped single quotes" do
@@ -143,7 +147,7 @@ str = <<EOS
     """
 EOS
         @listener.should_receive(:py_string).with('\" \"\"', 1)
-        @lexer.scan(str)
+        scan(str)
       end
     end
   end

data/spec/gherkin/shared/{row_spec.rb → row_group.rb}

@@ -1,9 +1,13 @@
 # encoding: utf-8
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+require 'spec_helper'
 
 module Gherkin
   module Lexer
     shared_examples_for "a Gherkin lexer lexing rows" do
+      def scan(gherkin)
+        @lexer.scan(gherkin, "test.feature", 0)
+      end
+
       rows = {
         "|a|b|\n"        => %w{a b},
         "|a|b|c|\n"      => %w{a b c},
@@ -12,33 +16,34 @@ module Gherkin
       rows.each do |text, expected|
         it "should parse #{text}" do
           @listener.should_receive(:row).with(r(expected), 1)
-          @lexer.scan(text.dup)
+          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)
-        @lexer.scan("|a|b|c|d|e|f|g|h|i|j|k|l|m|n|o|p|\n")
+        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)
-        @lexer.scan("| foo | bar |\n")
+        scan("| foo | bar |\n")
       end
 
       it "should escape backslashed pipes" do
         @listener.should_receive(:row).with(r(['|', 'the', '\a', '\\', '|\\|']), 1)
-        @lexer.scan('| \| | the | \a | \\ |   \|\\\|    |' + "\n")
+        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)
-        @lexer.scan("| Dill pickle | Valencia orange |\n")
+        scan("| Dill pickle | Valencia orange |\n")
       end
       
       it "should allow utf-8" do
-        @lexer.scan(" | ůﻚ | 2 | \n")
+        scan(" | ůﻚ | 2 | \n")
         @listener.to_sexp.should == [
+          [:location, 'test.feature', 0],
           [:row, ["ůﻚ", "2"], 1],
           [:eof]
         ]
@@ -46,58 +51,70 @@ module Gherkin
 
       it "should allow utf-8 using should_receive" do
         @listener.should_receive(:row).with(r(['繁體中文  而且','並且','繁體中文  而且','並且']), 1)
-        @lexer.scan("| 繁體中文  而且|並且| 繁體中文  而且|並且|\n")
+        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)
-        @lexer.scan("| 1 | 2 |\n| 3 | 4 |\n")
+        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)
-        @lexer.scan("| 1 |  |\n|| 4 |\n")
+        scan("| 1 |  |\n|| 4 |\n")
       end
 
       it "should parse a row with empty cells" do
         @listener.should_receive(:row).with(r(['1', '']), 1).twice
-        @lexer.scan("| 1 |  |\n")
-        @lexer.scan("|1||\n")
+        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)
-        @lexer.scan("| 1 | 2 |")
+        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)
-        @lexer.scan("|1|2|\n")
+        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)
-        @lexer.scan("| 1 | 2 | \n ")
+        scan("| 1 | 2 | \n ")
       end
       
       it "should parse a row with lots of whitespace" do
         @listener.should_receive(:row).with(r(["abc", "123"]), 1)
-        @lexer.scan("  \t| \t   abc\t| \t123\t \t\t| \t\t   \t \t\n  ")
+        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)
-        @lexer.scan("|abc|\n#|123|\n|def|\n") 
+        scan("|abc|\n#|123|\n|def|\n") 
       end
       
       it "should raise LexingError for rows that aren't closed" do
         lambda { 
-          @lexer.scan("|| oh hello \n") 
-        }.should raise_error(/Parsing error on line 1: '|| oh hello/)
+          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

data/spec/gherkin/shared/{tags_spec.rb → tags_group.rb}

@@ -1,49 +1,53 @@
 # encoding: utf-8
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+require 'spec_helper'
 
 module Gherkin
   module Lexer
     shared_examples_for "a Gherkin lexer lexing tags" do
+      def scan(gherkin)
+        @lexer.scan(gherkin, "test.feature", 0)
+      end
+
       it "should lex a single tag" do
         @listener.should_receive(:tag).with("@dog", 1)
-        @lexer.scan("@dog\n")
+        scan("@dog\n")
       end
   
       it "should lex multiple tags" do
         @listener.should_receive(:tag).twice
-        @lexer.scan("@dog @cat\n")
+        scan("@dog @cat\n")
       end
   
       it "should lex UTF-8 tags" do
         @listener.should_receive(:tag).with("@シナリオテンプレート", 1)
-        @lexer.scan("@シナリオテンプレート\n")
+        scan("@シナリオテンプレート\n")
       end
         
       it "should lex mixed tags" do
         @listener.should_receive(:tag).with("@wip", 1).ordered
         @listener.should_receive(:tag).with("@Значения", 1).ordered
-        @lexer.scan("@wip @Значения\n")
+        scan("@wip @Значения\n")
       end
   
       it "should lex wacky identifiers" do
         @listener.should_receive(:tag).exactly(4).times
-        @lexer.scan("@BJ-x98.77 @BJ-z12.33 @O_o" "@#not_a_comment\n")
+        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
-        @lexer.scan("@one@two\n")
+        scan("@one@two\n")
       end
     
       it "should not lex tags beginning with two @@ signs" do
         @listener.should_not_receive(:tag)
-        lambda { @lexer.scan("@@test\n") }.should raise_error(/Lexing error on line 1/)
+        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 { @lexer.scan("@\n") }.should raise_error(/Lexing error on line 1/)
+        lambda { scan("@\n") }.should raise_error(/Lexing error on line 1/)
       end
     end
   end

data/spec/spec_helper.rb

@@ -1,43 +1,23 @@
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'spec/gherkin'))
 require 'gherkin'
 require 'stringio'
 require 'gherkin/sexp_recorder'
+require 'gherkin/output_stream_string_io'
 require 'rubygems'
-require 'spec'
-require 'spec/autorun'
-require 'shared/lexer_spec'
-require 'shared/tags_spec'
-require 'shared/py_string_spec'
-require 'shared/row_spec'
-
-if defined?(JRUBY_VERSION)
-  class OutputStreamStringIO < Java.java.io.ByteArrayOutputStream
-    def rewind
-    end
-
-    def read
-      toString("UTF-8")
-    end
-  end
-end
-
-class StringIO
-  class << self
-    def new
-      if defined?(JRUBY_VERSION)
-        OutputStreamStringIO.new
-      else
-        super
-      end
-    end
-  end
-end
+require 'rspec/autorun'
+require 'gherkin/shared/lexer_group'
+require 'gherkin/shared/tags_group'
+require 'gherkin/shared/py_string_group'
+require 'gherkin/shared/row_group'
 
 module GherkinSpecHelper
+  # TODO: Rename to gherkin_scan_file
   def scan_file(file)
-    @lexer.scan(File.new(File.dirname(__FILE__) + "/gherkin/fixtures/" + file).read)
+    @lexer.scan(File.new(File.dirname(__FILE__) + "/gherkin/fixtures/" + file).read, file, 0)
+  end
+
+  # TODO: Remove
+  def parse_file(file)
+    @parser.parse(File.new(File.dirname(__FILE__) + "/gherkin/fixtures/" + file).read)
   end
 
   def rubify_hash(hash)
@@ -51,12 +31,12 @@ module GherkinSpecHelper
   end
 end
 
-Spec::Runner.configure do |c|
+RSpec.configure do |c|
   c.include(GherkinSpecHelper)
 end
 
 # Allows comparison of Java List with Ruby Array (rows)
-Spec::Matchers.define :r do |expected|
+RSpec::Matchers.define :r do |expected|
   match do |row|
     def row.inspect
       "r " + self.map{|cell| cell}.inspect
@@ -65,7 +45,7 @@ Spec::Matchers.define :r do |expected|
   end
 end
 
-Spec::Matchers.define :a do |expected|
+RSpec::Matchers.define :a do |expected|
   match do |array|
     def array.inspect
       "a " + self.map{|e| e.to_sym}.inspect
@@ -74,13 +54,13 @@ Spec::Matchers.define :a do |expected|
   end
 end
 
-Spec::Matchers.define :sym do |expected|
+RSpec::Matchers.define :sym do |expected|
   match do |actual|
     expected.to_s == actual.to_s
   end
 end
 
-Spec::Matchers.define :allow do |event|
+RSpec::Matchers.define :allow do |event|
   match do |parser|
     parser.expected.index(event)
   end  

data/tasks/bench.rake

@@ -111,7 +111,7 @@ class Benchmarker
     parser = Gherkin::Parser::Parser.new(NullListener.new, true, "root")
     lexer = Gherkin::I18nLexer.new(parser, true)
     @features.each do |feature|
-      lexer.scan(File.read(feature))
+      lexer.scan(File.read(feature), feature, 0)
     end
   end
 
@@ -122,7 +122,7 @@ class Benchmarker
     parser = Gherkin::Parser::Parser.new(NullListener.new, true, "root")
     lexer = Gherkin::I18nLexer.new(parser, false)
     @features.each do |feature|
-      lexer.scan(File.read(feature))
+      lexer.scan(File.read(feature), feature, 0)
     end
   end
 
@@ -132,7 +132,7 @@ class Benchmarker
     require 'null_listener'
     lexer = Gherkin::I18nLexer.new(NullListener.new, false)
     @features.each do |feature|
-      lexer.scan(File.read(feature))
+      lexer.scan(File.read(feature), feature, 0)
     end
   end
 end