gherkin 1.0.30-universal-dotnet

data/lib/gherkin/i18n_lexer.rb

@@ -0,0 +1,38 @@
+require 'gherkin/i18n'
+require 'gherkin/native'
+
+module Gherkin
+  I18nLexerNotFound = Class.new(LoadError)
+  LexingError = Class.new(StandardError)
+
+  # The main entry point to lexing Gherkin source.
+  class I18nLexer
+    native_impl('gherkin')
+
+    LANGUAGE_PATTERN = /language\s*:\s*(.*)/ #: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

data/lib/gherkin/native.rb

@@ -0,0 +1,7 @@
+if defined?(RUBY_ENGINE) && RUBY_ENGINE == "ironruby"
+  require 'gherkin/native/ikvm'
+elsif defined?(JRUBY_VERSION)
+  require 'gherkin/native/java'
+else
+  require 'gherkin/native/null'
+end

data/lib/gherkin/native/ikvm.rb

@@ -0,0 +1,55 @@
+class Class
+
+  def implements(java_class_name)
+    m = java_class_name.split('.').inject(Object) do |mod, name|
+      mod = mod.const_get(name)
+    end
+    include m
+  end
+
+  # Causes a .NET class to be instantiated instead of the Ruby class when 
+  # running on IronRuby. This is used to test both pure .NET and pure Ruby classes 
+  # from the same Ruby based test suite. The .NET Class must have a package name
+  # that corresponds with the Ruby class.
+  def native_impl(lib)
+    begin
+      load_assembly(lib)
+    rescue LoadError => e
+      e.message << "\nTry this: SET MONO_PATH=#{File.expand_path(File.dirname(__FILE__) + '/../..')} (or export MONO_PATH=...)"
+      raise e
+    end
+
+    class << self
+      def ikvmify(arg)
+        if Array === arg
+          arg.map{|a| ikvmify(a)}
+        else
+          case(arg)
+          when Regexp
+            Object.const_get('java').const_get('util').const_get('regex').const_get('Pattern').compile(arg.source)
+          else
+            arg
+          end
+        end
+      end
+
+      def new(*args)
+        ikvm_class.new(*ikvmify(args))
+      end
+
+      def ===(object)
+        super || object.java_kind_of?(java_class)
+      end
+
+      def ikvm_class
+        names = self.name.split('::')
+        namespace = Object
+        names[0..-2].each do |module_name|
+          namespace = namespace.const_get(module_name.downcase)
+        end
+
+        namespace.const_get(names[-1])
+      end
+    end
+  end
+end

data/lib/gherkin/native/java.rb

@@ -0,0 +1,47 @@
+class Class
+
+  def implements(java_class_name)
+    # no-op
+  end
+
+  # Causes a Java class to be instantiated instead of the Ruby class when 
+  # running on JRuby. This is used to test both pure Java and pure Ruby classes 
+  # from the same Ruby based test suite. The Java Class must have a package name
+  # that corresponds with the Ruby class.
+  def native_impl(lib)
+    require "#{lib}.jar"
+
+    class << self
+      def javaify(arg)
+        if Array === arg
+          arg.map{|a| javaify(a)}
+        else
+          case(arg)
+          when Regexp
+            java.util.regex.Pattern.compile(arg.source)
+          else
+            arg
+          end
+        end
+      end
+
+      def new(*args)
+        java_class.new(*javaify(args))
+      end
+
+      def ===(object)
+        super || object.java_kind_of?(java_class)
+      end
+
+      def java_class
+        names = self.name.split('::')
+        package = Java
+        names[0..-2].each do |module_name|
+          package = package.__send__(module_name.downcase)
+        end
+
+        package.__send__(names[-1])
+      end
+    end
+  end
+end

data/lib/gherkin/native/null.rb

@@ -0,0 +1,9 @@
+class Class
+  def implements(java_class_name)
+    # no-op
+  end
+
+  def native_impl(lib)
+    # no-op
+  end
+end

data/lib/gherkin/parser/event.rb

