cucumber 0.8.5 → 0.8.6

data/lib/cucumber/rake/task.rb

@@ -1,4 +1,12 @@
 require 'cucumber/platform'
+require 'gherkin/formatter/ansi_escapes'
+
+begin
+  # Support Rake > 0.8.7
+  require 'rake/dsl_definition'
+  include Rake::DSL
+rescue LoadError
+end
 
 module Cucumber
   module Rake
@@ -8,7 +16,7 @@ module Cucumber
     #
     #   Cucumber::Rake::Task.new
     #
-    # This will define a task named <tt>cucumber</tt> described as 'Run Cucumber features'. 
+    # This will define a task named <tt>cucumber</tt> described as 'Run Cucumber features'.
     # It will use steps from 'features/**/*.rb' and features in 'features/**/*.feature'.
     #
     # To further configure the task, you can pass a block:
@@ -22,68 +30,96 @@ module Cucumber
     #   Cucumber::Rake::Task.new do |t|
     #     t.rcov = true
     #   end
-    # 
+    #
     # See the attributes for additional configuration possibilities.
     class Task
+      include Gherkin::Formatter::AnsiEscapes
+
       class InProcessCucumberRunner #:nodoc:
         attr_reader :args
-        
+
         def initialize(libs, cucumber_opts, feature_files)
           raise "libs must be an Array when running in-process" unless Array === libs
           libs.reverse.each{|lib| $LOAD_PATH.unshift(lib)}
           @args = (
-            cucumber_opts + 
+            cucumber_opts +
             feature_files
           ).flatten.compact
         end
-        
+
         def run
           require 'cucumber/cli/main'
           failure = Cucumber::Cli::Main.execute(args)
           raise "Cucumber failed" if failure
         end
       end
-      
+
       class ForkedCucumberRunner #:nodoc:
-        attr_reader :args
-        
-        def initialize(libs, cucumber_bin, cucumber_opts, feature_files)
-          @args = (
-            ['-I'] + load_path(libs) + 
-            quoted_binary(cucumber_bin) + 
-            cucumber_opts + 
-            feature_files
-          ).flatten
+
+        def initialize(libs, cucumber_bin, cucumber_opts, bundler, feature_files)
+          @libs          = libs
+          @cucumber_bin  = cucumber_bin
+          @cucumber_opts = cucumber_opts
+          @bundler       = bundler
+          @feature_files = feature_files
         end
 
         def load_path(libs)
-          ['"%s"' % libs.join(File::PATH_SEPARATOR)]
+          ['"%s"' % @libs.join(File::PATH_SEPARATOR)]
         end
 
         def quoted_binary(cucumber_bin)
           ['"%s"' % cucumber_bin]
         end
 
-        def runner
-          File.exist?("./Gemfile") ? ["bundle", "exec", RUBY] : [RUBY]
+        def use_bundler
+          @bundler.nil? ? File.exist?("./Gemfile") && gem_available?("bundler") : @bundler
+        end
+
+        def gem_available?(gemname)
+          gem_available_new_rubygems?(gemname) || gem_available_old_rubygems?(gemname)
+        end
+
+        def gem_available_old_rubygems?(gemname)
+          Gem.available?(gemname)
+        end
+
+        def gem_available_new_rubygems?(gemname)
+          Gem::Specification.respond_to?(:find_all_by_name) && Gem::Specification.find_all_by_name(gemname).any?
+        end
+
+        def cmd
+          if use_bundler
+            [ Cucumber::RUBY_BINARY, '-S', 'bundle', 'exec', 'cucumber', @cucumber_opts,
+            @feature_files ].flatten
+          else
+            [ Cucumber::RUBY_BINARY, '-I', load_path(@libs), quoted_binary(@cucumber_bin),
+            @cucumber_opts, @feature_files ].flatten
+          end
         end
 
         def run
-          sh((runner + args).join(" "))
+          sh(cmd.join(" "))
         end
       end
 
       class RCovCucumberRunner < ForkedCucumberRunner #:nodoc:
