gherkin 2.2.5-x86-mingw32

data/spec/gherkin/formatter/tabs.feature

@@ -0,0 +1,9 @@
+Feature: Adding
+
+	Scenario: Add two numbers
+		Given the following input:
+			"""
+			hello
+			"""
+		When the calculator is run
+		Then the output should be 4

data/spec/gherkin/formatter/tag_count_formatter_spec.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'gherkin/parser/parser'
+require 'gherkin/formatter/tag_count_formatter'
+
+module Gherkin
+  module Formatter
+    describe TagCountFormatter do
+      it "should count tags" do
+        tag_counts = {}
+        dummy = Gherkin::SexpRecorder.new
+        formatter = Gherkin::Formatter::TagCountFormatter.new(dummy, tag_counts)
+        parser = Gherkin::Parser::Parser.new(formatter)
+
+        f = File.new(File.dirname(__FILE__) + "/../fixtures/complex_with_tags.feature").read
+        parser.parse(f, 'f.feature', 0)
+        
+        tag_counts.should == {
+          "@hamster" => ["f.feature:58"],
+          "@tag1"    => ["f.feature:18","f.feature:23","f.feature:39","f.feature:52","f.feature:58"],
+          "@tag2"    => ["f.feature:18","f.feature:23","f.feature:39","f.feature:52","f.feature:58"],
+          "@tag3"    => ["f.feature:18", "f.feature:23"],
+          "@tag4"    => ["f.feature:18"],
+          "@neat"    => ["f.feature:52"],
+          "@more"    => ["f.feature:52", "f.feature:58"]
+        }
+      end
+    end
+  end
+end

data/spec/gherkin/i18n_spec.rb

@@ -0,0 +1,149 @@
+#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 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
+
+      describe 'keywords' do
+        it "should have code keywords without space, comma or apostrophe" do
+          ['Akkor', 'Etantdonné', 'Lorsque', '假設'].each do |code_keyword|
+            Gherkin::I18n.code_keywords.should include(code_keyword)
+          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 == %{
+      | ar        | Arabic                 | العربية              |
+      | bg        | Bulgarian              | български            |
+      | 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     |
+      | 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ă               |
+      | ro-RO     | Romanian (diacritical) | română (diacritical) |
+      | 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
+        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é "          |
+      | when             | "* ", "Quand ", "Lorsque ", "Lorsqu'"  |
+      | then             | "* ", "Alors "                         |
+      | and              | "* ", "Et "                            |
+      | but              | "* ", "Mais "                          |
+      | given (code)     | "Soit", "Etantdonné"                   |
+      | 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 py_strings"
+      it_should_behave_like "a Gherkin lexer lexing rows"
+    end
+  end
+end
+end

data/spec/gherkin/json.rb

@@ -0,0 +1,5 @@
+JSON_SIMPLE_JAR = ENV['HOME'] + '/.m2/repository/com/googlecode/json-simple/json-simple/1.1/json-simple-1.1.jar'
+
+if defined?(JRUBY_VERSION)
+  require JSON_SIMPLE_JAR
+end

data/spec/gherkin/json_parser_spec.rb

@@ -0,0 +1,67 @@
+#encoding: utf-8
+require 'ap'
+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)
+      p.parse(json, 'unknown.json', 0)
+      expected = JSON.parse(json)
+      actual   = JSON.parse(io.string)
+
+      actual.should == expected
+    end
+
+    it "should parse a barely empty feature" do
+      check_json(%{{
+        "keyword": "Feature", 
+        "name": "One", 
+        "description": "", 
+        "line" : 3 
+      }})
+    end
+
+    it "should parse feature with tags and one scenario" do
+      check_json(%{{
+        "tags": [
+          {
+            "name": "@foo",
+            "line": 22
+          }
+        ],
+        "keyword": "Feature", 
+        "name": "One", 
+        "description": "", 
+        "line": 3,
+        "elements": [
+          {
+            "type": "scenario",
+            "steps": [
+              {
+                "name": "Hello",
+                "multiline_arg": {
+                  "type": "table",
+                  "value": [
+                    {
+                      "cells": ["foo", "bar"]
+                    }
+                  ]
+                }
+              }
+            ]
+          }
+        ]
+      }})
+    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,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/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,19 @@
+#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 py_strings"
+      it_should_behave_like "a Gherkin lexer lexing rows"
+    end
+  end
+end

data/spec/gherkin/sexp_recorder.rb

@@ -0,0 +1,56 @@
+require 'gherkin/rubify'
+require 'gherkin/formatter/model'
+
+module Gherkin
+  class SexpRecorder
+    include Rubify
+    
+    def initialize
+      @sexps = []
+    end
+
+    def method_missing(event, *args)
+      event = :scenario_outline if event == :scenarioOutline # Special Java Lexer handling
+      event = :py_string if event == :pyString # Special Java Lexer handling
+      event = :syntax_error if event == :syntaxError # Special Java Lexer handling
+      args  = rubify(args)
+      args  = sexpify(args)
+      @sexps << [event] + args
+    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)
+      if (defined?(JRUBY_VERSION) && Java.java.util.Collection === o) || Array === o
+        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