gherkin 2.12.2 → 3.2.0

data/lib/gherkin/listener/event.rb

@@ -1,45 +0,0 @@
-module Gherkin
-  module Listener
-    class Event < Array
-      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)
-        begin
-          listener.__send__(event, *args)
-        rescue ArgumentError => e
-          e.message << "\nListener: #{listener.class}, args: #{args.inspect}"
-          raise e
-        end
-      end
-
-    private
-
-      def name
-        self[2]
-      end
-
-      def line
-        self[-1]
-      end
-
-      def args
-        self[1..-1]
-      end
-    end
-  end
-end

data/lib/gherkin/listener/formatter_listener.rb

@@ -1,150 +0,0 @@
-require 'gherkin/native'
-require 'gherkin/formatter/model'
-
-module Gherkin
-  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).
-    class FormatterListener
-      native_impl('gherkin')
-
-      def initialize(formatter)
-        @formatter = formatter
-        @stash = Stash.new
-        @current_builder = nil
-      end
-
-      def comment(value, line)
-        @stash.comment Formatter::Model::Comment.new(value, line)
-      end
-
-      def tag(name, line)
-        @stash.tag Formatter::Model::Tag.new(name, line)
-      end
-
-      def feature(keyword, name, description, line)
-        @stash.feature(name) do |comments, tags, id|
-          replay Formatter::Model::Feature.new(comments, tags, keyword, name, description, line, id)
-        end
-      end
-
-      def background(keyword, name, description, line)
-        @stash.feature_element(name) do |comments, tags, id|
-          replay Formatter::Model::Background.new(comments, keyword, name, description, line)
-        end
-      end
-
-      def scenario(keyword, name, description, line)
-        replay_step_or_examples
-        @stash.feature_element(name) do |comments, tags, id|
-          replay Formatter::Model::Scenario.new(comments, tags, keyword, name, description, line, id)
-        end
-      end
-
-      def scenario_outline(keyword, name, description, line)
-        replay_step_or_examples
-        @stash.feature_element(name) do |comments, tags, id|
-          replay Formatter::Model::ScenarioOutline.new(comments, tags, keyword, name, description, line, id)
-        end
-      end
-
-      def examples(keyword, name, description, line)
-        replay_step_or_examples
-        @stash.examples(name) do |comments, tags, id|
-          @current_builder = Formatter::Model::Examples::Builder.new(comments, tags, keyword, name, description, line, id)
-        end
-      end
-
-      def step(keyword, name, line)
-        replay_step_or_examples
-        @stash.step do |comments|
-          @current_builder = Formatter::Model::Step::Builder.new(comments, keyword, name, line)
-        end
-      end
-
-      def row(cells, line)
-        @stash.row do |comments, id|
-          @current_builder.row(comments, cells, line, id)
-        end
-      end
-
-      def doc_string(content_type, value, line)
-        @current_builder.doc_string(value, content_type, line)
-      end
-
-      def eof
-        replay_step_or_examples
-        @formatter.eof
-      end
-
-      def syntax_error(state, ev, legal_events, uri, line)
-        @formatter.syntax_error(state, ev, legal_events, uri, line)
-      end
-
-    private
-    
-      def replay(element)
-        element.replay(@formatter)
-      end
-      
-      class Stash
-        attr_reader :comments, :tags, :ids
-        
-        def initialize
-          @comments, @tags, @ids = [], [], []
-          @row_index = 0
-        end
-        
-        def comment(comment)
-          @comments << comment
-        end
-        
-        def feature(name)
-          @feature_id = id(name)
-          yield @comments, @tags, @feature_id
-          @comments, @tags = [], []
-        end
-
-        def feature_element(name)
-          @feature_element_id = "#{@feature_id};#{id(name)}"
-          yield @comments, @tags, @feature_element_id
-          @comments, @tags = [], []
-        end
-        
-        def examples(name)
-          @examples_id = "#{@feature_element_id};#{id(name)}"
-          @row_index = 0
-          yield @comments, @tags, @examples_id
-          @comments, @tags = [], []
-        end
-
-        def step
-          @row_index += 1
-          yield @comments
-          @comments = []
-        end
-
-        def row
-          @row_index += 1
-          yield @comments, defined?(@examples_id) ? "#{@examples_id};#{@row_index}" : :undefined_examples_id
-          @comments = []
-        end
-
-        def tag(tag)
-          @tags << tag
-        end
-
-        def id(name)
-          (name || '').gsub(/[\s_]/, '-').downcase
-        end
-      end
-
-      def replay_step_or_examples
-        return unless @current_builder
-        replay(@current_builder)
-        @current_builder = nil
-      end
-    end
-  end
-end

data/lib/gherkin/native.rb

