gherkin 1.0.3 → 1.0.4

data/lib/gherkin/parser/filter_listener.rb

@@ -0,0 +1,191 @@
+require 'gherkin/parser/sexp'
+require 'gherkin/parser/tag_expression'
+
+module Gherkin
+  module Parser
+    # This class filters events based on filter criteria.
+    class FilterListener
+      # Creates a new instance that replays events to +listener+, filtered by +filters+,
+      # a Hash that can contain:
+      #
+      # * <tt>:lines</tt> An Array of line numbers to filter on.
+      # * <tt>:name_regexen</tt> An Array of name regexen to filter on. Matches against :feature, :scenario, :scenario_outline and :examples
+      # * <tt>:tag_expression</tt> A TagExpression to filter on.
+      #
+      def initialize(listener, filters)
+        @listener = listener
+        @filter_method = detect_filter(filters)
+        
+        @meta_buffer = []
+        @feature_buffer = []
+        @scenario_buffer = []
+        @examples_buffer = []
+        @examples_rows_buffer = []
+
+        @feature_tags = []
+        @scenario_tags = []
+        @example_tags = []
+
+        @table_state = :step
+      end
+      
+      private
+
+      def method_missing(*sexp_args)
+        sexp = Sexp.new(sexp_args)
+
+        return sexp.replay(@listener) if no_filters?
+
+        case(sexp.event)
+        when :tag
+          @meta_buffer << sexp
+        when :comment
+          @meta_buffer << sexp
+        when :feature
+          @feature_buffer = @meta_buffer
+          @feature_buffer << sexp
+          @feature_tags = extract_tags
+          @meta_buffer = []
+          @feature_ok = true if filter_match?(sexp)
+        when :background
+          @feature_buffer += @meta_buffer
+          @feature_buffer << sexp
+          @meta_buffer = []
+          @table_state = :background
+          @feature_ok = true if filter_match?(sexp)
+        when :scenario
+          replay_examples_rows_buffer
+          @scenario_buffer = @meta_buffer
+          @scenario_buffer << sexp
+          @scenario_tags = extract_tags
+          @example_tags = []
+          @meta_buffer = []
+          @scenario_ok = filter_match?(*@scenario_buffer) || tag_match?
+          @examples_ok = false
+          @table_state = :step
+        when :scenario_outline
+          replay_examples_rows_buffer
+          @scenario_buffer = @meta_buffer
+          @scenario_buffer << sexp
+          @scenario_tags = extract_tags
+          @example_tags = []
+          @meta_buffer = []
+          @scenario_ok = filter_match?(*@scenario_buffer)
+          @examples_ok = false
+          @table_state = :step
+        when :examples
+          replay_examples_rows_buffer
+          @examples_buffer = @meta_buffer
+          @examples_buffer << sexp
+          @example_tags = extract_tags
+          @meta_buffer = []
+          @examples_rows_buffer = []
+          @examples_ok = filter_match?(*@examples_buffer) || tag_match?
+          @table_state = :examples
+        when :step
+          case(@table_state)
+          when :background
+            @feature_buffer += @meta_buffer
+            @feature_buffer << sexp
+            @meta_buffer = []
+            @feature_ok = true if filter_match?(sexp)
+          else
+            @scenario_buffer << sexp
+            @scenario_ok ||= filter_match?(*@scenario_buffer)
+            @table_state = :step
+          end
+        when :row
+          case(@table_state)
+          when :examples
+            unless header_row_already_buffered?
+              @examples_buffer << sexp
+              @examples_ok = true if filter_match?(*@examples_buffer)
+            else
+              @examples_rows_buffer << sexp if @scenario_ok || @examples_ok || @feature_ok || filter_match?(sexp)
+            end
+          when :step
+            @scenario_buffer << sexp
+            @scenario_ok ||= filter_match?(*@scenario_buffer)
+          when :background
+            @feature_buffer += @meta_buffer
+            @feature_buffer << sexp
+            @meta_buffer = []
+          else
+            raise "Bad table_state:#{@table_state.inspect}"
+          end
+        when :py_string
+          @scenario_buffer << sexp
+          @scenario_ok ||= filter_match?(*@scenario_buffer)
+        when :eof
+          replay_examples_rows_buffer
+          sexp.replay(@listener)
+          return
+        else
+          super
+        end
+
+        if @scenario_ok || @examples_ok || @feature_ok
+          replay_buffers
+        end
+      end
+
+      def detect_filter(filters)
+        @filters = filters
+        raise "Bad filter: #{filters.inspect}" if filters.map{|filter| filter.class}.uniq.length > 1
+        @filter_method = case(filters[0])
+        when Fixnum 
+          :line_match?
+        when Regexp 
+          :name_match?
+        when String 
+          TagExpression.new(*filters)
+        end
+      end
+
+      def no_filters?
+        @filters.empty?
+      end
+
+      def header_row_already_buffered?
+        return false unless @examples_buffer.any?
+        @examples_buffer[-1].event == :row
+      end
+      
+      def filter_match?(*sexps)
+        return false unless[:name_match?, :line_match?].include?(@filter_method)
+        sexps.detect{|sexp| sexp.__send__(@filter_method, @filters)}
+      end
+
+      def tag_match?
+        return false unless TagExpression === @filter_method
+        @filter_method.eval(*current_tags)
+      end
+
+      def replay_buffers
+        (@feature_buffer + @scenario_buffer).each do |sexp| 
+          sexp.replay(@listener)
+        end
+        @feature_buffer = []
+        @scenario_buffer = [] 
+      end
+
+      def replay_examples_rows_buffer
+        if @examples_rows_buffer.any?
+          replay_buffers
+          (@examples_buffer + @examples_rows_buffer).each do |sexp|
+            sexp.replay(@listener)
+          end
+          @examples_rows_buffer = []
+        end
+      end
+      
+      def current_tags
+        @feature_tags + @scenario_tags + @example_tags
+      end
+
+      def extract_tags
+        @meta_buffer.select { |sexp| sexp.event == :tag }.map { |sexp| sexp.keyword }
+      end
+    end
+  end
+end

