turnip 0.3.1 → 1.0.0

data/examples/steps/backtick_steps.rb

@@ -0,0 +1,10 @@
+step "I run :cmd" do |cmd|
+  step('I attack it') if cmd == 'killall monsters'
+end
+
+placeholder :cmd do
+  match /`([^`]*)`/ do |cmd|
+    cmd
+  end
+end
+

data/examples/steps/dragon_steps.rb

@@ -0,0 +1,41 @@
+require_relative "knight_steps"
+
+module DragonSteps
+  include KnightSteps
+
+  attr_accessor :dragon
+
+  def dragon_attack
+    dragon * 10
+  end
+
+  step "there is a dragon" do
+    self.dragon = 1
+  end
+
+  step "the dragon attacks the knight" do
+    knight.attacked_for(dragon_attack)
+  end
+end
+
+module RedDragonSteps
+  include DragonSteps
+
+  attr_accessor :red_dragon
+
+  def dragon_attack
+    attack = super
+    if red_dragon
+      attack + 15
+    else
+      attack
+    end
+  end
+
+  step "the dragon breathes fire" do
+    self.red_dragon = 1
+  end
+end
+
+RSpec.configure { |c| c.include DragonSteps, :dragon => true }
+RSpec.configure { |c| c.include RedDragonSteps, :red_dragon => true }

data/examples/{knight_steps.rb → steps/knight_steps.rb}

@@ -1,4 +1,4 @@
-steps_for :knight do
+module KnightSteps
   attr_accessor :knight
 
   class Knight
@@ -27,3 +27,5 @@ steps_for :knight do
     knight.should_not be_alive
   end
 end
+
+RSpec.configure { |c| c.include KnightSteps, :knight => true }

data/examples/{steps.rb → steps/steps.rb}

@@ -17,7 +17,7 @@ end
 step "this is ambiguous" do
 end
 
-step "this is ambiguous" do
+step "this is :ambiguous" do
 end
 
 step "there is a monster called :name" do |name|
@@ -79,6 +79,30 @@ step "the song should have :count lines" do |count|
   @song.to_s.split("\n").length.should eq(count)
 end
 
+step "it should be strong/tough" do
+  @monster.should >= 2
+end
+
+step "it should be (a) badass" do
+  @monster.should >= 2
+end
+
+step "it should be (a) badass" do
+  @monster.should >= 2
+end
+
+step "it should be terrible(st)" do
+  @monster.should >= 2
+end
+
+step "it (should) have/has :count (terrifying) hitpoint(s)" do |count|
+  @monster.should == count
+end
+
+step "raise error" do
+  raise "foobar"
+end
+
 placeholder :count do
   match /\d+/ do |count|
     count.to_i

data/examples/steps_for.feature

@@ -1,10 +1,10 @@
 Feature: Steps for a feature
   @evil
-  Scenario:
+  Scenario: Evil
     Given the monster has an alignment
     Then that alignment should be "Evil"
 
   @neutral
-  Scenario:
+  Scenario: Neutral
     Given the monster has an alignment
     Then that alignment should be "Neutral"

data/examples/steps_with_variations.feature

@@ -0,0 +1,17 @@
+Feature: steps with variations, such as alternative words or optional words
+  Scenario: alternative words
+    Given there is a strong monster
+    Then it should be strong
+    And it should be tough
+  Scenario: optional words
+    Given there is a strong monster
+    Then it should be badass
+    And it should be a badass
+  Scenario: optional parts of words
+    Given there is a strong monster
+    Then it should be terrible
+    And it should be terriblest
+  Scenario: putting it all together
+    Given there is a strong monster
+    Then it should have 2 terrifying hitpoints
+    And it has 2 hitpoint

data/lib/turnip.rb

@@ -1,48 +1,33 @@
-require "gherkin"
-require "gherkin/formatter/tag_count_formatter"
-
 require "turnip/version"
 require "turnip/dsl"
-
-require 'rspec'
+require "turnip/execute"
+require "turnip/define"
+require "turnip/builder"
+require "turnip/step_definition"
+require "turnip/placeholder"
+require "turnip/table"
 
 module Turnip
-  autoload :Config, 'turnip/config'
-  autoload :FeatureFile, 'turnip/feature_file'
-  autoload :Loader, 'turnip/loader'
-  autoload :Builder, 'turnip/builder'
-  autoload :StepDefinition, 'turnip/step_definition'
-  autoload :Placeholder, 'turnip/placeholder'
-  autoload :Table, 'turnip/table'
-  autoload :StepLoader, 'turnip/step_loader'
-  autoload :StepModule, 'turnip/step_module'
-  autoload :ScenarioRunner, 'turnip/scenario_runner'
-  autoload :RunnerDSL, 'turnip/runner_dsl'
-  autoload :ScenarioContext, 'turnip/scenario_context'
+  class Pending < StandardError; end
+  class Ambiguous < StandardError; end
+
+  ##
+  #
+  # The global step module, adding steps here will make them available in all
+  # your tests.
+  #
+  module Steps
+  end
 
   class << self
     attr_accessor :type
-
-    def run(feature_file)
-      Turnip::Builder.build(feature_file).features.each do |feature|
-        describe feature.name, feature.metadata_hash do
-          feature.scenarios.each do |scenario|
-            it scenario.name, scenario.metadata_hash do
-              Turnip::ScenarioRunner.new(self).load(Turnip::ScenarioContext.new(feature, scenario)).run
-            end
-          end
-        end
-      end
-    end
   end
 end
 
 Turnip.type = :turnip
 
-RSpec::Core::Configuration.send(:include, Turnip::Loader)
-
-RSpec.configure do |config|
-  config.pattern << ",**/*.feature"
-end
+Module.send(:include, Turnip::Define)
 
 self.extend Turnip::DSL
+
+require "turnip/rspec"

data/lib/turnip/builder.rb

@@ -1,13 +1,11 @@
+require "gherkin"
+
 module Turnip
   class Builder
     module Tags
       def tags
         @raw.tags.map { |tag| tag.name.sub(/^@/, '') }
       end
-      
-      def active_tags
-        tags.map(&:to_sym)
-      end
 
       def tags_hash
         Hash[tags.map { |t| [t.to_sym, true] }]
@@ -36,13 +34,9 @@ module Turnip
         @scenarios = []
         @backgrounds = []
       end
-      
-      # Feature's active_tags automatically prepends the :global tag
-      # as well as its feature_tag if defined
-      def active_tags
-        active_tags = [:global]
-        active_tags << feature_tag.to_sym if feature_tag
-        active_tags + super
+
+      def line
+        @raw.line
       end
 
       def metadata_hash
@@ -88,30 +82,36 @@ module Turnip
           Scenario.new(@raw).tap do |scenario|
             scenario.steps = steps.map do |step|
               new_description = step.description.gsub(/<([^>]*)>/) { |_| Hash[headers.zip(row)][$1] }
-              Step.new(new_description, step.extra_arg)
+              Step.new(new_description, step.extra_args, step.line)
             end
           end
         end
       end
     end
 
-    class Step < Struct.new(:description, :extra_arg)
+    class Step < Struct.new(:description, :extra_args, :line)
+      # 1.9.2 support hack
+      def split(*args)
+        self.to_s.split(*args)
+      end
+
+      def to_s
+        description
+      end
     end
 
     attr_reader :features
 
     class << self
       def build(feature_file)
-        Turnip::Builder.new(feature_file).tap do |builder|
-          formatter = Gherkin::Formatter::TagCountFormatter.new(builder, {})
-          parser = Gherkin::Parser::Parser.new(formatter, true, "root", false)
-          parser.parse(feature_file.content, nil, 0)
+        Turnip::Builder.new.tap do |builder|
+          parser = Gherkin::Parser::Parser.new(builder, true)
+          parser.parse(File.read(feature_file), nil, 0)
         end
       end
     end
 
-    def initialize(feature_file)
-      @feature_file = feature_file
+    def initialize
       @features = []
     end
 
@@ -122,8 +122,6 @@ module Turnip
 
     def feature(feature)
       @current_feature = Feature.new(feature)
-      # Automatically add a tag based on the name of the feature to the Feature if configured to
-      @current_feature.feature_tag = @feature_file.feature_name if Turnip::Config.autotag_features
       @features << @current_feature
     end
 
@@ -141,12 +139,16 @@ module Turnip
     end
 
     def step(step)
+      extra_args = []
       if step.doc_string
-        extra_arg = step.doc_string.value
+        extra_args.push step.doc_string.value
       elsif step.rows
-        extra_arg = Turnip::Table.new(step.rows.map { |row| row.cells(&:value) })
+        extra_args.push Turnip::Table.new(step.rows.map { |row| row.cells(&:value) })
       end
-      @current_step_context.steps << Step.new(step.name, extra_arg)
+      @current_step_context.steps << Step.new(step.name, extra_args, step.line)
+    end
+
+    def uri(*)
     end
 
     def eof

data/lib/turnip/define.rb

@@ -0,0 +1,9 @@
+module Turnip
+  module Define
+    def step(expression, &block)
+      step = Turnip::StepDefinition.new(expression, &block)
+      send(:define_method, "match: #{expression}") { |description| step.match(description) }
+      send(:define_method, expression, &block)
+    end
+  end
+end

data/lib/turnip/dsl.rb

@@ -5,26 +5,20 @@ module Turnip
     end
 
     def step(description, &block)
-      global_step_module_entry.step_module.steps << Turnip::StepDefinition.new(description, &block)
+      Turnip::Steps.step(description, &block)
     end
 
     def steps_for(tag, &block)
-      Turnip::StepModule.steps_for(tag, &block)
-    end
-
-    private
-
-    def global_step_module_entry
-      @global_step_module_entry ||= begin
-                                      anon = Module.new do
-                                        def self.steps
-                                          @steps ||= []
-                                        end
-                                      end
-                                      entry = Turnip::StepModule::Entry.new([:global], anon, [])
-                                      Turnip::StepModule.module_registry[:global] << entry
-                                      entry
-                                    end
+      if tag.to_s == "global"
+        warn "[Turnip] using steps_for(:global) is deprecated, add steps to Turnip::Steps instead"
+        Turnip::Steps.module_eval(&block)
+      else
+        Module.new do
+          singleton_class.send(:define_method, :tag) { tag }
+          module_eval(&block)
+          ::RSpec.configure { |c| c.include self, tag => true }
+        end
+      end
     end
   end
 end

data/lib/turnip/execute.rb

@@ -0,0 +1,15 @@
+module Turnip
+  module Execute
+    def step(description, *extra_args)
+      extra_args.concat(description.extra_args) if description.respond_to?(:extra_args)
+
+      matches = methods.map do |method|
+        next unless method.to_s.start_with?("match: ")
+        send(method.to_s, description.to_s)
+      end.compact
+      raise Turnip::Pending, description if matches.length == 0
+      raise Turnip::Ambiguous, description if matches.length > 1
+      send(matches.first.expression, *(matches.first.params + extra_args))
+    end
+  end
+end

data/lib/turnip/rspec.rb

@@ -0,0 +1,80 @@
+require "turnip"
+require "rspec"
+
+module Turnip
+  module RSpec
+
+    ##
+    #
+    # This module hooks Turnip into RSpec by duck punching the load Kernel
+    # method. If the file is a feature file, we run Turnip instead!
+    #
+    module Loader
+      def load(*a, &b)
+        if a.first.end_with?('.feature')
+          begin
+            require 'spec_helper'
+          rescue LoadError
+          end
+          Turnip::RSpec.run(a.first)
+        else
+          super
+        end
+      end
+    end
+
+    ##
+    #
+    # This module provides an improved method to run steps inside RSpec, adding
+    # proper support for pending steps, as well as nicer backtraces.
+    #
+    module Execute
+      include Turnip::Execute
+
+      def run_step(feature_file, step)
+        begin
+          step(step)
+        rescue Turnip::Pending
+          pending("No such step: '#{step}'")
+        rescue StandardError => e
+          e.backtrace.push "#{feature_file}:#{step.line}:in `#{step.description}'"
+          raise e
+        end
+      end
+    end
+
+    class << self
+      def run(feature_file)
+        Turnip::Builder.build(feature_file).features.each do |feature|
+          describe feature.name, feature.metadata_hash do
+            before do
+              # This is kind of a hack, but it will make RSpec throw way nicer exceptions
+              example.metadata[:file_path] = feature_file
+
+              feature.backgrounds.map(&:steps).flatten.each do |step|
+                run_step(feature_file, step)
+              end
+            end
+            feature.scenarios.each do |scenario|
+              describe scenario.name, scenario.metadata_hash do
+                it scenario.steps.map(&:description).join(' -> ') do
+                  scenario.steps.each do |step|
+                    run_step(feature_file, step)
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+::RSpec::Core::Configuration.send(:include, Turnip::RSpec::Loader)
+
+::RSpec.configure do |config|
+  config.include Turnip::RSpec::Execute
+  config.include Turnip::Steps
+  config.pattern << ",**/*.feature"
+end