bryanl-gherkin 2.11.1.1-java

data/spec/gherkin/i18n_spec.rb

@@ -0,0 +1,241 @@
+#encoding: utf-8
+require 'spec_helper'
+
+module Gherkin
+  module Lexer
+    describe I18n do
+      before do
+        @listener = Gherkin::SexpRecorder.new
+      end
+
+      def scan_file(lexer, file)
+        lexer.scan(File.new(File.dirname(__FILE__) + "/fixtures/" + file).read)
+      end
+
+      it "should recognize keywords in the language of the lexer" do
+        lexer = Gherkin::Lexer::I18nLexer.new(@listener, false)
+        scan_file(lexer, "i18n_no.feature")
+        @listener.to_sexp.should == [
+          [:comment, "#language:no", 1],
+          [: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],
+          [:eof]
+        ]
+      end
+
+      it "should recognize keywords that are a little ambiguous" do
+        lexer = Gherkin::Lexer::I18nLexer.new(@listener, false)
+        scan_file(lexer, "i18n_fr2.feature")
+        @listener.to_sexp.should == [
+          [:comment, "#language:fr", 1],
+          [:feature, "Fonctionnalité", "i18n", "", 2],
+          [:scenario, "Scénario", "Le French", "", 4],
+          [:step, "Etant donné ", "qqch", 5],
+          [:step, "Etant donnée ", "qqch", 6],
+          [:step, "Etant donnés ", "qqch", 7],
+          [:step, "Etant données ", "qqch", 8],
+          [:eof]
+        ]
+      end
+
+      it "should parse languages without a space after keywords" do
+        lexer = Gherkin::Lexer::I18nLexer.new(@listener, false)
+        scan_file(lexer, "i18n_zh-CN.feature")
+        @listener.to_sexp.should == [
+          [:comment, "#language:zh-CN", 1],
+          [:feature, "功能", "加法", "", 2],
+          [:scenario, "场景", "两个数相加", "", 4],
+          [:step, "假如", "我已经在计算器里输入6", 5],
+          [:step, "而且", "我已经在计算器里输入7", 6],
+          [:step, "当", "我按相加按钮", 7],
+          [:step, "那么", "我应该在屏幕上看到的结果是13", 8],
+          [:eof]
+        ] 
+      end
+
+      it "should parse languages with spaces after some keywords but not others" do
+        lexer = Gherkin::Lexer::I18nLexer.new(@listener, false)
+        scan_file(lexer, "i18n_fr.feature")
+        @listener.to_sexp.should == [
+          [:comment, "#language:fr", 1],
+          [: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],
+          [:row, %w{a b somme}, 11],
+          [:row, %w{2 2 4}, 12],
+          [:row, %w{2 3 5}, 13],
+          [:eof]
+        ]
+      end
+
+      it "should recognize keywords in Portuguese (1st variant)" do
+        lexer = Gherkin::Lexer::I18nLexer.new(@listener, false)
+        scan_file(lexer, "i18n_pt1.feature")
+        @listener.to_sexp.should == [
+          [:comment, "# language: pt", 1],
+          [:feature, "Funcionalidade", "Reconhece \"Funcionalidade\"", "", 2],
+          [:background, "Contexto", "Reconhece \"Contexto\"", "", 4],
+          [:scenario, "Cenário", "Reconhece \"Cenário\" com acento", "", 6],
+          [:scenario, "Cenario", "Reconhece \"Cenário\" sem acento", "", 8],
+          [:scenario_outline, "Esquema do Cenário", "Reconhece \"Esquema do Cenário\" com acento", "", 10],
+          [:step, "Dado ", "que <Valor> é um valor e que reconhece \"Dado\";", 11],
+          [:step, "Dada ", "a afirmação de que reconhece \"Dada\";", 12],
+          [:step, "Dados ", "os factos acima e ainda que reconhece \"Dados\";", 13],
+          [:step, "Dadas ", "as afirmações acima e ainda que reconhece \"Dadas\";", 14],
+          [:step, "Quando ", "reconhece \"Quando\";", 15],
+          [:step, "Então ", "também reconhece \"Então\" com acento e", 16],
+          [:step, "Entao ", "também reconhece \"Então\" sem acento;", 17],
+          [:step, "E ", "reconhece \"E\";", 18],
+          [:step, "Mas ", "também reconhece \"Mas\".", 19],
+          [:examples, "Exemplos", "Reconhece \"Exemplos\"", "", 21],
+          [:row, ["Valor"], 22],
+          [:row, ["1"], 23],
+          [:scenario_outline, "Esquema do Cenario", "Reconhece \"Esquema do Cenário\" sem acento", "", 25],
+          [:step, "Dado ", "que <Valor> é um valor;", 26],
+          [:examples, "Cenários", "Reconhece \"Cenários\" com acento", "", 28],
+          [:row, ["Valor"], 29],
+          [:row, ["1"], 30],
+          [:scenario_outline, "Delineação do Cenário", "Reconhece \"Delineação do Cenário\" com acento", "", 32],
+          [:step, "Dado ", "que <Valor> é um valor;", 33],
+          [:examples, "Cenarios", "Reconhece \"Cenários\" sem acento", "", 35],
+          [:row, ["Valor"], 36],
+          [:row, ["1"], 37],
+          [:scenario_outline, "Delineacao do Cenario", "Reconhece \"Delineação do Cenário\" sem acento", "", 39],
+          [:step, "Dado ", "que <Valor> é um valor;", 40],
+          [:examples, "Exemplos", "Reconhece \"Exemplos\"", "", 42],
+          [:row, ["Valor"], 43],
+          [:row, ["1"], 44],
+          [:eof]
+        ]
+      end
+
+      it "should recognize keywords in Portuguese (2nd variant)" do
+        lexer = Gherkin::Lexer::I18nLexer.new(@listener, false)
+        scan_file(lexer, "i18n_pt2.feature")
+        @listener.to_sexp.should == [
+          [:comment, "# language: pt", 1],
+          [:feature, "Característica", "Reconhece \"Característica\" com acento", "", 2],
+          [:background, "Cenário de Fundo", "Reconhece \"Cenário de Fundo\" com acento", "", 4],
+          [:eof]
+        ]
+      end
+
+      it "should recognize keywords in Portuguese (3rd variant)" do
+        lexer = Gherkin::Lexer::I18nLexer.new(@listener, false)
+        scan_file(lexer, "i18n_pt3.feature")
+        @listener.to_sexp.should == [
+          [:comment, "# language: pt", 1],
+          [:feature, "Caracteristica", "Reconhece \"Característica\" sem acento", "", 2],
+          [:background, "Cenario de Fundo", "Reconhece \"Cenário de Fundo\" sem acento", "", 4],
+          [:eof]
+        ]
+      end
+
+      it "should recognize keywords in Portuguese (4th variant)" do
+        lexer = Gherkin::Lexer::I18nLexer.new(@listener, false)
+        scan_file(lexer, "i18n_pt4.feature")
+        @listener.to_sexp.should == [
+          [:comment, "# language: pt", 1],
+          [:feature, "Característica", "Reconhece \"Característica\" com acento", "", 2],
+          [:background, "Fundo", "Reconhece \"Fundo\"", "", 4],
+          [:eof]
+        ]
+      end
+
+      describe 'keywords' do
+        it "should have code keywords without space, comma, exclamation or apostrophe" do
+          ['Avast', 'Akkor', 'Etantdonné', 'Lorsque', '假設'].each do |code_keyword|
+            Gherkin::I18n.code_keywords.should include(code_keyword)
+          end
+        end
+
+        it "should reject the bullet stars" do
+          Gherkin::I18n.code_keywords.should_not include('*')
+        end
+
+        it "should report keyword regexp" do
+          Gherkin::I18n.keyword_regexp(:step).should =~ /\|Quando \|Quand \|Quan \|Pryd \|Pokud \|/
+        end
+
+        it "should print available languages" do
+          ("\n" + Gherkin::I18n.language_table).should == %{
+      | ar        | Arabic              | العربية           |
+      | bg        | Bulgarian           | български         |
+      | bm        | Malay               | Bahasa Melayu     |
+      | ca        | Catalan             | català            |
+      | cs        | Czech               | Česky             |
+      | cy-GB     | Welsh               | Cymraeg           |
+      | da        | Danish              | dansk             |
+      | de        | German              | Deutsch           |
+      | en        | English             | English           |
+      | en-Scouse | Scouse              | Scouse            |
+      | en-au     | Australian          | Australian        |
+      | en-lol    | LOLCAT              | LOLCAT            |
+      | en-pirate | Pirate              | Pirate            |
+      | en-tx     | Texan               | Texan             |
+      | eo        | Esperanto           | Esperanto         |
+      | es        | Spanish             | español           |
+      | et        | Estonian            | eesti keel        |
+      | fi        | Finnish             | suomi             |
+      | fr        | French              | français          |
+      | he        | Hebrew              | עברית             |
+      | hr        | Croatian            | hrvatski          |
+      | hu        | Hungarian           | magyar            |
+      | id        | Indonesian          | Bahasa Indonesia  |
+      | is        | Icelandic           | Íslenska          |
+      | it        | Italian             | italiano          |
+      | ja        | Japanese            | 日本語               |
+      | ko        | Korean              | 한국어               |
+      | lt        | Lithuanian          | lietuvių kalba    |
+      | lu        | Luxemburgish        | Lëtzebuergesch    |
+      | lv        | Latvian             | latviešu          |
+      | nl        | Dutch               | Nederlands        |
+      | no        | Norwegian           | norsk             |
+      | pl        | Polish              | polski            |
+      | pt        | Portuguese          | português         |
+      | ro        | Romanian            | română            |
+      | ru        | Russian             | русский           |
+      | sk        | Slovak              | Slovensky         |
+      | sr-Cyrl   | Serbian             | Српски            |
+      | sr-Latn   | Serbian (Latin)     | Srpski (Latinica) |
+      | sv        | Swedish             | Svenska           |
+      | tr        | Turkish             | Türkçe            |
+      | uk        | Ukrainian           | Українська        |
+      | uz        | Uzbek               | Узбекча           |
+      | vi        | Vietnamese          | Tiếng Việt        |
+      | zh-CN     | Chinese simplified  | 简体中文              |
+      | zh-TW     | Chinese traditional | 繁體中文              |
+}
+        end
+
+        it "should print keywords for a given language" do
+          ("\n" + Gherkin::I18n.get('fr').keyword_table).should == %{
+      | feature          | "Fonctionnalité"                                                                                                                                      |
+      | background       | "Contexte"                                                                                                                                            |
+      | scenario         | "Scénario"                                                                                                                                            |
+      | scenario_outline | "Plan du scénario", "Plan du Scénario"                                                                                                                |
+      | examples         | "Exemples"                                                                                                                                            |
+      | given            | "* ", "Soit ", "Etant donné ", "Etant donnée ", "Etant donnés ", "Etant données ", "Étant donné ", "Étant donnée ", "Étant donnés ", "Étant données " |
+      | when             | "* ", "Quand ", "Lorsque ", "Lorsqu'"                                                                                                                 |
+      | then             | "* ", "Alors "                                                                                                                                        |
+      | and              | "* ", "Et "                                                                                                                                           |
+      | but              | "* ", "Mais "                                                                                                                                         |
+      | given (code)     | "Soit", "Etantdonné", "Etantdonnée", "Etantdonnés", "Etantdonnées", "Étantdonné", "Étantdonnée", "Étantdonnés", "Étantdonnées"                        |
+      | when (code)      | "Quand", "Lorsque", "Lorsqu"                                                                                                                          |
+      | then (code)      | "Alors"                                                                                                                                               |
+      | and (code)       | "Et"                                                                                                                                                  |
+      | but (code)       | "Mais"                                                                                                                                                |
+}
+        end
+      end
+    end
+  end
+end

