benhamill-gherkin 2.3.5

data/lib/gherkin/json_parser.rb

@@ -0,0 +1,137 @@
+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(formatter)
+      @formatter = 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, feature_uri='unknown.json', line_offset=0)
+      o = JSON.parse(o) if String === o
+      @formatter.uri(feature_uri)
+
+      Formatter::Model::Feature.new(comments(o), tags(o), keyword(o), name(o), description(o), line(o)).replay(@formatter)
+      (o["elements"] || []).each do |feature_element|
+        feature_element(feature_element).replay(@formatter)
+        (feature_element["steps"] || []).each do |step|
+          step(step).replay(@formatter)
+          match(step)
+          result(step)
+          embeddings(step)
+        end
+        (feature_element["examples"] || []).each do |eo|
+          Formatter::Model::Examples.new(comments(eo), tags(eo), keyword(eo), name(eo), description(eo), line(eo), rows(eo['rows'])).replay(@formatter)
+        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))
+      when 'scenario_outline'
+        Formatter::Model::ScenarioOutline.new(comments(o), tags(o), keyword(o), name(o), description(o), line(o))
+      end
+    end
+
+    def step(o)
+      step = Formatter::Model::Step.new(comments(o), keyword(o), name(o), line(o))
+
+      if(ma = o['multiline_arg'])
+        if(ma['type'] == 'table')
+          step.multiline_arg = rows(ma['value'])
+        else
+          step.multiline_arg = Formatter::Model::PyString.new(ma['value'], ma['line'])
+        end
+      end
+
+      step
+    end
+
+    def match(o)
+      if(m = o['match'])
+        Formatter::Model::Match.new(arguments(m), location(m)).replay(@formatter)
+      end
+    end
+
+    def result(o)
+      if(r = o['result'])
+        Formatter::Model::Result.new(status(r), duration(r), error_message(r)).replay(@formatter)
+      end
+    end
+
+    def embeddings(o)
+      (o['embeddings'] || []).each do |embedding|
+        @formatter.embedding(embedding['mime_type'], Base64::decode64(embedding['data']))
+      end
+    end
+
+    def rows(o)
+      o.map{|row| Formatter::Model::Row.new(comments(row), row['cells'], row['line'])}
+    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 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,47 @@
+require 'gherkin/i18n'
+require 'gherkin/native'
+
+module Gherkin
+  module Lexer
+    I18nLexerNotFound = Class.new(LoadError)
+    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,113 @@
+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
+        @comments = []
+        @tags = []
+        @table = nil
+      end
+
+      def comment(value, line)
+        @comments << Formatter::Model::Comment.new(value, line)
+      end
+
+      def tag(name, line)
+        @tags << Formatter::Model::Tag.new(name, line)
+      end
+
+      def feature(keyword, name, description, line)
+        @formatter.feature(Formatter::Model::Feature.new(grab_comments!, grab_tags!, keyword, name, description, line))
+      end
+
+      def background(keyword, name, description, line)
+        @formatter.background(Formatter::Model::Background.new(grab_comments!, keyword, name, description, line))
+      end
+
+      def scenario(keyword, name, description, line)
+        replay_step_or_examples
+        @formatter.scenario(Formatter::Model::Scenario.new(grab_comments!, grab_tags!, keyword, name, description, line))
+      end
+
+      def scenario_outline(keyword, name, description, line)
+        replay_step_or_examples
+        @formatter.scenario_outline(Formatter::Model::ScenarioOutline.new(grab_comments!, grab_tags!, keyword, name, description, line))
+      end
+
+      def examples(keyword, name, description, line)
+        replay_step_or_examples
+        @examples_statement = Formatter::Model::Examples.new(grab_comments!, grab_tags!, keyword, name, description, line)
+      end
+
+      def step(keyword, name, line)
+        replay_step_or_examples
+        @step_statement = Formatter::Model::Step.new(grab_comments!, keyword, name, line)
+      end
+
+      def row(cells, line)
+        @table ||= []
+        @table << Formatter::Model::Row.new(grab_comments!, cells, line)
+      end
+
+      def py_string(string, line)
+        @py_string = Formatter::Model::PyString.new(string, 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 grab_comments!
+        comments = @comments
+        @comments = []
+        comments
+      end
+
+      def grab_tags!
+        tags = @tags
+        @tags = []
+        tags
+      end
+
+      def grab_rows!
+        table = @table
+        @table = nil
+        table
+      end
+
+      def grab_py_string!
+        py_string = @py_string
+        @py_string = nil
+        py_string
+      end
+
+      def replay_step_or_examples
+        if(@step_statement)
+          @step_statement.multiline_arg = grab_py_string! || grab_rows!
+          @formatter.step(@step_statement)
+          @step_statement = nil
+        end
+        if(@examples_statement)
+          @examples_statement.rows = grab_rows!
+          @formatter.examples(@examples_statement)
+          @examples_statement = nil
+        end
+      end
+    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,55 @@
+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)
+        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)
+        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