data/lib/gherkin/parser/parser.rb

@@ -0,0 +1,142 @@
+module Gherkin
+  module Parser
+    class ParseError < StandardError
+      def initialize(state, new_state, expected_states, line)
+        super("Parse error on line #{line}. Found #{new_state} when expecting one of: #{expected_states.join(', ')}. (Current state: #{state}).")
+      end
+    end
+
+    class Parser
+      def self.new(listener, raise_on_error=false, machine_name='root')
+        if defined?(JRUBY_VERSION)
+          require 'gherkin.jar'
+          Java::GherkinParser::Parser.new(listener, raise_on_error, machine_name)
+        else
+          super
+        end
+      end
+
+      # Initialize the parser. +machine_name+ refers to a state machine table.
+      def initialize(listener, raise_on_error, machine_name)
+        @listener = listener
+        @raise_on_error = raise_on_error
+        @machines = []
+        push_machine(machine_name)
+      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
+      end
+
+      def event(ev, line)
+        machine.event(ev, line) do |state, expected|
+          if @raise_on_error
+            raise ParseError.new(state, ev, expected, line)
+          else
+            @listener.syntax_error(state, ev, expected, line)
+            return false
+          end
+        end
+        true
+      end
+
+      def push_machine(name)
+        @machines.push(Machine.new(self, name))
+      end
+
+      def pop_machine
+        @machines.pop
+      end
+
+      def machine
+        @machines[-1]
+      end
+
+      def expected
+        machine.expected
+      end
+
+      def force_state(state)
+        machine.instance_variable_set('@state', state)
+      end
+
+      class Machine
+        def initialize(parser, name)
+          @parser = parser
+          @name = name
+          @transition_map = transition_map(name)
+          @state = name
+        end
+
+        def event(ev, line)
+          states = @transition_map[@state]
+          raise "Unknown state: #{@state.inspect} for machine #{@name}" if states.nil?
+          new_state = states[ev]
+          case new_state
+          when "E"
+            yield @state, expected
+          when /push\((.+)\)/
+            @parser.push_machine($1)
+            @parser.event(ev, line)
+          when "pop()"
+            @parser.pop_machine()
+            @parser.event(ev, line)
+          else
+            raise "Unknown transition: #{ev.inspect} among #{states.inspect} for machine #{@name}" if new_state.nil?
+            @state = new_state
+          end
+        end
+
+        def expected
+          allowed = @transition_map[@state].find_all { |_, action| action != "E" }
+          allowed.collect { |state| state[0] }.sort - ['eof']
+        end
+
+        private
+
+        @@transition_maps = {}
+
+        def transition_map(name)
+          @@transition_maps[name] ||= build_transition_map(name)
+        end
+
+        def build_transition_map(name)
+          table = transition_table(name)
+          events = table.shift[1..-1]
+          table.inject({}) do |machine, actions|
+            state = actions.shift
+            machine[state] = Hash[*events.zip(actions).flatten]
+            machine
+          end
+        end
+
+        def transition_table(name)
+          state_machine_reader = StateMachineReader.new
+          lexer = Gherkin::I18n.new('en').lexer(state_machine_reader, false)
+          lexer.scan(File.read(File.dirname(__FILE__) + "/#{name}.txt"))
+          state_machine_reader.rows
+        end
+
+        class StateMachineReader
+          attr_reader :rows
+
+          def initialize
+            @rows = []
+          end
+
+          def row(row, line_number)
+            @rows << row
+          end
+
+          def eof
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/gherkin/parser/sexp.rb

