spinach 0.1.4 → 0.1.5

data/lib/spinach/hooks.rb

@@ -0,0 +1,132 @@
+require_relative 'hookable'
+
+module Spinach
+  # Spinach's hooks is a subscription mechanism to allow developers to define
+  # certain callbacks given several Spinach signals, like running a feature,
+  # executing a particular step and such.
+  class Hooks
+    include Hookable
+
+    # Runs before the entire spinach run
+    #
+    # @example
+    #   Spinach.before_run do
+    #     # Whatever
+    #   end
+    hook :before_run
+
+    # Runs after the entire spinach run
+    #
+    # @example
+    #   Spinach.after_run do |status|
+    #     # status is true when the run is successful, false otherwise
+    #   end
+    hook :after_run
+
+    # Runs before every feature,
+    #
+    # @example
+    #   Spinach.before_feature do |feature_data|
+    #     # feature_data is a hash of the parsed feature data
+    #   end
+    hook :before_feature
+
+    # Runs after every feature
+    #
+    # @example
+    #   Spinach.after_feature do |feature_data|
+    #     # feature_data is a hash of the parsed feature data
+    #   end
+    hook :after_feature
+
+    # Runs when an undefined feature is found
+    #
+    # @example
+    #   Spinach.on_undefined_feature do |feature_data, exception|
+    #     # feature_data is a hash of the parsed feature data
+    #     # exception contains the thrown exception
+    #   end
+    hook :on_undefined_feature
+
+    # Runs before every scenario
+    #
+    # @example
+    #   Spinach.before_scenario do |scenario_data|
+    #     # feature_data is a hash of the parsed scenario data
+    #   end
+    hook :before_scenario
+
+    # Runs after every scenario
+    #
+    # @example
+    #   Spinach.after_scenario do |scenario_data|
+    #     # feature_data is a hash of the parsed scenario data
+    #   end
+    hook :after_scenario
+
+    # Runs before every step execution
+    #
+    # @example
+    #   Spinach.before_step do |step_data|
+    #     # step_data contains a hash with this step's data
+    #   end
+    hook :before_step
+
+    # Runs after every step execution
+    #
+    # @example
+    #   Spinach.before_step do |step_data|
+    #     # step_data contains a hash with this step's data
+    #   end
+    hook :after_step
+
+    # Runs after every successful step execution
+    #
+    # @example
+    #   Spinach.on_successful_step do |step_data, location|
+    #     # step_data contains a hash with this step's data
+    #     # step_location contains a string indication this step definition's
+    #     # location
+    #   end
+    hook :on_successful_step
+
+    # Runs after every failed step execution
+    #
+    # @example
+    #   Spinach.on_failed_step do |step_data, location|
+    #     # step_data contains a hash with this step's data
+    #     # step_location contains a string indication this step definition's
+    #     # location
+    #   end
+    hook :on_failed_step
+
+    # Runs after every step execution that raises an exception
+    #
+    # @example
+    #   Spinach.on_error_step do |step_data, location|
+    #     # step_data contains a hash with this step's data
+    #     # step_location contains a string indication this step definition's
+    #     # location
+    #   end
+    hook :on_error_step
+
+    # Runs every time a step which is not defined is called
+    #
+    # @example
+    #   Spinach.on_undefined_step do |step_data, location|
+    #     # step_data contains a hash with this step's data
+    #     # step_location contains a string indication this step definition's
+    #     # location
+    #   end
+    hook :on_undefined_step
+
+    # Runs every time a step is skipped because there has been an unsuccessful
+    # one just before.
+    #
+    # @example
+    #   Spinach.on_undefined_step do |step_data|
+    #     # step_data contains a hash with this step's data
+    #   end
+    hook :on_skipped_step
+  end
+end

data/lib/spinach/reporter/stdout/error_reporting.rb