@@ -0,0 +1,45 @@
+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
+
+      def keyword
+        self[1]
+      end
+      
+      def line_match?(lines)
+        lines.include?(line)
+      end
+
+      def name_match?(name_regexen)
+        return false unless [:feature, :background, :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/filter_listener.rb

@@ -0,0 +1,199 @@
+require 'gherkin/parser/event'
+require 'gherkin/parser/tag_expression'
+require 'gherkin/native'
+
+module Gherkin
+  module Parser
+    # This class filters events based on filter criteria.
+    class FilterListener
+      native_impl('gherkin')
+    
+      # Creates a new instance that replays events to +listener+, filtered by +filters+,
+      # an Array that can contain one of the following:
+      #
+      # * Line numbers (Fixnum) to filter on.
+      # * Name regexen (Regexp) to filter on. Matches against :feature, :background, :scenario, :scenario_outline and :examples
+      # * Tag expressions (String) 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(*event_args)
+        event = Event.new(event_args)
+
+        return event.replay(@listener) if no_filters?
+
+        case(event.event)
+        when :tag
+          @meta_buffer << event
+        when :comment
+          @meta_buffer << event
+        when :feature
+          @feature_buffer = @meta_buffer
+          @feature_buffer << event
+          @feature_tags = extract_tags
+          @meta_buffer = []
+          @feature_ok = true if filter_match?(event)
+        when :background
+          @feature_buffer += @meta_buffer
+          @feature_buffer << event
+          @meta_buffer = []
+          @table_state = :background
+          @background_ok = true if filter_match?(event)
+        when :scenario
+          replay_examples_rows_buffer
+          @scenario_buffer = @meta_buffer
+          @scenario_buffer << event
+          @scenario_tags = extract_tags
+          @example_tags = []
+          @meta_buffer = []
+          @scenario_ok = filter_match?(*@scenario_buffer) || tag_match?
+          @examples_ok = false
+          @background_ok = false
+          @table_state = :step
+        when :scenario_outline
+          replay_examples_rows_buffer
+          @scenario_buffer = @meta_buffer
+          @scenario_buffer << event
+          @scenario_tags = extract_tags
+          @example_tags = []
+          @meta_buffer = []
+          @scenario_ok = filter_match?(*@scenario_buffer)
+          @examples_ok = false
+          @background_ok = false
+          @table_state = :step
+        when :examples
+          replay_examples_rows_buffer
+          @examples_buffer = @meta_buffer
+          @examples_buffer << event
+          @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 << event
+            @meta_buffer = []
+            @background_ok = true if filter_match?(event)
+          else
+            @scenario_buffer << event
+            @scenario_ok ||= filter_match?(*@scenario_buffer)
+            @table_state = :step
+          end
+        when :row
+          case(@table_state)
+          when :examples
+            unless header_row_already_buffered?
+              @examples_buffer << event
+              @examples_ok = true if filter_match?(*@examples_buffer)
+            else
+              @examples_rows_buffer << event if @scenario_ok || @examples_ok || @feature_ok || filter_match?(event)
+            end
+          when :step
+            @scenario_buffer << event
+            @scenario_ok ||= filter_match?(*@scenario_buffer)
+          when :background
+            @feature_buffer += @meta_buffer
+            @feature_buffer << event
+            @meta_buffer = []
+          else
+            raise "Bad table_state:#{@table_state.inspect}"
+          end
+        when :py_string
+          if @table_state == :background
+            @feature_buffer << event
+            @feature_ok ||= filter_match?(*@feature_buffer)
+          else
+            @scenario_buffer << event
+            @scenario_ok ||= filter_match?(*@scenario_buffer)
+          end
+        when :eof
+          replay_examples_rows_buffer
+          event.replay(@listener)
+          return
+        else
+          super
+        end
+
+        if @scenario_ok || @examples_ok || @feature_ok || @background_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 @examples_buffer.any? && @examples_buffer[-1].event == :row
+      end
+      
+      def filter_match?(*events)
+        return false unless[:name_match?, :line_match?].include?(@filter_method)
+        events.detect{|event| event.__send__(@filter_method, @filters)}
+      end
+
+      def tag_match?
+        return TagExpression === @filter_method && @filter_method.eval(current_tags)
+      end
+
+      def replay_buffers
+        (@feature_buffer + @scenario_buffer).each do |event| 
+          event.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 |event|
+            event.replay(@listener)
+          end
+          @examples_rows_buffer = []
+        end
+      end
+      
+      def current_tags
+        @feature_tags + @scenario_tags + @example_tags
+      end
+
+      def extract_tags
+        @meta_buffer.select { |event| event.event == :tag }.map { |event| event.keyword }
+      end
+    end
+  end
+end

data/lib/gherkin/parser/meta.txt

@@ -0,0 +1,5 @@
+ |         | feature | background | scenario | scenario_outline | examples | step  | row   | py_string | eof | comment | tag |
+ | meta    | E       | E          | E        | E                | E        | E     | E     | E         | eof | comment | tag |
+ | comment | pop()   | pop()      | pop()    | pop()            | pop()    | pop() | pop() | pop()     | eof | pop()   | tag |
+ | tag     | pop()   | E          | pop()    | pop()            | pop()    | E     | E     | E         | E   | E       | tag |
+ | eof     | E       | E          | E        | E                | E        | E     | E     | E         | E   | E       | E   |

data/lib/gherkin/parser/parser.rb

@@ -0,0 +1,142 @@
+require 'gherkin/native'
+
+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
+      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
+        @raise_on_error = raise_on_error
+        @machines = []
+        @machine_name = machine_name
+        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
+        if method == :eof
+          pop_machine
+          push_machine(@machine_name)
+        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)
+          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