bryanl-gherkin 2.11.1.1-java

data/lib/gherkin/json_parser.rb

@@ -0,0 +1,177 @@
+require 'json'
+require 'gherkin/formatter/model'
+require 'gherkin/formatter/argument'
+require 'gherkin/native'
+require 'base64'
+
+module Gherkin
+  class JSONParser
+    native_impl('gherkin')
+
+    include Base64
+
+    def initialize(reporter, formatter)
+      @reporter, @formatter = reporter, formatter
+    end
+
+    # Parse a gherkin object +o+, which can either be a JSON String,
+    # or a Hash (from a parsed JSON String).
+    def parse(o)
+      o = JSON.parse(o) if String === o
+
+      o.each do |f|
+        @formatter.uri(f['uri'])
+        Formatter::Model::Feature.new(comments(f), tags(f), keyword(f), name(f), description(f), line(f), id(f)).replay(@formatter)
+        (f["elements"] || []).each do |feature_element|
+          feature_element(feature_element).replay(@formatter)
+
+          (feature_element["before"] || []).each do |hook|
+            before(hook)
+          end
+
+          (feature_element["steps"] || []).each do |step|
+            step(step).replay(@formatter)
+            match(step)
+            result(step)
+            embeddings(step)
+            output(step)
+          end
+
+          (feature_element["after"] || []).each do |hook|
+            after(hook)
+          end
+
+          (feature_element["examples"] || []).each do |eo|
+            Formatter::Model::Examples.new(comments(eo), tags(eo), keyword(eo), name(eo), description(eo), line(eo), id(eo), examples_rows(eo['rows'])).replay(@formatter)
+          end
+        end
+      end
+
+      @formatter.eof
+    end
+
+  private
+
+    def feature_element(o)
+      case o['type']
+      when 'background'
+        Formatter::Model::Background.new(comments(o), keyword(o), name(o), description(o), line(o))
+      when 'scenario'
+        Formatter::Model::Scenario.new(comments(o), tags(o), keyword(o), name(o), description(o), line(o), id(o))
+      when 'scenario_outline'
+        Formatter::Model::ScenarioOutline.new(comments(o), tags(o), keyword(o), name(o), description(o), line(o), id(o))
+      end
+    end
+
+    def step(o)
+      builder = Formatter::Model::Step::Builder.new(comments(o), keyword(o), name(o), line(o))
+
+      (o['rows'] || []).each do |row|
+        builder.row comments(row), row['cells'], row['line'], nil
+      end
+
+      if(o['doc_string'])
+        ds = o['doc_string']
+        builder.doc_string ds['value'], ds['content_type'].to_s, ds['line']
+      end
+
+      builder.build
+    end
+
+    def match(o)
+      if(m = o['match'])
+        Formatter::Model::Match.new(arguments(m), location(m)).replay(@reporter)
+      end
+    end
+
+    def result(o)
+      if(r = o['result'])
+        Formatter::Model::Result.new(status(r), duration(r), error_message(r)).replay(@reporter)
+      end
+    end
+
+    def before(o)
+      m = o['match']
+      match = Formatter::Model::Match.new([], location(m))
+      r = o['result']
+      result = Formatter::Model::Result.new(status(r), duration(r), error_message(r))
+      @reporter.before(match, result)
+    end
+
+    def after(o)
+      m = o['match']
+      match = Formatter::Model::Match.new([], location(m))
+      r = o['result']
+      result = Formatter::Model::Result.new(status(r), duration(r), error_message(r))
+      @reporter.after(match, result)
+    end
+
+    def embeddings(o)
+      (o['embeddings'] || []).each do |embedding|
+        @reporter.embedding(embedding['mime_type'], Base64::decode64(embedding['data']))
+      end
+    end
+
+    def output(o)
+      (o['output'] || []).each do |text|
+        @reporter.write(text)
+      end
+    end
+
+    def examples_rows(o)
+      o.map{|row| Formatter::Model::ExamplesTableRow.new(comments(row), row['cells'], row['line'], row['id'])}
+    end
+
+    def comments(o)
+      (o['comments'] || []).map do |comment|
+        Formatter::Model::Comment.new(comment['value'], comment['line'])
+      end
+    end
+
+    def tags(o)
+      (o['tags'] || []).map do |tag|
+        Formatter::Model::Tag.new(tag['name'], tag['line'])
+      end
+    end
+
+    def keyword(o)
+      o['keyword']
+    end
+
+    def name(o)
+      o['name']
+    end
+
+    def description(o)
+      o['description']
+    end
+
+    def line(o)
+      o['line']
+    end
+
+    def id(o)
+      o['id']
+    end
+
+    def arguments(m)
+      m['arguments'].map{|a| Formatter::Argument.new(a['offset'], a['val'])}
+    end
+
+    def location(m)
+      m['location']
+    end
+
+    def status(r)
+      r['status']
+    end
+
+    def duration(r)
+      r['duration']
+    end
+
+    def error_message(r)
+      r['error_message']
+    end
+  end
+end

data/lib/gherkin/lexer/i18n_lexer.rb

@@ -0,0 +1,46 @@
+require 'gherkin/i18n'
+require 'gherkin/native'
+
+module Gherkin
+  module Lexer
+    LexingError = Class.new(StandardError)
+
+    # The main entry point to lexing Gherkin source.
+    class I18nLexer
+      native_impl('gherkin')
+
+      COMMENT_OR_EMPTY_LINE_PATTERN = /^\s*#|^\s*$/
+      LANGUAGE_PATTERN = /^\s*#\s*language\s*:\s*([a-zA-Z\-]+)/ #: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)
+        key = 'en'
+        source.each_line do |line|
+          break unless COMMENT_OR_EMPTY_LINE_PATTERN =~ line
+          if LANGUAGE_PATTERN =~ line
+            key = $1
+            break
+          end
+        end
+        I18n.get(key)
+      end
+
+    end
+  end
+end

data/lib/gherkin/listener/event.rb

@@ -0,0 +1,45 @@
+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

@@ -0,0 +1,143 @@
+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
+      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.basic_statement do |comments, id|
+          @current_builder = Formatter::Model::Step::Builder.new(comments, keyword, name, line)
+        end
+      end
+
+      def row(cells, line)
+        @stash.basic_statement 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 basic_statement
+          @row_index += 1
+          yield @comments, "#{@examples_id};#{@row_index}"
+          @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/java.rb

@@ -0,0 +1,72 @@
+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
+            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

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

data/lib/gherkin/native/therubyracer.rb

@@ -0,0 +1,39 @@
+require 'v8'
+
+class Class
+  def native_impl(lib)
+    class << self
+      def new(*args)
+        js = {
+          'Gherkin::Formatter::JSONFormatter' => 'js/lib/gherkin/formatter/json_formatter.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)
+      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/native.rb

@@ -0,0 +1,7 @@
+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/parser/meta.txt

@@ -0,0 +1,5 @@
+ |         | 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

@@ -0,0 +1,164 @@
+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)
+        @formatter = formatter
+        @listener = Listener::FormatterListener.new(@formatter)
+        @raise_on_error = raise_on_error
+        @machine_name = machine_name
+        @machines = []
+        push_machine(@machine_name)
+        @lexer = Gherkin::Lexer::I18nLexer.new(self, force_ruby)
+      end
+
+      def parse(gherkin, feature_uri, line_offset)
+        @formatter.uri(feature_uri)
+        @line_offset = line_offset
+        @lexer.scan(gherkin)
+      end
+
+      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
+        event(method.to_s, args[-1])
+        @listener.__send__(method, *args)
+        if method == :eof
+          pop_machine
+          push_machine(@machine_name)
+        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