@@ -0,0 +1,163 @@
+module Spinach
+  class Reporter
+    class Stdout < Reporter
+      # This module handles Stdout's reporter error reporting capabilities.
+      module ErrorReporting
+
+        # Prints the errors for this run.
+        #
+        def error_summary
+          error.puts "\nError summary:\n"
+          report_error_steps
+          report_failed_steps
+          report_undefined_features
+          report_undefined_steps
+        end
+
+        # Prints the steps that raised an error.
+        #
+        def report_error_steps
+          report_errors('Errors', error_steps, :light_red) if error_steps.any?
+        end
+
+        # Prints failing steps.
+        #
+        def report_failed_steps
+          report_errors('Failures', failed_steps, :light_red) if failed_steps.any?
+        end
+
+        # Prints undefined steps.
+        #
+        def report_undefined_steps
+          report_errors('Undefined steps', undefined_steps, :yellow) if undefined_steps.any?
+        end
+
+        def report_undefined_features
+          if undefined_features.any?
+            error.puts "  Undefined features (#{undefined_features.length})".light_yellow
+            undefined_features.each do |feature|
+              error.puts "    #{feature['name']}".yellow
+            end
+          end
+        end
+
+        # Prints the error for a given set of steps
+        #
+        # @param [String] banner
+        #   the text to prepend as the title
+        #
+        # @param [Array] steps
+        #   the steps to output
+        #
+        # @param [Symbol] color
+        #   The color code to use with Colorize to colorize the output.
+        #
+        def report_errors(banner, steps, color)
+          error.puts "  #{banner} (#{steps.length})".colorize(color)
+          steps.each do |error|
+            report_error error
+          end
+          error.puts ""
+        end
+
+        # Prints an error in a nice format
+        #
+        # @param [Array] error
+        #  An array containing the feature, scenario, step and exception
+        #
+        # @param [Symbol] format
+        #   The format to output the error. Currently supproted formats are
+        #   :summarized (default) and :full
+        #
+        # @return [String]
+        #  The error report
+        #
+        def report_error(error, format=:summarized)
+          case format
+            when :summarized
+              self.error.puts summarized_error(error)
+            when :full
+              self.error.puts full_error(error)
+            else
+              raise "Format not defined"
+          end
+        end
+
+        # Returns summarized error report
+        #
+        # @param [Array] error
+        #  An array containing the feature, scenario, step and exception
+        #
+        # @return [String]
+        #  The summarized error report
+        #
+        def summarized_error(error)
+          feature, scenario, step, exception = error
+          summary = "    #{feature['name']} :: #{scenario['name']} :: #{full_step step}"
+          if exception.kind_of?(Spinach::StepNotDefinedException)
+            summary.yellow
+          else
+            summary.red
+          end
+        end
+
+        # Returns a complete error report
+        #
+        # @param [Array] error
+        #  An array containing the feature, scenario, step and exception
+        #
+        # @return [String]
+        #  The coplete error report
+        #
+        def full_error(error)
+          feature, scenario, step, exception = error
+          output = "\n"
+          output += report_exception(exception)
+          output +="\n"
+
+          if exception.kind_of?(Spinach::StepNotDefinedException)
+            output << "\n"
+            output << "        You can define it with: \n\n".yellow
+            suggestion = Generators::StepGenerator.new(step).generate
+            suggestion.split("\n").each do |line|
+              output << "          #{line}\n".yellow
+            end
+            output << "\n"
+          else
+            if options[:backtrace]
+              output += "\n"
+              exception.backtrace.map do |line|
+                output << "        #{line}\n"
+              end
+            else
+              output << "        #{exception.backtrace[0]}"
+            end
+          end
+          output
+        end
+
+
+        # Prints a information when an exception is raised.
+        #
+        # @param [Exception] exception
+        #   The exception to report
+        #
+        # @return [String]
+        #  The exception report
+        #
+        def report_exception(exception)
+          output = exception.message.split("\n").map{ |line|
+            "        #{line}"
+          }.join("\n")
+
+          if exception.kind_of?(Spinach::StepNotDefinedException)
+            output.yellow
+          else
+            output.red
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/spinach/reporter/stdout.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+require_relative 'stdout/error_reporting'
 
 module Spinach
   class Reporter
