spinach 0.0.2 → 0.0.4

data/.travis.yml

@@ -0,0 +1,8 @@
+env:
+ - RBXOPT=-X19 JRUBY_OPTS="--1.9"
+rvm:
+  - 1.9.2
+  - 1.9.3
+  - ruby-head
+  - rbx-2.0
+  - jruby

data/Rakefile

@@ -5,8 +5,12 @@ Bundler::GemHelper.install_tasks
 require 'rake/testtask'
 Rake::TestTask.new do |t|
   t.libs << "test"
-  t.test_files = FileList['test/**/*_test.rb']
-  t.verbose = true
+  t.test_files = FileList['./test/**/*_test.rb']
+  # t.loader = :direct
 end
 
-task :default => [:test]
+task :spinach do
+  exec "bundle exec spinach"
+end
+
+task :default => [:test, :spinach]

data/bin/spinach

@@ -6,20 +6,10 @@ rescue LoadError
   require_relative '../lib/spinach'
 end
 
-Dir.glob(
-  File.expand_path File.join(Spinach.config[:step_definitions_path], '**', '*.rb')
-).each do |file|
-  require file
+features = if ARGV.any?
+  ARGV
+else
+  Dir.glob(File.join 'features', '**', '*.feature')
 end
 
-Dir.glob(
-  File.expand_path File.join(Spinach.config[:support_path], '**', '*.rb')
-).each do |file|
-  require file
-end
-
-ARGV.each do |file|
-  Spinach::Runner.new(
-    Spinach::Parser.new(file).parse
-  ).run
-end
+Spinach::Runner.new(features).run

data/features/feature_name_guessing.feature

@@ -0,0 +1,10 @@
+Feature: Feature name guessing
+  In order to be faster writing steps
+  As a test writer
+  I want the names of the features to be guessed from the feature class name
+
+  Scenario: Basic guess
+    Given I am writing a feature called "My cool feature"
+    And I write a class named "MyCoolFeature"
+    When I run spinach
+    Then I want "MyCoolFeature" class to be used to run it

data/features/steps/feature_name_guessing.rb

