cucumber 0.9.2 → 0.9.3

data/Gemfile

@@ -1,10 +1,2 @@
 source "http://rubygems.org"
 gemspec
-
-# Use source from sibling folders (if available) instead of gems
-%w[gherkin].each do |g|
-  if File.directory?(File.dirname(__FILE__) + "/../#{g}")
-    @dependencies.reject!{|dep| dep.name == g}
-    gem g, :path => "../#{g}"
-  end
-end

data/History.txt

@@ -1,3 +1,11 @@
+== 0.9.3 (2010-10-24)
+
+=== Bugfixes
+* Better JSON representation of Regexps (Aslak Hellesøy)
+* Update to work with latest spork (Matt Wynne)
+* Prevent MiniTest::Unit#autorun from running in at_exit hook. (Aslak Hellesøy) 
+* Fixed incorect --help for --strict. It fails on both pending and undefined. (Aslak Hellesøy)
+
 == 0.9.2 (2010-10-04)
 
 === Bugfixes

data/cucumber.gemspec

@@ -24,7 +24,7 @@ for important information about this release. Happy cuking!
 
 }
 
-  s.add_dependency 'gherkin', '~> 2.2.5'
+  s.add_dependency 'gherkin', '~> 2.2.9'
   s.add_dependency 'term-ansicolor', '~> 1.0.5'
   s.add_dependency 'builder', '~> 2.1.2'
   s.add_dependency 'diff-lcs', '~> 1.1.2'

data/features/api/list_step_defs_as_json.feature

@@ -9,8 +9,8 @@ Feature: List step defs as json
   Scenario: Two Ruby step definitions, in the same file
     Given a file named "features/step_definitions/foo_steps.rb" with:
       """
-      Given(/foo/) {}
-      Given(/b.r/) {}
+      Given(/foo/i) {}
+      Given(/b.r/xm) {}
       """
     When I run the following Ruby code:
       """
@@ -21,15 +21,17 @@ Feature: List step defs as json
     Then it should pass
     And the output should contain the following JSON:
       """
-      [ "/foo/", "/b.r/" ]
-      
+      [
+        {"source": "foo", "flags": "i"},
+        {"source": "b.r", "flags": "mx"}
+      ]
       """
 
   Scenario: Non-default directory structure
     Given a file named "my_weird/place/foo_steps.rb" with:
       """
       Given(/foo/) {}
-      Given(/b.r/) {}
+      Given(/b.r/x) {}
       """
     When I run the following Ruby code:
       """
@@ -40,6 +42,9 @@ Feature: List step defs as json
     Then it should pass
     And the output should contain the following JSON:
       """
-      [ "/foo/", "/b.r/" ]
+      [
+        {"source": "foo", "flags": ""},
+        {"source": "b.r", "flags": "x"}
+      ]
       
       """

data/features/api/run_cli_main_with_existing_runtime.feature

@@ -0,0 +1,34 @@
+Feature: Run Cli::Main with existing Runtime
+
+  This is the API that Spork uses. It creates an existing runtime then
+  calls load_programming_language('rb') on it to load the RbDsl.
+  When the process forks, Spork them passes the runtime to Cli::Main to 
+  run it.
+
+    Background: 
+      Given a standard Cucumber project directory structure
+
+    Scenario: Run a single feature
+      Given a file named "features/step_definitions/success.rb" with:
+        """
+        Given(/pass/) {}
+        """
+      Given a file named "features/success.feature" with:
+        """
+        Feature: 
+          Scenario: 
+            Given I pass
+        """
+      When I run the following Ruby code:
+        """
+        require 'cucumber'
+        runtime = Cucumber::Runtime.new
+        runtime.load_programming_language('rb')
+        Cucumber::Cli::Main.new([]).execute!(runtime)
+        
+        """
+      Then it should pass
+      And the output should contain:
+        """
+        Given I pass
+        """

data/features/step_definitions/cucumber_steps.rb