@@ -6,6 +7,8 @@ module Spinach
     #
     class Stdout < Reporter
 
+      include ErrorReporting
+
       # The output buffers to store the reports.
       attr_reader :out, :error
 
@@ -191,138 +194,6 @@ module Spinach
         out.puts "Steps Summary: #{successful_summary}, #{undefined_summary}, #{failed_summary}, #{error_summary}\n\n"
       end
 
-      # Prints the errors for this run.
-      #
-      def error_summary
-        error.puts "\nError summary:\n"
-        report_error_steps
-        report_failed_steps
-        report_undefined_features
-        report_undefined_steps
-      end
-
-      # Prints the steps that raised an error.
-      #
-      def report_error_steps
-        report_errors('Errors', error_steps, :light_red) if error_steps.any?
-      end
-
-      # Prints failing steps.
-      #
-      def report_failed_steps
-        report_errors('Failures', failed_steps, :light_red) if failed_steps.any?
-      end
-
-      # Prints undefined steps.
-      #
-      def report_undefined_steps
-        report_errors('Undefined steps', undefined_steps, :yellow) if undefined_steps.any?
-      end
-
-      def report_undefined_features
-        if undefined_features.any?
-          error.puts "  Undefined features (#{undefined_features.length})".light_yellow
-          undefined_features.each do |feature|
-            error.puts "    #{feature['name']}".yellow
-          end
-        end
-      end
-
-      # Prints the error for a given set of steps
-      #
-      # @param [String] banner
-      #   the text to prepend as the title
-      #
-      # @param [Array] steps
-      #   the steps to output
-      #
-      # @param [Symbol] color
-      #   The color code to use with Colorize to colorize the output.
-      #
-      def report_errors(banner, steps, color)
-        error.puts "  #{banner} (#{steps.length})".colorize(color)
-        steps.each do |error|
-          report_error error
-        end
-        error.puts ""
-      end
-
-      # Prints an error in a nice format
-      #
-      # @param [Array] error
-      #  An array containing the feature, scenario, step and exception
-      #
-      # @param [Symbol] format
-      #   The format to output the error. Currently supproted formats are
-      #   :summarized (default) and :full
-      #
-      # @returns [String]
-      #  The error report
-      #
-      def report_error(error, format=:summarized)
-        case format
-          when :summarized
-            self.error.puts summarized_error(error)
-          when :full
-            self.error.puts full_error(error)
-          else
-            raise "Format not defined"
-        end
-      end
-
-      # Returns summarized error report
-      #
-      # @param [Array] error
-      #  An array containing the feature, scenario, step and exception
-      #
-      # @returns [String]
-      #  The summarized error report
-      #
-      def summarized_error(error)
-        feature, scenario, step, exception = error
-        summary = "    #{feature['name']} :: #{scenario['name']} :: #{full_step step}"
-        if exception.kind_of?(Spinach::StepNotDefinedException)
-          summary.yellow
-        else
-          summary.red
-        end
-      end
-
-      # Returns a complete error report
-      #
-      # @param [Array] error
-      #  An array containing the feature, scenario, step and exception
-      #
-      # @returns [String]
-      #  The coplete error report
-      #
-      def full_error(error)
-        feature, scenario, step, exception = error
-        output = "\n"
-        output += report_exception(exception)
-        output +="\n"
-
-        if exception.kind_of?(Spinach::StepNotDefinedException)
-          output << "\n"
-          output << "        You can define it with: \n\n".yellow
-          suggestion = Generators::StepGenerator.new(step).generate
-          suggestion.split("\n").each do |line|
-            output << "          #{line}\n".yellow
-          end
-          output << "\n"
-        else
-          if options[:backtrace]
-            output += "\n"
-            exception.backtrace.map do |line|
-              output << "        #{line}\n"
-            end
-          else
-            output << "        #{exception.backtrace[0]}"
-          end
-        end
-        output
-      end
-
       # Constructs the full step definition
       #
       # @param [Hash] step
