gurke 2.0.0.dev.1.b17 → 2.0.0.dev.1.b18

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NDc3MWMyNWIzYzQ0MGRmMWFkMmIyMmFmMjYwMTgzN2I3NmQ0YTdmYQ==
+    MTliYzQwOGExYjAzODMxMTE3YWZhMmU1ZDhmZDM5YjZjZWM5Y2E5ZA==
   data.tar.gz: !binary |-
-    ODQ4YWI3ZTUyZDhmYjk2YzQ2NWQwOWY1ZmM1YzFkNDQ5YWRhZTJjYQ==
+    ZjdiNTE1MDQ5NTk5ZmY4YTIwZGZhZWM2MmRhZGYwMWQ1YWRhZjVjYQ==
 SHA512:
   metadata.gz: !binary |-
-    OTcwMGYwOTM2NTEzNGQ0MWU0YmFiN2I3OWMxNjAxZTc4N2Q0OGEwYTdkOGY4
-    NDJkNmI0MjY0ZTYzYzcyMTVhNDZkYWY0MWE2MzVmYTc1ZjE1ZTMxYzZkMjQ2
-    OGU4ZTRmODkyZTQ2MWMzY2VjOTM0MWE5MTdhNWQwODdiYjEwZmQ=
+    Y2EzNTBhOTE4OTFmOWQ2ZjU0NzI1MWY2YjhhMGE1N2EyNGJiNjNlYTA5NTNl
+    MmVmM2Y0NWM4NTVhYzIxNDY0OTY5ZDBiZTZkYTIwODAwMDljMzIxNTNkMTYy
+    Y2JmZmZiZjc3ZTYwNTdkMzlhNzgyOTMwZjk3NzEzZWIzNDRjNGU=
   data.tar.gz: !binary |-
-    MmUyOWRiZDQ3ZWYyMDU5ZGY0M2Y3ODk2MmIyYThjNGI2MGYzNTEyMTJiNzJl
-    ZTAzOGZlNzIwMGJmNGQzZDBlY2E5ZDBlZDk1ZDlhOWVlZDFhMzJiYjJjODJh
-    ZGNjMmU1OWFjOTdjMTkwNmFjNTE5ZDQ4NDI1MGViZTliNTA4ZjA=
+    NGFiZmE4ODNkMDkxODY3ZWZjYTE1ODBkYzNkYjY4MWU1NTgwNzYxZDEzY2Y4
+    ZTBlOWY3M2U2ZWQ2MGFjODFiYThhNDEyOWYzZmU3MWQ0M2JlMzVjMTBhZjVh
+    YzYwNDNhZGNmOTFjZmQ2YmYxYzRkZjU1MmM5ZDdlMDkyMzg2NTg=

data/lib/gurke.rb

@@ -8,6 +8,9 @@ module Gurke
   require 'gurke/step'
   require 'gurke/tag'
 
+  require 'gurke/run_list'
+  require 'gurke/feature_list'
+
   require 'gurke/dsl'
   require 'gurke/builder'
   require 'gurke/configuration'
@@ -16,6 +19,11 @@ module Gurke
   require 'gurke/step_definition'
   require 'gurke/reporter'
 
+  module Reporters
+    require 'gurke/reporters/null_reporter'
+    require 'gurke/reporters/default_reporter'
+  end
+
   class Error < StandardError; end
   class StepPending < Error; end
   class StepAmbiguous < Error; end

data/lib/gurke/background.rb

@@ -14,20 +14,31 @@ module Gurke
     #
     attr_reader :line
 
+    # List of steps this background specifies.
+    #
+    # @return [Array<Step>] Steps.
+    #
+    attr_reader :steps
+
     # @api private
     attr_reader :raw
 
     # @api private
     def initialize(file, line, raw)
-      @file, @line, @raw = file, line, raw
+      @file  = file
+      @line  = line
+      @raw   = raw
+      @steps = RunList.new
     end
 
-    # Return list of steps this background specifies.
-    #
-    # @return [Array<Step>] Steps.
+    # @api private
     #
-    def steps
-      @steps ||= []
+    def run(runner, reporter, scenario, world)
+      reporter.invoke :start_background, self, scenario
+
+      steps.run runner, reporter, scenario, world
+    ensure
+      reporter.invoke :end_background, self, scenario
     end
   end
 end