data/spec/gherkin/java_lexer_spec.rb

@@ -0,0 +1,20 @@
+#encoding: utf-8
+if defined?(JRUBY_VERSION)
+require 'spec_helper'
+
+module Gherkin
+  module JavaLexer
+    describe "Java Lexer" do
+      before do
+        @listener = Gherkin::SexpRecorder.new
+        @lexer = Java::GherkinLexer::I18nLexer.new(@listener)
+      end
+
+      it_should_behave_like "a Gherkin lexer"
+      it_should_behave_like "a Gherkin lexer lexing tags"
+      it_should_behave_like "a Gherkin lexer lexing doc_strings"
+      it_should_behave_like "a Gherkin lexer lexing rows"
+    end
+  end
+end
+end

data/spec/gherkin/js_lexer_spec.rb

@@ -0,0 +1,23 @@
+#encoding: utf-8
+if !defined?(JRUBY_VERSION) && ENV['GHERKIN_JS']
+require 'spec_helper'
+require 'gherkin/js_lexer'
+
+module Gherkin
+  module Lexer
+    describe "JavaScript Lexer" do
+      before do
+        @listener = Gherkin::SexpRecorder.new
+        @lexer = Gherkin::JsLexer['en'].new(@listener)
+      end
+    
+      it_should_behave_like "a Gherkin lexer"
+      it_should_behave_like "a Gherkin lexer lexing tags"
+      it_should_behave_like "a Gherkin lexer lexing doc_strings"
+      it_should_behave_like "a Gherkin lexer lexing rows"
+      # TODO - make this pass!
+      # it_should_behave_like "parsing windows files"
+    end
+  end
+end
+end

