bryanl-gherkin 2.11.1.1

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

data/spec/gherkin/shared/doc_string_group.rb

@@ -0,0 +1,163 @@
+# encoding: utf-8
+require 'spec_helper'
+
+module Gherkin
+  module Lexer
+    shared_examples_for "a Gherkin lexer lexing doc_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(:doc_string).with('', "  Hello\nGoodbye", 4)
+        scan(str)
+      end
+
+      it "should parse a simple doc_string" do
+        @listener.should_receive(:doc_string).with('', "I am a doc_string", 1)
+        scan ps("I am a doc_string")
+      end
+
+      it "should parse an empty doc_string" do
+        @listener.should_receive(:doc_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
+doc_string = <<EOS
+"""
+
+
+
+"""
+EOS
+        @listener.should_receive(:doc_string).with('', "\n\n", 1)
+        scan(doc_string)
+      end
+      
+      it "should parse content separated by two newlines" do
+        scan ps("A\n\nB")
+        @listener.to_sexp.should == [
+          [:doc_string, '', "A\n\nB", 1],
+          [:eof]
+        ]
+      end
+      
+      it "should parse a multiline string" do
+        @listener.should_receive(:doc_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(:doc_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(:doc_string).with('', "  Line one\nLine two", 1)
+        scan(str)
+      end
+            
+      it "should preserve tabs within the content" do
+        @listener.should_receive(:doc_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 doc_strings" do
+doc_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(:doc_string).with('', doc_string, 1)
+        scan ps(doc_string)
+      end
+ 
+      it "should allow whitespace after the closing doc_string delimiter" do
+str = <<EOS
+    """
+      Line one
+    """           
+EOS
+        @listener.should_receive(:doc_string).with('', "  Line one", 1)
+        scan(str)
+      end
+
+      it "should preserve the last newline(s) at the end of a doc_string" do
+str = <<EOS
+     """
+     DocString text
+
+
+     """
+EOS
+        @listener.should_receive(:doc_string).with('', "DocString text\n\n", 1)
+        scan(str)
+      end        
+
+      it "should preserve CRLFs within doc_strings" do
+        @listener.should_receive(:doc_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(:doc_string).with('', '"""', 1)
+        scan(str)
+      end
+
+      it "should not unescape escaped single quotes" do
+str = <<EOS
+    """
+    \\" \\"\\"
+    """
+EOS
+        @listener.should_receive(:doc_string).with('', '\" \"\"', 1)
+        scan(str)
+      end
+      
+      it "should lex doc_string content_types" do
+str = <<EOS
+    """gherkin type
+    Feature: Doc String Types
+    """
+EOS
+        @listener.should_receive(:doc_string).with('gherkin type', 'Feature: Doc String Types', 1)
+        scan(str)
+      end
+    end
+  end
+end