data/lib/gurke/builder.rb

@@ -8,7 +8,7 @@ module Gurke
 
     def initialize(options)
       @options  = options
-      @features = []
+      @features = FeatureList.new
       @language = 'en'
       @parser   = Gherkin::Parser::Parser.new(
         self, true, 'root', false, @language)
@@ -30,49 +30,54 @@ module Gurke
     end
 
     def feature(raw)
-      tags = raw.tags.map{|t| Tag.new(@file, t.line, t) }
+      tags = raw.tags.map{|t| Tag.new @file, t.line, t }
 
-      @current_feature = Feature.new(@file, raw.line, tags, raw)
-      @features << @current_feature
+      @feature  = Feature.new(@file, raw.line, tags, raw)
+      @scenario = nil
+      @type     = nil
+
+      features << @feature
     end
 
     def background(raw)
-      @current_context = Background.new(@file, raw.line, raw)
-      @current_feature.backgrounds << @current_context
+      @context = Background.new @file, raw.line, raw
+      @type    = nil
+
+      @feature.backgrounds << @context
     end
 
     def scenario(raw)
-      tags = raw.tags.map{|t| Tag.new(@file, t.line, t) }
-      tags += @current_feature.tags
+      tags  = raw.tags.map{|t| Tag.new @file, t.line, t }
+      tags += features.last.tags
 
-      @current_context = Scenario.new(@file, raw.line, tags, raw)
+      @scenario = Scenario.new @feature, @file, raw.line, tags, raw
+      @context  = @scenario
+      @type     = nil
 
-      unless filtered?(@current_context)
-        @current_feature.scenarios << @current_context
-      end
+      @feature.scenarios << @scenario unless filtered?(@scenario)
     end
 
     def step(raw)
-      type = get_type(raw.keyword.strip)
+      @type = lookup_type raw.keyword.strip
 
-      @current_context.steps << Step.new(@file, raw.line, type, raw)
+      @context.steps << Step.new(@file, raw.line, @type, raw)
     end
 
     def eof(*)
       @features.reject!{|f| f.scenarios.empty? }
-      @current_context = nil
-      @current_feature = nil
-      @file            = nil
+      @feature  = nil
+      @scenario = nil
+      @context  = nil
+      @type     = nil
+      @file     = nil
     end
 
-    def get_type(keyword)
+    private
+
+    def lookup_type(keyword)
       case (kw = @keywords.fetch(keyword))
         when :and, :but
-          if (step = @current_context.steps.last)
-            step.type
-          else
-            nil
-          end
+          @type
         else
           kw
       end

data/lib/gurke/feature.rb

@@ -14,6 +14,18 @@ module Gurke
     #
     attr_reader :line
 
+    # List of scenarios this feature specifies.
+    #
+    # @return [Array<Scenario>] Scenarios.
+    #
+    attr_reader :scenarios
+
+    # List of backgrounds this feature specifies.
+    #
+    # @return [Array<Background>] Backgrounds.
+    #
+    attr_reader :backgrounds
+
     attr_reader :tags
 
     # @api private
@@ -21,7 +33,13 @@ module Gurke
 
     # @api private
     def initialize(file, line, tags, raw)
-      @file, @line, @tags, @raw = file, line, tags, raw
+      @scenarios   = RunList.new
+      @backgrounds = RunList.new
+
+      @file = file
+      @line = line
+      @tags = tags
+      @raw  = raw
     end
 
     def name
@@ -32,18 +50,6 @@ module Gurke
       raw.description
     end
 
-    # Return list of scenarios this feature specifies.
-    #
-    # @return [Array<Scenario>] Scenarios.
-    #
-    def scenarios
-      @scenarios ||= []
-    end
-
-    def backgrounds
-      @backgrounds ||= []
-    end
-
     # Return name of this feature.
     #
     # @return [String] Feature name.
@@ -51,5 +57,34 @@ module Gurke
     def name
       raw.name
     end
