cucumber 1.3.10 → 2.0.0

data/lib/cucumber/cli/main.rb

@@ -7,10 +7,7 @@ end
 require 'optparse'
 require 'cucumber'
 require 'logger'
-require 'cucumber/parser'
-require 'cucumber/feature_file'
 require 'cucumber/cli/configuration'
-require 'cucumber/cli/drb_client'
 
 module Cucumber
   module Cli
@@ -21,21 +18,15 @@ module Cucumber
         end
       end
 
-      def initialize(args, stdin=STDIN, out=STDOUT, err=STDERR, kernel=Kernel)
-        raise "args can't be nil" unless args
-        raise "out can't be nil" unless out
-        raise "err can't be nil" unless err
-        raise "kernel can't be nil" unless kernel
+      def initialize(args, _=nil, out=STDOUT, err=STDERR, kernel=Kernel)
         @args   = args
         @out    = out
         @err    = err
         @kernel = kernel
-        @configuration = nil
       end
 
       def execute!(existing_runtime = nil)
         trap_interrupt
-        return @drb_output if run_drb_client
 
         runtime = if existing_runtime
           existing_runtime.configure(configuration)
@@ -45,11 +36,18 @@ module Cucumber
         end
 
         runtime.run!
-        runtime.write_stepdefs_json
-        failure = runtime.results.failure? || Cucumber.wants_to_quit
+        failure = runtime.failure? || Cucumber.wants_to_quit
         @kernel.exit(failure ? 1 : 0)
+      rescue FileNotFoundException => e
+        @err.puts(e.message)
+        @err.puts("Couldn't open #{e.path}")
+        @kernel.exit(1)
+      rescue FeatureFolderNotFoundException => e
+        @err.puts(e.message + ". You can use `cucumber --init` to get started.")
+        @kernel.exit(1)
       rescue ProfilesNotDefinedError, YmlLoadError, ProfileNotFound => e
         @err.puts(e.message)
+        @kernel.exit(1)
       rescue SystemExit => e
         @kernel.exit(e.status)
       rescue Errno::EACCES, Errno::ENOENT => e
@@ -62,25 +60,14 @@ module Cucumber
       end
 
       def configuration
-        return @configuration if @configuration
-
-        @configuration = Configuration.new(@out, @err)
-        @configuration.parse!(@args)
-        Cucumber.logger = @configuration.log
-        @configuration
+        @configuration ||= Configuration.new(@out, @err).tap do |configuration|
+          configuration.parse!(@args)
+          Cucumber.logger = configuration.log
+        end
       end
 
       private
 
-      def run_drb_client
-        return false unless configuration.drb?
-        warn("Spork is no longer supported as of Cucumber 1.3.0. Please downgrade to version 1.2.5")
-        @drb_output = DRbClient.run(@args, @err, @out, configuration.drb_port)
-        true
-      rescue DRbClientError => e
-        @err.puts "WARNING: #{e.message} Running features locally:"
-      end
-
       def trap_interrupt
         trap('INT') do
           exit!(1) if Cucumber.wants_to_quit

data/lib/cucumber/cli/options.rb

@@ -1,6 +1,7 @@
 require 'cucumber/cli/profile_loader'
 require 'cucumber/formatter/ansicolor'
 require 'cucumber/rb_support/rb_language'
+require 'cucumber/project_initializer'
 
 module Cucumber
   module Cli
@@ -27,7 +28,7 @@ module Cucumber
       max = BUILTIN_FORMATS.keys.map{|s| s.length}.max
       FORMAT_HELP = (BUILTIN_FORMATS.keys.sort.map do |key|
         "  #{key}#{' ' * (max - key.length)} : #{BUILTIN_FORMATS[key][1]}"
-      end) + ["Use --format rerun --out features.txt to write out failing",
+      end) + ["Use --format rerun --out rerun.txt to write out failing",
         "features. You can rerun them with cucumber @rerun.txt.",
         "FORMAT can also be the fully qualified class name of",
         "your own custom formatter. If the class isn't loaded,",
@@ -38,8 +39,6 @@ module Cucumber
         "path underneath your features/support directory or anywhere",
         "on Ruby's LOAD_PATH, for example in a Ruby gem."
       ]