@@ -332,25 +203,6 @@ module Spinach
         "#{step['keyword'].strip} #{step['name'].strip}"
       end
 
-      # Prints a information when an exception is raised.
-      #
-      # @param [Exception] exception
-      #   The exception to report
-      #
-      # @returns [String]
-      #  The exception report
-      #
-      def report_exception(exception)
-        output = exception.message.split("\n").map{ |line|
-          "        #{line}"
-        }.join("\n")
-
-        if exception.kind_of?(Spinach::StepNotDefinedException)
-          output.yellow
-        else
-          output.red
-        end
-      end
     end
   end
 end

data/lib/spinach/reporter.rb

@@ -19,35 +19,32 @@ module Spinach
 
     # A Hash with options for the reporter
     #
-    attr_reader :options
-
-    attr_accessor :current_feature, :current_scenario
+    attr_reader :options, :current_feature, :current_scenario
 
     attr_reader :undefined_steps, :failed_steps, :error_steps, :undefined_features, :successful_steps
 
+    # Hooks the reporter to the runner endpoints
     def bind
-      runner.after_run method(:after_run)
-      feature_runner.before_run method(:before_feature_run)
-      feature_runner.after_run method(:after_feature_run)
-      feature_runner.when_not_found method(:on_feature_not_found)
-      scenario_runner.before_run method(:before_scenario_run)
-      scenario_runner.after_run method(:after_scenario_run)
-      scenario_runner.on_successful_step method(:on_successful_step)
-      scenario_runner.on_undefined_step method(:on_undefined_step)
-      scenario_runner.on_failed_step method(:on_failed_step)
-      scenario_runner.on_error_step method(:on_error_step)
-      scenario_runner.on_skipped_step method(:on_skipped_step)
+      Spinach.hooks.tap do |hooks|
+        hooks.after_run { |*args| after_run(*args) }
+        hooks.before_feature { |*args| before_feature_run(*args) }
+        hooks.after_feature { |*args| after_feature_run(*args) }
+        hooks.on_undefined_feature { |*args| on_feature_not_found(*args) }
+        hooks.before_scenario { |*args| before_scenario_run(*args) }
+        hooks.after_scenario { |*args| after_scenario_run(*args) }
+        hooks.on_successful_step { |*args| on_successful_step(*args) }
+        hooks.on_undefined_step { |*args| on_undefined_step(*args) }
+        hooks.on_failed_step { |*args| on_failed_step(*args) }
+        hooks.on_error_step { |*args| on_error_step(*args) }
+        hooks.on_skipped_step { |*args| on_skipped_step(*args) }
 
-      feature_runner.before_run method(:current_feature=)
-      feature_runner.after_run method(:clear_current_feature)
-      scenario_runner.before_run method(:current_scenario=)
-      scenario_runner.after_run method(:clear_current_scenario)
+        hooks.before_feature { |*args| set_current_feature(*args) }
+        hooks.after_feature { |*args| clear_current_feature(*args) }
+        hooks.before_scenario { |*args| set_current_scenario(*args) }
+        hooks.after_scenario { |*args| clear_current_scenario(*args) }
+      end
     end
 
-    def feature_runner; Runner::Feature; end
-    def scenario_runner; Runner::Scenario; end
-    def runner; Runner; end
-
     def after_run(*args); end;
     def before_feature_run(*args); end
     def after_feature_run(*args); end
@@ -60,14 +57,31 @@ module Spinach
     def on_undefined_step(*args); end;
     def on_skipped_step(*args); end;
 
