spinach 0.1.5.4 → 0.2.0.1

data/lib/spinach/exceptions.rb

@@ -18,7 +18,7 @@ module Spinach
     #
     # @api public
     def message
-      "Step '#{@step}' not found"
+      "Step '#{@step.name}' not found"
     end
   end
 end

data/lib/spinach/feature.rb

@@ -0,0 +1,16 @@
+module Spinach
+  class Feature
+    attr_accessor :line
+    attr_accessor :name, :scenarios
+    attr_accessor :background
+
+    def initialize
+      @scenarios = []
+    end
+
+    def background_steps
+      @background.nil? ? [] : @background.steps
+    end
+
+  end
+end

data/lib/spinach/frameworks.rb

@@ -0,0 +1,2 @@
+require_relative 'frameworks/minitest' if defined?(MiniTest)
+require_relative 'frameworks/rspec' if defined?(RSpec::Expectations)

data/lib/spinach/generators/feature_generator.rb

@@ -4,39 +4,28 @@ module Spinach
     # given the parsed feture data
     class FeatureGenerator
 
-      # @param [Hash] data
-      #   the parsed feature data returned from the {Parser}
-      def initialize(data)
-        @data = data
+      attr_reader :feature
+
+      # @param [Feature] feature
+      #   The feature returned from the {Parser}
+      def initialize(feature)
+        @feature = feature
       end
 
       # @return [Array<Hash>]
-      #   an array of unique steps found in this scenario, avoiding name
+      #   an array of unique steps found in this feature, avoiding name
       #   repetition
       def steps
-        return @steps if @steps
-        @steps = []
-        if scenarios = @data['elements']
-          scenarios.each do  |scenario|
-            if scenario_steps = scenario['steps']
-              scenario_steps.each do |step|
-                unless @steps.any?{|s| s['name'] == step['name']}
-                  @steps << {
-                    'keyword' => step['keyword'].strip,
-                    'name' => step['name'].strip
-                  }
-                end
-              end
-            end
-          end
-        end
-        @steps
+        scenario_steps   = @feature.scenarios.map(&:steps).flatten
+        background_steps = @feature.background_steps
+
+        (scenario_steps + background_steps).uniq(&:name)
       end
 
       # @return [String]
       #   this feature's name
       def name
-        @data['name'].strip if @data['name']
+        @feature.name
       end
 
       # @return [String]

data/lib/spinach/generators/step_generator.rb

@@ -4,17 +4,17 @@ module Spinach
   #
   class Generators::StepGenerator
 
-    # @param [Hash] data
-    #   the parsed step data returned from the {Parser}
-    def initialize(data)
-      @data = data
+    # @param [Step] step
+    #   The step.
+    def initialize(step)
+      @step = step
     end
 
     # @return [String]
     #   an example step definition
     def generate
       result = StringIO.new
-      result.puts "#{@data['keyword']} '#{Spinach::Support.escape_single_commas @data['name']}' do"
+      result.puts "#{@step.keyword} '#{Spinach::Support.escape_single_commas @step.name}' do"
       result.puts "  raise 'step not implemented'"
       result.puts "end"
       result.string

data/lib/spinach/hookable.rb

@@ -24,8 +24,8 @@ module Spinach
         define_method hook do |&block|
           add_hook(hook, &block)
         end
-        define_method "run_#{hook}" do |*args|
-          run_hook(hook, *args)
+        define_method "run_#{hook}" do |*args, &block|
+          run_hook(hook, *args, &block)
         end
       end
     end
@@ -50,9 +50,11 @@ module Spinach
       # @param [String] name
       #   the hook's name
       #
-      def run_hook(name, *args)
+      def run_hook(name, *args, &block)
         if callbacks = hooks[name.to_sym]
-          callbacks.each{ |c| c.call(*args) }
+          callbacks.each{ |c| c.call(*args, &block) }
+        else
+          yield if block
         end
       end
 

data/lib/spinach/hooks.rb

@@ -56,6 +56,14 @@ module Spinach
     #   end
     hook :before_scenario
 
+    # Runs around every scenario
+    # @example
+    #   Spinach.hooks.around_scenario do |scenario_data, &block|
+    #     # feature_data is a hash of the parsed scenario data
+    #     block.call
+    #   end
+    hook :around_scenario
+
     # Runs after every scenario
     #
     # @example
@@ -139,10 +147,10 @@ module Spinach
     #     # change capybara driver
     #   end
     def on_tag(tag)
-      before_scenario do |data|
-        next unless data["tags"]
-        tags = data["tags"].map{ |tag| tag["name"].gsub(/^@/, "") }
-        yield(data) if tags.include? tag.to_s
+      before_scenario do |scenario|
+        tags = scenario.tags
+        next unless tags.any?
+        yield(scenario) if tags.include? tag.to_s
       end
     end
   end

data/lib/spinach/parser.rb

@@ -1,5 +1,5 @@
 require 'gherkin'