@@ -0,0 +1,39 @@
+require 'aruba/api'
+class FeatureNameGuessing < Spinach::Feature
+  include Aruba::Api
+
+  Given 'I am writing a feature called "My cool feature"' do
+    write_file('features/my_cool_feature.feature',
+               'Feature: My cool feature
+
+                Scenario: This is scenario is cool
+                  When this is so meta
+                  Then the world is crazy
+               ')
+  end
+
+  And 'I write a class named "MyCoolFeature"' do
+    write_file('features/steps/my_cool_feature.rb',
+               'class MyCoolFeature < Spinach::Feature
+                  When "this is so meta" do
+                  end
+
+                  Then "the world is crazy" do
+                  end
+                end')
+  end
+
+  When 'I run spinach'do
+    run_feature 'features/my_cool_feature.feature'
+  end
+
+  Then 'I want "MyCoolFeature" class to be used to run it' do
+    all_stderr.must_be_empty
+  end
+
+  private
+
+  def run_feature(command)
+    run "../../bin/spinach #{command}"
+  end
+end

data/lib/spinach/capybara.rb

@@ -21,8 +21,6 @@ module Spinach
           include ::Capybara::DSL
           include InstanceMethods
 
-          def before
-          end
           def after
             ::Capybara.current_session.reset! if ::Capybara.app
           end

data/lib/spinach/config.rb

@@ -41,7 +41,7 @@ module Spinach
     # output to the standard output
     #
     def default_reporter
-      @default_reporter || Spinach::Reporter::Stdout
+      @default_reporter || Spinach::Reporter::Stdout.new
     end
 
     # Allows you to read the config object using a hash-like syntax.

data/lib/spinach/dsl.rb

@@ -4,39 +4,74 @@ module Spinach
   #
   module DSL
 
-    # Defines an action to perform given a particular step literal.
-    #
-    # @param [String] step name
-    #   The step literal
-    # @param [Proc] block
-    #   action to perform in that step
-    #
-    # @example
-    #   class MyFeature << Spinach::Feature
-    #     When "I go to the toilet" do
-    #       @sittin_on_the_toilet.must_equal true
-    #     end
-    #   end
-    #
-    %w{When Given Then And But}.each do |connector|
-      define_method connector do |string, &block|
-        define_method("#{connector} #{string}", &block)
+    def self.included(base)
+      base.class_eval do
+        include InstanceMethods
+        extend ClassMethods
       end
     end
 
-    # Defines this feature's name
-    #
-    # @example
-    #   class MyFeature < Spinach::Feature
-    #     feature "Satisfy needs"
-    #   end
-    #
-    def feature(name)
-      @feature_name = name
+    module ClassMethods
+
+      # Defines an action to perform given a particular step literal.
+      #
+      # @param [String] step name
+      #   The step literal
+      # @param [Proc] block
+      #   action to perform in that step
+      #
+      # @example
+      #   class MyFeature << Spinach::Feature
+      #     When "I go to the toilet" do
+      #       @sittin_on_the_toilet.must_equal true
+      #     end
+      #   end
+      #
+      def Given(string, &block)
+        define_method(string, &block)
+      end
+
+      alias_method :When, :Given
+      alias_method :Then, :Given
+      alias_method :And, :Given
+      alias_method :But, :Given
+
+      # Defines this feature's name
+      #
+      # @example
+      #   class MyFeature < Spinach::Feature
+      #     feature "Satisfy needs"
+      #   end
+      #
+      def feature(name)
+        @feature_name = name
+      end
+
+      # @return [String] this feature's name
+      #
+      attr_reader :feature_name
     end
 
-    # @return [String] this feature's name
-    #
-    attr_reader :feature_name
+    module InstanceMethods
+
+      # Execute a given step.
+      #
+      # @param [String] step
+      #   the step to execute
+      #
+      def execute_step(step)
+        if self.respond_to?(step)
+          self.send(step)
+        else
+          raise Spinach::StepNotDefinedException.new(
+            self, step
+          )
+        end
+      end
+
+      def name
+        self.class.feature_name
+      end
+    end
   end
 end

data/lib/spinach/exceptions.rb

@@ -0,0 +1,28 @@
+module Spinach
+  # This class represents the feature raised when Spniach can't find a class
+  # for a feature.
+  class FeatureNotFoundException < StandardError
+    def initialize(options)
+      @not_found_class = options.first
+      @feature = options.last
+    end
+
+    def message
+      "Could not find class for `#{@feature}` feature. Please create a #{@not_found_class}.rb file at #{Spinach.config[:step_definitions_path]}"
+    end
+  end
+
+  # This class represents the step raised when Spinach can't find a step for a
+  # Scenario.
+  #
+  class StepNotDefinedException < StandardError
+
+    attr_reader :feature, :step
+
+    def initialize(feature, step)
+      @feature = feature
+      @step = step
+    end
+  end
+
+end

data/lib/spinach/feature.rb

@@ -5,7 +5,7 @@ module Spinach
   # The feature class is the class where all the features must inherit from.
   #
   class Feature
-    extend DSL
+    include DSL
     include MiniTest::Assertions
 
     def before; end;

data/lib/spinach/parser.rb

@@ -6,6 +6,10 @@ module Spinach
   # needed from the plain feature definition.
   #
   class Parser
+
+    # @param [String] filename
+    #   the file to parse
+    #
     def initialize(filename)
       @filename = filename
       @formatter = Gherkin::Formatter::JSONFormatter.new(nil)

data/lib/spinach/reporter/stdout.rb

@@ -0,0 +1,75 @@
+# encoding: utf-8
+
+module Spinach
+  class Reporter
+    # The Stdout reporter outputs the runner results to the standard output
+    #
+    class Stdout < Reporter
+
+      # Prints the feature name to the standard output
+      #
+      def feature(name)
+        puts "\nFeature: #{name}".white.underline
+      end
+
+      # Prints the scenario name to the standard ouput
+      #
+      def scenario(name)
+        puts "\n  Scenario: #{name}".white
+      end
+
+      # Prints the step name to the standard output. If failed, it puts an
+      # F! before
+      #
+      def step(keyword, name, result)
+        case result
+          when :success
+            puts "    ✔  #{keyword} #{name}".green
+          when :undefined_step
+            puts "    ?  #{keyword} #{name}".yellow
+          when :failure
+            puts "    ✘  #{keyword} #{name}".red
+          when :error
+            puts "    !  #{keyword} #{name}".red
+          when :skip
+            puts "    ~  #{keyword} #{name}".cyan
+        end
+      end
+
+      # Prints a blank line at the end
+      #
+      def end
+        puts ""
+      end
+
+      def error_summary(errors)
+        puts
+        puts "    #{"Error summary".underline}"
+        puts
+        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
+
+          puts
+          puts "    #{scenario.feature_name.light_white} :: #{scenario.name.light_blue} :: #{step.light_green} (line #{line})"
+          puts "    #{step_file}" if step_file
+          puts
+          puts "    * #{error.message}".red
+          puts error.backtrace.map {|e| "      #{e}"}
+          puts
+        end
+      end
+
+      def report_exception(exception)
+        @errors << exception
+        output = exception.message.split("\n").map{ |line|
+          "        #{line}"
+        }.join("\n")
+        puts "#{output}\n\n"
+      end
+
+    end
+  end
+end

data/lib/spinach/reporter.rb

@@ -6,6 +6,10 @@ module Spinach
   # results
   #
   class Reporter
+    # Initialize a reporter with an empty error container.
+    def initialize
+      @errors = []
+    end
 
     # Receives this hook when a feature is invoked
     # @param [String] name
@@ -29,7 +33,7 @@ module Spinach
     # @param [Symbol] result
     #   the step name and its finishing state. May be :success or :failure
     #
-    def step(name, result)
+    def step(keyword, name, result)
       raise "Abstract method!"
     end
 
@@ -39,43 +43,7 @@ module Spinach
       raise "Abstract method!"
     end
 
-    # The Stdout reporter outputs the runner results to the standard output
-    #
-    class Stdout < Reporter
-
-      # Prints the feature name to the standard output
-      #
-      def feature(name)
-        puts "\nFeature: #{name}".white.underline
-      end
-
-      # Prints the scenario name to the standard ouput
-      #
-      def scenario(name)
-        puts "  Scenario: #{name}".white
-      end
-
-      # Prints the step name to the standard output. If failed, it puts an
-      # F! before
-      #
-      def step(name, result)
-        words = name.split(" ")
-        connector = words.shift
-        phrase = words.join(" ")
-        if result == :success
-          puts "  ✔  #{connector} #{phrase}".green
-        elsif result == :failure
-          puts "  ✘  #{connector} #{phrase}".red
-        elsif result == :skip
-          puts "  ~  #{connector} #{phrase}".yellow
-        end
-      end
-
-      # Prints a blank line at the end
-      #
-      def end
-        puts ""
-      end
-    end
   end
 end
+
+require_relative 'reporter/stdout'

data/lib/spinach/runner/feature.rb

@@ -0,0 +1,72 @@
+module Spinach
+  class Runner
+    # A feature runner handles a particular Spinach::Feature run.
+    #
+    class Feature
+
+      # @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)
+        @filename, @scenario_line = filename.split(':')
+        @reporter = reporter
+      end
+
+      attr_reader :reporter
+      attr_reader :filename
+
+      # @return [Spinach::Feature]
+      #   the feature towards which this scenario will be run
+      #
+      def feature
+        @feature ||= Spinach.find_feature(feature_name).new
+      end
+
+      # @return [Hash]
+      #   the parsed data for this feature
+      #
+      def data
+        @data ||= Spinach::Parser.new(filename).parse
+      end
+
+      # @return [String]
+      #   this feature's name
+      #
+      def feature_name
+        @feature_name ||= data['name']
+      end
+
+      # @return [Hash]
+      #   the parsed scenarios for this runner's feature
+      #
+      def scenarios
+        @scenarios ||= data['elements']
+      end
+
+      # Runs this feature
+      #
+      def run
+        reporter.feature(feature_name)
+        failures = []
+        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)
+          end
+        end
+
+        unless failures.length.zero?
+          reporter.error_summary(failures)
+        end
+      end
+
+    end
+  end
+end

data/lib/spinach/runner/scenario.rb

@@ -0,0 +1,55 @@
+module Spinach
+  class Runner
+    # A Scenario Runner handles a particular scenario run.
+    #
+    class Scenario
+      attr_reader :name, :feature, :feature_name, :steps, :reporter
+
+      # @param [Spinach::Feature] feature
+      #   the feature that contains the steps
+      #
+      # @param [Hash] data
+      #   the parsed feature data
+      #
+      # @param [Spinach::Reporter]
+      #   the reporter
+      #
+      def initialize(feature_name, feature, data, reporter)
+        @feature_name = feature_name
+        @name = data['name']
+        @steps = data['steps']
+        @reporter = reporter
+        @feature = feature
+      end
+
+      # Runs this scenario and signals the reporter
+      #
+      def run
+        reporter.scenario(name)
+        steps.each do |step|
+          keyword = step['keyword'].strip
+          name = step['name'].strip
+          line = step['line']
+          unless @failure
+            begin
+              feature.execute_step(name)
+              reporter.step(keyword, name, :success)
+            rescue MiniTest::Assertion => e
+              @failure = [e, name, line, self]
+              reporter.step(keyword, name, :failure)
+            rescue Spinach::StepNotDefinedException => e
+              @failure = [e, name, line, self]
+              reporter.step(keyword, name, :undefined_step)
+            rescue StandardError => e
+              @failure = [e, name, line, self]
+              reporter.step(keyword, name, :error)
+            end
+          else
+            reporter.step(keyword, name, :skip)
+          end
+        end
+        @failure
+      end
+    end
+  end
+end

data/lib/spinach/runner.rb

@@ -3,84 +3,85 @@ module Spinach
   # actual calls to the feature classes.
   #
   class Runner
+
     # Initializes the runner with a parsed feature
-    # @param [Hash] data
-    #   the parsed feature data
     #
-    def initialize(data)
-      @feature_name = data['name']
-      @scenarios = data['elements']
-      @reporter = Spinach::config.default_reporter.new
-    end
+    # @param [Array<String>] filenames
+    #   an array of feature filenames to run
+    #
+    # @param [Hash] options
+    #
+    # @option options [String] :step_definitions_path
+    #   The path in which step definitions are found
+    #
+    # @option options [String] :support_path
+    #   The path with the support ruby files
+    #
+    def initialize(filenames, options = {})
+      @filenames = filenames
 
-    # The default reporter associated to this run
-    attr_reader :reporter
+      @step_definitions_path = options.delete(:step_definitions_path ) ||
+        Spinach.config.step_definitions_path
+
+      @support_path = options.delete(:support_path ) ||
+        Spinach.config.support_path
 
-    # Returns the feature class for the provided feature data
-    # @return [Spinach::Feature] feature
-    #   this runner's feature
-    #
-    def feature
-      @feature ||= Spinach.find_feature(@feature_name)
     end
 
-    # @return [Hash]
-    #   the parsed scenarios for this runner's feature
-    #
-    def scenarios
-      @scenarios
+    def reporter
+      @reporter ||= Spinach::config.default_reporter
     end
 
+    attr_reader :filenames
+
+    # The default path where the steps are located
+    attr_reader :step_definitions_path
+
+    # The default path where the support files are located
+    attr_reader :support_path
+
     # Runs this runner and outputs the results in a colorful manner.
     #
     def run
-      step_count = 0
-      reports = []
-
-      reporter.feature(@feature_name)
+      require_dependencies
 
-      scenarios.each do |scenario|
-        Scenario.new(self, scenario).run
+      filenames.each do |filename|
+        Feature.new(filename, reporter).run
       end
       reporter.end
 
     end
 
-    class Scenario
-      attr_reader :name, :steps
-
-      def initialize(runner, data)
-        @name = data['name']
-        @steps = data['steps']
-        @runner = runner
+    # Requires step definitions and support files
+    #
+    def require_dependencies
+      (support_files + step_definition_files).each do |file|
+        require file
       end
+    end
 
-      def reporter; @runner.reporter; end;
-
-      def feature
-        @feature ||= @runner.feature.new
-      end
+    # List of step definition files
+    #
+    # @return [Array<String>] files
+    #
+    def step_definition_files
+      Dir.glob(
+        File.expand_path File.join(step_definitions_path, '**', '*.rb')
+      )
+    end
 
-      def run
-        reporter.scenario(name)
-        feature.send(:before)
-        steps.each do |step|
-          step_name = "#{step['keyword'].strip} #{step['name']}"
-          unless @failed
-            begin
-              feature.send(step_name)
-              reporter.step(step_name, :success)
-            rescue MiniTest::Assertion=>e
-              reporter.step(step_name, :failure)
-              @failed = true
-            end
-          else
-            reporter.step(step_name, :skip)
-          end
-        end
-        feature.send(:after)
-      end
+    # List of support files
+    #
+    # @return [Array<String>] files
+    #
+    def support_files
+      Dir.glob(
+        File.expand_path File.join(support_path, '**', '*.rb')
+      )
     end
 
   end
 end
+
+require_relative 'runner/feature'
+require_relative 'runner/scenario'