spinach 0.0.6 → 0.1.0

data/lib/spinach/reporter/stdout.rb

@@ -6,81 +6,279 @@ module Spinach
     #
     class Stdout < Reporter
 
+      # The output buffers to store the reports.
+      attr_reader :out, :error
+
+      # The last scenario error
+      attr_accessor :scenario_error
+
+      # Initialitzes the runner
+      #
+      # @param [Hash] options
+      #  Sets a custom output buffer by setting options[:output]
+      #  Sets a custom error buffer by setting options[:error]
+      #
+      def initialize(*args)
+        super(*args)
+        @out = options[:output] || $stdout
+        @error = options[:error] || $stderr
+      end
+
       # Prints the feature name to the standard output
       #
-      def feature(name)
-        puts "\n#{'Feature:'.magenta} #{name.light_magenta}"
+      # @param [Hash] data
+      #   The feature in a JSON Gherkin format
+      #
+      def before_feature_run(data)
+        name = data['name']
+        out.puts "\n#{'Feature:'.magenta} #{name.light_magenta}"
       end
 
       # Prints the scenario name to the standard ouput
       #
-      def scenario(name)
-        puts "\n  #{'Scenario:'.green} #{name.light_green}"
-        puts
-      end
-
-      # Prints the step name to the standard output. If failed, it puts an
-      # F! before
-      #
-      def step(keyword, name, result)
-        color, symbol = case result
-          when :success
-            [:green, '✔']
-          when :undefined_step
-            [:yellow, '?']
-          when :failure
-            [:red, '✘']
-          when :error
-            [:red, '!']
-          when :skip
-            [:cyan, '~']
+      # @param [Hash] data
+      #   The feature in a JSON Gherkin format
+      #
+      def before_scenario_run(data)
+        name = data['name']
+        out.puts "\n  #{'Scenario:'.green} #{name.light_green}"
+        out.puts
+      end
+
+      # Adds an error report and re
+      #
+      # @param [Hash] data
+      #   The feature in a JSON Gherkin format
+      #
+      def after_scenario_run(data)
+        if scenario_error
+          report_error(scenario_error, :full)
+          self.scenario_error = nil
         end
-        puts "    #{symbol.colorize(:"light_#{color}")}  #{keyword.colorize(:"light_#{color}")} #{name.colorize(color)}"
+      end
 
+      # Adds a passed step to the output buffer.
+      #
+      # @param [Hash] step
+      #   The step in a JSON Gherkin format
+      #
+      def on_successful_step(step)
+        output_step('✔', step, :green)
       end
 
-      # Prints a blank line at the end
+      # Adds a failing step to the output buffer.
+      #
+      # @param [Hash] step
+      #   The step in a JSON Gherkin format
+      #
+      # @param [Exception] failure
+      #   The exception that caused the failure
       #
-      def end
-        puts ""
+      def on_failed_step(step, failure)
+        output_step('✘', step, :red)
+        self.scenario_error = [current_feature, current_scenario, step, failure]
+        failed_steps << scenario_error
       end
 
-      def error_summary(errors)
-        puts
-        puts "    !  Error summary for this feature (#{errors.length})".light_white
-        errors.each do |error, step, line, scenario|
-          step_file = error.backtrace.detect do |f|
-            f =~ /<class:#{scenario.feature.class}>/
-          end
-          step_file = step_file.split(':')[0..1].join(':') if step_file
-
-          color = if error.kind_of?(Spinach::StepNotDefinedException)
-                    :light_yellow
-                  else
-                    :light_red
-                  end
-
-          puts
-          puts "       #{scenario.feature_name} :: #{scenario.name} :: #{step.colorize(color)} (line #{line})"
-          puts "       #{step_file}" if step_file
-          error.message.split("\n").each do |line|
-            puts "         #{line}".colorize(color)
-          end
-          if options[:backtrace]
-            puts error.backtrace.map {|e| "      #{e}"}
+      # Adds a step that has raised an error to the output buffer.
+      #
+      # @param [Hash] step
+      #   The step in a JSON Gherkin format
+      #
+      # @param [Exception] failure
+      #   The exception that caused the failure
+      #
+      def on_error_step(step, failure)
+        output_step('!', step, :red)
+        self.scenario_error = [current_feature, current_scenario, step, failure]
+        error_steps << scenario_error
+      end
+
+      # Adds an undefined step to the output buffer.
+      #
+      # @param [Hash] step
+      #   The step in a JSON Gherkin format
+      #
+      def on_undefined_step(step)
+        output_step('?', step, :yellow)
+        self.scenario_error = [current_feature, current_scenario, step]
+        undefined_steps << scenario_error
+      end
+
+      # Adds a step that has been skipped to the output buffer.
+      #
+      # @param [Hash] step
+      #   The step that Gherkin extracts
+      #
+      def on_skipped_step(step)
+        output_step('~', step, :cyan)
+      end
+
+      # Adds to the output buffer a step result
+      #
+      # @param [String] symbol
+      #   A symbol to prepend before the step keyword (might be useful to
+      #   indicate if everything went ok or not).
+      #
+      # @param [Hash] step
+      #   The step in a JSON Gherkin format
+      #
+      # @param [Symbol] color
+      #   The color code to use with Colorize to colorize the output.
+      #
+      def output_step(symbol, step, color)
+        out.puts "    #{symbol.colorize(:"light_#{color}")}  #{step['keyword'].strip.colorize(:"light_#{color}")} #{step['name'].strip.colorize(color)}"
+      end
+
+      # It prints the error summary if the run has failed
+      #
+      # @param [True,False] success
+      #   whether the run has succeed or not
+      #
+      def after_run(success)
+        error_summary unless success
+      end
+
+      # Prints the errors for ths run.
+      #
+      def error_summary
+        error.puts "\nError summary:\n"
+        report_error_steps
+        report_failed_steps
+        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
+
+      # 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 = String.new
+        output += report_exception(exception)
+        output +="\n"
+
+        if options[:backtrace]
+          output += "\n"
+          exception.backtrace.map do |line|
+            output << "        #{line}\n"
           end
