gherkin 1.0.30 → 2.0.0

data/lib/gherkin/parser/event.rb

@@ -1,11 +1,6 @@
 module Gherkin
   module Parser
     class Event < Array
-      def initialize(*args)
-        super
-        self[1] = self[1].to_a if event == :row # Special JRuby handling
-      end
-
       def event
         self[0]
       end
@@ -24,7 +19,12 @@ module Gherkin
       end
 
       def replay(listener)
-        listener.__send__(event, *args)
+        begin
+          listener.__send__(event, *args)
+        rescue ArgumentError => e
+          e.message << "\nListener: #{listener.class}, args: #{args.inspect}"
+          raise e
+        end
       end
 
     private

data/lib/gherkin/parser/filter_listener.rb

@@ -31,7 +31,11 @@ module Gherkin
 
         @table_state = :step
       end
-      
+
+      def location(uri, offset)
+        @listener.location(uri, offset)
+      end
+
       private
 
       def method_missing(*event_args)

data/lib/gherkin/parser/formatter_listener.rb

@@ -0,0 +1,113 @@
+require 'gherkin/native'
+require 'gherkin/parser/row'
+
+module Gherkin
+  module Parser
+    # Adapter from the "raw" Gherkin <tt>Listener</tt> API
+    # to the slightly more high-level <tt>Formatter</tt> API,
+    # which is easier to implement (less state to keep track of).
+    class FormatterListener
+      native_impl('gherkin')
+
+      def initialize(formatter)
+        @formatter = formatter
+        @comments = []
+        @tags = []
+        @table = nil
+      end
+
+      def location(uri, offset)
+        @uri = uri
+        @offset = offset
+      end
+
+      def comment(content, line)
+        @comments << content
+      end
+
+      def tag(name, line)
+        @tags << name
+      end
+
+      def feature(keyword, name, description, line)
+        @formatter.feature(grab_comments!, grab_tags!, keyword, name, description, @uri)
+      end
+
+      def background(keyword, name, description, line)
+        @formatter.background(grab_comments!, keyword, name, description, line)
+      end
+
+      def scenario(keyword, name, description, line)
+        replay_step_or_examples
+        @formatter.scenario(grab_comments!, grab_tags!, keyword, name, description, line)
+      end
+
+      def scenario_outline(keyword, name, description, line)
+        replay_step_or_examples
+        @formatter.scenario_outline(grab_comments!, grab_tags!, keyword, name, description, line)
+      end
+
+      def examples(keyword, name, description, line)
+        replay_step_or_examples
+        @examples = [grab_comments!, grab_tags!, keyword, name, description, line]
+      end
+
+      def step(keyword, name, line)
+        replay_step_or_examples
+        @step = [grab_comments!, keyword, name, line]
+      end
+
+      def row(cells, line)
+        @table ||= []
+        @table << Row.new(cells, grab_comments!, line)
+      end
+
+      def py_string(py_string, line)
+        @py_string = py_string
+      end
+
+      def eof
+        replay_step_or_examples
+        @formatter.eof
+      end
+
+    private
+
+      def grab_comments!
+        comments = @comments
+        @comments = []
+        comments
+      end
+
+      def grab_tags!
+        tags = @tags
+        @tags = []
+        tags
+      end
+
+      def grab_table!
+        table = @table
+        @table = nil
+        table
+      end
+
+      def grab_py_string!
+        py_string = @py_string
+        @py_string = nil
+        py_string
+      end
+
+      def replay_step_or_examples
+        if(@step)
+          multiline_arg = grab_py_string! || grab_table!
+          @formatter.step(*(@step + [multiline_arg, nil, nil, nil, nil]))
+          @step = nil
+        end
+        if(@examples)
+          @formatter.examples(*(@examples + [grab_table!]))
+          @examples = nil
+        end
+      end
+    end
+  end
+end

data/lib/gherkin/parser/json_parser.rb