-      DRB_FLAG = '--drb'
-      DRB_OPTIONAL_FLAG = '--[no-]drb'
       PROFILE_SHORT_FLAG = '-p'
       NO_PROFILE_SHORT_FLAG = '-P'
       PROFILE_LONG_FLAG = '--profile'
@@ -47,8 +46,9 @@ module Cucumber
       OPTIONS_WITH_ARGS = ['-r', '--require', '--i18n', '-f', '--format', '-o', '--out',
                                   '-t', '--tags', '-n', '--name', '-e', '--exclude',
                                   PROFILE_SHORT_FLAG, PROFILE_LONG_FLAG,
-                                  '-a', '--autoformat', '-l', '--lines', '--port',
+                                  '-l', '--lines', '--port',
                                   '-I', '--snippet-type']
+      ORDER_TYPES = %w{defined random}
 
       def self.parse(args, out_stream, error_stream, options = {})
         new(out_stream, error_stream, options).parse!(args)
@@ -76,43 +76,6 @@ module Cucumber
         @options[key] = value
       end
 
-      def expanded_args_without_drb
-        return @expanded_args_without_drb  if @expanded_args_without_drb
-        @expanded_args_without_drb = (
-          previous_flag_was_profile = false
-          previous_flag_requires_arg = false
-
-          @expanded_args.reject do |arg|
-            # ignore profiles
-            if previous_flag_was_profile
-              previous_flag_was_profile = false
-              next true
-            end
-            if [PROFILE_SHORT_FLAG, PROFILE_LONG_FLAG].include?(arg)
-              previous_flag_was_profile = true
-              next true
-            end
-
-            # accept all options which requires arguments
-            # and don't try to look @overridden_paths in it's arguments!
-            if previous_flag_requires_arg
-              previous_flag_requires_arg = false
-              next false
-            end
-            if OPTIONS_WITH_ARGS.include?(arg)
-              previous_flag_requires_arg = true
-              next false
-            end
-
-            # ignore --drb flag and overridden features paths
-            arg == DRB_FLAG || @overridden_paths.include?(arg)
-          end
-        )
-
-        @expanded_args_without_drb.push("--no-profile") unless @expanded_args_without_drb.include?(NO_PROFILE_LONG_FLAG) || @expanded_args_without_drb.include?(NO_PROFILE_SHORT_FLAG)
-        @expanded_args_without_drb
-      end
-
       def parse!(args)
         @args = args
         @expanded_args = @args.dup
@@ -164,6 +127,12 @@ module Cucumber
             *FORMAT_HELP) do |v|
             @options[:formats] << [v, @out_stream]
           end
+          opts.on('--init',
+            'Initializes folder structure and generates conventional files for',
+            'a Cucumber project.') do |v|
+            ProjectInitializer.new.run
+            Kernel.exit(0)
+          end
           opts.on("-o", "--out [FILE|DIR]",
             "Write output to a file/directory instead of STDOUT. This option",
             "applies to the previously specified --format, or the",
@@ -220,16 +189,6 @@ module Cucumber
             "This also omits the loading of your support/env.rb file if it exists.") do
             @options[:dry_run] = true
           end
-          opts.on("-a", "--autoformat DIR",
-            "Reformats (pretty prints) feature files and write them to DIRECTORY.",
-            "Be careful if you choose to overwrite the originals.",
-            "Implies --dry-run --format pretty.") do |directory|
-            @options[:autoformat] = directory
-            Cucumber::Term::ANSIColor.coloring = false
-            @options[:dry_run] = true
-            @quiet = true
-          end
-
           opts.on("-m", "--no-multiline",
             "Don't print multiline strings and tables under steps.") do
             @options[:no_multiline] = true