@@ -61,7 +61,6 @@ When /^I run the following Ruby code:$/ do |code|
   run %{#{Cucumber::RUBY_BINARY} -r rubygems -I #{cucumber_lib_dir} -e "#{code}"}
 end
 
-
 Then /^it should (fail|pass)$/ do |success|
   if success == 'fail'
     last_exit_status.should_not == 0
@@ -77,7 +76,7 @@ Then /^it should (fail|pass) with$/ do |success, output|
   Then("it should #{success}")
 end
 
-Then /^the output should contain$/ do |text|
+Then /^the output should contain:?$/ do |text|
   last_stdout.should include(text)
 end
 

data/lib/cucumber.rb

@@ -8,6 +8,7 @@ require 'cucumber/step_mother'
 require 'cucumber/cli/main'
 require 'cucumber/broadcaster'
 require 'cucumber/step_definitions'
+require 'cucumber/core_ext/disable_mini_unit_autorun'
 
 module Cucumber
   class << self

data/lib/cucumber/cli/main.rb

@@ -13,14 +13,6 @@ require 'cucumber/formatter/color_io'
 require 'cucumber/cli/configuration'
 require 'cucumber/cli/drb_client'
 
-if defined?(Spork::TestFramework::Cucumber)
-  class Spork::TestFramework::Cucumber < Spork::TestFramework
-    def run_tests(argv, stderr, stdout)
-      ::Cucumber::Cli::Main.new(argv, stdout, stderr).execute!
-    end
-  end
-end
-
 module Cucumber
   module Cli
     class Main
@@ -42,15 +34,17 @@ module Cucumber
         @configuration = nil
       end
 
-      def execute!(legacy_step_mother = nil)
-        if legacy_step_mother
-          warn("Passing a step_mother to #execute! is deprecated, and has been ignored: #{caller[0]}")
-        end
-
+      def execute!(existing_runtime = nil)
         trap_interrupt
         return @drb_output if run_drb_client
         
-        runtime = Runtime.new(configuration)
+        runtime = if existing_runtime
+          existing_runtime.configure(configuration)
+          existing_runtime
+        else
+          Runtime.new(configuration)
+        end
+
         runtime.run!
         runtime.results.failure?
       rescue ProfilesNotDefinedError, YmlLoadError, ProfileNotFound => e

data/lib/cucumber/cli/options.rb

@@ -229,7 +229,7 @@ module Cucumber
           opts.on("-b", "--backtrace", "Show full backtrace for all errors.") do
             Cucumber.use_full_backtrace = true
           end
-          opts.on("-S", "--strict", "Fail if there are any undefined steps.") do
+          opts.on("-S", "--strict", "Fail if there are any undefined or pending steps.") do
             @options[:strict] = true
           end
           opts.on("-w", "--wip", "Fail if there are any passing scenarios.") do

data/lib/cucumber/core_ext/disable_mini_unit_autorun.rb

@@ -0,0 +1,10 @@
+# Why: http://groups.google.com/group/cukes/browse_thread/thread/5682d41436e235d7
+begin
+  require 'minitest/unit'
+  class MiniTest::Unit
+    class << self
+      @@installed_at_exit = true
+    end
+  end
+rescue LoadError => ignore
+end

data/lib/cucumber/platform.rb

@@ -4,7 +4,7 @@ require 'rbconfig'
 
 module Cucumber
 unless defined?(Cucumber::VERSION)
-  VERSION       = '0.9.2'
+  VERSION       = '0.9.3'
   BINARY        = File.expand_path(File.dirname(__FILE__) + '/../../bin/cucumber')
   LIBDIR        = File.expand_path(File.dirname(__FILE__) + '/../../lib')
   JRUBY         = defined?(JRUBY_VERSION)

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/runtime.rb

@@ -18,10 +18,21 @@ module Cucumber
     def initialize(configuration = Configuration.default)
       @current_scenario = nil
       @configuration = Configuration.parse(configuration)
-      @support_code = SupportCode.new(self, @configuration.guess?)
+      @support_code = SupportCode.new(self, @configuration)
       @results = Results.new(@configuration)
     end
     
+    # Allows you to take an existing runtime and change it's configuration
+    def configure(new_configuration)
+      @configuration = Configuration.parse(new_configuration)
+      @support_code.configure(@configuration)
+      @results.configure(@configuration)
+    end
+    
+    def load_programming_language(language)
+      @support_code.load_programming_language(language)
+    end
+    
     def run!
       load_step_definitions
       fire_after_configuration_hook
@@ -48,67 +59,6 @@ module Cucumber
       @results.steps(status)
     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)