-        def initialize(libs, cucumber_bin, cucumber_opts, feature_files, rcov_opts)
-          @args = (
-            ['-I'] + load_path(libs) + 
-            ['-S', 'rcov'] + rcov_opts +
-            quoted_binary(cucumber_bin) + 
-            ['--'] + 
-            cucumber_opts + 
-            feature_files
-          ).flatten
+
+        def initialize(libs, cucumber_bin, cucumber_opts, bundler, feature_files, rcov_opts)
+          super(       libs, cucumber_bin, cucumber_opts, bundler, feature_files )
+          @rcov_opts = rcov_opts
+        end
+
+        def cmd
+          if use_bundler
+            [Cucumber::RUBY_BINARY, '-S', 'bundle', 'exec', 'rcov', @rcov_opts,
+             quoted_binary(@cucumber_bin), '--', @cucumber_opts, @feature_files].flatten
+          else
+            [Cucumber::RUBY_BINARY, '-I', load_path(@libs), '-S', 'rcov', @rcov_opts,
+             quoted_binary(@cucumber_bin), '--', @cucumber_opts, @feature_files].flatten
+          end
         end
+        
       end
 
       LIB = File.expand_path(File.dirname(__FILE__) + '/../..') #:nodoc:
@@ -104,6 +140,12 @@ module Cucumber
       # Run cucumber with RCov? Defaults to false. If you set this to
       # true, +fork+ is implicit.
       attr_accessor :rcov
+      def rcov=(flag)
+        if(flag && Cucumber::RUBY_1_9)
+          raise failed + "RCov only works on Ruby 1.8.x. You may want to use SimpleCov: https://github.com/colszowka/simplecov" + reset
+        end
+        @rcov = flag
+      end
 
       # Extra options to pass to rcov.
       # It's recommended to pass an Array, but if it's a String it will be #split by ' '.
@@ -117,10 +159,17 @@ module Cucumber
       # your load path and gems.
       attr_accessor :fork
 
-      # Define what profile to be used.  When used with cucumber_opts it is simply appended 
+      # Define what profile to be used.  When used with cucumber_opts it is simply appended
       # to it. Will be ignored when CUCUMBER_OPTS is used.
       attr_accessor :profile
 
+      # Whether or not to run with bundler (bundle exec). Setting this to false may speed
+      # up the execution. The default value is true if Bundler is installed and you have
+      # a Gemfile, false otherwise.
+      #
+      # Note that this attribute has no effect if you don't run in forked mode.
+      attr_accessor :bundler
+
       # Define Cucumber Rake task
       def initialize(task_name = "cucumber", desc = "Run Cucumber features")
         @task_name, @desc = task_name, desc
@@ -146,9 +195,9 @@ module Cucumber
       def runner(task_args = nil) #:nodoc:
         cucumber_opts = [(ENV['CUCUMBER_OPTS'] ? ENV['CUCUMBER_OPTS'].split(/\s+/) : nil) || cucumber_opts_with_profile]
         if(@rcov)
-          RCovCucumberRunner.new(libs, binary, cucumber_opts, feature_files, rcov_opts)
+          RCovCucumberRunner.new(libs, binary, cucumber_opts, bundler, feature_files, rcov_opts)
         elsif(@fork)
-          ForkedCucumberRunner.new(libs, binary, cucumber_opts, feature_files)
+          ForkedCucumberRunner.new(libs, binary, cucumber_opts, bundler, feature_files)
         else
           InProcessCucumberRunner.new(libs, cucumber_opts, feature_files)
         end

data/lib/cucumber/rb_support/rb_dsl.rb

@@ -88,6 +88,7 @@ module Cucumber
       
       # Registers a proc that will run after Cucumber is configured. You can register as 
       # as you want (typically from ruby scripts under <tt>support/hooks.rb</tt>).
+      # TODO: Deprecate this
       def AfterConfiguration(&proc)
         RbDsl.register_rb_hook('after_configuration', [], proc)
       end      

data/lib/cucumber/rb_support/rb_language.rb

@@ -1,3 +1,4 @@
+require 'cucumber/core_ext/instance_exec'
 require 'cucumber/rb_support/rb_dsl'
 require 'cucumber/rb_support/rb_world'
 require 'cucumber/rb_support/rb_step_definition'
@@ -21,7 +22,7 @@ module Cucumber
         message << first_proc.backtrace_line('World') << "\n"
         message << second_proc.backtrace_line('World') << "\n\n"
         message << "Use Ruby modules instead to extend your worlds. See the Cucumber::RbSupport::RbDsl#World RDoc\n"