+
+    def failed?
+      scenarios.any?(&:failed?)
+    end
+
+    def pending?
+      scenarios.any?(&:pending?)
+    end
+
+    # @api private
+    def run(runner, reporter)
+      reporter.invoke :before_feature, self
+
+      runner.hook :feature, nil do
+        run_feature runner, reporter
+      end
+    ensure
+      reporter.invoke :after_feature
+    end
+
+    private
+
+    def run_feature(runner, reporter)
+      reporter.invoke :start_feature, self
+
+      scenarios.run runner, reporter
+    ensure
+      reporter.invoke :end_feature, self
+    end
   end
 end

data/lib/gurke/feature_list.rb

@@ -0,0 +1,37 @@
+module Gurke
+  #
+  # A {FeatureList} is a list of {Feature} objects.
+  #
+  class FeatureList < Array
+    #
+    # Run all features from this list.
+    #
+    # @return [Boolean] False if any scenario has failed or is pending.
+    #
+    # @api private
+    #
+    def run(runner, reporter)
+      reporter.invoke :before_features, self
+
+      runner.hook(:features, nil) do
+        run_features runner, reporter
+      end
+
+      reporter.invoke :after_features, self
+
+      !any?{|s| s.failed? || s.pending? }
+    end
+
+    private
+
+    def run_features(runner, reporter)
+      reporter.invoke :start_features, self
+
+      each do |feature|
+        feature.run runner, reporter
+      end
+    ensure
+      reporter.invoke :end_features, self
+    end
+  end
+end

data/lib/gurke/reporter.rb

@@ -1,98 +1,259 @@
-require 'colorize'
-
-# Colorize colors:
-#   :black, :red, :green, :yellow, :blue,
-#   :magenta, :cyan, :white, :default, :light_black,
-#   :light_red, :light_green, :light_yellow, :light_blue,
-#   :light_magenta, :light_cyan, :light_white
-
 module Gurke
+  #
+  # A {Reporter} provides callbacks that will be executed whenever
+  # a specific execution step starts or ends.
+  #
+  # @api public
   #
   class Reporter
-    def start_features(*)
+    # rubocop:disable UnusedMethodArgument
+
+    # List of all callback methods as symbols.
+    #
+    CALLBACKS = [
+      :before_features,
+      :before_feature,
+      :before_scenario,
+      :before_step,
+      :start_features,
+      :start_feature,
+      :start_scenario,
+      :start_background,
+      :start_step,
+      :end_features,
+      :end_feature,
+      :end_scenario,
+      :end_background,
+      :end_step,
+      :after_features,
+      :after_feature,
+      :after_scenario,
+      :after_step
+    ]
+
+    # Called before the execution of any feature and before any
+    # before-features hook is invoked.
+    #
+    # @param features [Array<Feature>] List of all features that
+    #   are going to be executed.
+    #
+    # @api public
+    #
+    def before_features(features)
+      raise NotImplementedError.new \
+        "#{self.class.name}#before_features must be implemented in subclass."
     end
 
-    def start_feature(feature)
-      io.puts "#{yellow('Feature')}: #{feature.name}"
-      io.puts '  ' + light_black(feature.description.split("\n").join("\n  "))
-      io.puts
+    # Called before the execute of any feature, but after all
+    # before-features hooks.
+    #
+    # @param features [Array<Feature>] List of all features that
+    #   are going to be executed.
+    #
+    # @api public
+    #
+    def start_features(features)
+      raise NotImplementedError.new \
+        "#{self.class.name}#before_features must be implemented in subclass."
     end
 
-    def start_scenario(scenario, feature)
-      io.puts "  #{yellow('Scenario')}: #{scenario.name}"
-      io.puts light_black('    Background:') if feature.backgrounds.any?
+    # Called for each feature before it starts, but before any
+    # before-feature hook is run.
+    #
+    # @param feature [Feature] The feature that is going to
+    #   be executed now.
+    #
+    # @api public
+    #
+    def before_feature(feature)
+      raise NotImplementedError.new \
+        "#{self.class.name}#start_feature must be implemented in subclass."
     end
 
-    def start_background(*)
-      @background = true
+    # Called for each feature before it starts, but after
+    # all before-feature hooks.
+    #
+    # @param feature [Feature] The feature that is going to
+    #   be executed now.
+    #
+    # @api public
+    #
+    def start_feature(feature)
+      raise NotImplementedError.new \
+        "#{self.class.name}#start_feature must be implemented in subclass."
     end
 