-          puts
+        else
+          output << "        #{exception.backtrace[0]}"
         end
+        output
+      end
+
+      # Constructs the full step definition
+      #
+      # @param [Hash] step
+      #   The step in a JSON Gherkin format
+      #
+      def full_step(step)
+        "#{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)
-        @errors << exception
         output = exception.message.split("\n").map{ |line|
           "        #{line}"
         }.join("\n")
-        puts "#{output}\n\n"
-      end
 
+        if exception.kind_of?(Spinach::StepNotDefinedException)
+          output.yellow
+        else
+          output.red
+        end
+      end
     end
   end
 end

data/lib/spinach/reporter.rb

@@ -10,40 +10,57 @@ module Spinach
     def initialize(options = {})
       @errors = []
       @options = options
+      @undefined_steps = []
+      @failed_steps = []
+      @error_steps = []
     end
 
-    attr_accessor :options
-
-    # Receives this hook when a feature is invoked
-    # @param [String] name
-    #   the feature name
+    # A Hash with options for the reporter
     #
-    def feature(name)
-      raise "Abstract method!"
-    end
+    attr_reader :options
 
-    # Receives this hook when a scenario is invoked
-    # @param [String] name
-    #   the scenario name
-    #
-    def scenario(name)
-      raise "Abstract method!"
+    attr_accessor :current_feature, :current_scenario
+
+    attr_reader :undefined_steps, :failed_steps, :error_steps
+
+    def bind
+      runner.after_run method(:after_run)
+      feature_runner.before_run method(:before_feature_run)
+      feature_runner.after_run method(:after_feature_run)
+      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_failed_step method(:on_failed_step)
+      scenario_runner.on_error_step method(:on_error_step)
+      scenario_runner.on_skipped_step method(:on_skipped_step)
+
+      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)
     end
 
-    # Receives this hook when a step is invoked
-    # @param [String] name
-    #   the scenario name
-    # @param [Symbol] result
-    #   the step name and its finishing state. May be :success or :failure
-    #
-    def step(keyword, name, result)
-      raise "Abstract method!"
+    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
+    def before_scenario_run(*args); end
+    def after_scenario_run(*args); end
+    def on_successful_step(*args); end;
+    def on_failed_step(*args); end;
+    def on_error_step(*args); end;
+    def on_undefined_step(*args); end;
+    def on_skipped_step(*args); end;
+
+    def clear_current_feature(*args)
+      self.current_feature = nil
     end
 
-    # Receives this hook when a feature reaches its end
-    #
-    def end
-      raise "Abstract method!"
+    def clear_current_scenario(*args)
+      self.current_scenario = nil
     end
 
   end

data/lib/spinach/runner/feature.rb

@@ -1,75 +1,88 @@
+require 'hooks'
+
 module Spinach
   class Runner
-    # A feature runner handles a particular Spinach::Feature run.
+    # A feature runner handles a particular feature run.
     #
     class Feature
+      include Hooks
+
+      # The {Reporter} used in this feature.
+      attr_reader :reporter
+
+      # The file that describes the feature.
+      attr_reader :filename
+
+      define_hook :before_run
+      define_hook :after_run
 
       # @param [String] filename
       #   path to the feature file. Scenario line could be passed to run just
       #   that scenario.
       #   @example feature/a_cool_feature.feature:12
       #
-      # @param [Spinach::Reporter] reporter
-      #   the reporter that will log this run
-      #
-      def initialize(filename, reporter)
+      # @api public
+      def initialize(filename)
         @filename, @scenario_line = filename.split(':')