@@ -271,14 +230,17 @@ module Cucumber
           opts.on("-x", "--expand", "Expand Scenario Outline Tables in output.") do
             @options[:expand] = true
           end
-          opts.on(DRB_OPTIONAL_FLAG, "Run features against a DRb server. (i.e. with the spork gem)") do |drb|
-            @options[:drb] = drb
-          end
-          opts.on("--port PORT", "Specify DRb port.  Ignored without --drb") do |port|
-            @options[:drb_port] = port
-          end
-          opts.on("--dotcucumber DIR", "Write metadata to DIR") do |dir|
-            @options[:dotcucumber] = dir
+          opts.on("--order TYPE[:SEED]", "Run examples in the specified order. Available types:",
+            *<<-TEXT.split("\n")) do |order|
+  [defined]     Run scenarios in the order they were defined (default).
+  [random]      Shuffle scenarios before running.
+Specify SEED to reproduce the shuffling from a previous run.
+  e.g. --order random:5738
+TEXT
+            @options[:order], @options[:seed] = *order.split(":")
+            unless ORDER_TYPES.include?(@options[:order])
+              fail "'#{@options[:order]}' is not a recognised order type. Please use one of #{ORDER_TYPES.join(", ")}."
+            end
           end
           opts.on_tail("--version", "Show version.") do
             @out_stream.puts Cucumber::VERSION
@@ -311,7 +273,7 @@ module Cucumber
       end
 
       def filters
-        @options.values_at(:name_regexps, :tag_expressions).select{|v| !v.empty?}.first || []
+        @options[:filters] ||= []
       end
 
     protected

data/lib/cucumber/cli/profile_loader.rb

@@ -60,7 +60,7 @@ Defined profiles in cucumber.yml:
         require 'erb'
         require 'yaml'
         begin
-          @cucumber_erb = ERB.new(IO.read(cucumber_file)).result(binding)
+          @cucumber_erb = ERB.new(IO.read(cucumber_file), nil, '%').result(binding)
         rescue Exception => e
           raise(YmlLoadError,"cucumber.yml was found, but could not be parsed with ERB.  Please refer to cucumber's documentation on correct profile usage.\n#{$!.inspect}")
         end

data/lib/cucumber/configuration.rb

@@ -14,6 +14,10 @@ module Cucumber
       @options = default_options.merge(user_options)
     end
 
+    def randomize?
+      @options[:randomize]
+    end
+
     def dry_run?
       @options[:dry_run]
     end

data/lib/cucumber/constantize.rb

@@ -33,12 +33,13 @@ module Cucumber
     end
 
     private
-      def constantize_name(constant, name)
-        if Cucumber::RUBY_1_8_7
-          constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
-        else
-          constant.const_defined?(name, false) ? constant.const_get(name, false) : constant.const_missing(name)
-        end
+
+    def constantize_name(constant, name)
+      if constant.const_defined?(name, false)
+        constant.const_get(name, false)
+      else
+        constant.const_missing(name)
       end
+    end
   end
 end

data/lib/cucumber/core_ext/instance_exec.rb

@@ -8,35 +8,12 @@ module Cucumber
 end
 
 class Object #:nodoc:
-  unless defined? instance_exec # 1.9
-    # http://eigenclass.org/hiki/bounded+space+instance_exec
-    module InstanceExecHelper #:nodoc:
-    end
-    include InstanceExecHelper
-    def instance_exec(*args, &block)
-      begin
-        old_critical, Thread.critical = Thread.critical, true
-        n = 0
-        n += 1 while respond_to?(mname="__instance_exec#{n}")
-        InstanceExecHelper.module_eval{ define_method(mname, &block) }
-      ensure
-        Thread.critical = old_critical
-      end
-      begin
-        ret = send(mname, *args)
-      ensure
-        InstanceExecHelper.module_eval{ remove_method(mname) } rescue nil
-      end
-      ret
-    end
-  end
-
   # TODO: Move most of this stuff out to an InstanceExecutor class.
   def cucumber_instance_exec(check_arity, pseudo_method, *args, &block)
     cucumber_run_with_backtrace_filtering(pseudo_method) do
       if check_arity && !cucumber_compatible_arity?(args, block)
         instance_exec do
