spinach 0.5.2 → 0.6.0

data/features/steps/before_and_after_hooks_inheritance.rb

@@ -0,0 +1,43 @@
+class BeforeAndAfterHooksInheritanceBase < Spinach::FeatureSteps
+  class << self
+    attr_accessor :var1
+    attr_accessor :var2
+  end
+
+  before do
+    if self.class.var2.nil?
+      self.class.var2 = :i_am_here
+    else
+      self.class.var2 = :dirty
+    end
+    if self.class.var1.nil?
+      self.class.var1 = :clean
+    else
+      self.class.var1 = :dirty
+    end
+  end
+
+  after do
+    self.class.var1 = nil
+  end
+
+end
+
+class BeforeAndAfterHooksInheritance < BeforeAndAfterHooksInheritanceBase
+  before do
+    self.class.var1 = :in_subclass
+  end
+
+  after do
+    self.class.var2 = nil
+  end
+
+  Then 'I can see the variable being overridden in the subclass' do
+    self.class.var1.must_equal :in_subclass
+  end
+
+  Then "I can see the variable setup in the super class before hook" do
+    self.class.var2.must_equal :i_am_here
+  end
+
+end

data/features/steps/reporting/use_customized_reporter.rb

@@ -0,0 +1,98 @@
+class UseCustomizedReporter < Spinach::FeatureSteps
+
+  feature "Use customized reporter"
+
+  include Integration::SpinachRunner
+
+  before do
+    class_str = <<-EOF
+  class Spinach::TestReporter < Spinach::Reporter
+    attr_reader :out, :error
+    attr_accessor :scenario_error
+    attr_accessor :scenario
+
+    def initialize(*args)
+      super(*args)
+      @out = options[:output] || $stdout
+      @error = options[:error] || $stderr
+      @max_step_name_length = 0
+    end
+
+    def before_feature_run(feature)
+      out.puts "The customized class"
+    end
+
+    def before_scenario_run(scenario, step_definitions = nil)
+    end
+
+    def after_scenario_run(scenario, step_definitions = nil)
+    end
+
+    def on_successful_step(step, step_location, step_definitions = nil)
+    end
+
+    def on_failed_step(step, failure, step_location, step_definitions = nil)
+    end
+
+    def on_error_step(step, failure, step_location, step_definitions = nil)
+    end
+
+    def on_undefined_step(step, failure, step_definitions = nil)
+    end
+
+    def on_pending_step(step, failure)
+    end
+
+    def on_feature_not_found(feature)
+    end
+
+    def on_skipped_step(step, step_definitions = nil)
+    end
+
+    def output_step(symbol, step, color, step_location = nil)
+    end
+
+    def after_run(success)
+    end
+
+    def run_summary
+    end
+
+    def full_step(step)
+    end
+
+  end
+    EOF
+
+    write_file "test_reporter.rb", class_str
+  end
+
+  Given 'I have a feature that has no error or failure' do
+    write_file('features/success_feature.feature', """
+Feature: A success feature
+
+  Scenario: This is scenario will succeed
+    Then I succeed
+               """)
+
+               write_file('features/steps/success_feature.rb',
+                          <<-EOF
+    require_relative "../../test_reporter"
+class ASuccessFeature < Spinach::FeatureSteps
+      feature "A success feature"
+      Then "I succeed" do
+      end
+     end
+     EOF
+)
+               @feature = "features/success_feature.feature"
+  end
+
+  When 'I run it using the new reporter' do
+    run_feature @feature, append: "-r Spinach::TestReporter"
+  end
+
+  Then 'I see the desired output' do
+    @stdout.must_include("The customized class")
+  end
+end

data/lib/spinach.rb

@@ -1,4 +1,5 @@
 require_relative 'spinach/version'
+require_relative 'spinach/helpers'
 require_relative 'spinach/config'
 require_relative 'spinach/hookable'
 require_relative 'spinach/hooks'

data/lib/spinach/cli.rb

@@ -20,17 +20,10 @@ module Spinach
     #
     # @api public
     def run
+      options
       Spinach::Runner.new(feature_files).run
     end
 
-    # Inits the reporter with a default one.
-    #
-    # @api public
-    def init_reporter
-      reporter = Spinach::Reporter::Stdout.new(options[:reporter])
-      reporter.bind
-    end
-
     # @return [Hash]
     #   A hash of options separated by its type.
     #
@@ -52,8 +45,6 @@ module Spinach
     #
     # @api private
     def parse_options
-      reporter_options = {}
-      reporter_options[:backtrace] = false
       config = {}
 
       begin