-require 'gherkin/formatter/json_formatter'
+require_relative 'parser/visitor'
 
 module Spinach
   # Parser leverages Gherkin to parse the feature definition.
@@ -11,8 +11,6 @@ module Spinach
     # @api public
     def initialize(content)
       @content = content
-      @formatter = Gherkin::Formatter::JSONFormatter.new(nil)
-      @parser = Gherkin::Parser::Parser.new(@formatter)
     end
 
     # @param [String] filename
@@ -31,15 +29,15 @@ module Spinach
     # @api public
     attr_reader :content
 
-    # Parses the feature file and returns an AST as a Hash.
+    # Parses the feature file and returns a Feature.
     #
-    # @return [Hash]
-    #   The parsed Gherkin output.
+    # @return [Feature]
+    #   The Feature.
     #
     # @api public
     def parse
-      @parser.parse(content, @filename, __LINE__-1)
-      @formatter.gherkin_object
+      ast = Gherkin.parse(@content.strip)
+      Visitor.new.visit(ast)
     end
   end
 end

data/lib/spinach/parser/visitor.rb

@@ -0,0 +1,109 @@
+module Spinach
+  class Parser
+    # The Spinach Visitor traverses the output AST from the Gherkin parser and
+    # populates its Feature with all the scenarios, tags, steps, etc.
+    #
+    # @example
+    #
+    #   ast     = Gherkin.parse(File.read('some.feature')
+    #   visitor = Spinach::Parser::Visitor.new
+    #   feature = visitor.visit(ast)
+    #
+    class Visitor
+      attr_reader :feature
+
+      # @param [Feature] feature
+      #   The feature to populate,
+      #
+      # @api public
+      def initialize
+        @feature = Feature.new
+      end
+
+      # @param [Gherkin::AST::Feature] ast
+      #   The AST root node to visit.
+      #
+      # @api public
+      def visit(ast)
+        ast.accept self
+        @feature
+      end
+
+      # Sets the feature name and iterates over the feature scenarios.
+      #
+      # @param [Gherkin::AST::Feature] feature
+      #   The feature to visit.
+      #
+      # @api public
+      def visit_Feature(node)
+        @feature.name = node.name
+        node.background.accept(self)
+        node.scenarios.each { |scenario| scenario.accept(self) }
+      end
+
+      # Iterates over the steps.
+      #
+      # @param [Gherkin::AST::Scenario] node
+      #   The scenario to visit.
+      #
+      # @api public
+      def visit_Background(node)
+        background = Background.new(@feature)
+        background.line = node.line
+
+        @current_step_set = background
+        node.steps.each { |step| step.accept(self) }
+        @current_step_set = nil
+
+        @feature.background = background
+      end
+
+      # Sets the scenario name and iterates over the steps.
+      #
+      # @param [Gherkin::AST::Scenario] node
+      #   The scenario to visit.
+      #
+      # @api public
+      def visit_Scenario(node)
+        scenario      = Scenario.new(@feature)
+        scenario.name = node.name
+        scenario.line = node.line
+
+        @current_scenario = scenario
+        node.tags.each  { |tag|  tag.accept(self)  }
+        @current_scenario = nil
+
+        @current_step_set = scenario
+        node.steps.each { |step| step.accept(self) }
+        @current_step_set = nil
+
+        @feature.scenarios << scenario
+      end
+
+      # Adds the tag to the current scenario.
+      #
+      # @param [Gherkin::AST::Tag] node
+      #   The tag to add.
+      #
+      # @api public
+      def visit_Tag(node)
+        @current_scenario.tags << node.name
+      end
+
+      # Adds the step to the current scenario.
+      #
+      # @param [Gherkin::AST::Step] step
+      #   The step to add.
+      #
+      # @api public
+      def visit_Step(node)
+        step = Step.new(@current_scenario)
+        step.name    = node.name
+        step.line    = node.line
+        step.keyword = node.keyword
+
+        @current_step_set.steps << step
+      end
+    end
+  end
+end

data/lib/spinach/reporter.rb

@@ -31,6 +31,7 @@ module Spinach
         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.around_scenario { |*args, &block| around_scenario_run(*args, &block) }
         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) }
@@ -50,6 +51,9 @@ module Spinach
     def after_feature_run(*args); end
     def on_feature_not_found(*args); end
     def before_scenario_run(*args); end
+    def around_scenario_run(*args)
+      yield
+    end
     def after_scenario_run(*args); end
     def on_successful_step(*args); end;
     def on_failed_step(*args); end;
@@ -59,10 +63,10 @@ module Spinach
 
     # Stores the current feature
     #
-    # @param [Hash]
-    #   the data for this feature
-    def set_current_feature(data)
-      @current_feature = data
+    # @param [Feature]
+    #   The feature.
+    def set_current_feature(feature)
+      @current_feature = feature
     end
 
     # Clears this current feature
@@ -74,8 +78,8 @@ module Spinach
     #
     # @param [Hash]
     #   the data for this scenario
-    def set_current_scenario(data)
-      @current_scenario = data
+    def set_current_scenario(scenario)
+      @current_scenario = scenario
     end
 
     # Clears this current scenario

