gherkin 2.1.5 → 2.2.0

data/lib/gherkin/lexer/i18n_lexer.rb

@@ -0,0 +1,40 @@
+require 'gherkin/i18n'
+require 'gherkin/native'
+
+module Gherkin
+  module Lexer
+    I18nLexerNotFound = Class.new(LoadError)
+    LexingError = Class.new(StandardError)
+
+    # The main entry point to lexing Gherkin source.
+    class I18nLexer
+      native_impl('gherkin')
+
+      LANGUAGE_PATTERN = /^\s*#\s*language\s*:\s*([a-zA-Z\-]+)/ #:nodoc:
+      attr_reader :i18n_language
+
+      def initialize(listener, force_ruby=false)
+        @listener = listener
+        @force_ruby = force_ruby
+      end
+
+      def scan(source)
+        create_delegate(source).scan(source)
+      end
+
+    private
+
+      def create_delegate(source)
+        @i18n_language = lang(source)
+        @i18n_language.lexer(@listener, @force_ruby)
+      end
+
+      def lang(source)
+        line_one = source.split(/\n/)[0]
+        match = LANGUAGE_PATTERN.match(line_one)
+        I18n.get(match ? match[1] : 'en')
+      end
+
+    end
+  end
+end

data/lib/gherkin/listener/formatter_listener.rb

@@ -16,10 +16,6 @@ module Gherkin
         @table = nil
       end
 
-      def location(feature_uri)
-        @feature_uri = feature_uri
-      end
-
       def comment(value, line)
         @comments << Formatter::Model::Comment.new(value, line)
       end
@@ -29,31 +25,31 @@ module Gherkin
       end
 
       def feature(keyword, name, description, line)
-        @formatter.feature(statement(grab_comments!, grab_tags!, keyword, name, description, line), @feature_uri)
+        @formatter.feature(Formatter::Model::Feature.new(grab_comments!, grab_tags!, keyword, name, description, line))
       end
 
       def background(keyword, name, description, line)
-        @formatter.background(statement(grab_comments!, [], keyword, name, description, line))
+        @formatter.background(Formatter::Model::Background.new(grab_comments!, keyword, name, description, line))
       end
 
       def scenario(keyword, name, description, line)
         replay_step_or_examples
-        @formatter.scenario(statement(grab_comments!, grab_tags!, keyword, name, description, line))
+        @formatter.scenario(Formatter::Model::Scenario.new(grab_comments!, grab_tags!, keyword, name, description, line))
       end
 
       def scenario_outline(keyword, name, description, line)
         replay_step_or_examples
-        @formatter.scenario_outline(statement(grab_comments!, grab_tags!, keyword, name, description, line))
+        @formatter.scenario_outline(Formatter::Model::ScenarioOutline.new(grab_comments!, grab_tags!, keyword, name, description, line))
       end
 
       def examples(keyword, name, description, line)
         replay_step_or_examples
-        @examples_statement = statement(grab_comments!, grab_tags!, keyword, name, description, line)
+        @examples_statement = Formatter::Model::Examples.new(grab_comments!, grab_tags!, keyword, name, description, line)
       end
 
       def step(keyword, name, line)
         replay_step_or_examples
-        @step_statement = statement(grab_comments!, [], keyword, name, nil, line)
+        @step_statement = Formatter::Model::Step.new(grab_comments!, keyword, name, nil, line)
       end
 
       def row(cells, line)
@@ -76,10 +72,6 @@ module Gherkin
 
     private
 
-      def statement(comments, tags, keyword, name, description, line)
-        Formatter::Model::Statement.new(comments, tags, keyword, name, description, line)
-      end
-
       def grab_comments!
         comments = @comments
         @comments = []
@@ -92,7 +84,7 @@ module Gherkin
         tags
       end
 
-      def grab_table!
+      def grab_rows!
         table = @table
         @table = nil
         table
@@ -106,12 +98,13 @@ module Gherkin
 
       def replay_step_or_examples
         if(@step_statement)
-          multiline_arg = grab_py_string! || grab_table!
-          @formatter.step(@step_statement, multiline_arg, nil)
+          @step_statement.multiline_arg = grab_py_string! || grab_rows!
+          @formatter.step(@step_statement)
           @step_statement = nil
         end
         if(@examples_statement)
-          @formatter.examples(@examples_statement, grab_table!)
+          @examples_statement.rows = grab_rows!
+          @formatter.examples(@examples_statement)
           @examples_statement = nil
         end
       end

data/lib/gherkin/parser/parser.rb

@@ -1,5 +1,5 @@
 require 'gherkin/i18n'
