cucumber 2.0.0.beta.5 → 2.0.0.rc.1

data/lib/cucumber/formatter/ansicolor.rb

@@ -1,14 +1,6 @@
 require 'cucumber/platform'
 require 'cucumber/term/ansicolor'
 
-if Cucumber::IRONRUBY
-  begin
-    require 'iron-term-ansicolor'
-  rescue LoadError
-    STDERR.puts %{*** WARNING: You must "igem install iron-term-ansicolor" to get coloured ouput in on IronRuby}
-  end
-end
-
 if Cucumber::WINDOWS_MRI
   unless ENV['ANSICON']
     STDERR.puts %{*** WARNING: You must use ANSICON 1.31 or higher (https://github.com/adoxa/ansicon/) to get coloured output on Windows}

data/lib/cucumber/formatter/html.rb

@@ -2,6 +2,7 @@ require 'erb'
 require 'builder'
 require 'cucumber/formatter/duration'
 require 'cucumber/formatter/io'
+require 'pathname'
 
 module Cucumber
   module Formatter
@@ -50,6 +51,10 @@ module Cucumber
       def embed_image(src, label)
         id = "img_#{@img_id}"
         @img_id += 1
+        if @io.respond_to?(:path) and File.file?(src)
+          out_dir = Pathname.new(File.dirname(File.absolute_path(@io.path)))
+          src = Pathname.new(File.absolute_path(src)).relative_path_from(out_dir)
+        end        
         @builder.span(:class => 'embed') do |pre|
           pre << %{<a href="" onclick="img=document.getElementById('#{id}'); img.style.display = (img.style.display == 'none' ? 'block' : 'none');return false">#{label}</a><br>&nbsp;
           <img id="#{id}" style="display: none" src="#{src}"/>}
@@ -562,7 +567,7 @@ module Cucumber
       end
 
       def backtrace_line(line)
-        line.gsub(/\A([^:]*\.(?:rb|feature|haml)):(\d*).*\z/) do
+        line.gsub(/^([^:]*\.(?:rb|feature|haml)):(\d*).*$/) do
           if ENV['TM_PROJECT_DIRECTORY']
             "<a href=\"txmt://open?url=file://#{File.expand_path($1)}&line=#{$2}\">#{$1}:#{$2}</a> "
           else

data/lib/cucumber/formatter/legacy_api/adapter.rb

@@ -238,6 +238,7 @@ module Cucumber
           end
 
           def after_step_hook(hook, result)
+            p current_test_step_source if current_test_step_source.step.nil?
             line = StepBacktraceLine.new(current_test_step_source.step)
             @child.after_step_hook Ast::HookResult.new(LegacyResultBuilder.new(result).
               append_to_exception_backtrace(line), @delayed_messages, @delayed_embeddings)
@@ -398,7 +399,11 @@ module Cucumber
 
         # Basic printer used by default
         class AfterHookPrinter
-          include Cucumber.initializer(:formatter)
+          attr_reader :formatter
+
+          def initialize(formatter)
+            @formatter = formatter
+          end
 
           include PrintsAfterHooks
 
@@ -409,6 +414,12 @@ module Cucumber
 
         BackgroundPrinter = Struct.new(:formatter, :node, :before_hook_results) do
 
+          def after_test_case(*)
+          end
+
+          def after_hook(*)
+          end
+
           def before
             formatter.before_background node
             formatter.background_name node.keyword, node.legacy_conflated_name_and_description, node.location.to_s, indent.of(node)
@@ -965,6 +976,11 @@ module Cucumber
       end
 
       class StepBacktraceLine < Struct.new(:step)
+        def initialize(step)
+          raise ArgumentError if step.nil?
+          super
+        end
+
         def to_s
           step.backtrace_line
         end

data/lib/cucumber/formatter/legacy_api/ast.rb

@@ -118,7 +118,12 @@ module Cucumber
           end
 
           def step_result_attributes
-            [keyword, step_match, multiline_arg, status, exception, source_indent, background, file_colon_line]
+            legacy_multiline_arg = if multiline_arg.kind_of?(Core::Ast::EmptyMultilineArgument)
+              nil
+            else
+              step.multiline_arg
+            end
+            [keyword, step_match, legacy_multiline_arg, status, exception, source_indent, background, file_colon_line]
           end
 
           def failed?

data/lib/cucumber/hooks.rb

@@ -0,0 +1,97 @@
+require 'cucumber/core/test/around_hook'
+
+module Cucumber
+
+  # Hooks quack enough like `Cucumber::Core::Ast` source nodes that we can use them as 
+  # source for test steps
+  module Hooks
+
+    class << self
+      def before_hook(source, &block)
+        build_hook_step(source, block, BeforeHook, Core::Test::UnskippableAction)
+      end
+
+      def after_hook(source, &block)
+        build_hook_step(source, block, AfterHook, Core::Test::UnskippableAction)
+      end
+
+      def after_step_hook(source, &block)
+        raise ArgumentError unless source.last.kind_of?(Core::Ast::Step)
+        build_hook_step(source, block, AfterStepHook, Core::Test::Action)
+      end
+
+      def around_hook(source, &block)
+        Core::Test::AroundHook.new(&block)
+      end
+
+      private
+
+      def build_hook_step(source, block, hook_type, action_type)
+        action = action_type.new(&block)
+        hook = hook_type.new(action.location)
+        Core::Test::Step.new(source + [hook], action)
+      end
+    end
+
+    class AfterHook
+      attr_reader :location
+
+      def initialize(location)
+        @location = location
+      end
+
+      def name
+        "After hook"
+      end
+
+      def match_locations?(queried_locations)
+        queried_locations.any? { |other_location| other_location.match?(location) }
+      end
+
+      def describe_to(visitor, *args)
+        visitor.after_hook(self, *args)
+      end
+    end
+
+    class BeforeHook
+      attr_reader :location
+
+      def initialize(location)
+        @location = location
+      end
+
+      def name
+        "Before hook"
+      end
+
+      def match_locations?(queried_locations)
+        queried_locations.any? { |other_location| other_location.match?(location) }
+      end
+
+      def describe_to(visitor, *args)
+        visitor.before_hook(self, *args)
+      end
+    end
+
+    class AfterStepHook
+      attr_reader :location
+
+      def initialize(location)
+        @location = location
+      end
+
+      def name
+        "AfterStep hook"
+      end
+
+      def match_locations?(queried_locations)
+        queried_locations.any? { |other_location| other_location.match?(location) }
+      end
+
+      def describe_to(visitor, *args)
+        visitor.after_step_hook(self, *args)
+      end
+    end
+
+  end
+end

data/lib/cucumber/platform.rb

@@ -4,14 +4,13 @@ require 'rbconfig'
 
 module Cucumber
   unless defined?(Cucumber::VERSION)
-    VERSION       = '2.0.0.beta.5'
+    VERSION       = '2.0.0.rc.1'
     BINARY        = File.expand_path(File.dirname(__FILE__) + '/../../bin/cucumber')
     LIBDIR        = File.expand_path(File.dirname(__FILE__) + '/../../lib')
     JRUBY         = defined?(JRUBY_VERSION)
-    IRONRUBY      = defined?(RUBY_ENGINE) && RUBY_ENGINE == "ironruby"
     WINDOWS       = RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
     OS_X          = RbConfig::CONFIG['host_os'] =~ /darwin/
-    WINDOWS_MRI   = WINDOWS && !JRUBY && !IRONRUBY
+    WINDOWS_MRI   = WINDOWS && !JRUBY
     RAILS         = defined?(Rails)
     RUBY_BINARY   = File.join(RbConfig::CONFIG['bindir'], RbConfig::CONFIG['ruby_install_name'])
     RUBY_2_1      = RUBY_VERSION =~ /^2\.1/

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

@@ -9,9 +9,7 @@ require 'cucumber/load_path'
 require 'cucumber/language_support/language_methods'
 require 'cucumber/formatter/duration'
 require 'cucumber/file_specs'
-require 'cucumber/filters/quit'
-require 'cucumber/filters/randomizer'
-require 'cucumber/filters/tag_limits'
+require 'cucumber/filters'
 require 'cucumber/formatter/fanout'
 
 module Cucumber
@@ -68,7 +66,8 @@ module Cucumber
       fire_after_configuration_hook
       self.visitor = report
 
-      execute features, mappings, report, filters
+      receiver = Test::Runner.new(report)
+      compile features, receiver, filters
     end
 
     def features_paths
@@ -173,11 +172,6 @@ module Cucumber
       end
     end
 
-    require 'cucumber/mappings'
-    def mappings
-      @mappings = Mappings.for(self)
-    end
-
     require 'cucumber/formatter/legacy_api/adapter'
     require 'cucumber/formatter/legacy_api/runtime_facade'
     require 'cucumber/formatter/legacy_api/results'
@@ -218,12 +212,21 @@ module Cucumber
       name_regexps = @configuration.name_regexps
       tag_limits = @configuration.tag_limits
       [].tap do |filters|
-        filters << [Filters::Randomizer, [@configuration.seed]] if @configuration.randomize?
-        filters << [Filters::TagLimits, [tag_limits]] if tag_limits.any?
-        filters << [Cucumber::Core::Test::TagFilter, [tag_expressions]]
-        filters << [Cucumber::Core::Test::NameFilter, [name_regexps]]
-        filters << [Cucumber::Core::Test::LocationsFilter, [filespecs.locations]]
-        filters << [Filters::Quit, []]
+        filters << Filters::Randomizer.new(@configuration.seed) if @configuration.randomize?
+        filters << Filters::TagLimits.new(tag_limits) if tag_limits.any?
+        filters << Cucumber::Core::Test::TagFilter.new(tag_expressions)
+        filters << Cucumber::Core::Test::NameFilter.new(name_regexps)
+        filters << Cucumber::Core::Test::LocationsFilter.new(filespecs.locations)
+        filters << Filters::Quit.new
+        filters << Filters::ActivateSteps.new(@support_code)
+        unless configuration.dry_run?
+          filters << Filters::ApplyAfterStepHooks.new(@support_code)
+          filters << Filters::ApplyBeforeHooks.new(@support_code)
+          filters << Filters::ApplyAfterHooks.new(@support_code)
+          filters << Filters::ApplyAroundHooks.new(@support_code)
+          # need to do this last so it becomes the first test step
+          filters << Filters::PrepareWorld.new(self)
+        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)
+        )
+      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