data/lib/spinach/reporter/stdout.rb

@@ -36,8 +36,8 @@ module Spinach
       # @param [Hash] data
       #   The feature in a JSON Gherkin format
       #
-      def before_feature_run(data)
-        name = data['name']
+      def before_feature_run(feature)
+        name = feature.name
         out.puts "\n#{'Feature:'.magenta} #{name.light_magenta}"
       end
 
@@ -46,9 +46,9 @@ module Spinach
       # @param [Hash] data
       #   The feature in a JSON Gherkin format
       #
-      def before_scenario_run(data)
-        @max_step_name_length = data['steps'].map{|step| step['name'].length}.max if data['steps']
-        name = data['name']
+      def before_scenario_run(scenario)
+        @max_step_name_length = scenario.steps.map(&:name).map(&:length).max if scenario.steps.any?
+        name = scenario.name
         out.puts "\n  #{'Scenario:'.green} #{name.light_green}"
       end
 
@@ -57,7 +57,7 @@ module Spinach
       # @param [Hash] data
       #   The feature in a JSON Gherkin format
       #
-      def after_scenario_run(data)
+      def after_scenario_run(scenario)
         if scenario_error
           report_error(scenario_error, :full)
           self.scenario_error = nil
@@ -66,8 +66,8 @@ module Spinach
 
       # Adds a passed step to the output buffer.
       #
-      # @param [Hash] step
-      #   The step in a JSON Gherkin format
+      # @param [Step] step
+      #   The step.
       #
       # @param [Array] step_location
       #   The step source location
@@ -127,7 +127,7 @@ module Spinach
       #
       def on_feature_not_found(feature)
         generator = Generators::FeatureGenerator.new(feature)
-        lines = "Could not find steps for `#{feature['name']}` feature\n\n"
+        lines = "Could not find steps for `#{feature.name}` feature\n\n"
         lines << "\nPlease create the file #{generator.filename} at #{generator.path}, with:\n\n"
 
         lines << generator.generate
@@ -167,8 +167,18 @@ module Spinach
       def output_step(symbol, step, color, step_location = nil)
         step_location = step_location.first.gsub("#{File.expand_path('.')}/", '# ')+":#{step_location.last.to_s}" if step_location
         max_length = @max_step_name_length + 60 # Colorize and output format correction
+
         # REMEMBER TO CORRECT PREVIOUS MAX LENGTH IF OUTPUT FORMAT IS MODIFIED
-        out.puts "    #{symbol.colorize(:"light_#{color}")}  #{step['keyword'].strip.colorize(:"light_#{color}")} #{step['name'].strip.colorize(color)} ".ljust(max_length) + step_location.to_s.colorize(:grey)
+        buffer = []
+        buffer << indent(4)
+        buffer << symbol.colorize(:"light_#{color}")
+        buffer << indent(2)
+        buffer << step.keyword.colorize(:"light_#{color}")
+        buffer << indent(1)
+        buffer << step.name.colorize(color)
+        joined = buffer.join.ljust(max_length)
+
+        out.puts(joined + step_location.to_s.colorize(:grey))
       end
 
       # It prints the error summary if the run has failed
@@ -186,22 +196,37 @@ module Spinach
       # Prints the feature success summary for this run.
       #
       def run_summary
-        successful_summary = "(".colorize(:green)+successful_steps.length.to_s.colorize(:light_green)+") Successful".colorize(:green)
-        undefined_summary = "(".colorize(:yellow)+undefined_steps.length.to_s.colorize(:light_yellow)+") Undefined".colorize(:yellow)
-        failed_summary = "(".colorize(:red)+failed_steps.length.to_s.colorize(:light_red)+") Failed".colorize(:red)
-        error_summary = "(".colorize(:red)+error_steps.length.to_s.colorize(:light_red)+") Error".colorize(:red)
+        successful_summary = format_summary(:green,  successful_steps, 'Successful')
+        undefined_summary  = format_summary(:yellow, undefined_steps,  'Undefined')
+        failed_summary     = format_summary(:red,    failed_steps,     'Failed')
+        error_summary      = format_summary(:red,    error_steps,      'Error')
+
         out.puts "Steps Summary: #{successful_summary}, #{undefined_summary}, #{failed_summary}, #{error_summary}\n\n"
       end
 
       # Constructs the full step definition
       #
       # @param [Hash] step
-      #   The step in a JSON Gherkin format
+      #   The step.
       #
       def full_step(step)
-        "#{step['keyword'].strip} #{step['name'].strip}"
+        "#{step.keyword} #{step.name}"
       end
 
+      private
+
+      def indent(n = 1)
+        " " * n
+      end
+
+      def format_summary(color, steps, message)
+        buffer = []
+        buffer << "(".colorize(color)
+        buffer << steps.length.to_s.colorize(:"light_#{color}")
+        buffer << ") ".colorize(color)
+        buffer << message.colorize(color)
+        buffer.join
+      end
     end
   end
 end