-        message << "or http://wiki.github.com/aslakhellesoy/cucumber/a-whole-new-world.\n\n"
+        message << "or http://wiki.github.com/cucumber/cucumber/a-whole-new-world.\n\n"
         super(message)
       end
     end
@@ -29,7 +30,8 @@ module Cucumber
     # The Ruby implementation of the programming language API.
     class RbLanguage
       include LanguageSupport::LanguageMethods
-      attr_reader :current_world
+      attr_reader :current_world,
+                  :step_definitions
 
       Gherkin::I18n.code_keywords.each do |adverb|
         RbDsl.alias_adverb(adverb)
@@ -65,7 +67,7 @@ module Cucumber
 
       # Gets called for each file under features (or whatever is overridden
       # with --require).
-      def step_definitions_for(rb_file)
+      def step_definitions_for(rb_file) # Looks Unused - Delete?
         begin
           require rb_file # This will cause self.add_step_definition and self.add_hook to be called from RbDsl
           step_definitions
@@ -76,7 +78,7 @@ module Cucumber
           @step_definitions = nil
         end
       end
-
+      
       def step_matches(name_to_match, name_to_format)
         @step_definitions.map do |step_definition|
           if(arguments = step_definition.arguments_from(name_to_match))
@@ -89,7 +91,7 @@ module Cucumber
 
       ARGUMENT_PATTERNS = ['"([^"]*)"', '(\d+)']
 
-      def snippet_text(step_keyword, step_name, multiline_arg_class)
+      def snippet_text(code_keyword, step_name, multiline_arg_class)
         snippet_pattern = Regexp.escape(step_name).gsub('\ ', ' ').gsub('/', '\/')
         arg_count = 0
         ARGUMENT_PATTERNS.each do |pattern|
@@ -105,7 +107,7 @@ module Cucumber
           multiline_class_comment = "# #{multiline_arg_class.default_arg_name} is a #{multiline_arg_class.to_s}\n  "
         end
 
-        "#{Gherkin::I18n.code_keyword_for(step_keyword)} /^#{snippet_pattern}$/ do#{block_arg_string}\n  #{multiline_class_comment}pending # express the regexp above with the code you wish you had\nend"
+        "#{code_keyword} /^#{snippet_pattern}$/ do#{block_arg_string}\n  #{multiline_class_comment}pending # express the regexp above with the code you wish you had\nend"
       end
 
       def begin_rb_scenario(scenario)
@@ -138,9 +140,9 @@ module Cucumber
       end
 
       def load_code_file(code_file)
-        require File.expand_path(code_file) # This will cause self.add_step_definition, self.add_hook, and self.add_transform to be called from RbDsl
+        load File.expand_path(code_file) # This will cause self.add_step_definition, self.add_hook, and self.add_transform to be called from RbDsl
       end
-
+      
       protected
 
       def begin_scenario(scenario)

data/lib/cucumber/rb_support/rb_step_definition.rb

@@ -38,6 +38,14 @@ module Cucumber
         @regexp.inspect
       end
 
+      def to_hash
+        flags = ''
+        flags += 'm' if (@regexp.options & Regexp::MULTILINE) != 0
+        flags += 'i' if (@regexp.options & Regexp::IGNORECASE) != 0
+        flags += 'x' if (@regexp.options & Regexp::EXTENDED) != 0
+        {'source' => @regexp.source, 'flags' => flags}
+      end
+
       def ==(step_definition)
         regexp_source == step_definition.regexp_source
       end

data/lib/cucumber/rb_support/rb_transform.rb

@@ -32,6 +32,23 @@ module Cucumber
           @rb_language.current_world.cucumber_instance_exec(true, @regexp.inspect, *args, &@proc)
         end
       end
+    
+      def to_s
+        strip_captures(strip_anchors(@regexp.source))
+      end
+    
+    private
+
+      def strip_captures(regexp_source)
+        regexp_source.
+          gsub(/(\()/, '').
+          gsub(/(\))/, '')
+      end
+
+      def strip_anchors(regexp_source)
+        regexp_source.
+          gsub(/(^\^|\$$)/, '')
+      end
     end
   end
 end

data/lib/cucumber/rb_support/rb_world.rb

@@ -1,7 +1,11 @@
+require 'gherkin/formatter/ansi_escapes'
+
 module Cucumber
   module RbSupport
     # All steps are run in the context of an object that extends this module.
     module RbWorld