-    def finish_background(*)
-      @background = false
+    # Called for each each scenario before it starts. Will be
+    # called before any hooks for the given scenario is executed.
+    #
+    # @param scenario [Scenario] Current scenario.
+    #
+    # @api public
+    #
+    def before_scenario(scenario)
+      raise NotImplementedError.new \
+        "#{self.class.name}#before_scenario must be implemented in subclass."
     end
 
-    def start_step(step, *)
-      io.print '  ' if @background
-      io.print '    '
-      io.print yellow(step.keyword)
-      io.print step.name.gsub(/"(.*?)"/, cyan('\0'))
+    # Called for each each scenario before it starts, but after
+    # all before hooks for given scenario.
+    #
+    # @param scenario [Scenario] Current scenario.
+    #
+    # @api public
+    #
+    def start_scenario(scenario)
+      raise NotImplementedError.new \
+        "#{self.class.name}#start_scenario must be implemented in subclass."
     end
 
-    def finish_step(step, *)
-      case step.state
-        when :pending
-          print_braces yellow('pending')
-        when :failed
-          print_braces red('failure')
-          io.puts
-          io.puts red("      #{step.exception.class}:")
+    # Called before each background.
+    #
+    # @param background [Background] Current background.
+    # @param scenario [Scenario] Current scenario.
+    #
+    # @api public
+    #
+    def start_background(background, scenario)
+      raise NotImplementedError.new \
+        "#{self.class.name}#start_background must be implemented in subclass."
+    end
 
-          msg = step.exception.message.split("\n").join("\n          ")
-          io.puts red("        #{msg}")
+    # Called after each background.
+    #
+    # @param background [Background] Current background.
+    # @param scenario [Scenario] Current scenario.
+    #
+    # @api public
+    #
+    def end_background(background, scenario)
+      raise NotImplementedError.new \
+        "#{self.class.name}#end_background must be implemented in subclass."
+    end
 
-          io.puts red("      #{step.exception.backtrace.join("\n      ")}")
-        when :success
-          print_braces green('success')
-        else
-          print_braces cyan('skipped')
-      end
-      io.puts
-      io.flush
+    # Called before each step and before any before-step hook.
+    #
+    # @param step [Step] Current Step.
+    # @param scenario [Scenario] Current scenario.
+    #
+    # @api public
+    #
+    def before_step(step, scenario)
+      raise NotImplementedError.new \
+        "#{self.class.name}#before_step must be implemented in subclass."
     end
 
-    def finish_scenario(*)
-      io.puts
+    # Called before each step and after all before-step hooks.
+    #
+    # @param step [Step] Current Step.
+    # @param scenario [Scenario] Current scenario.
+    #
+    # @api public
+    #
+    def start_step(step, scenario)
+      raise NotImplementedError.new \
+        "#{self.class.name}#start_step must be implemented in subclass."
     end
 
-    def finish_feature(*)
-      io.puts
+    # Called after each step but before any after-step hook.
+    #
+    # @param step_result [StepResult] Result of current Step.
+    # @param scenario [Scenario] Current scenario.
+    # @param feature [Feature] Current feature.
+    #
+    # @api public
+    #
+    def end_step(step_result, scenario)
+      raise NotImplementedError.new \
+        "#{self.class.name}#end_step must be implemented in subclass."
     end
 
-    def finish_features(features)
-      scenarios = features.map(&:scenarios).flatten
+    # Called after each step, after all step hook.
+    #
+    # @param step_result [StepResult] Result of current Step.
+    # @param scenario [Scenario] Current scenario.
+    # @param feature [Feature] Current feature.
+    #
+    # @api public
+    #
+    def after_step(step_result, scenario)
+      raise NotImplementedError.new \
+        "#{self.class.name}#after_step must be implemented in subclass."
+    end
 
-      io.puts "  #{scenarios.size} scenarios: "\
-              "#{scenarios.select(&:failed?).size} failing, "\
-              "#{scenarios.select(&:pending?).size} pending"
-      io.puts
+    # Called after each scenario but before any after hook.
+    #
+    # @param scenario [Scenario] Current scenario.
+    # @param feature [Feature] Current feature.
+    #
+    # @api public
+    #
+    def end_scenario(scenario)
+      raise NotImplementedError.new \
+        "#{self.class.name}#end_scenario must be implemented in subclass."
     end
 
