gherkin 1.0.30-java → 2.0.0-java

data/spec/gherkin/i18n_spec.rb

@@ -1,5 +1,5 @@
 #encoding: utf-8
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'spec_helper'
 
 module Gherkin
   module Lexer
@@ -9,16 +9,17 @@ module Gherkin
       end
 
       def scan_file(lexer, file)
-        lexer.scan(File.new(File.dirname(__FILE__) + "/fixtures/" + file).read)
+        lexer.scan(File.new(File.dirname(__FILE__) + "/fixtures/" + file).read, file, 0)
       end
 
       it "should recognize keywords in the language of the lexer" do
         lexer = Gherkin::I18nLexer.new(@listener, false)
         scan_file(lexer, "i18n_no.feature")
         @listener.to_sexp.should == [
+          [:location, "i18n_no.feature", 0],
           [:comment, "#language:no", 1],
-          [:feature, "Egenskap", "i18n support", 2],
-          [:scenario, "Scenario", "Parsing many languages", 4],
+          [:feature, "Egenskap", "i18n support", "", 2],
+          [:scenario, "Scenario", "Parsing many languages", "", 4],
           [:step, "Gitt ", "Gherkin supports many languages", 5],
           [:step, "Når ",  "Norwegian keywords are parsed", 6],
           [:step, "Så ", "they should be recognized", 7],
@@ -30,9 +31,10 @@ module Gherkin
         lexer = Gherkin::I18nLexer.new(@listener, false)
         scan_file(lexer, "i18n_zh-CN.feature")
         @listener.to_sexp.should == [
+          [:location, "i18n_zh-CN.feature", 0],
           [:comment, "#language:zh-CN", 1],
-          [:feature, "功能", "加法", 2],
-          [:scenario, "场景", "两个数相加", 4],
+          [:feature, "功能", "加法", "", 2],
+          [:scenario, "场景", "两个数相加", "", 4],
           [:step, "假如", "我已经在计算器里输入6", 5],
           [:step, "而且", "我已经在计算器里输入7", 6],
           [:step, "当", "我按相加按钮", 7],
@@ -45,15 +47,16 @@ module Gherkin
         lexer = Gherkin::I18nLexer.new(@listener, false)
         scan_file(lexer, "i18n_fr.feature")
         @listener.to_sexp.should == [
+          [:location, "i18n_fr.feature", 0],
           [:comment, "#language:fr", 1],
-          [:feature, "Fonctionnalité", "Addition", 2],
-          [:scenario_outline, "Plan du scénario", "Addition de produits dérivés", 3],
+          [:feature, "Fonctionnalité", "Addition", "", 2],
+          [:scenario_outline, "Plan du scénario", "Addition de produits dérivés", "", 3],
           [:step, "Soit ", "une calculatrice", 4],
           [:step, "Etant donné ", "qu'on tape <a>", 5],
           [:step, "Et ", "qu'on tape <b>", 6],
           [:step, "Lorsqu'", "on tape additionner", 7],
           [:step, "Alors ", "le résultat doit être <somme>", 8],
-          [:examples, "Exemples", "", 10],
+          [:examples, "Exemples", "", "", 10],
           [:row, %w{a b somme}, 11],
           [:row, %w{2 2 4}, 12],
           [:row, %w{2 3 5}, 13],
@@ -68,6 +71,10 @@ module Gherkin
           end
         end
 
+        it "should report keyword regexp" do
+          Gherkin::I18n.keyword_regexp(:step).should =~ /\|Quando \|Quand \|Quan \|Pryd \|Pokud \|/
+        end
+
         unless defined?(JRUBY_VERSION)
         it "should print available languages" do
           ("\n" + Gherkin::I18n.language_table).should == %{

data/spec/gherkin/java_lexer_spec.rb

@@ -1,7 +1,6 @@
 #encoding: utf-8
 if defined?(JRUBY_VERSION)
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-require 'gherkin.jar'
+require 'spec_helper'
 
 module Gherkin
   module JavaLexer

data/spec/gherkin/output_stream_string_io.rb

@@ -0,0 +1,24 @@
+if defined?(JRUBY_VERSION)
+  class OutputStreamStringIO < Java.java.io.ByteArrayOutputStream
+    def write(what)
+      if String === what
+        super(Java.java.lang.String.new(what).getBytes("UTF-8"))
+      else
+        super(what)
+      end
+    end
+
+    def string
+      toString("UTF-8")
+    end
+  end
+
+  require 'stringio'
+  class StringIO
+    class << self
+      def new
+        OutputStreamStringIO.new
+      end
+    end
+  end
+end

data/spec/gherkin/parser/filter_listener_spec.rb

@@ -1,6 +1,7 @@
 # encoding: utf-8
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+require 'spec_helper'
 require 'gherkin/parser/filter_listener'
+require 'gherkin/parser/formatter_listener'
 require 'gherkin/formatter/pretty_formatter'
 require 'stringio'
 
@@ -11,8 +12,12 @@ module Gherkin
       class LineListener
         attr_reader :lines
         
+        def location(uri, offset)
+        end
+        
         def method_missing(*sexp_args)
           @lines ||= []
+          raise "Hmm" if sexp_args == [:eof, []]
           @lines << sexp_args[-1]
         end
       end
@@ -25,16 +30,17 @@ module Gherkin
 
       def verify_output(expected_output, filters)
         io = StringIO.new
-        scan(Gherkin::Formatter::PrettyFormatter.new(io, true), filters)
-        io.rewind
-        io.read.should == expected_output
+        formatter = Gherkin::Formatter::PrettyFormatter.new(io, true)
+        listener = Gherkin::Parser::FormatterListener.new(formatter)
+        scan(listener, filters)
+        io.string.should == expected_output
       end
 
       def scan(listener, filters)
-        filter_listener = FilterListener.new(listener, filters)
+        filter_listener = Gherkin::Parser::FilterListener.new(listener, filters)
         parser = Gherkin::Parser::Parser.new(filter_listener, true, "root")
         lexer  = Gherkin::I18nLexer.new(parser, true)
-        lexer.scan(@input)
+        lexer.scan(@input, "test.feature", 0)
       end
 
       context "Scenario" do
@@ -195,8 +201,8 @@ Feature: 2
 
       context "Scenario Outline" do
         before do
-          @input = %{Feature: 1
-
+          @input = %{Feature: Fname
+  Fdesc
   @tag3
   Scenario Outline: 4
     Given <foo> 5
@@ -252,7 +258,8 @@ Feature: 2
         end
 
         it "should replay itself properly" do
-          filtered = %{Feature: 1
+          filtered = %{Feature: Fname
+  Fdesc
 
   @tag3
   Scenario Outline: 4

data/spec/gherkin/parser/formatter_listener_spec.rb

@@ -0,0 +1,134 @@
+require 'spec_helper'
+require 'gherkin/parser/formatter_listener'
+require 'gherkin/parser/parser'
+require 'gherkin/parser/row'
+require 'gherkin/i18n_lexer'
+require 'stringio'
+
+module Gherkin
+  module Parser
+    describe FormatterListener do
+      before do
+        @formatter = Gherkin::SexpRecorder.new
+        @fl = Gherkin::Parser::FormatterListener.new(@formatter)
+        @lexer = Gherkin::I18nLexer.new(Gherkin::Parser::Parser.new(@fl))
+      end
+      
+      it "should pass tags to #feature method" do
+        @fl.tag("@hello", 1)
+        @fl.feature("Feature", "awesome", "description", 2)
+        @fl.eof
+
+        @formatter.to_sexp.should == [
+          [:feature, [], ["@hello"], "Feature", "awesome", "description", nil],
+          [:eof]
+        ]
+      end
+
+      it "should pass comments to #feature method" do
+        @fl.comment("# comment", 1)
+        @fl.feature("Feature", "awesome", "description", 2)
+        @fl.eof
+
+        @formatter.to_sexp.should == [
+          [:feature, ["# comment"], [], "Feature", "awesome", "description", nil],
+          [:eof]
+        ]
+      end
+
+      it "should pass comments and tags to #feature and #scenario methods" do
+        @fl.comment("# one", 1)
+        @fl.tag("@two", 2)
+        @fl.feature("Feature", "three", "feature description", 3)
+        @fl.comment("# four", 4)
+        @fl.tag("@five", 5)
+        @fl.scenario("Scenario", "six", "scenario description", 6)
+        @fl.eof
+
+        @formatter.to_sexp.should == [
+          [:feature,  ["# one"],  ["@two"],  "Feature",  "three", "feature description", nil],
+          [:scenario, ["# four"], ["@five"], "Scenario", "six", "scenario description", 6],
+          [:eof]
+        ]
+      end
+
+      it "should replay step table" do
+        @fl.step("Given ", "foo", 10)
+        @fl.row(['yo'], 11)
+        @fl.comment("# Hello", 12)
+        @fl.comment("# World", 13)
+        @fl.row(['bro'], 14)
+        @fl.eof
+
+        @formatter.to_sexp.should == [
+          [:step, [], "Given ",  "foo", 10, [
+            {"line"=>11, "comments"=>[], "cells"=>["yo"]}, 
+            {"line"=>14, "comments"=>["# Hello", "# World"], "cells"=>["bro"]}
+          ], nil, nil, nil, nil],
+          [:eof]
+        ]
+      end
+
+      it "should format an entire feature" do
+        @lexer.scan(File.new(File.dirname(__FILE__) + "/../fixtures/complex.feature").read, "complex.feature", 0)
+        @formatter.to_sexp.should == [
+          [:feature, ["#Comment on line 1", "#Comment on line 2"], ["@tag1", "@tag2"],
+            "Feature",
+            "Feature Text",
+            "In order to test multiline forms\nAs a ragel writer\nI need to check for complex combinations",
+            "complex.feature"],
+          [:background, ["#Comment on line 9", "#Comment on line 11"], "Background", "", "", 13],
+          [:step, [], "Given ", "this is a background step", 14, nil, nil, nil, nil, nil],
+          [:step, [], "And ", "this is another one", 15, nil, nil, nil, nil, nil],
+          [:scenario, [], ["@tag3", "@tag4"], "Scenario", "Reading a Scenario", "", 18],
+          [:step, [], "Given ", "there is a step", 19, nil, nil, nil, nil, nil],
+          [:step, [], "But ", "not another step", 20, nil, nil, nil, nil, nil],
+          [:scenario, [], ["@tag3"], "Scenario", "Reading a second scenario", "With two lines of text", 23],
+          [:step, ["#Comment on line 24"], "Given ", "a third step with a table", 26, [
+            {
+              "comments" => [],
+              "line" => 27,
+              "cells" => ["a", "b"]
+            }, 
+            {
+              "comments" => [],
+              "line" => 28,
+              "cells" => ["c", "d"]
+            }, 
+            {
+              "comments" => [],
+              "line" => 29,
+              "cells" => ["e", "f"]
+            } ], nil, nil, nil, nil],
+          [:step, [], "And ", "I am still testing things", 30, [
+            {
+              "comments" => [],
+              "line" => 31,
+              "cells" => ["g", "h"]
+            }, 
+            {
+              "comments" => [],
+              "line" => 32,
+              "cells" => ["e", "r"]
+            }, 
+            {
+              "comments" => [],
+              "line" => 33,
+              "cells" => ["k", "i"]
+            }, 
+            {
+              "comments" => [],
+              "line" => 34,
+              "cells" => ["n", ""]
+            } ], nil, nil, nil, nil],
+          [:step, [], "And ", "I am done testing these tables", 35, nil, nil, nil, nil, nil],
+          [:step, ["#Comment on line 29"], "Then ", "I am happy", 37, nil, nil, nil, nil, nil],
+          [:scenario, [], [], "Scenario", "Hammerzeit", "", 39],
+          [:step, [], "Given ", "All work and no play", 40, "Makes Homer something something\nAnd something else", nil, nil, nil, nil],
+          [:step, [], "Then ", "crazy", 45, nil, nil, nil, nil, nil],
+          [:eof]
+        ]
+      end
+    end
+  end
+end

data/spec/gherkin/parser/json_parser_spec.rb

@@ -0,0 +1,129 @@
+#encoding: utf-8
+require 'spec_helper'
+require 'gherkin/parser/json_parser'
+
+module Gherkin
+  module Parser
+    describe JSONParser do 
+
+      before do
+        @listener = Gherkin::SexpRecorder.new
+        @parser = Gherkin::Parser::JSONParser.new(@listener)
+      end
+
+      describe "An empty feature" do
+        it "should parse empty features" do
+          @parser.parse('{}')
+          @listener.to_sexp.should == [
+            [:eof]
+          ]
+        end
+      end
+
+      describe "A barely empty feature" do
+        it "should parse a feature with no elements" do
+          @parser.parse('{ "name" : "One", "line" : 3 }')
+          @listener.to_sexp.should == [
+            [:feature, "Feature", "One", 3],
+            [:eof]
+          ]
+        end
+      end
+
+      describe "Determining language" do
+        it "should pick up the i18n language from attributes" do
+          @parser.parse('{ "language" : "fr" }')
+          @parser.i18n_language.iso_code.should == "fr"
+        end
+
+        it "should default to English if no language is found" do
+          @parser.parse('{ "name": "A Featuer" }')
+          @parser.i18n_language.iso_code.should == "en"
+        end
+      end
+
+      describe "Missing line numbers" do
+        it "should indicate a line number of 0 if a line attribute doesn't exist" do
+          @parser.parse('{ "name" : "My Sweet Featur" }')
+          @listener.to_sexp.should == [
+            [:feature, "Feature", "My Sweet Featur", 0],
+            [:eof]
+          ]
+        end
+
+        it "should use line number from file_colon_line if exists" do
+          @parser.parse('{ "name" : "My Sweet Featur", 
+                           "file_colon_line": "my_nice_feature.js:12" }')
+          @listener.to_sexp.should == [
+            [:feature, "Feature", "My Sweet Featur", 12],
+            [:eof]
+          ]
+        end
+      end
+
+      describe "Keywords" do
+        it "should use the keyword from the source when provided" do
+          @parser.parse('{ "name" : "My Sweet Featur", "language": "fr", "keyword": "Feature" }')
+          @listener.to_sexp.should == [
+            [:feature, "Feature", "My Sweet Featur", 0],
+            [:eof]
+          ]
+        end
+
+        it "should use a default keyword from the i18n_language if no keyword is provided" do
+          @parser.parse('{ "name" : "My Sweet Featur", "language": "fr" }')
+          @listener.to_sexp.should == [
+            [:feature, "Fonctionnalité", "My Sweet Featur", 0],
+            [:eof]
+          ]
+          
+        end
+      end
+
+      describe "A complex feature with tags, comments, multiple scenarios, and multiple steps and tables" do
+        it "should find things in the right order" do
+          parse_file("complex.js")
+          @listener.to_sexp.should == [
+            [:tag, "@tag1", 0],
+            [:tag, "@tag2", 0],
+            [:feature, "Feature", "Feature Text\nIn order to test multiline forms", 0],
+            [:background, "Background", "", 0],
+            [:step, "Given ", "this is a background step", 0],
+            [:step, "When ", "this is another one", 412],
+            [:tag, "@foo", 0],
+            [:scenario_outline, "Scenario Outline", "An Scenario Outline", 0],
+            [:step, "Given ", "A step with a table", 0],
+            [:row, %w{a row for a step}, 0],
+            [:tag, "@exampletag", 0],
+            [:examples, "Examples", "Sweet Example", 0],
+            [:row, %w{Fill In}, 0],
+            [:row, %w{The Blanks}, 0],
+            [:tag, "@tag3", 0],
+            [:tag, "@tag4", 0],
+            [:scenario, "Scenario", "Reading a Scenario", 0],
+            [:step, "Given ", "there is a step", 0],
+            [:step, "Given ", "not another step", 0],
+            [:tag, "@tag3", 0],
+            [:scenario, "Scenario", "Reading a second scenario\nWith two lines of text", 0],
+            [:step, "Given ", "a third step with a table", 0],
+            [:row, %w{a b}, 0],
+            [:row, %w{c d}, 0],
+            [:row, %w{e f}, 0],
+            [:step, "Given ", "I am still testing things", 0],
+            [:row, %w{g h}, 0],
+            [:row, %w{e r}, 0],
+            [:row, %w{k i}, 0],
+            [:row, ['n', ''], 0], 
+            [:step, "Given ", "I am done testing these tables", 0],
+            [:step, "Given ", "I am happy", 0],
+            [:scenario, "Scenario", "Hammerzeit", 0],
+            [:step, "Given ", "All work and no play", 0],
+            [:py_string, "Makes Homer something something\nAnd something else", 0 ],
+            [:step, "Given ", "crazy", 0],
+            [:eof]
+          ]
+        end        
+      end
+    end
+  end
+end

data/spec/gherkin/parser/parser_spec.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+require 'spec_helper'
 require 'gherkin/parser/parser'
 
 module Gherkin
@@ -6,7 +6,7 @@ module Gherkin
     describe Parser do
       before do
         @listener = mock('listener')
-        @parser = Parser.new(@listener, true)
+        @parser = Gherkin::Parser::Parser.new(@listener, true)
       end
 
       it "should delegate events to the listener" do
@@ -16,7 +16,7 @@ module Gherkin
 
       it "should raise helpful error messages by default" do
         lambda { 
-          @parser.scenario("Scenario", "My pet scenario", 12) 
+          @parser.scenario("Scenario", "My pet scenario", "", 12) 
         }.should raise_error(/Parse error on line 12\. Found scenario when expecting one of: comment, feature, tag\. \(Current state: root\)\.$/)
       end
 
@@ -27,22 +27,22 @@ module Gherkin
 
       it "should delegate an error message when raise on error is false" do
         @listener.should_receive(:syntax_error).with(sym(:root), sym(:background), a([:comment, :feature, :tag]), 1)
-        @parser = Parser.new(@listener, false)
-        @parser.background("Background", "Content", 1)
+        @parser = Gherkin::Parser::Parser.new(@listener, false)
+        @parser.background("Background", "Content", "", 1)
       end
 
       [true, false].each do |native|
         it "should be reusable for several feature files (native lexer: #{native})" do
-          listener = mock('listener', :null_object => true)
-          parser = Parser.new(listener, true)
+          listener = mock('listener').as_null_object
+          parser = Gherkin::Parser::Parser.new(listener, true)
           lexer = Gherkin::I18nLexer.new(parser, native)
           feature = <<-EOF
 Feature: foo
   Scenario: bar
     Given zap
 EOF
-          lexer.scan(feature)
-          lexer.scan(feature)
+          lexer.scan(feature, "test.feature", 0)
+          lexer.scan(feature, "test.feature", 0)
         end
       end
     end