@@ -0,0 +1,102 @@
+require 'json'
+require 'gherkin/i18n'
+
+module Gherkin
+  module Parser
+    class JSONParser
+      attr_reader :i18n_language
+
+      def initialize(listener)
+        @listener = listener
+      end
+
+      def parse(src)
+        feature = JSON.parse(src)
+
+        @i18n_language = Gherkin::I18n.get(feature["language"] || "en" )
+
+        tags_for(feature)
+        @listener.feature(keyword_for("feature", feature), feature["name"], line_for(feature)) if feature["name"]
+
+        if feature["background"]
+          @listener.background(keyword_for("background", feature["background"]), feature["background"]["name"], line_for(feature["background"]))
+          steps_for(feature["background"])
+        end
+
+        feature["elements"].each do |feature_element|
+          parse_element(feature_element) 
+        end if feature["elements"]
+
+        @listener.eof
+      end
+
+      private
+
+      def parse_element(feature_element)
+        case feature_element["type"]
+        when "Scenario" then parse_scenario(feature_element)
+        when "Scenario Outline" then parse_outline(feature_element)
+        end
+      end
+
+      def parse_outline(scenario_outline)
+        tags_for(scenario_outline)
+        @listener.scenario_outline(keyword_for("scenario_outline", scenario_outline), scenario_outline["name"], line_for(scenario_outline) )
+        steps_for(scenario_outline)
+        scenario_outline["examples"].each do |examples|
+          tags_for(examples)
+          @listener.examples(keyword_for("examples", examples), examples["name"], line_for(examples))
+          rows_for(examples)
+        end
+      end
+
+      def parse_scenario(scenario)
+        tags_for(scenario)
+        @listener.scenario(keyword_for("scenario", scenario), scenario["name"], line_for(scenario))
+        steps_for(scenario)
+      end
+
+      def tags_for(element)
+        element["tags"].each do |tag|
+          @listener.tag(tag, 0)
+        end if element["tags"]
+      end
+
+      def steps_for(element)
+        element["steps"].each do |step|
+          @listener.step(keyword_for("given",step), step["name"], line_for(step))
+          py_string_for(step)    
+          rows_for(step)
+        end
+      end
+
+      def py_string_for(element)
+        @listener.py_string(element["py_string"], 0) if element["py_string"]
+      end
+
+      def rows_for(element)
+        element["table"].each do |row|
+          @listener.row(cells_for(row), 0)
+        end if element["table"]
+      end
+
+      def cells_for(row)
+        row["cells"].inject([]) { |col, ele| col << ele["text"] }
+      end
+
+      def line_for(element)
+        if element["line"]
+          element["line"]
+        elsif element["file_colon_line"]
+          element["file_colon_line"].split(':')[1].to_i
+        else
+          0
+        end
+      end
+
+      def keyword_for(gherkin_keyword, element)
+        element["keyword"] || i18n_language.keywords(gherkin_keyword).reject { |kw| kw == "* " }.first
+      end
+    end
+  end
+end

data/lib/gherkin/parser/parser.rb

@@ -20,11 +20,15 @@ module Gherkin
         push_machine(@machine_name)
       end
 
+      def location(uri, offset)
+        @listener.location(uri, offset)
+      end
+
       # Doesn't yet fall back to super
       def method_missing(method, *args)
         # TODO: Catch exception and call super
         if(event(method.to_s, args[-1]))
-          @listener.send(method, *args)
+          @listener.__send__(method, *args)
         end
         if method == :eof
           pop_machine
@@ -117,7 +121,8 @@ module Gherkin
         def transition_table(name)
           state_machine_reader = StateMachineReader.new
           lexer = Gherkin::I18n.new('en').lexer(state_machine_reader)
-          lexer.scan(File.read(File.dirname(__FILE__) + "/#{name}.txt"))
+          machine = File.dirname(__FILE__) + "/#{name}.txt"
+          lexer.scan(File.read(machine), machine, 0)
           state_machine_reader.rows
         end
 
@@ -128,6 +133,9 @@ module Gherkin
             @rows = []
           end
 
+          def location(uri, offset)
+          end
+
           def row(row, line_number)
             @rows << row
           end

data/lib/gherkin/parser/row.rb

