cucumber 1.3.10 → 2.0.0

data/lib/cucumber/project_initializer.rb

@@ -0,0 +1,43 @@
+module Cucumber
+
+  # Generates generic file structure for a cucumber project
+  class ProjectInitializer
+    def run
+      create_directory('features')
+      create_directory('features/step_definitions')
+      create_directory('features/support')
+      create_file('features/support/env.rb')
+    end
+
+    private
+
+    def create_directory(dir_name)
+      create_directory_or_file dir_name, true
+    end
+
+    def create_file(file_name)
+      create_directory_or_file file_name, false
+    end
+
+    def create_directory_or_file(file_name, directory)
+      file_type = if directory
+                    :mkdir_p
+                  else
+                    :touch
+                  end
+
+      report_exists(file_name) || return if File.exists?(file_name)
+
+      report_creating(file_name)
+      FileUtils.send file_type, file_name
+    end
+
+    def report_exists(file)
+      puts "   exist   #{file}"
+    end
+
+    def report_creating(file)
+      puts "  create   #{file}"
+    end
+  end
+end

data/lib/cucumber/rake/task.rb

@@ -23,12 +23,6 @@ module Cucumber
     #     t.cucumber_opts = %w{--format progress}
     #   end
     #
-    # This task can also be configured to be run with RCov:
-    #
-    #   Cucumber::Rake::Task.new do |t|
-    #     t.rcov = true
-    #   end
-    #
     # See the attributes for additional configuration possibilities.
     class Task
       include Gherkin::Formatter::AnsiEscapes
@@ -103,27 +97,6 @@ module Cucumber
         end
       end
 
-      class RCovCucumberRunner < ForkedCucumberRunner #:nodoc:
-
-        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:
-
       # Directories to add to the Ruby $LOAD_PATH
       attr_accessor :libs
 
@@ -137,23 +110,6 @@ module Cucumber
         @cucumber_opts = String === opts ? opts.split(' ') : opts
       end
 
-      # 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_8_7
-          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 ' '.
-      attr_accessor :rcov_opts
-      def rcov_opts=(opts) #:nodoc:
-        @rcov_opts = String === opts ? opts.split(' ') : opts
-      end
-
       # Whether or not to fork a new ruby interpreter. Defaults to true. You may gain
       # some startup speed if you set it to false, but this may also cause issues with
       # your load path and gems.
@@ -176,12 +132,8 @@ module Cucumber
         @fork = true
         @libs = ['lib']
         @rcov_opts = %w{--rails --exclude osx\/objc,gems\/}
-
         yield self if block_given?
-
         @binary = binary.nil? ? Cucumber::BINARY : File.expand_path(binary)
-        @libs.insert(0, LIB) if binary == Cucumber::BINARY
-
         define_task
       end
 
@@ -194,13 +146,10 @@ 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, bundler, feature_files, rcov_opts)
-        elsif(@fork)
-          ForkedCucumberRunner.new(libs, binary, cucumber_opts, bundler, feature_files)
-        else
-          InProcessCucumberRunner.new(libs, cucumber_opts, feature_files)
+        if(@fork)
+          return ForkedCucumberRunner.new(libs, binary, cucumber_opts, bundler, feature_files)
         end
+        InProcessCucumberRunner.new(libs, cucumber_opts, feature_files)
       end
 
       def cucumber_opts_with_profile #:nodoc:

data/lib/cucumber/rb_support/rb_hook.rb

@@ -10,8 +10,8 @@ module Cucumber
         @proc = proc
       end
 
-      def invoke(location, argument, &block)
-        @rb_language.current_world.cucumber_instance_exec(false, location, *[argument, block].compact, &@proc)
+      def invoke(pseudo_method, arguments, &block)
+        @rb_language.current_world.cucumber_instance_exec(false, pseudo_method, *[arguments, block].compact, &@proc)
       end
     end
   end

data/lib/cucumber/rb_support/rb_language.rb

@@ -5,18 +5,7 @@ require 'cucumber/rb_support/rb_step_definition'
 require 'cucumber/rb_support/rb_hook'
 require 'cucumber/rb_support/rb_transform'
 require 'cucumber/rb_support/snippet'
-
-begin
-  require 'rspec/expectations'
-rescue LoadError
-  begin
-    require 'spec/expectations'
-    require 'spec/runner/differs/default'
-    require 'ostruct'
-  rescue LoadError
-    require 'test/unit/assertions'
-  end
-end
+require 'multi_test'
 
 module Cucumber
   module RbSupport
@@ -48,7 +37,6 @@ module Cucumber
 
       Gherkin::I18n.code_keywords.each do |adverb|
         RbDsl.alias_adverb(adverb)
-        RbWorld.alias_adverb(adverb)
       end
 
       def initialize(runtime)