+    # Stores the current feature
+    #
+    # @param [Hash]
+    #   the data for this feature
+    def set_current_feature(data)
+      @current_feature = data
+    end
+
+    # Clears this current feature
     def clear_current_feature(*args)
-      self.current_feature = nil
+      @current_feature = nil
     end
 
-    def clear_current_scenario(*args)
-      self.current_scenario = nil
+    # Stores the current scenario
+    #
+    # @param [Hash]
+    #   the data for this scenario
+    def set_current_scenario(data)
+      @current_scenario = data
     end
 
+    # Clears this current scenario
+    def clear_current_scenario(*args)
+      @current_scenario = nil
+    end
   end
 end
 

data/lib/spinach/runner/{feature.rb → feature_runner.rb}

@@ -1,22 +1,12 @@
-require 'hooks'
-
 module Spinach
   class Runner
     # A feature runner handles a particular feature run.
     #
-    class Feature
-      include Hooks
-
-      # The {Reporter} used in this feature.
-      attr_reader :reporter
+    class FeatureRunner
 
       # The file that describes the feature.
       attr_reader :filename
 
-      define_hook :before_run
-      define_hook :after_run
-      define_hook :when_not_found
-
       # @param [String] filename
       #   path to the feature file. Scenario line could be passed to run just
       #   that scenario.
@@ -62,20 +52,20 @@ module Spinach
       #
       # @api public
       def run
-        run_hook :before_run, data
+        Spinach.hooks.run_before_feature data
 
         scenarios.each do |scenario|
           if !@scenario_line || scenario['line'].to_s == @scenario_line
-            success = Scenario.new(feature_name, scenario).run
+            success = ScenarioRunner.new(feature_name, scenario).run
             @failed = true unless success
           end
         end
 
       rescue Spinach::FeatureStepsNotFoundException => e
-        run_hook :when_not_found, data, e
+        Spinach.hooks.run_on_undefined_feature data, e
         @failed = true
       ensure
-        run_hook :after_run, data
+        Spinach.hooks.run_after_feature data
         return !@failed
       end
     end

data/lib/spinach/runner/scenario_runner.rb

@@ -0,0 +1,65 @@
+module Spinach
+  class Runner
+    # A Scenario Runner handles a particular scenario run.
+    #
+    class ScenarioRunner
+      attr_reader :feature_name, :data
+
+      # @param [String] feature_name
+      #   The feature name
+      #
+      # @param [Hash] data
+      #   The parsed feature data.
+      #
+      # @api public
+      def initialize(feature_name, data)
+        @feature_name = feature_name
+        @data = data
+      end
+
+      def steps
+        @steps ||= data['steps']
+      end
+
+      # @return [FeatureSteps]
+      #   The feature object used to run this scenario.
+      #
+      # @api public
+      def feature_steps
+        @feature_steps ||= Spinach.find_feature_steps(feature_name).new
+      end
+
+      # Runs this scenario
+      # @return [True, False]
+      #   true if this scenario succeeded, false if not
+      def run
+        Spinach.hooks.run_before_scenario data
+        steps.each do |step|
+          Spinach.hooks.run_before_step step
+          unless @exception
+            begin
+              step_location = feature_steps.execute_step(step['name'])
+              Spinach.hooks.run_on_successful_step step, step_location
+            rescue Spinach::FeatureStepsNotFoundException => e
+              raise e
+            rescue *Spinach.config[:failure_exceptions] => e
+              @exception = e
+              Spinach.hooks.run_on_failed_step step, @exception, step_location
+            rescue Spinach::StepNotDefinedException => e
+              @exception = e
+              Spinach.hooks.run_on_undefined_step step, @exception
+            rescue Exception => e
+              @exception = e
+              Spinach.hooks.run_on_error_step step, @exception, step_location
+            end
+          else
+            Spinach.hooks.run_on_skipped_step step
+          end
+          Spinach.hooks.run_after_step step
+        end
+        Spinach.hooks.run_after_scenario data
+        !@exception
+      end
+    end
+  end
+end