-        @reporter = reporter
       end
 
-      attr_reader :reporter
+      # The file taht describes the feature.
+      #
       attr_reader :filename
 
-      # @return [Spinach::Feature]
-      #   the feature towards which this scenario will be run
+      # @return [Feature]
+      #   The feature object used to run this scenario.
       #
+      # @api public
       def feature
         @feature ||= Spinach.find_feature(feature_name).new
       end
 
       # @return [Hash]
-      #   the parsed data for this feature
+      #   The parsed data for this feature.
       #
+      # @api public
       def data
         @data ||= Spinach::Parser.new(filename).parse
       end
 
       # @return [String]
-      #   this feature's name
+      #   This feature name.
       #
+      # @api public
       def feature_name
         @feature_name ||= data['name']
       end
 
       # @return [Hash]
-      #   the parsed scenarios for this runner's feature
+      #   The parsed scenarios for this runner's feature.
       #
+      # @api public
       def scenarios
         @scenarios ||= (data['elements'] || [])
       end
 
-      # Runs this feature
+      # Runs this feature.
       #
+      # @return [true, false]
+      #   Whether the run was successful or not.
+      #
+      # @api public
       def run
-        reporter.feature(feature_name)
-        failures = []
+        run_hook :before_run, data
+        feature.run_hook :before, data
+
         scenarios.each do |scenario|
           if !@scenario_line || scenario['line'].to_s == @scenario_line
-            feature.send(:before)
-            failure = Scenario.new(feature_name, feature, scenario, reporter).run
-            failures << failure if failure
-            feature.send(:after)
+            @success = Scenario.new(feature_name, feature, scenario).run
           end
         end
 
-        unless failures.length.zero?
-          reporter.error_summary(failures)
-          return false
-        else
-          return true
-        end
-      end
+        feature.run_hook :after, data
+        run_hook :after_run, data
 
+        return !!@success
+      end
     end
   end
 end

data/lib/spinach/runner/scenario.rb

@@ -1,54 +1,69 @@
+require 'hooks'
+
 module Spinach
   class Runner
     # A Scenario Runner handles a particular scenario run.
     #
     class Scenario
-      attr_reader :name, :feature, :feature_name, :steps, :reporter
+      attr_reader :feature, :feature_name, :data
+
+      include Hooks
 
-      # @param [Spinach::Feature] feature
-      #   the feature that contains the steps
+      define_hook :before_run
+      define_hook :on_successful_step
+      define_hook :on_failed_step
+      define_hook :on_error_step
+      define_hook :on_undefined_step
+      define_hook :on_skipped_step
+      define_hook :after_run
+
+      # @param [Feature] feature
+      #   The feature that contains the steps.
       #
       # @param [Hash] data
-      #   the parsed feature data
-      #
-      # @param [Spinach::Reporter]
-      #   the reporter
+      #   The parsed feature data.
       #
-      def initialize(feature_name, feature, data, reporter)
+      # @api public
+      def initialize(feature_name, feature, data)
         @feature_name = feature_name
-        @name = data['name']
-        @steps = data['steps']
-        @reporter = reporter
+        @data = data
         @feature = feature
       end
 
-      # Runs this scenario and signals the reporter
-      #
+      def steps
+        @steps ||= data['steps']
+      end
+
+      # Runs this scenario
+      # @return [True, False]
+      #   true if this scenario succeeded, false if not
       def run
-        reporter.scenario(name)
+        run_hook :before_run, data
+        feature.run_hook :before_scenario, data
         steps.each do |step|
-          keyword = step['keyword'].strip
-          name = step['name'].strip
-          line = step['line']
-          unless @failure
+          feature.run_hook :before_step, step
+          unless @exception
             begin
-              feature.execute_step(name)
-              reporter.step(keyword, name, :success)
+              feature.execute_step(step['name'])
+              run_hook :on_successful_step, step
             rescue MiniTest::Assertion => e
-              @failure = [e, name, line, self]
-              reporter.step(keyword, name, :failure)
+              @exception = e
+              run_hook :on_failed_step, step, @exception
             rescue Spinach::StepNotDefinedException => e
-              @failure = [e, name, line, self]
-              reporter.step(keyword, name, :undefined_step)
+              @exception = e
+              run_hook :on_undefined_step, step, @exception
             rescue StandardError => e
-              @failure = [e, name, line, self]
-              reporter.step(keyword, name, :error)
+              @exception = e
+              run_hook :on_error_step, step, @exception
             end
           else
-            reporter.step(keyword, name, :skip)
+            run_hook :on_skipped_step, step
           end
+          feature.run_hook :after_step, step
         end
-        @failure
+        feature.run_hook :after_scenario, data
+        run_hook :after_run, data
+        !@exception
       end
     end
   end