@@ -56,22 +44,6 @@ module Cucumber
         @step_definitions = []
         RbDsl.rb_language = self
         @world_proc = @world_modules = nil
-        @assertions_module = find_best_assertions_module
-      end
-
-      def find_best_assertions_module
-        begin
-          ::RSpec::Matchers
-        rescue NameError
-          # RSpec >=1.2.4
-          begin
-            options = OpenStruct.new(:diff_format => :unified, :context_lines => 3)
-            Spec::Expectations.differ = Spec::Expectations::Differs::Default.new(options)
-            ::Spec::Matchers
-          rescue NameError
-            ::Test::Unit::Assertions
-          end
-        end
       end
 
       def step_matches(name_to_match, name_to_format)
@@ -84,9 +56,9 @@ module Cucumber
         end.compact
       end
 
-      def snippet_text(code_keyword, step_name, multiline_arg_class, snippet_type = :regexp)
+      def snippet_text(code_keyword, step_name, multiline_arg, snippet_type = :regexp)
         snippet_class = typed_snippet_class(snippet_type)
-        snippet_class.new(code_keyword, step_name, multiline_arg_class).to_s
+        snippet_class.new(code_keyword, step_name, multiline_arg).to_s
       end
 
       def begin_rb_scenario(scenario)
@@ -122,8 +94,6 @@ module Cucumber
         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)
         begin_rb_scenario(scenario)
       end
@@ -145,7 +115,7 @@ module Cucumber
 
       def extend_world
         @current_world.extend(RbWorld)
-        @current_world.extend(@assertions_module)
+        MultiTest.extend_with_best_assertion_library(@current_world)
         (@world_modules || []).each do |mod|
           @current_world.extend(mod)
         end

data/lib/cucumber/rb_support/rb_step_definition.rb

@@ -44,10 +44,19 @@ module Cucumber
           raise ArgumentError unless proc_or_sym.is_a?(Symbol)
           message = proc_or_sym
           target_proc = parse_target_proc_from(options)
-          lambda do |*args|
+          patch_location_onto lambda { |*args|
             target = instance_exec(&target_proc)
             target.send(message, *args)
-          end
+          }
+        end
+
+        def patch_location_onto(block)
+          file, line = caller[5].split(':')[0..1]
+          location = Core::Ast::Location.new(
+            Pathname.new(file).relative_path_from(Pathname.new(Dir.pwd)),
+            line)
+          block.define_singleton_method(:file_colon_line) { location.to_s }
+          block
         end
 
         def parse_target_proc_from(options)

data/lib/cucumber/rb_support/rb_transform.rb

@@ -39,7 +39,9 @@ module Cucumber
 
     private
       def convert_captures(regexp_source)