-          ari = cucumber_arity(block)
+          ari = block.arity
           ari = ari < 0 ? (ari.abs-1).to_s+"+" : ari
           s1 = ari == 1 ? "" : "s"
           s2 = args.length == 1 ? "" : "s"
@@ -52,15 +29,11 @@ class Object #:nodoc:
 
   private
 
-  def cucumber_arity(block)
-    a = block.arity
-    Cucumber::RUBY_1_8_7 ? (a == -1 ? 0 : a) : a
-  end
-
   def cucumber_compatible_arity?(args, block)
-    ari = cucumber_arity(block)
-    len = args.length
-    return true if ari == len or ari < 0 && len >= ari.abs-1
+    return true if block.arity == args.length
+    if block.arity < 0
+      return true if args.length >= (block.arity.abs - 1)
+    end
     false
   end
 
@@ -74,7 +47,7 @@ class Object #:nodoc:
     end
   end
 
-  INSTANCE_EXEC_OFFSET = (Cucumber::RUBY_2_0 || Cucumber::RUBY_1_9 || Cucumber::RUBY_1_8_7 || Cucumber::JRUBY) ? -3 : -4
+  INSTANCE_EXEC_OFFSET = -3
 
   def replace_instance_exec_invocation_line!(backtrace, instance_exec_invocation_line, pseudo_method)
     return if Cucumber.use_full_backtrace
@@ -82,11 +55,7 @@ class Object #:nodoc:
     instance_exec_pos = backtrace.index(instance_exec_invocation_line)
     if instance_exec_pos
       replacement_line = instance_exec_pos + INSTANCE_EXEC_OFFSET
