cucumber 0.8.6 → 0.8.7

data/lib/cucumber/rb_support/rb_dsl.rb

@@ -88,7 +88,6 @@ 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,4 +1,3 @@
-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'
@@ -22,7 +21,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/cucumber/cucumber/a-whole-new-world.\n\n"
+        message << "or http://wiki.github.com/aslakhellesoy/cucumber/a-whole-new-world.\n\n"
         super(message)
       end
     end
@@ -30,8 +29,7 @@ module Cucumber
     # The Ruby implementation of the programming language API.
     class RbLanguage
       include LanguageSupport::LanguageMethods
-      attr_reader :current_world,
-                  :step_definitions
+      attr_reader :current_world
 
       Gherkin::I18n.code_keywords.each do |adverb|
         RbDsl.alias_adverb(adverb)
@@ -67,7 +65,7 @@ module Cucumber
 
       # Gets called for each file under features (or whatever is overridden
       # with --require).
-      def step_definitions_for(rb_file) # Looks Unused - Delete?
+      def step_definitions_for(rb_file)
         begin
           require rb_file # This will cause self.add_step_definition and self.add_hook to be called from RbDsl
           step_definitions
@@ -78,7 +76,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))
@@ -91,7 +89,7 @@ module Cucumber
 
       ARGUMENT_PATTERNS = ['"([^"]*)"', '(\d+)']
 
-      def snippet_text(code_keyword, step_name, multiline_arg_class)
+      def snippet_text(step_keyword, step_name, multiline_arg_class)
         snippet_pattern = Regexp.escape(step_name).gsub('\ ', ' ').gsub('/', '\/')
         arg_count = 0
         ARGUMENT_PATTERNS.each do |pattern|
@@ -107,7 +105,7 @@ module Cucumber
           multiline_class_comment = "# #{multiline_arg_class.default_arg_name} is a #{multiline_arg_class.to_s}\n  "
         end
 
-        "#{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"
+        "#{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"
       end
 
       def begin_rb_scenario(scenario)
@@ -140,9 +138,9 @@ module Cucumber
       end
 
       def load_code_file(code_file)
-        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
+        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
       end
-      
+
       protected
 
       def begin_scenario(scenario)

data/lib/cucumber/rb_support/rb_step_definition.rb

@@ -38,14 +38,6 @@ 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,23 +32,6 @@ 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,11 +1,7 @@
-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
@@ -36,19 +32,14 @@ module Cucumber
         @__cucumber_step_mother.table(text_or_table, file, line_offset)
       end
 
-      # 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)
+      # 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)
       end
 
-      # See StepMother#puts
-      def puts(*messages)
-        @__cucumber_step_mother.puts(*messages)
+      # See StepMother#announce
+      def announce(announcement)
+        @__cucumber_step_mother.announce(announcement)
       end
 
       # See StepMother#ask
@@ -57,8 +48,17 @@ module Cucumber
       end
 
       # See StepMother#embed
-      def embed(file, mime_type, label='Screenshot')
-        @__cucumber_step_mother.embed(file, mime_type, label)
+      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
       end
 
       # Mark the matched step as pending.
@@ -88,15 +88,7 @@ module Cucumber
       # such errors in World we define it to just return a simple String.
       #
       def inspect #:nodoc:
-        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
+        sprintf("#<%s:0x%x>", self.class, self.object_id)
       end
     end
   end

data/lib/cucumber/rspec/doubles.rb

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

data/lib/cucumber/step_match.rb

@@ -1,6 +1,6 @@
 module Cucumber
   class StepMatch #:nodoc:
-    attr_reader :step_definition, :step_arguments
+    attr_reader :step_definition
 
     # 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::DocString.new(multiline_arg) if String === multiline_arg
+      multiline_arg = Ast::PyString.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,9 +107,5 @@ module Cucumber
     def text_length
       @step.text_length
     end
-
-    def step_arguments
-      []
-    end
   end
 end

data/lib/cucumber/step_mother.rb

@@ -1,10 +1,431 @@
-require 'cucumber/runtime'
+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'
 
 module Cucumber
-  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
+  # 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
     end
   end
-end
+end