@@ -0,0 +1,15 @@
+require 'gherkin/native'
+
+module Gherkin
+  module Parser
+    class Row
+      native_impl('gherkin')
+
+      attr_reader :cells, :comments, :line
+      
+      def initialize(cells, comments, line)
+        @cells, @comments, @line = cells, comments, line
+      end
+    end
+  end
+end

data/lib/gherkin/rubify.rb

@@ -2,6 +2,8 @@ module Gherkin
   module Rubify
     if defined?(JRUBY_VERSION)
       # Translate Java objects to Ruby.
+      # This is especially important to convert java.util.List coming
+      # from Java and back to a Ruby Array.
       def rubify(o)
         if Java.java.util.Collection === o || Array === o
           o.map{|e| rubify(e)}

data/lib/gherkin/tools/files.rb

@@ -24,7 +24,7 @@ module Gherkin
         parser = Gherkin::Parser::Parser.new(listener, true, "root")
         lexer = Gherkin::I18nLexer.new(parser, false)
         begin
-          lexer.scan(IO.read(file))
+          lexer.scan(IO.read(file), file, 0)
         rescue => e
           e.message << " (#{file})"
           raise e

data/lib/gherkin/tools/reformat.rb

@@ -10,8 +10,7 @@ module Gherkin
           purdy = StringIO.new
           listener = Formatter::PrettyFormatter.new(purdy)
           scan(file, listener)
-          purdy.rewind
-          File.open(file, 'w') {|io| io.write(purdy.read)}
+          File.open(file, 'w') {|io| io.write(purdy.string)}
         end
       end
     end

data/lib/gherkin/tools/stats.rb

@@ -10,7 +10,7 @@ module Gherkin
         each do |f|
           parser = Gherkin::Parser::Parser.new(listener, true)
           lexer = Gherkin::I18nLexer.new(parser)
-          lexer.scan(IO.read(f))
+          lexer.scan(IO.read(f), f, 0)
         end
         puts "Features:  #{listener.features}"
         puts "Scenarios: #{listener.scenarios}"

data/lib/gherkin/tools/stats_listener.rb

@@ -20,21 +20,21 @@ module Gherkin
       def comment(content, line)
       end
 
-      def feature(keyword, name, line)
+      def feature(keyword, name, description, line)
         @features += 1
       end
 
-      def background(keyword, name, line)
+      def background(keyword, name, description, line)
       end
 
-      def scenario(keyword, name, line)
+      def scenario(keyword, name, description, line)
         @scenarios += 1
       end
 
-      def scenario_outline(keyword, name, line)
+      def scenario_outline(keyword, name, description, line)
       end
 
-      def examples(keyword, name, line)
+      def examples(keyword, name, description, line)
       end
 
       def step(keyword, name, line)

data/ragel/lexer.c.rl.erb

@@ -66,7 +66,7 @@ static VALUE rb_eGherkinLexingError;
 #define PTR_TO(P) (data + lexer->P)
 
 #define STORE_KW_END_CON(EVENT) \
-  store_kw_con(listener, # EVENT, \
+  store_multiline_kw_con(listener, # EVENT, \
     PTR_TO(keyword_start), LEN(keyword_start, PTR_TO(keyword_end - 1)), \
     PTR_TO(content_start), LEN(content_start, PTR_TO(content_end)), \
     lexer->current_line, lexer->eol); \
@@ -129,7 +129,7 @@ static VALUE rb_eGherkinLexingError;
     store_kw_con(listener, "step",
       PTR_TO(keyword_start), LEN(keyword_start, PTR_TO(keyword_end)),
       PTR_TO(content_start), LEN(content_start, p), 
-      lexer->current_line, lexer->eol);
+      lexer->current_line);
   }
   
   action store_comment_content {
@@ -251,31 +251,59 @@ strip_i(VALUE str, VALUE ary)
 }
 
 static VALUE 