-      if Cucumber::RUBY_1_8_7
-        backtrace[replacement_line] += ":in `#{pseudo_method}'" if pseudo_method
-      else
-        backtrace[replacement_line].gsub!(/`.*'/, "`#{pseudo_method}'") if pseudo_method
-      end
+      backtrace[replacement_line].gsub!(/`.*'/, "`#{pseudo_method}'") if pseudo_method
 
       depth = backtrace.count { |line| line == instance_exec_invocation_line }
       end_pos = depth > 1 ? instance_exec_pos : -1

data/lib/cucumber/core_ext/proc.rb

@@ -17,7 +17,7 @@ class Proc #:nodoc:
       path, line = *to_s.match(PROC_PATTERN)[1..2]
       path = File.expand_path(path)
       pwd = File.expand_path(PWD)
-      pwd.force_encoding(path.encoding) unless Cucumber::RUBY_1_8_7
+      pwd.force_encoding(path.encoding)
       if path.index(pwd)
         path = path[pwd.length+1..-1]
       elsif path =~ /.*\/gems\/(.*\.rb)$/

data/lib/cucumber/encoding.rb

@@ -0,0 +1,5 @@
+# See https://github.com/cucumber/cucumber/issues/693
+if defined? Encoding
+  Encoding.default_external = 'utf-8'
+  Encoding.default_internal = 'utf-8'
+end

data/lib/cucumber/errors.rb

@@ -1,24 +1,35 @@
+require 'cucumber/core/test/result'
+
 module Cucumber
   # Raised when there is no matching StepDefinition for a step.
-  class Undefined < StandardError
-    attr_reader :step_name
+  class Undefined < Core::Test::Result::Undefined
+    def self.from(result, step_name)
+      if result.is_a?(self)
+        return result.with_message(with_prefix(result.message))
+      end
 
-    def initialize(step_name)
-      super %{Undefined step: "#{step_name}"}
-      @step_name = step_name
+      begin
+        raise self.new(with_prefix(step_name))
+      rescue => exception
+        return exception
+      end
     end
 
-    def nested!
-      @nested = true
+    def self.with_prefix(step_name)
+      %(Undefined step: "#{step_name}")
     end
+  end
 
-    def nested?
-      @nested
+  # Raised when there is no matching StepDefinition for a step called
+  # from within another step definition.
+  class UndefinedDynamicStep < StandardError
+    def initialize(step_name)
+      super %(Undefined dynamic step: "#{step_name}")
     end
   end
 
   # Raised when a StepDefinition's block invokes World#pending
-  class Pending < StandardError
+  class Pending < Core::Test::Result::Pending
   end
 
   # Raised when a step matches 2 or more StepDefinitions

data/lib/cucumber/file_specs.rb

@@ -0,0 +1,37 @@
+require 'cucumber'
+require 'cucumber/core/ast/location'
+
+module Cucumber
+  class FileSpecs
+    FILE_COLON_LINE_PATTERN = /^([\w\W]*?)(?::([\d:]+))?$/ #:nodoc:
+
+    def initialize(file_specs)
+      Cucumber.logger.debug("Features:\n")
+      @file_specs = file_specs.map { |s| FileSpec.new(s) }
+      Cucumber.logger.debug("\n")
+    end
+
+    def locations
+      @file_specs.map(&:locations).flatten
+    end
+
+    def files
+      @file_specs.map(&:file).uniq
+    end
+
+    class FileSpec
+      def initialize(s)
+        @file, @lines = *FILE_COLON_LINE_PATTERN.match(s).captures
+        Cucumber.logger.debug("  * #{@file}\n")
+        @lines = String(@lines).split(':').map { |line| Integer(line) }
+      end
+
+      attr_reader :file
+
+      def locations
+        return [ Core::Ast::Location.new(@file) ] if @lines.empty?
+        @lines.map { |line| Core::Ast::Location.new(@file, line) }
+      end
+    end
+  end
+end

data/lib/cucumber/filters/activate_steps.rb

@@ -0,0 +1,33 @@
+require 'cucumber/core/filter'
+
+module Cucumber
+  module Filters
+    class ActivateSteps < Core::Filter.new(:step_definitions)
+
+      def test_case(test_case)
+        CaseFilter.new(test_case, step_definitions).test_case.describe_to receiver
+      end
+
+      class CaseFilter
+        def initialize(test_case, step_definitions)
+          @original_test_case = test_case
+          @step_definitions = step_definitions
+        end
+
+        def test_case
+          @original_test_case.with_steps(new_test_steps)
+        end
+
+        private
+
+        def new_test_steps
+          @original_test_case.test_steps.map(&self.method(:attempt_to_activate))
+        end
+
+        def attempt_to_activate(test_step)
+          @step_definitions.find_match(test_step).activate(test_step)
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/filters/apply_after_hooks.rb

@@ -0,0 +1,9 @@
+module Cucumber
+  module Filters
+    class ApplyAfterHooks < Core::Filter.new(:hooks)
+      def test_case(test_case)
+        hooks.apply_after_hooks(test_case).describe_to(receiver)
+      end
+    end
+  end
+end

data/lib/cucumber/filters/apply_after_step_hooks.rb

@@ -0,0 +1,12 @@
+require 'cucumber/core/filter'
+
+module Cucumber
+  module Filters
+    class ApplyAfterStepHooks < Core::Filter.new(:hooks)
+      def test_case(test_case)
+        test_steps = hooks.find_after_step_hooks(test_case).apply(test_case.test_steps)
+        test_case.with_steps(test_steps).describe_to(receiver)
+      end
+    end
+  end
+end

data/lib/cucumber/filters/apply_around_hooks.rb

@@ -0,0 +1,12 @@
+require 'cucumber/core/filter'
+
+module Cucumber
+  module Filters
+    class ApplyAroundHooks < Core::Filter.new(:hooks)
+      def test_case(test_case)
+        around_hooks = hooks.find_around_hooks(test_case)
+        test_case.with_around_hooks(around_hooks).describe_to(receiver)
+      end
+    end
+  end
+end

data/lib/cucumber/filters/apply_before_hooks.rb

@@ -0,0 +1,9 @@
+module Cucumber
+  module Filters
+    class ApplyBeforeHooks < Core::Filter.new(:hooks)
+      def test_case(test_case)
+        hooks.apply_before_hooks(test_case).describe_to(receiver)
+      end
+    end
+  end
+end

data/lib/cucumber/filters/gated_receiver.rb

@@ -0,0 +1,25 @@
+module Cucumber
+  module Filters
+
+    class GatedReceiver
+      def initialize(receiver)
+        @receiver = receiver
+        @test_cases = []
+      end
+
+      def test_case(test_case)
+        @test_cases << test_case
+        self
+      end
+
+      def done
+        @test_cases.map do |test_case|
+          test_case.describe_to(@receiver)
+        end
+        @receiver.done
+        self
+      end
+    end
+
+  end
+end

data/lib/cucumber/filters/prepare_world.rb

@@ -0,0 +1,45 @@
+require 'cucumber/core/filter'
+require 'cucumber/running_test_case'
+require 'cucumber/hooks'
+
+module Cucumber
+  module Filters
+
+    class PrepareWorld < Core::Filter.new(:runtime)
+
+      def test_case(test_case)
+        CaseFilter.new(runtime, test_case).test_case.describe_to receiver
+      end
+
+      class CaseFilter
+        def initialize(runtime, original_test_case)
+          @runtime, @original_test_case = runtime, original_test_case
+        end
+
+        def test_case
+          init_scenario = Cucumber::Hooks.around_hook(@original_test_case.source) do |continue|
+            @runtime.begin_scenario(scenario)
+            continue.call
+            @runtime.end_scenario(scenario)
+          end
+          around_hooks = [init_scenario] + @original_test_case.around_hooks
+
+          default_hook = Cucumber::Hooks.before_hook(@original_test_case.source) do
+            #no op - legacy format adapter expects a before hooks
+          end
+          steps = [default_hook] + @original_test_case.test_steps
+
+          @original_test_case.with_around_hooks(around_hooks).with_steps(steps)
+        end
+
+        private
+
+        def scenario
+          @scenario ||= RunningTestCase.new(test_case)
+        end
+      end
+
+    end
+
+  end
+end

data/lib/cucumber/filters/quit.rb

@@ -0,0 +1,28 @@
+module Cucumber
+  module Filters
+
+    class Quit
+      def initialize(receiver=nil)
+        @receiver = receiver
+      end
+
+      def test_case(test_case)
+        unless Cucumber.wants_to_quit
+          test_case.describe_to @receiver
+        end
+        self
+      end
+
+      def done
+        @receiver.done
+        self
+      end
+
+      def with_receiver(receiver)
+        self.class.new(receiver)
+      end
+    end
+
+  end
+end
+

data/lib/cucumber/filters/randomizer.rb

@@ -0,0 +1,40 @@
+module Cucumber
+  module Filters
+
+    # Batches up all test cases, randomizes them, and then sends them on
+    class Randomizer
+      def initialize(seed, receiver=nil)
+        @receiver = receiver
+        @test_cases = []
+        @seed = seed
+      end
+
+      def test_case(test_case)
+        @test_cases << test_case
+        self
+      end
+
+      def done
+        shuffled_test_cases.each do |test_case|
+          test_case.describe_to(@receiver)
+        end
+        @receiver.done
+        self
+      end
+
+      def with_receiver(receiver)
+        self.class.new(@seed, receiver)
+      end
+
+      private
+
+      def shuffled_test_cases
+        @test_cases.shuffle(random: Random.new(seed))
+      end
+
+      attr_reader :seed
+      private :seed
+    end
+
+  end
+end