data/spec/gherkin/json_parser_spec.rb

@@ -0,0 +1,176 @@
+#encoding: utf-8
+require 'stringio'
+require 'spec_helper'
+require 'gherkin/json_parser'
+require 'gherkin/formatter/json_formatter'
+
+module Gherkin
+  describe JSONParser do 
+
+    def check_json(json)
+      io = StringIO.new
+      f = Formatter::JSONFormatter.new(io)
+      p = JSONParser.new(f, f)
+      p.parse(json)
+      f.done
+      expected = JSON.parse(json)
+      actual   = JSON.parse(io.string)
+
+      begin
+        actual.should == expected
+      rescue
+        puts "EXPECTED"
+        puts json
+        puts "ACTUAL"
+        puts io.string
+        puts "======"
+
+        raise
+      end
+    end
+
+    it "should parse a barely empty feature" do
+      check_json(%{[
+        {
+          "id": "one",
+          "uri": "test.feature",
+          "keyword": "Feature", 
+          "name": "One", 
+          "description": "", 
+          "line" : 3 
+        }
+      ]})
+    end
+
+    it "should parse feature with tags and one scenario" do
+      check_json(%{[
+        {
+          "id": "one",
+          "uri": "test.feature",
+          "tags": [
+            {
+              "name": "@foo",
+              "line": 22
+            }
+          ],
+          "keyword": "Feature", 
+          "name": "One", 
+          "description": "", 
+          "line": 3,
+          "elements": [
+            {
+              "id": "one/two",
+              "type": "scenario",
+              "steps": [
+                {
+                  "name": "Hello",
+                  "rows": [
+                    {
+                      "cells": ["foo", "bar"]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        }
+      ]})
+    end
+
+    it "should parse feature with match, result and embedding" do
+      check_json(%{
+          [
+              {
+                  "id":"one",
+                  "uri":"test.feature",
+                  "tags":[
+                      {
+                          "name":"@foo",
+                          "line":22
+                      }
+                  ],
+                  "keyword":"Feature",
+                  "name":"One",
+                  "description":"",
+                  "line":3,
+                  "elements":[
+                      {
+                          "id":"one/a-scenario",
+                          "type":"scenario",
+                          "before": [
+                              {
+                                  "match":{
+                                      "location":"features/step_definitions/hooks.rb:1"
+                                  },
+                                  "result":{
+                                      "status":"passed",
+                                      "error_message":"Passed hook",
+                                      "duration": 3
+                                  }
+                              },
+                              {
+                                  "match":{
+                                      "location":"features/step_definitions/hooks.rb:2"
+                                  },
+                                  "result":{
+                                      "status":"failed",
+                                      "error_message":"Failed hook",
+                                      "duration": 22
+                                  }
+                              }
+                          ],
+                          "steps":[
+                              {
+                                  "keyword":"Given ",
+                                  "name":"a passing step",
+                                  "line":6,
+                                  "match":{
+                                      "arguments":[
+                                          {
+                                              "offset":22,
+                                              "val":"cukes"
+                                          }
+                                      ],
+                                      "location":"features/step_definitions/steps.rb:1"
+                                  },
+                                  "result":{
+                                      "status":"failed",
+                                      "error_message":"You suck",
+                                      "duration":-1
+                                  },
+                                  "embeddings":[
+                                      {
+                                          "mime_type":"text/plain",
+                                          "data":"Tm8sIEknbSBub3QgaW50ZXJlc3RlZCBpbiBkZXZlbG9waW5nIGEgcG93ZXJmdWwgYnJhaW4uIEFsbCBJJ20gYWZ0ZXIgaXMganVzdCBhIG1lZGlvY3JlIGJyYWluLCBzb21ldGhpbmcgbGlrZSB0aGUgUHJlc2lkZW50IG9mIHRoZSBBbWVyaWNhbiBUZWxlcGhvbmUgYW5kIFRlbGVncmFwaCBDb21wYW55Lg=="
+                                      }
+                                  ],
+                                  "output":[
+                                      "Hello",
+                                      "World"
+                                  ]
+                              }
+                          ],
+                          "after": [
+                              {
+                                  "match":{
+                                      "location":"features/step_definitions/hooks.rb:3"
+                                  },
+                                  "result":{
+                                      "status":"failed",
+                                      "error_message":"Failed After",
+                                      "duration": 22
+                                  }
+                              }
+                          ]
+                      }
+                  ]
+              }
+          ]
+      })
+    end
+
+    it "shoud parse a complex feature" do
+      check_json('[' + fixture("complex.json") + ']')
+    end
+  end
+end

data/spec/gherkin/lexer/i18n_lexer_spec.rb

@@ -0,0 +1,43 @@
+#encoding: utf-8
+require 'spec_helper'
+
+module Gherkin
+  module Lexer
+    describe I18nLexer do
+      before do
+        @lexer = Gherkin::Lexer::I18nLexer.new(Gherkin::SexpRecorder.new, false)
+      end
+
+      it "should store the i18n language of the last scanned feature" do
+        @lexer.scan("# language: fr\n")
+        @lexer.i18n_language.iso_code.should == "fr"
+        @lexer.scan("# language: no\n")
+        @lexer.i18n_language.iso_code.should == "no"
+      end
+
+      it "should detect language when there are spaces and CRLF" do
+        @lexer.scan("# language: da  \r\n")
+        @lexer.i18n_language.iso_code.should == "da"
+      end
+
+      it "should detect language when the language comment is not the first line" do
+        @lexer.scan("# hello\n# language: no\n")
+        @lexer.i18n_language.iso_code.should == "no"
+      end
+
+      it "should detect language when the language is on the third line, and there are empty lines above" do
+        @lexer.scan("# hello\n\n# language: no\n")
+        @lexer.i18n_language.iso_code.should == "no"
+      end
+
+      it "should use English i18n by default" do
+        @lexer.scan("Feature: foo\n")
+        @lexer.i18n_language.iso_code.should == "en"
+      end
+
+      it "should === its ruby class, even when the impl is Java" do
+        Gherkin::Lexer::I18nLexer.should === Gherkin::Lexer::I18nLexer.new(Gherkin::SexpRecorder.new, true)
+      end
+    end
+  end
+end

data/spec/gherkin/output_stream_string_io.rb

@@ -0,0 +1,20 @@
+if defined?(JRUBY_VERSION)
+  class WriterStringIO < Java.java.io.StringWriter
+    def write(what)
+      super(Java.java.lang.String.new(what.to_s))
+    end
+
+    def string
+      toString()
+    end
+  end
+
+  require 'stringio'
+  class StringIO
+    class << self
+      def new
+        WriterStringIO.new
+      end
+    end
+  end
+end

data/spec/gherkin/parser/parser_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+module Gherkin
+  module Parser
+    describe Parser do
+      unless defined?(JRUBY_VERSION)
+        it "should raise when feature doesn't parse" do
+          p = Parser.new(mock('formatter').as_null_object)
+          lambda do
+            p.parse("Feature: f\nFeature: f", __FILE__, __LINE__-1)
+          end.should raise_error(/Parse error at/)
+        end
+      end
+    end
+  end
+end

data/spec/gherkin/rb_lexer_spec.rb

@@ -0,0 +1,20 @@
+#encoding: utf-8
+require 'spec_helper'
+require 'gherkin/rb_lexer/en'
+
+module Gherkin
+  module Lexer
+    describe "Ruby Lexer" do
+      before do
+        @listener = Gherkin::SexpRecorder.new
+        @lexer = Gherkin::RbLexer::En.new(@listener)
+      end
+
+      it_should_behave_like "a Gherkin lexer"
+      it_should_behave_like "a Gherkin lexer lexing tags"
+      it_should_behave_like "a Gherkin lexer lexing doc_strings"
+      it_should_behave_like "a Gherkin lexer lexing rows"
+      it_should_behave_like "parsing windows files"
+    end
+  end
+end

data/spec/gherkin/sexp_recorder.rb

@@ -0,0 +1,59 @@
+require 'gherkin/rubify'
+require 'gherkin/formatter/model'
+
+module Gherkin
+  class SexpRecorder
+    include Rubify
+    
+    def initialize
+      @sexps = []
+    end
+
+    # We can't use method_missing - therubyracer isn't able to invoke methods like that.
+    [:comment, :tag, :feature, :background, :scenario, :scenario_outline, :examples, :step, :doc_string, :row, :eof, :uri, :syntax_error].each do |event|
+      define_method(event) do |*args|
+        args  = rubify(args)
+        args  = sexpify(args)
+        @sexps << [event] + args
+      end
+    end
+
+    def to_sexp
+      @sexps
+    end
+
+    # Useful in IRB
+    def reset!
+      @sexps = []
+    end
+
+    def errors
+      @sexps.select { |sexp| sexp[0] == :syntax_error }
+    end
+
+    def line(number)
+      @sexps.find { |sexp| sexp.last == number }
+    end
+
+    def sexpify(o)
+      array = (defined?(JRUBY_VERSION) && Java.java.util.Collection === o) || 
+              (defined?(V8) && V8::Array === o) ||
+              Array === o
+      if array
+        o.map{|e| sexpify(e)}
+      elsif(Formatter::Model::Row === o)
+        {
+          "cells" => sexpify(o.cells),
+          "comments" => sexpify(o.comments),
+          "line" => o.line,
+        }
+      elsif(Formatter::Model::Comment === o)
+        o.value
+      elsif(Formatter::Model::Tag === o)
+        o.name
+      else
+        o
+      end
+    end
+  end
+end

data/spec/gherkin/shared/bom_group.rb

@@ -0,0 +1,20 @@
+#encoding: utf-8
+require 'spec_helper'
+
+module Gherkin
+  module Lexer
+    shared_examples_for "parsing windows files" do
+      describe "with BOM" do
+        it "should work just fine" do
+          scan_file("with_bom.feature")
+          @listener.to_sexp.should == [
+            [:feature, "Feature", "Feature Text", "", 1],
+            [:scenario, "Scenario", "Reading a Scenario", "", 2],
+            [:step, "Given ", "there is a step", 3],
+            [:eof]
+          ]
+        end
+      end
+    end
+  end
+end