-require 'gherkin/i18n_lexer'
+require 'gherkin/lexer/i18n_lexer'
 require 'gherkin/native'
 require 'gherkin/listener/formatter_listener'
 
@@ -22,13 +22,12 @@ module Gherkin
         @machine_name = machine_name
         @machines = []
         push_machine(@machine_name)
-        @lexer = I18nLexer.new(self, force_ruby)
+        @lexer = Gherkin::Lexer::I18nLexer.new(self, force_ruby)
       end
 
       def parse(gherkin, feature_uri, line_offset)
-        @feature_uri = feature_uri
+        @formatter.uri(feature_uri)
         @line_offset = line_offset
-        @listener.location(feature_uri)
         @lexer.scan(gherkin)
       end
 
@@ -148,7 +147,7 @@ module Gherkin
             @rows = []
           end
 
-          def location(uri, offset)
+          def uri(uri)
           end
 
           def row(row, line_number)

data/lib/gherkin/tools/stats_listener.rb

@@ -14,7 +14,7 @@ module Gherkin
         @steps     = 0
       end
 
-      def location(file, uri)
+      def location(uri)
       end
 
       def tag(name, line)

data/ragel/lexer.c.rl.erb

@@ -57,6 +57,7 @@ typedef struct lexer_state {
 } lexer_state;
 
 static VALUE mGherkin;
+static VALUE mGherkinLexer;
 static VALUE mCLexer;
 static VALUE cI18nLexer;
 static VALUE rb_eGherkinLexingError;