@@ -1,7 +0,0 @@
-if defined?(JRUBY_VERSION)
-  require 'gherkin/native/java'
-elsif ENV['GHERKIN_JS_NATIVE']
-  require 'gherkin/native/therubyracer'
-else
-  require 'gherkin/native/null'
-end

data/lib/gherkin/native/java.rb

@@ -1,72 +0,0 @@
-class Class
-  class IOWriter < Java.java.io.Writer
-    def initialize(io)
-      @io = io
-    end
-    
-    def write(cbuf, off, len)
-      @io.write(cbuf.unpack("U*")[off..len].pack("U*"))
-    end
-
-    def flush
-      @io.flush
-    end
-
-    def close
-      @io.close
-    end
-  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 new(*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 javaify(arg)
-        if Array === arg
-          arg.map{|a| javaify(a)}
-        else
-          case(arg)
-          when Regexp
-            java.util.regex.Pattern.compile(arg.source)
-          when Symbol
-            arg.to_s
-          when IO, StringIO
-            IOWriter.new(arg)
-          else
-            arg
-          end
-        end
-      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

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

data/lib/gherkin/native/therubyracer.rb

@@ -1,41 +0,0 @@
-require 'v8'
-
-class Class
-  def native_impl(lib)
-    class << self
-      def new(*args)
-        js = {
-          # Add more mappings here if needed. The mappings are only used by test code.
-          'Gherkin::Formatter::JSONFormatter' => 'js/lib/gherkin/formatter/json_formatter.js',
-          'Gherkin::Lexer::En' => 'js/lib/gherkin/lexer/en.js'
-        }[self.name]
-        if(js)
-          Proxy.new(js, *args)
-        else
-          super(*args)
-        end
-      end
-    end
-  end
-
-  class Proxy
-    def initialize(js, *args)
-      cxt = V8::Context.new
-      cxt['module'] = {}
-
-      # Mimic Node.js / Firebug console.log
-      cxt['console'] = STDOUT
-      def STDOUT.log(*a)
-        puts sprintf(*a.map(&:to_s))
-      end
-
-      cxt.load(js)
-      @js_obj = cxt['module']['exports'].new(*args)
-    end
-
-    def method_missing(name, *args)
-      a = args.map{|a| a.respond_to?(:to_hash) ? a.to_hash : a}
-      @js_obj.__send__(name, *a)
-    end
-  end
-end

data/lib/gherkin/parser/meta.txt

@@ -1,5 +0,0 @@
- |         | feature | background | scenario | scenario_outline | examples | step  | row   | doc_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

@@ -1,166 +0,0 @@
-require 'gherkin/i18n'
-require 'gherkin/lexer/i18n_lexer'
-require 'gherkin/native'
-require 'gherkin/listener/formatter_listener'
-
-module Gherkin
-  module Parser
-    class ParseError < StandardError
-      def initialize(state, new_state, expected_states, uri, line)
-        super("Parse error at #{uri}:#{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(formatter, raise_on_error=true, machine_name='root', force_ruby=false, iso_code = 'en')
-        @formatter = formatter
-        @listener = Listener::FormatterListener.new(@formatter)
-        @raise_on_error = raise_on_error
-        @machine_name = machine_name
-        @machines = []
-        @lexer = Gherkin::Lexer::I18nLexer.new(self, force_ruby, iso_code)
-      end
-
-      def parse(gherkin, feature_uri, line_offset)
-        @formatter.uri(feature_uri)
-        @line_offset = line_offset
-        @feature_uri = feature_uri
-        push_machine(@machine_name)
-        begin
-          @lexer.scan(gherkin)
-        ensure
-          pop_machine
-        end
-      end
-
-      def i18n_language
-        @lexer.i18n_language
-      end
-
-      def errors
-        @lexer.errors
-      end
-
-      [:comment, :tag, :feature, :background, :scenario, :scenario_outline, :examples, :step, :doc_string, :row, :eof].each do |m|
-        define_method(m) do |*args|
-          if(event(m.to_s, args[-1]))
-            @listener.__send__(m, *args)
-          end
-        end
-      end
-      
-      def event(ev, line)
-        l = line ? @line_offset+line : nil
-        machine.event(ev, l) do |state, legal_events|
-          if @raise_on_error
-            raise ParseError.new(state, ev, legal_events, @feature_uri, l)
-          else
-            # Only used for testing
-            @listener.syntax_error(state, ev, legal_events, @feature_uri, l)
-          end
-        end
-      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)
-          machine = File.dirname(__FILE__) + "/#{name}.txt"
-          lexer.scan(File.read(machine))
-          state_machine_reader.rows
-        end
-
-        class StateMachineReader
-          attr_reader :rows
-
-          def initialize
-            @rows = []
-          end
-
-          def uri(uri)
-          end
-
-          def row(row, line_number)
-            @rows << row
-          end
-
-          def eof
-          end
-        end
-
-      end
-    end
-  end
-end