@@ -0,0 +1,45 @@
+module Gherkin
+  module Parser
+    class Sexp < Array
+      def initialize(*args)
+        super
+        self[1] = self[1].to_a if event == :row # Special JRuby handling
+      end
+
+      def event
+        self[0]
+      end
+
+      def keyword
+        self[1]
+      end
+      
+      def line_match?(lines)
+        lines.include?(line)
+      end
+
+      def name_match?(name_regexen)
+        return false unless [:feature, :scenario, :scenario_outline, :examples].include?(event)
+        name_regexen.detect{|name_regex| name =~ name_regex}
+      end
+
+      def replay(listener)
+        listener.__send__(event, *args)
+      end
+
+    private
+
+      def name
+        self[2]
+      end
+
+      def line
+        self[-1]
+      end
+
+      def args
+        self[1..-1]
+      end
+    end
+  end
+end

data/lib/gherkin/parser/tag_expression.rb

@@ -0,0 +1,46 @@
+module Gherkin
+  module Parser
+    class TagExpression
+      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)
+        negatives, positives = tags.partition{|tag| tag =~ /^~/}
+        positive_limits = Hash[*positives.map{|positive| tag, limit = positive.split(':'); [tag, limit ? limit.to_i : nil]}.flatten]
+        @limits.merge!(positive_limits)
+        @ands << (negatives + positive_limits.keys)
+      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
+end

data/lib/gherkin/rb_lexer.rb

@@ -1,7 +1,7 @@
 module Gherkin
   module RbLexer
-    def self.[](i18n_language)
-      name = i18n_language.gsub(/[\s-]/, '')
+    def self.[](i18n_language_name)
+      name = i18n_language_name.gsub(/[\s-]/, '')
       require "gherkin/rb_lexer/#{name}"
       i18n_lexer_class_name = name.capitalize
       const_get(i18n_lexer_class_name)

data/ragel/lexer_common.rl.erb

@@ -27,7 +27,7 @@
   Step = space* I18N_Step %begin_content ^EOL+ %store_step_content :> EOL+;
   Comment = space* '#' >begin_content ^EOL* %store_comment_content :> EOL+;
   
-  Tag = ( '@' [^@\r\n\t ]+ >begin_content ) %store_tag_content;
+  Tag = ( ('@' [^@\r\n\t ]+) >begin_content ) %store_tag_content;
   Tags = space* (Tag space*)+ EOL+;
   
   StartRow = space* '|' >start_row;

data/spec/gherkin/{format → formatter}/argument_spec.rb

@@ -1,9 +1,9 @@
 # encoding: utf-8
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-require 'gherkin/format/argument'
+require 'gherkin/formatter/argument'
 
 module Gherkin
-  module Format
+  module Formatter
     class BracketFormat
       class << self
         def new