@@ -65,7 +56,7 @@ module Spinach
 
           opts.on('-b', '--backtrace',
                   'Show backtrace of errors') do |show_backtrace|
-            reporter_options[:backtrace] = show_backtrace
+            config[:reporter_options] = {backtrace: show_backtrace}
           end
 
           opts.on('-t', '--tags TAG',
@@ -73,13 +64,7 @@ module Spinach
             config[:tags] ||= []
             tags = tag.delete('@').split(',')
 
-            references_wip = lambda { |tag_groups|
-              tag_groups.any? { |tag_group|
-                tag_group.any? { |tag| tag =~ /wip$/ }
-              }
-            }
-
-            unless references_wip.(config[:tags]) || references_wip.([tags])
+            if (config[:tags] + tags).flatten.none? { |t| t =~ /wip$/ }
               tags.unshift '~wip'
             end
 
@@ -100,16 +85,23 @@ module Spinach
                   'Path where your features will be searched for') do |path|
             config[:features_path] = path
           end
+
+          opts.on('-r', '--reporter CLASS_NAME',
+                  'Formatter class name') do |class_name|
+            config[:reporter_class] = class_name
+          end
         end.parse!(@args)
 
         Spinach.config.parse_from_file
         config.each{|k,v| Spinach.config[k] = v}
+        if Spinach.config.tags.empty? ||
+          Spinach.config.tags.flatten.none?{ |t| t =~ /wip$/ }
+          Spinach.config.tags.unshift ['~wip']
+        end
       rescue OptionParser::ParseError => exception
         puts exception.message.capitalize
         exit 1
       end
-
-      {reporter: reporter_options}
     end
 
     # Uses given args to list the feature files to run. It will find a single

data/lib/spinach/config.rb

@@ -29,7 +29,10 @@ module Spinach
                 :failure_exceptions,
                 :config_path,
                 :tags,
-                :save_and_open_page_on_failure
+                :save_and_open_page_on_failure,
+                :reporter_class,
+                :reporter_options
+
 
     # The "features path" holds the place where your features will be
     # searched for. Defaults to 'features'
@@ -42,6 +45,24 @@ module Spinach
       @features_path || 'features'
     end
 
+    # The "reporter class" holds the reporter class name
+    # Default to Spinach::Reporter::Stdout
+    #
+    # @return [reporter object]
+    #    The reporter that responds to specific messages.
+    #
+    # @api public
+    def reporter_class
+      @reporter_class || "Spinach::Reporter::Stdout"
+    end
+
+    # The "reporter_options" holds the options of reporter_class
+    #
+    # @api public
+    def reporter_options
+      @reporter_options || {}
+    end
+
     # The "step definitions path" holds the place where your feature step
     # classes will be searched for. Defaults to '#{features_path}/steps'
     #

data/lib/spinach/dsl.rb

@@ -58,6 +58,69 @@ module Spinach
       alias_method :Then, :step
       alias_method :And, :step
       alias_method :But, :step
+      
+      # Defines a before hook for each scenario. The scope is limited only to the current
+      # step class (thus the current feature). 
+      #
+      # When a scenario is executed, the before each block will be run first before any steps
+      #
+      # User can define multiple before blocks throughout the class hierarchy and they are chained
+      # through the inheritance chain when executing
+      #
+      # @example
+      #
+      #   class MySpinach::Base< Spinach::FeatureSteps
+      #     before do
+      #       @var1 = 30
+      #       @var2 = 40
+      #     end
+      #   end
+      #
+      #   class MyFeature < MySpinach::Base
+      #     before do
+      #       self.original_session_timeout = 1000
+      #       change_session_timeout_to(1)
+      #       @var2 = 50
+      #     end
+      #   end
+      #
+      #   When running a scenario in MyFeature, @var1 is 30 and @var2 is 50
+      #
+      # @api public
+      def before(&block)
+        define_before_or_after_method_with_block(:before, &block)
+      end
+
+      # Defines a after hook for each scenario. The scope is limited only to the current
+      # step class (thus the current feature). 
+      #
+      # When a scenario is executed, the after each block will be run after any steps
+      #
+      # User can define multiple after blocks throughout the class hierarchy and they are chained
+      # through the inheritance chain when executing.
+      #
+      # @example
+      #
+      #   class MySpinach::Base < Spinach::FeatureSteps
+      #     after do
+      #       @var1 = 30
+      #       @var2 = 40
+      #     end
+      #   end
+      #
+      #   class MyFeature < MySpinach::Base
+      #     after do
+      #       change_session_timeout_to(original_session_timeout)
+      #       @var2 = 50
+      #     end
+      #   end
+      #
+      #   When running a scenario in MyFeature, @var1 is 30 and @var2 is 50
+      #
+      # @api public
+      def after(&block)
+        define_before_or_after_method_with_block(:after, &block)
+      end
 
       # Sets the feature name.
       #