-    private
+    # Called after each scenario and after all hooks.
+    #
+    # @param scenario [Scenario] Current scenario.
+    # @param feature [Feature] Current feature.
+    #
+    # @api public
+    #
+    def after_scenario(scenario)
+      raise NotImplementedError.new \
+        "#{self.class.name}#after_scenario must be implemented in subclass."
+    end
 
-    def print_braces(str)
-      io.print " (#{str})"
+    # Called after each feature but before any after hook.
+    #
+    # @param feature [Feature] Current feature.
+    #
+    # @api public
+    #
+    def end_feature(feature)
+      raise NotImplementedError.new \
+        "#{self.class.name}#end_feature must be implemented in subclass."
     end
 
-    def io
-      $stdout
+    # Called after each feature and after all hooks.
+    #
+    # @param feature [Feature] Current feature.
+    #
+    # @api public
+    #
+    def after_feature(feature)
+      raise NotImplementedError.new \
+        "#{self.class.name}#after_feature must be implemented in subclass."
     end
 
-    [:black, :red, :green, :yellow, :blue,
-     :magenta, :cyan, :white, :default, :light_black,
-     :light_red, :light_green, :light_yellow, :light_blue,
-     :light_magenta, :light_cyan, :light_white].each do |color|
+    # Called after all features but before any after-features hook.
+    #
+    # @param features [Array<Feature>] List of all features.
+    #
+    # @api public
+    #
+    def end_features(features)
+      raise NotImplementedError.new \
+        "#{self.class.name}#end_features must be implemented in subclass."
+    end
+
+    # Called after all features and after all hooks.
+    #
+    # @param features [Array<Feature>] List of all features.
+    #
+    # @api public
+    #
+    def after_features(features)
+      raise NotImplementedError.new \
+        "#{self.class.name}#after_features must be implemented in subclass."
+    end
 
-      define_method(color){|str|  io.tty? ? str.send(color) : str }
+    # @visibility private
+    def invoke(mth, *args)
+      send mth, *args
+    rescue => e
+      warn "Rescued in reporter: #{e}\n" + e.backtrace.join("\n")
     end
   end
 end

data/lib/gurke/reporters/default_reporter.rb

@@ -0,0 +1,95 @@
+require 'colorize'
+
+# Colorize colors:
+#   :black, :red, :green, :yellow, :blue,
+#   :magenta, :cyan, :white, :default, :light_black,
+#   :light_red, :light_green, :light_yellow, :light_blue,
+#   :light_magenta, :light_cyan, :light_white
+
+module Gurke::Reporters
+  #
+  class DefaultReporter < NullReporter
+    def before_feature(feature)
+      io.puts "#{yellow('Feature')}: #{feature.name}"
+      io.puts '  ' + light_black(feature.description.split("\n").join("\n  "))
+      io.puts
+    end
+
+    def before_scenario(scenario)
+      io.puts "  #{yellow('Scenario')}: #{scenario.name}"
+      io.puts light_black('    Background:') if scenario.backgrounds.any?
+    end
+
+    def start_background(*)
+      @background = true
+    end
+
+    def end_background(*)
+      @background = false
+    end
+
+    def before_step(step, *)
+      io.print '  ' if @background
+      io.print '    '
+      io.print yellow(step.keyword)
+      io.print step.name.gsub(/"(.*?)"/, cyan('\0'))
+    end
+
+    def after_step(step, *)
+      case step.state
+        when :pending
+          print_braces yellow('pending')
+        when :failed
+          print_braces red('failure')
+          io.puts
+          io.puts red("      #{step.exception.class}:")
+
+          msg = step.exception.message.split("\n").join("\n          ")
+          io.puts red("        #{msg}")
+
+          io.puts red("      #{step.exception.backtrace.join("\n      ")}")
+        when :success
+          print_braces green('success')
+        else
+          print_braces cyan('skipped')
+      end
+      io.puts
+      io.flush
+    end
+
+    def after_scenario(*)
+      io.puts
+    end
+
+    def after_feature(*)
+      io.puts
+    end
+
+    def after_features(features)
+      scenarios = features.map(&:scenarios).flatten
+
+      io.puts "  #{scenarios.size} scenarios: "\
+              "#{scenarios.select(&:failed?).size} failing, "\
+              "#{scenarios.select(&:pending?).size} pending"
+      io.puts
+    end
+
+    private
+
+    def print_braces(str)
+      io.print " (#{str})"
+    end
+
+    def io
+      $stdout
+    end
+
+    [:black, :red, :green, :yellow, :blue,
+     :magenta, :cyan, :white, :default, :light_black,
+     :light_red, :light_green, :light_yellow, :light_blue,
+     :light_magenta, :light_cyan, :light_white].each do |color|
+
+      define_method(color){|str|  io.tty? ? str.send(color) : str }
+    end
+  end
+end