-multiline_strip(VALUE text, int eol)
+multiline_strip(VALUE text)
 {
   VALUE map = rb_ary_new();
   VALUE split = rb_str_split(text, "\n");
   
   rb_iterate(rb_each, split, strip_i, map);
   
-  return rb_ary_join(split, rb_str_new2( \
-          eol == CRLF_FLAG ? CRLF : LF ));
+  return split;
 }
 
 static void 
 store_kw_con(VALUE listener, const char * event_name, 
              const char * keyword_at, size_t keyword_length, 
              const char * at,         size_t length, 
-             int current_line, int eol)
+             int current_line)
 {
   VALUE con = Qnil, kw = Qnil;
   kw = ENCODED_STR_NEW(keyword_at, keyword_length);
   con = ENCODED_STR_NEW(at, length);
-  con = multiline_strip(con, eol);
   rb_funcall(con, rb_intern("strip!"), 0);
   rb_funcall(listener, rb_intern(event_name), 3, kw, con, INT2FIX(current_line)); 
 }
 
+static void
+store_multiline_kw_con(VALUE listener, const char * event_name,
+                      const char * keyword_at, size_t keyword_length,
+                      const char * at,         size_t length,
+                      int current_line, int eol)
+{
+  VALUE con = Qnil, kw = Qnil, name = Qnil, desc = Qnil;
+
+  kw = ENCODED_STR_NEW(keyword_at, keyword_length);
+  con = ENCODED_STR_NEW(at, length);
+
+  VALUE split = multiline_strip(con);
+  
+  name = rb_funcall(split, rb_intern("shift"), 0);
+  desc = rb_ary_join(split, rb_str_new2( \
+          eol == CRLF_FLAG ? CRLF : LF ));
+
+  if( name == Qnil ) 
+  {
+    name = rb_str_new2("");
+  }
+  if( rb_funcall(desc, rb_intern("size"), 0) == 0) 
+  {
+    desc = rb_str_new2("");
+  }
+  rb_funcall(name, rb_intern("strip!"), 0);
+  rb_funcall(desc, rb_intern("strip!"), 0);
+  rb_funcall(listener, rb_intern(event_name), 4, kw, name, desc, INT2FIX(current_line)); 
+}
+
 static void 
 store_attr(VALUE listener, const char * attr_type,
            const char * at, size_t length, 
@@ -307,7 +335,7 @@ store_pystring_content(VALUE listener,
 static void 
 raise_lexer_error(const char * at, int line)
 { 
-  rb_raise(rb_eGherkinLexingError, "Lexing error on line %d: '%s'.", line, at);
+  rb_raise(rb_eGherkinLexingError, "Lexing error on line %d: '%s'. See http://wiki.github.com/aslakhellesoy/gherkin/lexingerror for more information.", line, at);
 }
 
 static int 
@@ -361,12 +389,14 @@ static VALUE CLexer_init(VALUE self, VALUE listener)
   return self;
 }
 
-static VALUE CLexer_scan(VALUE self, VALUE input)
+static VALUE CLexer_scan(VALUE self, VALUE input, VALUE uri, VALUE offset)
 {
+  VALUE listener = rb_iv_get(self, "@listener");
+  rb_funcall(listener, rb_intern("location"), 2, uri, offset);
+
   lexer_state *lexer = NULL;
   DATA_GET(self, lexer_state, lexer);
 
-
   VALUE input_copy = rb_str_dup(input);
 
   rb_str_append(input_copy, rb_str_new2("\n%_FEATURE_END_%"));
@@ -384,7 +414,6 @@ static VALUE CLexer_scan(VALUE self, VALUE input)
     const char *p, *pe, *eof;
     int cs = 0;
     
-    VALUE listener = rb_iv_get(self, "@listener");
     VALUE current_row = Qnil;
 
     p = data;
@@ -420,6 +449,6 @@ void Init_gherkin_lexer_<%= @i18n.underscored_iso_code %>()
   cI18nLexer = rb_define_class_under(mCLexer, "<%= @i18n.underscored_iso_code.capitalize %>", rb_cObject);
   rb_define_alloc_func(cI18nLexer, CLexer_alloc);
   rb_define_method(cI18nLexer, "initialize", CLexer_init, 1);
-  rb_define_method(cI18nLexer, "scan", CLexer_scan, 1);
+  rb_define_method(cI18nLexer, "scan", CLexer_scan, 3);
 }