data/lib/cucumber/runtime/step_hooks.rb

@@ -0,0 +1,22 @@
+module Cucumber
+  class Runtime
+    class StepHooks
+      def initialize(after)
+        @after = after
+      end
+
+      def apply(test_steps)
+        test_steps.flat_map do |test_step|
+          [test_step] + after_step_hooks(test_step)
+        end
+      end
+
+      private
+      def after_step_hooks(test_step)
+        @after.map do |action_block|
+          Hooks.after_step_hook(test_step.source, &action_block)
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/runtime/support_code.rb

@@ -1,5 +1,8 @@
 require 'cucumber/constantize'
 require 'cucumber/runtime/for_programming_languages'
+require 'cucumber/runtime/step_hooks'
+require 'cucumber/runtime/before_hooks'
+require 'cucumber/runtime/after_hooks'
 
 module Cucumber
 
@@ -7,7 +10,6 @@ module Cucumber
 
     class SupportCode
 
-      # TODO: figure out a way to move this to the core. We'd need to have access to the mappings to pass those in.
       require 'forwardable'
       class StepInvoker
         include Gherkin::Rubify
@@ -121,6 +123,59 @@ module Cucumber
         end.flatten
       end
 
+      def find_match(test_step)
+        begin
+          match = step_match(test_step.name)
+        rescue Cucumber::Undefined
+          return NoStepMatch.new(test_step.source.last, test_step.name)
+        end
+        if @configuration.dry_run?
+          return SkippingStepMatch.new
+        end
+        match
+      end
+
+      def find_after_step_hooks(test_case)
+        ruby = load_programming_language('rb')
+        scenario = Ast::Facade.new(test_case).build_scenario
+
+        action_blocks = ruby.hooks_for(:after_step, scenario).map do |hook|
+          ->(*args) { hook.invoke('AfterStep', args) }
+        end
+        StepHooks.new action_blocks
+      end
+
+      def apply_before_hooks(test_case)
+        ruby = load_programming_language('rb')
+        scenario = Ast::Facade.new(test_case).build_scenario
+
+        action_blocks = ruby.hooks_for(:before, scenario).map do |hook|
+          ->(result) { hook.invoke('Before', scenario.with_result(result)) }
+        end
+        BeforeHooks.new(action_blocks).apply_to(test_case)
+      end
+
+      def apply_after_hooks(test_case)
+        ruby = load_programming_language('rb')
+        scenario = Ast::Facade.new(test_case).build_scenario
+
+        action_blocks = ruby.hooks_for(:after, scenario).map do |hook|
+          ->(result) { hook.invoke('After', scenario.with_result(result)) }
+        end
+        AfterHooks.new(action_blocks).apply_to(test_case)
+      end
+
+      def find_around_hooks(test_case)
+        ruby = load_programming_language('rb')
+        scenario = Ast::Facade.new(test_case).build_scenario
+
+        ruby.hooks_for(:around, scenario).map do |hook|
+          Hooks.around_hook(test_case.source) do |run_scenario|
+            hook.invoke('Around', scenario, &run_scenario)
+          end
+        end
+      end
+
       def step_match(step_name, name_to_report=nil) #:nodoc:
         @match_cache ||= {}
 

