gherkin 2.0.2 → 2.1.0

data/lib/gherkin/i18n.yml

@@ -144,6 +144,19 @@
   then: "*|DEN"
   and: "*|AN"
   but: "*|BUT"
+"en-pirate":
+  name: Pirate
+  native: Pirate
+  feature: Ahoy matey!
+  background: Yo-ho-ho
+  scenario: Heave to
+  scenario_outline: Shiver me timbers
+  examples: Dead men tell no tales
+  given: "*|Gangway!"
+  when: "*|Blimey!"
+  then: "*|Let go and haul"
+  and: "*|Aye"
+  but: "*|Avast!"
 "en-Scouse":
   name: Scouse
   native: Scouse

data/lib/gherkin/i18n_lexer.rb

@@ -17,8 +17,8 @@ module Gherkin
       @force_ruby = force_ruby
     end
 
-    def scan(source, uri, offset)
-      create_delegate(source).scan(source, uri, offset)
+    def scan(source)
+      create_delegate(source).scan(source)
     end
 
   private

data/lib/gherkin/{json_lexer.rb → json_parser.rb}

@@ -1,13 +1,27 @@
 require 'json'
+require 'gherkin/listener/formatter_listener'
 
 module Gherkin
-  class JSONLexer
+  class JSONParser
 
-    def initialize(listener)
+    def initialize(formatter)
+      @formatter = formatter
+    end
+
+    def parse(src, feature_uri='unknown.json', line_offset=0)
+      @listener = Listener::FormatterListener.new(@formatter)
+      _parse(src, feature_uri, line_offset)
+    end
+
+    def parse_with_listener(src, listener)
       @listener = listener
+      _parse(src, 'unknown.json', 0)
     end
 
-    def scan(src, uri='unknown.json', offset=0)
+    private
+
+    def _parse(src, feature_uri, line_offset)
+      @listener.location(feature_uri)
       feature = JSON.parse(src)
 
       comments_for(feature)
@@ -27,8 +41,6 @@ module Gherkin
       @listener.eof
     end
 
-    private
-
     def parse_element(feature_element)
       comments_for(feature_element)
       tags_for(feature_element)

data/lib/gherkin/{parser → listener}/event.rb

@@ -1,5 +1,5 @@
 module Gherkin
-  module Parser
+  module Listener
     class Event < Array
       def event
         self[0]

data/lib/gherkin/{parser → listener}/formatter_listener.rb

@@ -1,8 +1,8 @@
 require 'gherkin/native'
-require 'gherkin/parser/row'
+require 'gherkin/formatter/model'
 
 module Gherkin
-  module Parser
+  module Listener
     # 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).
@@ -16,54 +16,53 @@ module Gherkin
         @table = nil
       end
 
-      def location(uri, offset)
-        @uri = uri
-        @offset = offset
+      def location(feature_uri)
+        @feature_uri = feature_uri
       end
 
-      def comment(content, line)
-        @comments << content
+      def comment(value, line)
+        @comments << Formatter::Model::Comment.new(value, line)
       end
 
       def tag(name, line)
-        @tags << name
+        @tags << Formatter::Model::Tag.new(name, line)
       end
 
       def feature(keyword, name, description, line)
-        @formatter.feature(grab_comments!, grab_tags!, keyword, name, description, @uri)
+        @formatter.feature(statement(grab_comments!, grab_tags!, keyword, name, description, line), @feature_uri)
       end
 
       def background(keyword, name, description, line)