data/lib/gurke/reporters/null_reporter.rb

@@ -0,0 +1,12 @@
+module Gurke::Reporters
+  #
+  # The {NullReporter} does not output anything.
+  #
+  class NullReporter < Gurke::Reporter
+    Gurke::Reporter::CALLBACKS.each do |cb|
+      class_eval <<-EOF, __FILE__, __LINE__
+        def #{cb}(*) end
+      EOF
+    end
+  end
+end

data/lib/gurke/run_list.rb

@@ -0,0 +1,18 @@
+module Gurke
+  #
+  # A {RunList} is a list of {Background}, {Scenario}
+  # or {Step} objects that can be {#run}.
+  #
+  class RunList < Array
+    #
+    # Run all backgrounds from this list.
+    #
+    # @api private
+    #
+    def run(runner, reporter, *args)
+      each do |o|
+        o.run runner, reporter, *args
+      end
+    end
+  end
+end

data/lib/gurke/runner.rb

@@ -12,108 +12,32 @@ module Gurke
     end
 
     def reporter
-      @reporter ||= Reporter.new
+      @reporter ||= Reporters::DefaultReporter.new
     end
 
     def run
       files.each{|f| builder.parse(f) }
+      features = builder.features
+      features.freeze
 
-      with_hooks(:features, nil, nil) do
-        run_features builder.features
-      end
-
-      !builder.features
-        .map(&:scenarios)
-        .flatten
-        .any?{|s| s.failed? || s.pending? }
-    end
-
-    def run_features(features)
-      reporter.start_features(features)
-
-      features.each do |feature|
-        run_feature(feature)
-      end
-
-      reporter.finish_features(features)
-    end
-
-    def run_feature(feature)
-      reporter.start_feature(feature)
-
-      feature.scenarios.each do |scenario|
-        run_scenario(scenario, feature)
-      end
-
-      reporter.finish_feature(feature)
-    end
-
-    def run_scenario(scenario, feature)
-      reporter.start_scenario(scenario, feature)
-
-      world = world_for(scenario, feature)
-
-      with_hooks(:scenario, scenario, world) do
-        feature.backgrounds.each do |b|
-          run_background(b, scenario, feature, world)
-        end
-        scenario.steps.each{|s| run_step(s, scenario, feature, world) }
-      end
-
-      reporter.finish_scenario(scenario, feature)
-    end
-
-    def run_background(background, scenario, feature, world)
-      reporter.start_background(background)
-
-      background.steps.each{|s| run_step(s, scenario, feature, world) }
-
-      reporter.finish_background(background)
-    end
-
-    def run_step(step, scenario, feature, world)
-      reporter.start_step(step, scenario, feature)
-
-      result = nil
-      with_filtered_backtrace do
-        match = Steps.find_step(step, world, step.type)
-
-        if scenario.pending? || scenario.failed?
-          result = StepResult.new(step, :skipped)
-          return
-        end
-
-        m = world.method(match.method_name)
-        world.send match.method_name, *(match.params + [step])[0...m.arity]
-      end
-
-      result = StepResult.new(step, :success)
-    rescue StepPending => e
-      scenario.pending! e
-      result = StepResult.new(step, :pending, e)
-    rescue => e
-      scenario.failed! e
-      result = StepResult.new(step, :failed, e)
-    ensure
-      reporter.finish_step(result, scenario, feature)
+      features.run self, reporter
     end
 