@@ -74,6 +137,25 @@ module Spinach
         @feature_name = name
       end
 
+      private
+
+      def before_or_after_private_method_name(location)
+        hash_value = hash
+        class_name = self.name || ""
+        class_name = class_name.gsub("::", "__").downcase
+        private_method_name = "_#{location}_each_block_#{hash.abs}_#{class_name}" #uniqueness
+      end
+
+      def define_before_or_after_method_with_block(location, &block)
+        define_method(before_or_after_private_method_name(location), &block)
+        private before_or_after_private_method_name(location)
+        private_method_name = before_or_after_private_method_name location
+        define_method "#{location}_each" do
+          super()
+          send(private_method_name)
+        end
+      end
+
     end
 
     # Instance methods to include in the host class.

data/lib/spinach/feature_steps.rb

@@ -26,5 +26,8 @@ module Spinach
         include_private(*args)
       end
     end
+
+    def before_each; end
+    def after_each; end
   end
 end

data/lib/spinach/helpers.rb

@@ -0,0 +1,16 @@
+module Spinach
+  module Helpers
+    class << self
+      def constantize(string)
+        names = string.split('::')
+        names.shift if names.empty? || names.first.empty?
+
+        constant = Object
+        names.each do |name|
+          constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
+        end
+        constant
+      end
+    end
+  end
+end

data/lib/spinach/runner.rb

@@ -46,6 +46,14 @@ module Spinach
     # The default path where the support files are located
     attr_reader :support_path
 
+    # Inits the reporter with a default one.
+    #
+    # @api public
+    def init_reporter
+      reporter = Helpers.constantize(Spinach.config[:reporter_class]).new(Spinach.config.reporter_options)
+      reporter.bind
+    end
+
     # Runs this runner and outputs the results in a colorful manner.
     #
     # @return [true, false]
@@ -55,6 +63,7 @@ module Spinach
     def run
       require_dependencies
       require_frameworks
+      init_reporter
 
       Spinach.hooks.run_before_run
 

data/lib/spinach/runner/feature_runner.rb

@@ -74,7 +74,7 @@ module Spinach
 
       def run_scenario?(scenario, current_scenario_index)
         match_line(current_scenario_index) && 
-          TagsMatcher.match((feature_tags << scenario.tags).flatten.compact)
+          TagsMatcher.match(feature_tags + scenario.tags)
       end
 
       def match_line(current_scenario_index)

data/lib/spinach/runner/scenario_runner.rb

@@ -47,6 +47,7 @@ module Spinach
         scenario_run = false
         Spinach.hooks.run_around_scenario @scenario, step_definitions do
           scenario_run = true
+          step_definitions.before_each
           steps.each do |step|
             Spinach.hooks.run_before_step step, step_definitions
 
@@ -58,6 +59,7 @@ module Spinach
 
             Spinach.hooks.run_after_step step, step_definitions
           end
+          step_definitions.after_each
         end
         raise "around_scenario hooks *must* yield" if !scenario_run && !@exception
         Spinach.hooks.run_after_scenario @scenario, step_definitions

data/lib/spinach/tags_matcher.rb

@@ -17,7 +17,10 @@ module Spinach
       def match(tags)
         return true if tag_groups.empty?
 
-        tag_groups.all? { |tag_group| match_tag_group(tag_group, tags) }
+        tag_groups.all? { |tag_group| 
+          res = match_tag_group(Array(tag_group), tags) 
+          res
+        }
       end
 
       private
@@ -28,16 +31,20 @@ module Spinach
 
       def match_tag_group(tag_group, tags)
         matched_tags = tag_group.select { |tag| !tag_negated?(tag) }
-        
-        matched = matched_tags.any? { |tag| tags.include?(tag) }
-
-        return true if matched
+        matched = if matched_tags.empty?
+          true
+        else
+          !tags.empty? && matched_tags.any? { |tag| tags.include?(tag) }
+        end
 
         negated_tags = tag_group.select { |tag| tag_negated? tag }
-        negated = negated_tags.any? {|tag| !tags.include?(tag.delete(NEGATION_SIGN))}
+        negated = if tags.empty?
+          false
+        else
+          negated_tags.any? {|tag| tags.include?(tag.delete(NEGATION_SIGN))}
+        end
 
-        return true if negated && tag_group.count == 1
-        false
+        !negated && matched
       end
 
       def tag_negated?(tag)