-        regexp_source.gsub(/(\()(?!\?:)/,'(?:')
+        regexp_source
+          .gsub(/(\()(?!\?[<:=!])/,'(?:')
+          .gsub(/(\(\?<)(?![=!])/,'(?:<')
       end
 
       def strip_captures(regexp_source)

data/lib/cucumber/rb_support/rb_world.rb

@@ -11,13 +11,6 @@ module Cucumber
       # @private
       AnsiEscapes = Gherkin::Formatter::AnsiEscapes
 
-      class << self
-        # @private
-        def alias_adverb(adverb)
-          alias_method adverb, :__cucumber_invoke
-        end
-      end
-
       # Call a Transform with a string from another Transform definition
       def Transform(arg)
         rb = @__cucumber_runtime.load_programming_language('rb')
@@ -27,12 +20,6 @@ module Cucumber
       # @private
       attr_writer :__cucumber_runtime, :__natural_language
 
-      # @private
-      def __cucumber_invoke(name, multiline_argument=nil) #:nodoc:
-        STDERR.puts AnsiEscapes.failed + "WARNING: Using 'Given/When/Then' in step definitions is deprecated, use 'step' to call other steps instead:" + caller[0] + AnsiEscapes.reset
-        @__cucumber_runtime.invoke(name, multiline_argument)
-      end
-
       # Run a single Gherkin step
       # @example Call another step
       #   step "I am logged in"
@@ -48,8 +35,9 @@ module Cucumber
       #   step "the email should contain:", "Dear sir,\nYou've won a prize!\n"
       # @param [String] name The name of the step
       # @param [String,Cucumber::Ast::DocString,Cucumber::Ast::Table] multiline_argument
-      def step(name, multiline_argument=nil)
-        @__cucumber_runtime.invoke(name, multiline_argument)
+      def step(name, raw_multiline_arg=nil)
+        location = Core::Ast::Location.of_caller
+        @__cucumber_runtime.invoke_dynamic_step(name, MultilineArgument.from(raw_multiline_arg, location))
       end
 
       # Run a snippet of Gherkin
@@ -60,7 +48,7 @@ module Cucumber
       #   }
       # @param [String] steps_text The Gherkin snippet to run
       def steps(steps_text)
-        @__cucumber_runtime.invoke_steps(steps_text, @__natural_language, caller[0])
+        @__cucumber_runtime.invoke_dynamic_steps(steps_text, @__natural_language, caller[0])
       end
 
       # Parse Gherkin into a {Cucumber::Ast::Table} object.
@@ -102,7 +90,7 @@ module Cucumber
       #   of sending the output directly to STDOUT, Cucumber will intercept and cache
       #   the message until the current step has finished, and then display it.
       #   
-      #   If you'd prefer to see the message immediately, call {Kernel#puts} instead.
+      #   If you'd prefer to see the message immediately, call {Kernel.puts} instead.
       def puts(*messages)
         @__cucumber_runtime.puts(*messages)
       end
@@ -123,14 +111,19 @@ module Cucumber
           begin
             yield
           rescue Exception
-            raise Pending.new(message)
+            raise Pending, message
           end
-          raise Pending.new("Expected pending '#{message}' to fail. No Error was raised. No longer pending?")
+          raise Pending, "Expected pending '#{message}' to fail. No Error was raised. No longer pending?"
         else
-          raise Pending.new(message)
+          raise Pending, message
         end
       end
 
+      # Skips this step and the remaining steps in the scenario
+      def skip_this_scenario(message = "Scenario skipped")
+        raise Core::Test::Result::Skipped, message
+      end
+
       # Prints the list of modules that are included in the World
       def inspect
         modules = [self.class]

data/lib/cucumber/rb_support/snippet.rb

@@ -2,15 +2,15 @@ module Cucumber
   module RbSupport
     module Snippet
 
-      ARGUMENT_PATTERNS = ['"(.*?)"', '(\d+)']
+      ARGUMENT_PATTERNS = ['"([^"]*)"', '(\d+)']
 
       class BaseSnippet
 
-        def initialize(code_keyword, pattern, multiline_argument_class)
+        def initialize(code_keyword, pattern, multiline_argument)
           @number_of_arguments = 0
           @code_keyword = code_keyword
           @pattern = replace_and_count_capturing_groups(pattern)
-          @multiline_argument_class = multiline_argument_class
+          @multiline_argument = MultilineArgumentSnippet.new(multiline_argument)
         end
 
         def to_s
@@ -27,7 +27,7 @@ module Cucumber
 
         private
 
-        attr_reader :code_keyword, :pattern, :multiline_argument_class, :number_of_arguments
+        attr_reader :code_keyword, :pattern, :multiline_argument, :number_of_arguments
 
         def replace_and_count_capturing_groups(pattern)
           modified_pattern = ::Regexp.escape(pattern).gsub('\ ', ' ').gsub('/', '\/')
@@ -43,32 +43,20 @@ module Cucumber
         def do_block
           do_block = ""
           do_block << "do#{arguments}\n"
-          do_block << multiline_comment if multiline_argument_class?
-          do_block << "  pending # express the regexp above with the code you wish you had\n"
+          multiline_argument.append_comment_to(do_block)
+          do_block << "  pending # Write code here that turns the phrase above into concrete actions\n"
           do_block << "end"
           do_block
         end
 
         def arguments
           block_args = (0...number_of_arguments).map { |n| "arg#{n+1}" }
-
-          if multiline_argument_class
-            block_args << multiline_argument_class.default_arg_name
-          end
-
+          multiline_argument.append_block_argument_to(block_args)
           block_args.empty? ? "" : " |#{block_args.join(", ")}|"
         end
 
-        def multiline_comment
-          "  # #{multiline_argument_class.default_arg_name} is a #{multiline_argument_class.to_s}\n"
-        end
-
-        def multiline_argument_class?
-          multiline_argument_class == Ast::Table
-        end
-
         def self.example
-          new("Given", "missing step", nil).step
+          new("Given", "missing step", MultilineArgument::None.new).step
         end
 
       end
@@ -103,6 +91,59 @@ module Cucumber
         end
       end
 
+      module MultilineArgumentSnippet
+
+        def self.new(multiline_argument)
+          builder = Builder.new
+          multiline_argument.describe_to(builder)
+          builder.result
+        end
+
+        class Builder
+          def doc_string(*args)
+            @result = DocString.new
+          end
+
+          def data_table(table, *args)
+            @result = DataTable.new(table)
+          end
+
+          def result
+            @result || None.new
+          end
+        end
+
+        class DocString
+          def append_block_argument_to(array)
+            array << 'string'
+          end
+
+          def append_comment_to(string)
+          end
+        end
+
+        class DataTable
+          def initialize(table)
+            @table = table
+          end
+
+          def append_block_argument_to(array)
+            array << 'table'
+          end
+
+          def append_comment_to(string)
+            string << "  # table is a #{@table.class.to_s}\n"
+          end
+        end
+
+        class None
+          def append_block_argument_to(array)
+          end
+
+          def append_comment_to(string)
+          end
+        end
+      end
     end
   end
 end

data/lib/cucumber/rspec/doubles.rb

@@ -1,16 +1,19 @@
-require 'rspec/core'
+require 'rspec/mocks'
 
-RSpec.configuration.configure_mock_framework
-World(RSpec::Core::MockFrameworkAdapter)
+World(RSpec::Mocks::ExampleMethods)
 
 Before do
-  RSpec::Mocks::setup(self)
+  if RSpec::Mocks::Version::STRING >= "2.9.9"
+    RSpec::Mocks.setup
+  else
+    RSpec::Mocks.setup(self)
+  end
 end
 
 After do
   begin
-    RSpec::Mocks::verify
+    RSpec::Mocks.verify
   ensure
-    RSpec::Mocks::teardown
+    RSpec::Mocks.teardown
   end
 end

data/lib/cucumber/running_test_case.rb

@@ -0,0 +1,115 @@
+require 'delegate'
+
+module Cucumber
+  # Represents the current status of a running test case.
+  # 
+  # This wraps a `Cucumber::Core::Test::Case` and delegates
+  # many methods to that object.
+  #
+  # We decorete the core object with the current result.
+  # In the first Before hook of a scenario, this will be an
+  # instance of `Cucumber::Core::Test::Result::Unknown`
+  # but as the scenario runs, it will be updated to reflect
+  # the passed / failed / undefined / skipped status of
+  # the test case.
+  #
+  # The test case might come from a regular Scenario or
+  # a Scenario outline. You can call the `#outline?`
+  # predicate to find out. If it's from an outline, 
+  # you get a couple of extra methods.
+  module RunningTestCase
+    def self.new(test_case)
+      Builder.new(test_case).result
+    end
+
+    class Builder
+      def initialize(test_case)
+        @test_case = test_case
+        test_case.describe_source_to(self)
+      end
+
+      def feature(feature)
+      end
+
+      def scenario(scenario)
+        @factory = Scenario
+      end
+
+      def scenario_outline(scenario)
+        @factory = ScenarioOutlineExample
+      end
+
+      def examples_table(examples_table)
+      end
+
+      def examples_table_row(row)
+      end
+
+      def result
+        @factory.new(@test_case)
+      end
+    end
+    private_constant :Builder
+
+    class Scenario < SimpleDelegator
+      def initialize(test_case, result = Core::Test::Result::Unknown.new)
+        @test_case = test_case
+        @result = result
+        super test_case
+      end
+
+      def accept_hook?(hook)
+        hook.tag_expressions.all? { |expression| @test_case.match_tags?(expression) }
+      end
+
+      def failed?
+        @result.failed?
+      end
+
+      def passed?
+        !failed?
+      end
+
+      def title
+        warn("deprecated: call #name instead")
+        name
+      end
+
+      def source_tags
+        #warn('deprecated: call #tags instead')
+        tags
+      end
+
+      def source_tag_names
+        tags.map &:name
+      end
+
+      def skip_invoke!
+        Cucumber.deprecate(self.class.name, __method__, "Call #skip_this_scenario on the World directly")
+        raise Cucumber::Core::Test::Result::Skipped
+      end
+
+      def outline?
+        false
+      end
+
+      def with_result(result)
+        self.class.new(@test_case, result)
+      end
+    end
+
+    class ScenarioOutlineExample < Scenario
+      def outline?
+        true
+      end
+
+      def scenario_outline
+        self
+      end
+
+      def cell_values
+        source.last.values
+      end
+    end
+  end
+end

data/lib/cucumber/runtime/after_hooks.rb

@@ -0,0 +1,24 @@
+module Cucumber
+  class Runtime
+    class AfterHooks
+      def initialize(action_blocks)
+        @action_blocks = action_blocks
+      end
+
+      def apply_to(test_case)
+        test_case.with_steps(
+          test_case.test_steps + after_hooks(test_case.source).reverse
+        )
+      end
+
+      private
+
+      def after_hooks(source)
+        @action_blocks.map do |action_block|
+          Hooks.after_hook(source, &action_block)
+        end
+      end
+    end
+  end
+end
+

data/lib/cucumber/runtime/before_hooks.rb

@@ -0,0 +1,23 @@
+module Cucumber
+  class Runtime
+    class BeforeHooks
+      def initialize(action_blocks)
+        @action_blocks = action_blocks
+      end
+
+      def apply_to(test_case)
+        test_case.with_steps(
+          before_hooks(test_case.source) + test_case.test_steps
+        )
+      end
+
+      private
+
+      def before_hooks(source)
+        @action_blocks.map do |action_block|
+          Hooks.before_hook(source, &action_block)
+        end
+      end
+    end
+  end
+end