-    def with_hooks(scope, _context, world, &block)
-      Configuration::BEFORE_HOOKS.for(scope).each do |hook|
-        hook.run(world)
-      end
+    def hook(scope, world, &block)
+      Configuration::BEFORE_HOOKS.for(scope).each{|hook| hook.run world }
       Configuration::AROUND_HOOKS.for(scope).reduce(block) do |blk, hook|
         proc { hook.run(world, blk) }
       end.call
+    ensure
       Configuration::AFTER_HOOKS.for(scope).each do |hook|
-        hook.run(world)
+        begin
+          hook.run world
+        rescue => e
+          warn "Rescued error in after hook: #{e}\n#{e.backtrace.join("\n")}"
+        end
       end
     end
 
-    def world_for(scenario, _feature)
-      scenario.send(:world)
-    end
-
     def with_filtered_backtrace
       yield
     rescue => e
@@ -123,34 +47,5 @@ module Gurke
       end
       raise
     end
-
-    #
-    class StepResult
-      attr_reader :step, :exception, :state
-
-      def initialize(step, state, err = nil)
-        @step, @state, @exception = step, state, err
-      end
-
-      Gurke::Step.public_instance_methods(false).each do |m|
-        define_method(m){|*args| step.send m, *args }
-      end
-
-      def failed?
-        @state == :failed
-      end
-
-      def pending?
-        @state == :pending
-      end
-
-      def skipped?
-        @state == :skipped
-      end
-
-      def success?
-        @state == :success
-      end
-    end
   end
 end

data/lib/gurke/scenario.rb

@@ -14,24 +14,35 @@ module Gurke
     #
     attr_reader :line
 
+    # The feature that contains this scenario.
+    #
+    # @return [Feature] Parent feature.
+    #
+    attr_reader :feature
+
+    # List of this scenario's steps.
+    #
+    # This does not include background steps.
+    #
+    # @return [Array<Step>] Steps.
+    #
+    attr_reader :steps
+
+    #
     attr_reader :tags
 
     # @api private
     attr_reader :raw
 
     # @api private
-    def initialize(file, line, tags, raw)
-      @file, @line, @tags, @raw = file, line, tags, raw
-    end
-
-    # Return list of this scenario's steps.
-    #
-    # This does not include background steps.
-    #
-    # @return [Array<Step>] Steps.
     #
-    def steps
-      @steps ||= []
+    def initialize(feature, file, line, tags, raw)
+      @feature = feature
+      @steps   = RunList.new
+      @file    = file
+      @line    = line
+      @tags    = tags
+      @raw     = raw
     end
 
     # Return name of the scenario.
@@ -42,23 +53,52 @@ module Gurke
       raw.name
     end
 
+    # Return all backgrounds for this scenario.
+    #
+    # They are taken from the feature containing this scenario.
+    #
+    # @return [Array<Background>] Backgrounds.
+    #
+    def backgrounds
+      feature.backgrounds
+    end
+
+    # Check if scenario is pending.
+    #
+    # @return [Boolean] True if pending, false otherwise.
+    #
     def pending?
       @state == :pending
     end
 
+    # Check if scenario has failed.
+    #
+    # @return [Boolean] True if failed, false otherwise.
+    #
     def failed?
       @state == :failed
     end
 
+    # Exception that led to either pending or failed state.
+    #
+    # @return [Exception] Exception or nil of none given.
+    #
     attr_reader :exception
 
-    # @api private
-    def failed!(error)
+    # Call to mark scenario as failed.
+    #
+    # @param error [Exception] Given an exception as reason.
+    #
+    def failed!(error = nil)
       @exception = error
       @state     = :failed
     end
 
-    # @api private
+    # Call to mark scenario as pending. Will do nothing
+    # if scenario is already failed.
+    #
+    # @param error [Exception] Given an exception as reason.
+    #
     def pending!(error)
       return if failed?
 
@@ -66,8 +106,29 @@ module Gurke
       @state     = :pending
     end
 