-      @support_code.load_programming_language!(ext)
-    end
-
-    def invoke(step_name, multiline_argument=nil)
-      # It is very important to leave multiline_argument=nil as a vararg. Cuke4Duke needs it that way. 
-      @support_code.invoke(step_name, multiline_argument)
-    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)
-      @support_code.invoke_steps(steps_text, i18n, file_colon_line)
-    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:
       @support_code.step_match(step_name, name_to_report)
     end

data/lib/cucumber/runtime/for_programming_languages.rb

@@ -0,0 +1,65 @@
+require 'forwardable'
+
+module Cucumber
+  class Runtime
+    # This is what a programming language will consider to be a runtime.
+    # 
+    # It's a thin class that directs the handul of methods needed by the
+    # programming languages to the right place.
+    class ForProgrammingLanguages
+      extend Forwardable
+    
+      def initialize(support_code, user_interface)
+        @support_code, @user_interface = support_code, user_interface
+      end
+
+      def_delegators :@user_interface,
+        :embed,
+        :ask,
+        :announce
+    
+      def_delegators :@support_code,
+        :invoke_steps,
+        :invoke,
+        :load_programming_language
+    
+      # 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
+    end
+  end
+end

data/lib/cucumber/runtime/results.rb

@@ -6,6 +6,10 @@ module Cucumber
         @configuration = configuration
       end
       
+      def configure(new_configuration)
+        @configuration = Configuration.parse(new_configuration)
+      end
+      
       def step_visited(step) #:nodoc:
         steps << step unless steps.index(step)
       end

data/lib/cucumber/runtime/support_code.rb

@@ -1,9 +1,12 @@
 require 'cucumber/constantize'
+require 'cucumber/runtime/for_programming_languages'
 
 module Cucumber
   class Runtime
     
     class SupportCode
+      
+      require 'forwardable'
       class StepInvoker
         include Gherkin::Rubify
 
@@ -31,25 +34,39 @@ module Cucumber
       end
     
       include Constantize
-
-      def initialize(step_mother, in_guess_mode)
-        @step_mother = step_mother
-        @guess_step_matches = in_guess_mode
+      
+      def initialize(user_interface, configuration={})
+        @configuration = Configuration.parse(configuration)
+        @runtime_facade = Runtime::ForProgrammingLanguages.new(self, user_interface)
         @unsupported_programming_languages = []
         @programming_languages = []
         @language_map = {}
       end
+      
+      def configure(new_configuration)
+        @configuration = Configuration.parse(new_configuration)
+      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
-
-      def load_programming_language!(ext)
+      
+      # 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(@step_mother)
+        programming_language = programming_language_class.new(@runtime_facade)
         @programming_languages << programming_language
         @language_map[ext] = programming_language
         programming_language
@@ -75,7 +92,7 @@ module Cucumber
       end
 
       def snippet_text(step_keyword, step_name, multiline_arg_class) #:nodoc:
-        load_programming_language!('rb') if unknown_programming_language?
+        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")
@@ -116,6 +133,7 @@ module Cucumber
       end
     
       def invoke(step_name, multiline_argument=nil)
+        # It is very important to leave multiline_argument=nil as a vararg. Cuke4Duke needs it that way. 
         begin
           step_match(step_name).invoke(multiline_argument)
         rescue Exception => e
@@ -127,7 +145,7 @@ module Cucumber
     private
   
       def guess_step_matches?
-        @guess_step_matches
+        @configuration.guess?
       end
     
       def matches(step_name, name_to_report)
@@ -165,11 +183,11 @@ module Cucumber
         Cucumber.logger
       end
     
-      def programming_language_for(step_def_file) #:nodoc:
+      def programming_language_for(step_def_file)
         if ext = File.extname(step_def_file)[1..-1]
           return nil if @unsupported_programming_languages.index(ext)
           begin
-            load_programming_language!(ext)
+            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