+      include Gherkin::Formatter::AnsiEscapes
+
       class << self
         def alias_adverb(adverb)
           alias_method adverb, :__cucumber_invoke
@@ -32,14 +36,19 @@ module Cucumber
         @__cucumber_step_mother.table(text_or_table, file, line_offset)
       end
 
-      # See StepMother#py_string
-      def py_string(string_with_triple_quotes, file=nil, line_offset=0)
-        @__cucumber_step_mother.py_string(string_with_triple_quotes, file, line_offset)
+      # See StepMother#doc_string
+      def doc_string(string_with_triple_quotes, file=nil, line_offset=0)
+        @__cucumber_step_mother.doc_string(string_with_triple_quotes, file, line_offset)
+      end
+
+      def announce(*messages)
+        STDERR.puts failed + "WARNING: #announce is deprecated. Use #puts instead:" + caller[0] + reset
+        puts(*messages)
       end
 
-      # See StepMother#announce
-      def announce(announcement)
-        @__cucumber_step_mother.announce(announcement)
+      # See StepMother#puts
+      def puts(*messages)
+        @__cucumber_step_mother.puts(*messages)
       end
 
       # See StepMother#ask
@@ -48,17 +57,8 @@ module Cucumber
       end
 
       # See StepMother#embed
-      def embed(file, mime_type)
-        @__cucumber_step_mother.embed(file, mime_type)
-      end
-
-      # Prints out the world class, followed by all included modules.
-      def announce_world
-        announce "WORLD:\n  #{self.class}"
-        world = self
-        (class << self; self; end).instance_eval do
-          world.announce "  #{included_modules.join("\n  ")}"
-        end
+      def embed(file, mime_type, label='Screenshot')
+        @__cucumber_step_mother.embed(file, mime_type, label)
       end
 
       # Mark the matched step as pending.
@@ -88,7 +88,15 @@ module Cucumber
       # such errors in World we define it to just return a simple String.
       #
       def inspect #:nodoc:
-        sprintf("#<%s:0x%x>", self.class, self.object_id)
+        modules = [self.class]
+        (class << self; self; end).instance_eval do
+          modules += included_modules
+        end
+        sprintf("#<%s:0x%x>", modules.join('+'), self.object_id)
+      end
+
+      def to_s
+        inspect
       end
     end
   end

data/lib/cucumber/rspec/doubles.rb

@@ -4,13 +4,13 @@ RSpec.configuration.configure_mock_framework
 World(RSpec::Core::MockFrameworkAdapter)
 
 Before do
-  _setup_mocks
+  RSpec::Mocks::setup(self)
 end
 
 After do
   begin
-    _verify_mocks
+    RSpec::Mocks::verify
   ensure
-    _teardown_mocks
+    RSpec::Mocks::teardown
   end
 end

data/lib/cucumber/step_match.rb

@@ -1,6 +1,6 @@
 module Cucumber
   class StepMatch #:nodoc:
-    attr_reader :step_definition
+    attr_reader :step_definition, :step_arguments
 
     # Creates a new StepMatch. The +name_to_report+ argument is what's reported, unless it's is,
     # in which case +name_to_report+ is used instead.
@@ -20,7 +20,7 @@ module Cucumber
     end
 
     def invoke(multiline_arg)
-      multiline_arg = Ast::PyString.new(multiline_arg) if String === multiline_arg
+      multiline_arg = Ast::DocString.new(multiline_arg) if String === multiline_arg
       all_args = args
       all_args << multiline_arg.to_step_definition_arg if multiline_arg
       @step_definition.invoke(all_args)
@@ -107,5 +107,9 @@ module Cucumber
     def text_length
       @step.text_length
     end
+
+    def step_arguments
+      []
+    end
   end
 end

data/lib/cucumber/step_mother.rb

@@ -1,431 +1,10 @@
-require 'cucumber/constantize'
-require 'cucumber/core_ext/instance_exec'
-require 'cucumber/language_support/language_methods'
-require 'cucumber/formatter/duration'
-require 'cucumber/cli/options'
-require 'timeout'
+require 'cucumber/runtime'
 
 module Cucumber