-        @formatter.background(grab_comments!, keyword, name, description, line)
+        @formatter.background(statement(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)
+        @formatter.scenario(statement(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)
+        @formatter.scenario_outline(statement(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]
+        @examples_statement = statement(grab_comments!, grab_tags!, keyword, name, description, line)
       end
 
       def step(keyword, name, line)
         replay_step_or_examples
-        @step = [grab_comments!, keyword, name, line]
+        @step_statement = statement(grab_comments!, [], keyword, name, nil, line)
       end
 
       def row(cells, line)
         @table ||= []
-        @table << Row.new(cells, grab_comments!, line)
+        @table << Formatter::Model::Row.new(grab_comments!, cells, line)
       end
 
-      def py_string(py_string, line)
-        @py_string = py_string
+      def py_string(string, line)
+        @py_string = Formatter::Model::PyString.new(string, line)
       end
 
       def eof
@@ -71,8 +70,16 @@ module Gherkin
         @formatter.eof
       end
 
+      def syntax_error(state, ev, legal_events, uri, line)
+        @formatter.syntax_error(state, ev, legal_events, uri, line)
+      end
+
     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 = []
@@ -98,14 +105,14 @@ module Gherkin
       end
 
       def replay_step_or_examples
-        if(@step)
+        if(@step_statement)
           multiline_arg = grab_py_string! || grab_table!
-          @formatter.step(*(@step + [multiline_arg, nil, nil, nil, nil]))
-          @step = nil
+          @formatter.step(@step_statement, multiline_arg, nil)
+          @step_statement = nil
         end
-        if(@examples)
-          @formatter.examples(*(@examples + [grab_table!]))
-          @examples = nil
+        if(@examples_statement)
+          @formatter.examples(@examples_statement, grab_table!)
+          @examples_statement = nil
         end
       end
     end

data/lib/gherkin/native/java.rb

@@ -26,7 +26,15 @@ class Class
       end
 
       def new(*args)
-        java_class.new(*javaify(args))
+        begin
+          java_class.new(*javaify(args))
+        rescue ArgumentError => e
+          e.message << "\n#{java_class.name}"
+          raise e
+        rescue NameError => e
+          e.message << "\n args: #{args.inspect}" 
+          raise e
+        end
       end
 
       def ===(object)

data/lib/gherkin/parser/parser.rb

@@ -1,4 +1,5 @@
 require 'gherkin/native'
+require 'gherkin/listener/formatter_listener'
 
 module Gherkin
   module Parser
@@ -12,24 +13,36 @@ module Gherkin
       native_impl('gherkin')
 
       # Initialize the parser. +machine_name+ refers to a state machine table.
-      def initialize(listener, raise_on_error=true, machine_name='root')
-        @listener = listener
+      def initialize(formatter, raise_on_error=true, machine_name='root', force_ruby=false)
+        @formatter = formatter
+        @listener = Listener::FormatterListener.new(@formatter)
         @raise_on_error = raise_on_error
-        @machines = []
         @machine_name = machine_name
+        @machines = []
         push_machine(@machine_name)
+        @lexer = I18nLexer.new(self, force_ruby)
+      end
+
+      def parse(gherkin, feature_uri, line_offset)
+        @feature_uri = feature_uri
+        @line_offset = line_offset
+        @listener.location(feature_uri)
+        @lexer.scan(gherkin)
       end
 
-      def location(uri, offset)
-        @listener.location(uri, offset)
+      def i18n_language
+        @lexer.i18n_language
+      end
+
+      def errors
+        @lexer.errors
       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)
-        end
+        event(method.to_s, args[-1])
+        @listener.__send__(method, *args)
         if method == :eof
           pop_machine
           push_machine(@machine_name)
@@ -37,15 +50,15 @@ module Gherkin
       end
 
       def event(ev, line)
-        machine.event(ev, line) do |state, expected|
+        l = line ? @line_offset+line : nil
+        machine.event(ev, l) do |state, legal_events|
           if @raise_on_error
-            raise ParseError.new(state, ev, expected, line)
+            raise ParseError.new(state, ev, legal_events, @feature_uri, l)
           else
-            @listener.syntax_error(state, ev, expected, line)
-            return false
+            # Only used for testing
+            @listener.syntax_error(state, ev, legal_events, @feature_uri, l)
           end
         end
-        true
       end
 
       def push_machine(name)
@@ -122,7 +135,7 @@ module Gherkin
           state_machine_reader = StateMachineReader.new
           lexer = Gherkin::I18n.new('en').lexer(state_machine_reader)
           machine = File.dirname(__FILE__) + "/#{name}.txt"
-          lexer.scan(File.read(machine), machine, 0)
+          lexer.scan(File.read(machine))
           state_machine_reader.rows
         end
 

data/lib/gherkin/rubify.rb

@@ -5,8 +5,12 @@ module Gherkin
       # 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
+        case(o)
+        when Java.java.util.Collection, Array
           o.map{|e| rubify(e)}
+        when Java.gherkin.formatter.model.PyString
+          require 'gherkin/formatter/model'
+          Formatter::Model::PyString.new(o.value, o.line)
         else
           o
         end

data/lib/gherkin/tag_expression.rb

@@ -0,0 +1,62 @@
+require 'gherkin/native'
+
+module Gherkin
+  class TagExpression
+    native_impl('gherkin')
+
+    attr_reader :limits
+
+    def initialize(tag_expressions)
+      @ands = []
+      @limits = {}
+      tag_expressions.each do |expr|
+        add(expr.strip.split(/\s*,\s*/))
+      end
+    end
+
+    def empty?
+      @ands.empty?
+    end
+
+    def eval(tags)
+      return true if @ands.flatten.empty?
+      vars = Hash[*tags.map{|tag| [tag, true]}.flatten]
+      !!Kernel.eval(ruby_expression)
+    end
+
+  private
+
+    def add(tags_with_negation_and_limits)
+      negatives, positives = tags_with_negation_and_limits.partition{|tag| tag =~ /^~/}
+      @ands << (store_and_extract_limits(negatives, true) + store_and_extract_limits(positives, false))
+    end
+
+    def store_and_extract_limits(tags_with_negation_and_limits, negated)
+      tags_with_negation = []
+      tags_with_negation_and_limits.each do |tag_with_negation_and_limit|
+        tag_with_negation, limit = tag_with_negation_and_limit.split(':')
+        tags_with_negation << tag_with_negation
+        if limit
+          tag_without_negation = negated ? tag_with_negation[1..-1] : tag_with_negation
+          if @limits[tag_without_negation] && @limits[tag_without_negation] != limit.to_i
+            raise "Inconsistent tag limits for #{tag_without_negation}: #{@limits[tag_without_negation]} and #{limit.to_i}" 
+          end
+          @limits[tag_without_negation] = limit.to_i
+        end
+      end
+      tags_with_negation
+    end
+
+    def ruby_expression
+      "(" + @ands.map do |ors|
+        ors.map do |tag|
+          if tag =~ /^~(.*)/
+            "!vars['#{$1}']"
+          else
+            "vars['#{tag}']"
+          end
+        end.join("||")
+      end.join(")&&(") + ")"
+    end
+  end
+end

data/lib/gherkin/tools/files.rb

@@ -20,11 +20,10 @@ module Gherkin
         Dir[*globs].uniq.sort.each(&proc)
       end
 
-      def scan(file, listener)
-        parser = Gherkin::Parser::Parser.new(listener, true, "root")
-        lexer = Gherkin::I18nLexer.new(parser, false)
+      def scan(file, formatter)
+        parser = Gherkin::Parser::Parser.new(formatter, true, "root")
         begin
-          lexer.scan(IO.read(file), file, 0)
+          parser.parse(IO.read(file), file, 0)
         rescue => e
           e.message << " (#{file})"
           raise e

data/lib/gherkin/tools/reformat.rb

@@ -1,7 +1,7 @@
 require 'stringio'
 require 'gherkin/tools/files'
 require 'gherkin/formatter/pretty_formatter'
-require 'gherkin/parser/formatter_listener'
+require 'gherkin/listener/formatter_listener'
 
 module Gherkin
   module Tools
@@ -10,7 +10,7 @@ module Gherkin
         each do |file|
           io = defined?(JRUBY_VERSION) ? Java.java.io.StringWriter.new : StringIO.new
           formatter = Formatter::PrettyFormatter.new(io, true)
-          listener = Parser::FormatterListener.new(formatter)
+          listener = Listener::FormatterListener.new(formatter)
           scan(file, listener)
           string = defined?(JRUBY_VERSION) ? io.getBuffer.toString : io.string
           File.open(file, 'w') {|io| io.write(string)}

data/lib/gherkin/tools/stats.rb

@@ -6,11 +6,10 @@ module Gherkin
   module Tools
     class Stats < Files
       def run
-        listener = StatsListener.new
+        formatter = StatsFormatter.new
         each do |f|
-          parser = Gherkin::Parser::Parser.new(listener, true)
-          lexer = Gherkin::I18nLexer.new(parser)
-          lexer.scan(IO.read(f), f, 0)
+          parser = Gherkin::Parser::Parser.new(formatter, true)
+          parser.parse(IO.read(f), f, 0)
         end
         puts "Features:  #{listener.features}"
         puts "Scenarios: #{listener.scenarios}"

data/lib/gherkin/tools/stats_listener.rb

@@ -50,7 +50,7 @@ module Gherkin
       def py_string(string, line)
       end
 
-      def syntax_error(state, event, legal_events, line)
+      def syntax_error(state, event, legal_events, uri, line)
       end
 
       def eof

data/ragel/lexer.c.rl.erb

@@ -389,10 +389,9 @@ static VALUE CLexer_init(VALUE self, VALUE listener)
   return self;
 }
 
-static VALUE CLexer_scan(VALUE self, VALUE input, VALUE uri, VALUE offset)
+static VALUE CLexer_scan(VALUE self, VALUE input)
 {
   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);
@@ -449,6 +448,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, 3);
+  rb_define_method(cI18nLexer, "scan", CLexer_scan, 1);
 }