+    # @api private
+    #
+    def run(runner, reporter)
+      reporter.invoke :before_scenario, self
+
+      runner.hook :scenario, world do
+        run_scenario runner, reporter
+      end
+    ensure
+      reporter.invoke :after_scenario, self
+    end
+
     private
 
+    def run_scenario(runner, reporter)
+      reporter.invoke :start_scenario, self
+
+      feature.backgrounds.run runner, reporter, self, world
+      steps.run runner, reporter, self, world
+    ensure
+      reporter.invoke :end_scenario, self
+    end
+
     def world
       @world ||= begin
         cls = Class.new

data/lib/gurke/step.rb

@@ -37,5 +37,77 @@ module Gurke
     def doc_string
       raw.doc_string.value if raw.doc_string
     end
+
+    # @api private
+    #
+    def run(runner, reporter, scenario, world)
+      reporter.invoke :before_step, self, scenario
+
+      result = runner.hook(:step, world) do
+        run_step runner, reporter, scenario, world
+      end
+    ensure
+      reporter.invoke :after_step, result, scenario
+    end
+
+    private
+
+    def run_step(runner, reporter, scenario, world)
+      reporter.invoke :start_step, self, scenario
+
+      result = nil
+      runner.with_filtered_backtrace do
+        match = Steps.find_step self, world, type
+
+        if scenario.pending? || scenario.failed?
+          result = StepResult.new self, :skipped
+          return result
+        end
+
+        m = world.method match.method_name
+        world.send match.method_name, *(match.params + [self])[0...m.arity]
+      end
+
+      result = StepResult.new self, :success
+    rescue StepPending => e
+      scenario.pending! e
+      result = StepResult.new self, :pending, e
+    rescue => e
+      scenario.failed! e
+      result = StepResult.new self, :failed, e
+    ensure
+      reporter.invoke :end_step, result, scenario
+    end
+
+    #
+    class StepResult
+      attr_reader :step, :exception, :state
+
+      def initialize(step, state, err = nil)
+        @step, @state, @exception = step, state, err
+      end
+
+      Step.public_instance_methods(false).each do |mth|
+        class_eval <<-EOS, __FILE__, __LINE__
+          def #{mth}(*args) @step.send #{mth}, *args; end
+        EOS
+      end
+
+      def failed?
+        @state == :failed
+      end
+
+      def pending?
+        @state == :pending
+      end
+
+      def skipped?
+        @state == :skipped
+      end
+
+      def success?
+        @state == :success
+      end
+    end
   end
 end

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+if ENV['CI'] || (defined?(:RUBY_ENGINE) && RUBY_ENGINE != 'rbx')
+  require 'coveralls'
+  Coveralls.wear! do
+    add_filter 'spec'
+  end
+end
+
+require 'bundler'
+Bundler.require
+
+require 'gurke'
+
+Dir[File.expand_path('spec/support/**/*.rb')].each{|f| require f }
+
+RSpec.configure do |config|
+  config.order = 'random'
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gurke
 version: !ruby/object:Gem::Version
-  version: 2.0.0.dev.1.b17
+  version: 2.0.0.dev.1.b18
 platform: ruby
 authors:
 - Jan Graichen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-30 00:00:00.000000000 Z
+date: 2014-05-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: trollop
@@ -93,8 +93,12 @@ files:
 - lib/gurke/configuration.rb
 - lib/gurke/dsl.rb
 - lib/gurke/feature.rb
+- lib/gurke/feature_list.rb
 - lib/gurke/reporter.rb
+- lib/gurke/reporters/default_reporter.rb
+- lib/gurke/reporters/null_reporter.rb
 - lib/gurke/rspec.rb
+- lib/gurke/run_list.rb
 - lib/gurke/runner.rb
 - lib/gurke/scenario.rb
 - lib/gurke/step.rb
@@ -102,6 +106,7 @@ files:
 - lib/gurke/steps.rb
 - lib/gurke/tag.rb
 - lib/gurke/version.rb
+- spec/spec_helper.rb
 homepage: https://github.com/jgraichen/gurke
 licenses:
 - MIT
@@ -134,3 +139,4 @@ test_files:
 - features/gurke/step_specific_definitions.feature
 - features/support/steps/cli_steps.rb
 - features/support/steps/file_steps.rb
+- spec/spec_helper.rb