data/lib/cucumber/step_match.rb

@@ -1,3 +1,5 @@
+require 'cucumber/multiline_argument'
+
 module Cucumber
   class StepMatch #:nodoc:
     attr_reader :step_definition, :step_arguments
@@ -12,15 +14,21 @@ module Cucumber
     end
 
     def args
-      @step_arguments.map{|g| g.val.freeze }
+      @step_arguments.map{|g| g.val }
     end
 
     def name
       @name_to_report
     end
 
+    def activate(test_step)
+      test_step.with_action do
+        invoke(MultilineArgument.from_core(test_step.source.last.multiline_arg))
+      end
+    end
+
     def invoke(multiline_arg)
-      all_args = args.dup
+      all_args = deep_clone_args
       multiline_arg.append_to(all_args)
       @step_definition.invoke(all_args)
     end
@@ -80,6 +88,17 @@ module Cucumber
     def inspect #:nodoc:
       sprintf("#<%s:0x%x>", self.class, self.object_id)
     end
+
+    private
+    def deep_clone_args
+      Marshal.load( Marshal.dump( args ) )
+    end
+  end
+
+  class SkippingStepMatch
+    def activate(test_step)
+      return test_step.with_action { raise Core::Test::Result::Skipped.new }
+    end
   end
 
   class NoStepMatch #:nodoc:
@@ -110,5 +129,10 @@ module Cucumber
     def step_arguments
       []
     end
+
+    def activate(test_step)
+      # noop
+      return test_step
+    end
   end
 end