@@ -442,7 +443,8 @@ static VALUE CLexer_scan(VALUE self, VALUE input)
 void Init_gherkin_lexer_<%= @i18n.underscored_iso_code %>()
 {
   mGherkin = rb_define_module("Gherkin");
-  rb_eGherkinLexingError = rb_const_get(mGherkin, rb_intern("LexingError"));
+  mGherkinLexer = rb_define_module_under(mGherkin, "Lexer");
+  rb_eGherkinLexingError = rb_const_get(mGherkinLexer, rb_intern("LexingError"));
 
   mCLexer = rb_define_module_under(mGherkin, "CLexer");
   cI18nLexer = rb_define_class_under(mCLexer, "<%= @i18n.underscored_iso_code.capitalize %>", rb_cObject);

data/ragel/lexer.java.rl.erb

@@ -1,13 +1,13 @@
-package gherkin.lexer;
+package gherkin.lexer.i18n;
 
 import java.io.UnsupportedEncodingException;
 import java.util.List;
 import java.util.ArrayList;
 import java.util.regex.Pattern;
 import java.util.regex.Matcher;
-import gherkin.Lexer;
-import gherkin.Listener;
-import gherkin.LexingError;
+import gherkin.lexer.Lexer;
+import gherkin.lexer.Listener;
+import gherkin.lexer.LexingError;
 
 public class <%= @i18n.underscored_iso_code.upcase %> implements Lexer {
   %%{

data/ragel/lexer.rb.rl.erb

@@ -1,3 +1,5 @@
+require 'gherkin/lexer/i18n_lexer'
+
 module Gherkin
   module RbLexer
     class <%= @i18n.underscored_iso_code.capitalize %> #:nodoc:
@@ -113,7 +115,7 @@ module Gherkin
         action end_feature {
           if cs < lexer_first_final
             content = current_line_content(data, p)
-            raise LexingError.new("Lexing error on line %d: '%s'. See http://wiki.github.com/aslakhellesoy/gherkin/lexingerror for more information." % [@line_number, content])
+            raise Gherkin::Lexer::LexingError.new("Lexing error on line %d: '%s'. See http://wiki.github.com/aslakhellesoy/gherkin/lexingerror for more information." % [@line_number, content])
           else
             @listener.eof
           end

data/spec/gherkin/fixtures/complex.json

@@ -1,5 +1,4 @@
 { 
-  "type": "feature",
   "name": "Feature Text",
   "keyword": "Feature",
   "description": "In order to test multiline forms",
@@ -41,11 +40,11 @@
         }
       ],
       "examples": [
-        { "type": "examples",
+        {
           "name": "Sweet Example", 
           "keyword": "Examples",
           "description": "",
-          "table" : [
+          "rows" : [
             {"cells" :
               [ "Fill","In" ]
             },

data/spec/gherkin/formatter/model_spec.rb

@@ -7,7 +7,7 @@ module Gherkin
       describe Tag do
         it "should be equal when name is equal" do
           tags = [Tag.new('@x', 1), Tag.new('@y', 2), Tag.new('@x', 3)]
-          tags.uniq.length.should == 2
+          tags.to_a.uniq.length.should == 2
         end
       end
     end

data/spec/gherkin/formatter/pretty_formatter_spec.rb

@@ -35,14 +35,15 @@ module Gherkin
       end
 
       it "should print comments when scenario is longer" do
-        @l.feature(Model::Statement.new([], [], "Feature", "Hello", "World", 1), "features/foo.feature")
+        @l.uri("features/foo.feature")
+        @l.feature(Model::Feature.new([], [], "Feature", "Hello", "World", 1))
         @l.steps([
           ['Given ', 'some stuff'],
           ['When ', 'foo']
         ])
-        @l.scenario(Model::Statement.new([], [], "Scenario", "The scenario", "", 4))
-        @l.step(Model::Statement.new([], [], "Given ", "some stuff", "", 5), nil, result('passed', nil, nil, "features/step_definitions/bar.rb:56"))
-        @l.step(Model::Statement.new([], [], "When ", "foo", "", 6), nil, result('passed', nil, nil, "features/step_definitions/bar.rb:96"))
+        @l.scenario(Model::Scenario.new([], [], "Scenario", "The scenario", "", 4))
+        @l.step(Model::Step.new([], "Given ", "some stuff", "", 5, nil, result('passed', nil, nil, "features/step_definitions/bar.rb:56")))
+        @l.step(Model::Step.new([], "When ", "foo", "", 6, nil, result('passed', nil, nil, "features/step_definitions/bar.rb:96")))
 
         assert_io(%{Feature: Hello
   World
@@ -54,12 +55,13 @@ module Gherkin
       end
 
       it "should print comments when step is longer" do
-        @l.feature(Model::Statement.new([], [], "Feature", "Hello", "World", 1), "features/foo.feature")
+        @l.uri("features/foo.feature")
+        @l.feature(Model::Feature.new([], [], "Feature", "Hello", "World", 1))
         @l.steps([
           ['Given ', 'some stuff that is longer']
         ])
-        @l.scenario(Model::Statement.new([], [], "Scenario", "The scenario", "", 4))
-        @l.step(Model::Statement.new([], [], "Given ", "some stuff that is longer", "", 5), nil, result('passed', nil, nil, "features/step_definitions/bar.rb:56"))
+        @l.scenario(Model::Scenario.new([], [], "Scenario", "The scenario", "", 4))
+        @l.step(Model::Step.new([], "Given ", "some stuff that is longer", "", 5, nil, result('passed', nil, nil, "features/step_definitions/bar.rb:56")))
 
         assert_io(%{Feature: Hello
   World
@@ -70,7 +72,8 @@ module Gherkin
       end
 
       it "should highlight arguments for regular steps" do
-        @l.step(Model::Statement.new([], [], "Given ", "I have 999 cukes in my belly", "", 3), nil, result('passed', nil, [Gherkin::Formatter::Argument.new(7, '999')], nil))
+        step = Model::Step.new([], "Given ", "I have 999 cukes in my belly", "", 3, nil, result('passed', nil, [Gherkin::Formatter::Argument.new(7, '999')], nil))
+        @l.step(step)
         assert_io("    Given I have 999 cukes in my belly\n")
       end
 

data/spec/gherkin/i18n_spec.rb

@@ -13,7 +13,7 @@ module Gherkin
       end
 
       it "should recognize keywords in the language of the lexer" do
-        lexer = Gherkin::I18nLexer.new(@listener, false)
+        lexer = Gherkin::Lexer::I18nLexer.new(@listener, false)
         scan_file(lexer, "i18n_no.feature")
         @listener.to_sexp.should == [
           [:comment, "#language:no", 1],
@@ -27,7 +27,7 @@ module Gherkin
       end
 
       it "should parse languages without a space after keywords" do
-        lexer = Gherkin::I18nLexer.new(@listener, false)
+        lexer = Gherkin::Lexer::I18nLexer.new(@listener, false)
         scan_file(lexer, "i18n_zh-CN.feature")
         @listener.to_sexp.should == [
           [:comment, "#language:zh-CN", 1],
@@ -42,7 +42,7 @@ module Gherkin
       end
 
       it "should parse languages with spaces after some keywords but not others" do
-        lexer = Gherkin::I18nLexer.new(@listener, false)
+        lexer = Gherkin::Lexer::I18nLexer.new(@listener, false)
         scan_file(lexer, "i18n_fr.feature")
         @listener.to_sexp.should == [
           [:comment, "#language:fr", 1],

data/spec/gherkin/java_lexer_spec.rb

@@ -7,7 +7,7 @@ module Gherkin
     describe "Java Lexer" do
       before do
         @listener = Gherkin::SexpRecorder.new
-        @lexer = Java::Gherkin::I18nLexer.new(@listener)
+        @lexer = Java::GherkinLexer::I18nLexer.new(@listener)
       end
 
       it_should_behave_like "a Gherkin lexer"

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

@@ -1,91 +1,67 @@
 #encoding: utf-8
+require 'ap'
 require 'spec_helper'
 require 'gherkin/json_parser'
+require 'gherkin/formatter/json_formatter'
 
 module Gherkin
   describe JSONParser do 
 
-    before do
-      @listener = Gherkin::SexpRecorder.new
-      @parser = Gherkin::JSONParser.new(nil)
-    end
+    def check_json(json)
+      io = StringIO.new
+      f = Formatter::JSONFormatter.new(io)
+      p = JSONParser.new(f)
+      p.parse(json, 'unknown.json')
+      expected = JSON.parse(json)
+      actual   = JSON.parse(io.string)
 
-    describe "An empty feature" do
-      it "should scan empty features" do
-        @parser.parse_with_listener('{}', @listener)
-        @listener.to_sexp.should == [
-          [:location, "unknown.json"],
-          [:eof]
-        ]
-      end
+      actual.should == expected
     end
 
-    describe "A barely empty feature" do
-      it "should scan a feature with no elements" do
-        @parser.parse_with_listener('{ "type": "feature", "keyword": "Feature", "name": "One", "description": "", "line" : 3 }', @listener)
-        @listener.to_sexp.should == [
-          [:location, "unknown.json"],
-          [:feature, "Feature", "One", "", 3],
-          [:eof]
-        ]
-      end
+    it "should parse a barely empty feature" do
+      check_json(%{{
+        "keyword": "Feature", 
+        "name": "One", 
+        "description": "", 
+        "line" : 3 
+      }})
     end
 
-    describe "Keywords" do
-      it "should use the keyword from the source when provided" do
-        @parser.parse_with_listener('{ "type": "feature", "name" : "My Sweet Featur", "language": "fr", "keyword": "Feature", "description": "" }', @listener)
-        @listener.to_sexp.should == [
-          [:location, "unknown.json"],
-          [:feature, "Feature", "My Sweet Featur", "",  nil],
-          [:eof]
+    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
+      }})
     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
-        @parser.parse_with_listener(fixture("complex.json"), @listener)
-        @listener.to_sexp.should == [
-          [:location, "unknown.json"],
-          [:tag, "@tag1", nil],
-          [:tag, "@tag2", nil],
-          [:feature, "Feature", "Feature Text","In order to test multiline forms", nil],
-          [:background, "Background", "", "", nil],
-          [:step, "Given ", "this is a background step", nil],
-          [:step, "When ", "this is another one", 412],
-          [:tag, "@foo", nil],
-          [:scenario_outline, "Scenario Outline", "An Scenario Outline","", nil],
-          [:step, "Given ", "A step with a table", nil],
-          [:row, %w{a row for a step}, nil],
-          [:tag, "@exampletag", nil],
-          [:examples, "Examples", "Sweet Example", "", nil],
-          [:row, %w{Fill In}, nil],
-          [:row, %w{The Blanks}, nil],
-          [:tag, "@tag3", nil],
-          [:tag, "@tag4", nil],
-          [:scenario, "Scenario", "Reading a Scenario", "", nil],
-          [:step, "Given ", "there is a step", nil],
-          [:step, "But ", "not another step", nil],
-          [:tag, "@tag3", nil],
-          [:scenario, "Scenario", "Reading a second scenario", "With two lines of text", nil],
-          [:step, "Given ", "a third step with a table", nil],
-          [:row, %w{a b}, 987],
-          [:row, %w{c d}, nil],
-          [:row, %w{e f}, nil],
-          [:step, "Given ", "I am still testing things", nil],
-          [:row, %w{g h}, nil],
-          [:row, %w{e r}, nil],
-          [:row, %w{k i}, nil],
-          [:row, ['n', ''], nil], 
-          [:step, "Given ", "I am done testing these tables", nil],
-          [:step, "Given ", "I am happy", nil],
-          [:scenario, "Scenario", "Hammerzeit", "", nil],
-          [:step, "Given ", "All work and no play", nil],
-          [:py_string, "Makes Homer something something\nAnd something else", 777],
-          [:step, "Given ", "crazy", nil],
-          [:eof]
-        ]
-      end        
+    it "shoud parse a complex feature" do
+      check_json(fixture("complex.json"))
     end
   end
 end