-  # Raised when there is no matching StepDefinition for a step.
-  class Undefined < StandardError
-    attr_reader :step_name
-
-    def initialize(step_name)
-      super %{Undefined step: "#{step_name}"}
-      @step_name = step_name
-    end
-    
-    def nested!
-      @nested = true
-    end
-
-    def nested?
-      @nested
-    end
-  end
-
-  # Raised when a StepDefinition's block invokes World#pending
-  class Pending < StandardError
-  end
-
-  # Raised when a step matches 2 or more StepDefinitions
-  class Ambiguous < StandardError
-    def initialize(step_name, step_definitions, used_guess)
-      message = "Ambiguous match of \"#{step_name}\":\n\n"
-      message << step_definitions.map{|sd| sd.backtrace_line}.join("\n")
-      message << "\n\n"
-      message << "You can run again with --guess to make Cucumber be more smart about it\n" unless used_guess
-      super(message)
-    end
-  end
-
-  class TagExcess < StandardError
-    def initialize(messages)
-      super(messages.join("\n"))
-    end
-  end
-
-  # This is the meaty part of Cucumber that ties everything together.
-  class StepMother
-    include Constantize
-    include Formatter::Duration
-    attr_writer :options, :visitor, :log
-
-    def initialize
-      @unsupported_programming_languages = []
-      @programming_languages = []
-      @language_map = {}
-      @current_scenario = nil
-    end
-
-    def load_plain_text_features(feature_files)
-      features = Ast::Features.new
-
-      tag_counts = {}
-      start = Time.new
-      log.debug("Features:\n")
-      feature_files.each do |f|
-        feature_file = FeatureFile.new(f)
-        feature = feature_file.parse(options, tag_counts)
-        if feature
-          features.add_feature(feature)
-          log.debug("  * #{f}\n")
-        end
-      end
-      duration = Time.now - start
-      log.debug("Parsing feature files took #{format_duration(duration)}\n\n")
-      
-      check_tag_limits(tag_counts)
-      
-      features
-    end
-
-    def check_tag_limits(tag_counts)
-      error_messages = []
-      options[:tag_expression].limits.each do |tag_name, tag_limit|
-        tag_locations = (tag_counts[tag_name] || [])
-        tag_count = tag_locations.length
-        if tag_count > tag_limit
-          error = "#{tag_name} occurred #{tag_count} times, but the limit was set to #{tag_limit}\n  " +
-            tag_locations.join("\n  ")
-          error_messages << error
-        end
-      end
-      raise TagExcess.new(error_messages) if error_messages.any?
-    end
-
-    def load_code_files(step_def_files)
-      log.debug("Code:\n")
-      step_def_files.each do |step_def_file|
-        load_code_file(step_def_file)
-      end
-      log.debug("\n")
-    end
-
-    def load_code_file(step_def_file)
-      if programming_language = programming_language_for(step_def_file)
-        log.debug("  * #{step_def_file}\n")
-        programming_language.load_code_file(step_def_file)
-      else
-        log.debug("  * #{step_def_file} [NOT SUPPORTED]\n")
-      end
-    end
-
-    # Loads and registers programming language implementation.
-    # Instances are cached, so calling with the same argument
-    # twice will return the same instance.
-    #
-    def load_programming_language(ext)
-      return @language_map[ext] if @language_map[ext]
-      programming_language_class = constantize("Cucumber::#{ext.capitalize}Support::#{ext.capitalize}Language")
-      programming_language = programming_language_class.new(self)
-      @programming_languages << programming_language
-      @language_map[ext] = programming_language
-      programming_language
-    end
-
-    # Returns the options passed on the command line.
-    def options
-      @options ||= Cli::Options.new
-    end
-
-    def step_visited(step) #:nodoc:
-      steps << step unless steps.index(step)
-    end
-
-    def steps(status = nil) #:nodoc:
-      @steps ||= []
-      if(status)
-        @steps.select{|step| step.status == status}
-      else
-        @steps
-      end
-    end
-
-    # Output +announcement+ alongside the formatted output.
-    # This is an alternative to using Kernel#puts - it will display
-    # nicer, and in all outputs (in case you use several formatters)
-    #
-    def announce(msg)
-      msg.respond_to?(:join) ? @visitor.announce(msg.join("\n")) : @visitor.announce(msg.to_s)
-    end
-
-    # Suspends execution and prompts +question+ to the console (STDOUT).
-    # An operator (manual tester) can then enter a line of text and hit
-    # <ENTER>. The entered text is returned, and both +question+ and
-    # the result is added to the output using #announce.
-    #
-    # If you want a beep to happen (to grab the manual tester's attention),
-    # just prepend ASCII character 7 to the question:
-    #
-    #   ask("#{7.chr}How many cukes are in the external system?")
-    #
-    # If that doesn't issue a beep, you can shell out to something else
-    # that makes a sound before invoking #ask.
-    #
-    def ask(question, timeout_seconds)
-      STDOUT.puts(question)
-      STDOUT.flush
-      announce(question)
-
-      if(Cucumber::JRUBY)
-        answer = jruby_gets(timeout_seconds)
-      else
-        answer = mri_gets(timeout_seconds)
-      end
-      
-      if(answer)
-        announce(answer)
-        answer
-      else
-        raise("Waited for input for #{timeout_seconds} seconds, then timed out.")
-      end
-    end
-
-    # Embed +file+ of MIME type +mime_type+ into the output. This may or may
-    # not be ignored, depending on what kind of formatter(s) are active.
-    #
-    def embed(file, mime_type)
-      @visitor.embed(file, mime_type)
-    end
-
-    def scenarios(status = nil) #:nodoc:
-      @scenarios ||= []
-      if(status)
-        @scenarios.select{|scenario| scenario.status == status}
-      else
-        @scenarios
-      end
-    end
-
-    def invoke(step_name, multiline_argument=nil)
-      begin
-        step_match(step_name).invoke(multiline_argument)
-      rescue Exception => e
-        e.nested! if Undefined === e
-        raise e
-      end
-    end
-
-    # Invokes a series of steps +steps_text+. Example:
-    #
-    #   invoke(%Q{
-    #     Given I have 8 cukes in my belly
-    #     Then I should not be thirsty
-    #   })
-    def invoke_steps(steps_text, i18n, file_colon_line)
-      file, line = file_colon_line.split(':')
-      parser = Gherkin::Parser::Parser.new(StepInvoker.new(self), true, 'steps')
-      parser.parse(steps_text, file, line.to_i)
-    end
-
-    class StepInvoker
-      def initialize(step_mother)
-        @step_mother = step_mother
-      end
-
-      def step(statement, multiline_arg, result)
-        cucumber_multiline_arg = case(multiline_arg)
-        when Gherkin::Formatter::Model::PyString
-          multiline_arg.value
-        when Array
-          Ast::Table.new(multiline_arg.map{|row| row.cells})
-        else
-          nil
-        end
-        @step_mother.invoke(*[statement.name, cucumber_multiline_arg].compact) 
-      end
-
-      def eof
-      end
-    end
-
-    # Returns a Cucumber::Ast::Table for +text_or_table+, which can either
-    # be a String:
-    #
-    #   table(%{
-    #     | account | description | amount |
-    #     | INT-100 | Taxi        | 114    |
-    #     | CUC-101 | Peeler      | 22     |
-    #   })
-    #
-    # or a 2D Array:
-    #
-    #   table([
-    #     %w{ account description amount },
-    #     %w{ INT-100 Taxi        114    },
-    #     %w{ CUC-101 Peeler      22     }
-    #   ])
-    #
-    def table(text_or_table, file=nil, line_offset=0)
-      if Array === text_or_table
-        Ast::Table.new(text_or_table)
-      else
-        Ast::Table.parse(text_or_table, file, line_offset)
-      end
-    end
-
-    # Returns a regular String for +string_with_triple_quotes+. Example:
-    #
-    #   """
-    #    hello
-    #   world
-    #   """
-    #
-    # Is retured as: " hello\nworld"
-    #
-    def py_string(string_with_triple_quotes, file=nil, line_offset=0)
-      Ast::PyString.parse(string_with_triple_quotes)
-    end
-
-    def step_match(step_name, name_to_report=nil) #:nodoc:
-      matches = @programming_languages.map do |programming_language| 
-        programming_language.step_matches(step_name, name_to_report).to_a
-      end.flatten
-      raise Undefined.new(step_name) if matches.empty?
-      matches = best_matches(step_name, matches) if matches.size > 1 && options[:guess]
-      raise Ambiguous.new(step_name, matches, options[:guess]) if matches.size > 1
-      matches[0]
-    end
-
-    def best_matches(step_name, step_matches) #:nodoc:
-      no_groups      = step_matches.select {|step_match| step_match.args.length == 0}
-      max_arg_length = step_matches.map {|step_match| step_match.args.length }.max
-      top_groups     = step_matches.select {|step_match| step_match.args.length == max_arg_length }
-
-      if no_groups.any?
-        longest_regexp_length = no_groups.map {|step_match| step_match.text_length }.max
-        no_groups.select {|step_match| step_match.text_length == longest_regexp_length }
-      elsif top_groups.any?
-        shortest_capture_length = top_groups.map {|step_match| step_match.args.inject(0) {|sum, c| sum + c.to_s.length } }.min
-        top_groups.select {|step_match| step_match.args.inject(0) {|sum, c| sum + c.to_s.length } == shortest_capture_length }
-      else
-        top_groups
-      end
-    end
-
-    def unmatched_step_definitions
-      @programming_languages.map do |programming_language| 
-        programming_language.unmatched_step_definitions
-      end.flatten
-    end
-
-    def snippet_text(step_keyword, step_name, multiline_arg_class) #:nodoc:
-      load_programming_language('rb') if unknown_programming_language?
-      @programming_languages.map do |programming_language|
-        programming_language.snippet_text(step_keyword, step_name, multiline_arg_class)
-      end.join("\n")
-    end
-
-    def unknown_programming_language?
-      @programming_languages.empty?
-    end
-
-    def with_hooks(scenario, skip_hooks=false)
-      around(scenario, skip_hooks) do
-        before_and_after(scenario, skip_hooks) do
-          yield scenario
-        end
-      end
-    end
-
-    def around(scenario, skip_hooks=false, &block) #:nodoc:
-      unless skip_hooks
-        @programming_languages.reverse.inject(block) do |blk, programming_language|
-          proc do
-            programming_language.around(scenario) do
-              blk.call(scenario)
-            end
-          end
-        end.call
-      else
-        yield
-      end
-    end
-
-    def before_and_after(scenario, skip_hooks=false) #:nodoc:
-      before(scenario) unless skip_hooks
-      yield scenario
-      after(scenario) unless skip_hooks
-      scenario_visited(scenario)
-    end
-
-    def before(scenario) #:nodoc:
-      return if options[:dry_run] || @current_scenario
-      @current_scenario = scenario
-      @programming_languages.each do |programming_language|
-        programming_language.before(scenario)
-      end
-    end
-    
-    def after(scenario) #:nodoc:
-      @current_scenario = nil
-      return if options[:dry_run]
-      @programming_languages.each do |programming_language|
-        programming_language.after(scenario)
-      end
-    end
-    
-    def after_step #:nodoc:
-      return if options[:dry_run]
-      @programming_languages.each do |programming_language|
-        programming_language.execute_after_step(@current_scenario)
-      end
-    end
-    
-    def after_configuration(configuration) #:nodoc
-      @programming_languages.each do |programming_language|
-        programming_language.after_configuration(configuration)
-      end
-    end
-
-    private
-
-    def programming_language_for(step_def_file) #:nodoc:
-      if ext = File.extname(step_def_file)[1..-1]
-        return nil if @unsupported_programming_languages.index(ext)
-        begin
-          load_programming_language(ext)
-        rescue LoadError => e
-          log.debug("Failed to load '#{ext}' programming language for file #{step_def_file}: #{e.message}\n")
-          @unsupported_programming_languages << ext
-          nil
-        end
-      else
-        nil
-      end
-    end
-
-    def max_step_definition_length #:nodoc:
-      @max_step_definition_length ||= step_definitions.map{|step_definition| step_definition.text_length}.max
-    end
-
-    def scenario_visited(scenario) #:nodoc:
-      scenarios << scenario unless scenarios.index(scenario)
-    end
-
-    def log
-      @log ||= Logger.new(STDOUT)
-    end
-
-    def mri_gets(timeout_seconds)
-      begin
-        Timeout.timeout(timeout_seconds) do
-          STDIN.gets
-        end
-      rescue Timeout::Error => e
-        nil
-      end
-    end
-
-    def jruby_gets(timeout_seconds)
-      answer = nil
-      t = java.lang.Thread.new do
-        answer = STDIN.gets
-      end
-      t.start
-      t.join(timeout_seconds * 1000)
-      answer
+  class StepMother < Runtime
+    def initialize(*args)
+      warn("StepMother has been deprecated and will be gently put to sleep at the next major release. Please use Runtime instead. #{caller[0]}")
+      super
     end
   end
-end
+end