lib/gurke/runner.rb in gurke-2.0.0.dev.1.b17 vs lib/gurke/runner.rb in gurke-2.0.0.dev.1.b18

@@ -10,147 +10,42 @@
       @files   = files
       @builder = Builder.new options
     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? }
+      features.run self, reporter
     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)
-    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
       unless options[:backtrace]
         base = File.expand_path(Gurke.root.dirname)
         e.backtrace.select!{|l| File.expand_path(l)[0...base.size] == base }
       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