turnip 0.2.0 → 0.3.0

data/examples/step_calling.feature

@@ -0,0 +1,14 @@
+Feature: Step-calling steps
+
+  Scenario: when the called step is visible
+    Given a visible step call
+
+  Scenario: when the called step is not visible
+    Given an invisible step call
+
+  Scenario: when the called step is global
+    Given a global step call
+
+  @autoload_steps
+  Scenario: when the called step is included via tag
+    Given an included call

data/examples/step_calling_steps.rb

@@ -0,0 +1,23 @@
+steps_for :step_calling do
+  step 'visible callee' do
+    @testing = 123
+  end
+
+  step 'a visible step call' do
+    step 'visible callee'
+    @testing.should eq(123)
+  end
+
+  step 'an invisible step call' do
+    step 'this is an unimplemented step'
+  end
+
+  step 'a global step call' do
+    step 'there is a monster'
+    @monster.should == 1
+  end
+
+  step 'an included call' do
+    step 'an auto-loaded step is available'
+  end
+end

data/examples/steps.rb

@@ -32,14 +32,6 @@ step 'it should be called "John"' do
   @monster_name.should == "John"
 end
 
-step "there are :count monkeys with :color hair" do |count, color|
-  @monkeys = Array.new(count) { color }
-end
-
-step "there should be 3 monkeys with blue hair" do
-  @monkeys.should == [:blue, :blue, :blue]
-end
-
 step "there is a monster with :count hitpoints" do |count|
   @monster = count
 end
@@ -75,20 +67,6 @@ step "the song should have :count lines" do |count|
   @song.to_s.split("\n").length.should eq(count)
 end
 
-step "the monster has an alignment", :for => :evil do
-  @alignment = 'Evil'
-end
-
-steps_for :neutral do
-  step "the monster has an alignment" do
-    @alignment = 'Neutral'
-  end
-end
-
-step "that alignment should be :alignment" do |alignment|
-  @alignment.should eq(alignment)
-end
-
 placeholder :count do
   match /\d+/ do |count|
     count.to_i

data/examples/steps_for_super.feature

@@ -0,0 +1,16 @@
+Feature: Red Dragons are deadly
+
+  @dragon
+  Scenario:
+    Given there is a dragon
+    And there is a knight
+    When the dragon attacks the knight
+    Then the knight is alive
+
+  @red_dragon
+  Scenario:
+    Given there is a dragon
+    And the dragon breathes fire
+    And there is a knight
+    When the dragon attacks the knight
+    Then the knight is dead

data/lib/turnip.rb

@@ -4,31 +4,31 @@ require "gherkin/formatter/tag_count_formatter"
 require "turnip/version"
 require "turnip/dsl"
 
+require 'rspec'
+
 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 << self
     attr_accessor :type
 
-    def run(content)
-      Turnip::Builder.build(content).features.each do |feature|
+    def run(feature_file)
+      Turnip::Builder.build(feature_file).features.each do |feature|
         describe feature.name, feature.metadata_hash do
-          feature.backgrounds.each do |background|
-            before do
-              background.steps.each do |step|
-                Turnip::StepDefinition.execute(self, step)
-              end
-            end
-          end
           feature.scenarios.each do |scenario|
             it scenario.name, scenario.metadata_hash do
-              scenario.steps.each do |step|
-                Turnip::StepDefinition.execute(self, step)
-              end
+              Turnip::ScenarioRunner.new(self).load(Turnip::ScenarioContext.new(feature, scenario)).run
             end
           end
         end

data/lib/turnip/builder.rb

@@ -4,6 +4,10 @@ module Turnip
       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] }]
@@ -25,12 +29,21 @@ module Turnip
       include Name
 
       attr_reader :scenarios, :backgrounds
+      attr_accessor :feature_tag
 
       def initialize(raw)
         @raw = raw
         @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
+      end
 
       def metadata_hash
         super.merge(:type => Turnip.type, :turnip => true)
@@ -88,16 +101,17 @@ module Turnip
     attr_reader :features
 
     class << self
-      def build(content)
-        Turnip::Builder.new.tap do |builder|
+      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(content, nil, 0)
+          parser.parse(feature_file.content, nil, 0)
         end
       end
     end
 
-    def initialize
+    def initialize(feature_file)
+      @feature_file = feature_file
       @features = []
     end
 
@@ -108,6 +122,8 @@ 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
 

data/lib/turnip/config.rb

@@ -0,0 +1,18 @@
+module Turnip
+  module Config
+    extend self
+
+    attr_accessor :autotag_features
+
+    def step_dirs
+      @step_dirs ||= ['spec']
+    end
+
+    def step_dirs=(dirs)
+      @step_dirs = [] unless @step_dirs
+      @step_dirs.concat(Array(dirs))
+    end
+  end
+end
+
+Turnip::Config.autotag_features = true

data/lib/turnip/dsl.rb

@@ -1,24 +1,30 @@
 module Turnip
   module DSL
-    class << self
-      attr_accessor :current_taggings
+    def placeholder(name, &block)
+      Turnip::Placeholder.add(name, &block)
     end
 
-    def step(description, options={}, &block)
-      if Turnip::DSL.current_taggings
-        options[:for] = [options[:for], *Turnip::DSL.current_taggings].compact.flatten
-      end
-      Turnip::StepDefinition.add(description, options, &block)
+    def step(description, &block)
+      global_step_module_entry.step_module.steps << Turnip::StepDefinition.new(description, &block)
     end
 
-    def steps_for(*taggings)
-      Turnip::DSL.current_taggings = [taggings, *Turnip::DSL.current_taggings].compact.flatten
-      yield
-      Turnip::DSL.current_taggings = nil
+    def steps_for(tag, &block)
+      Turnip::StepModule.steps_for(tag, &block)
     end
 
-    def placeholder(name, &block)
-      Turnip::Placeholder.add(name, &block)
+    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
     end
   end
 end

data/lib/turnip/feature_file.rb

@@ -0,0 +1,20 @@
+module Turnip
+  class FeatureFile
+    attr_accessor :file_name, :content, :feature_name
+    
+    def initialize(file_name)
+      @file_name = file_name
+    end
+    
+    def feature_name
+      @feature_name ||= begin
+        file = Pathname.new(file_name).basename.to_s
+        file[0...file.index('.feature')]
+      end
+    end
+    
+    def content
+      @content ||= File.read(file_name)
+    end
+  end
+end

data/lib/turnip/loader.rb

@@ -2,9 +2,12 @@ module Turnip
   module Loader
     def load(*a, &b)
       if a.first.end_with?('.feature')
-        require 'spec_helper'
-        content = File.read(a.first)
-        Turnip.run(content)
+        begin
+          require 'spec_helper'
+        rescue LoadError
+        end
+        Turnip::StepLoader.load_steps
+        Turnip.run(Turnip::FeatureFile.new(a.first))
       else
         super
       end

data/lib/turnip/placeholder.rb

@@ -27,7 +27,7 @@ module Turnip
 
       def default
         @default ||= new(:default) do
-          match %r((?:"([^"]+)"|([a-zA-Z0-9_-]+))) do |first, second|
+          match %r((?:["']([^["']]+)["']|([a-zA-Z0-9_-]+))) do |first, second|
             first or second
           end
         end

data/lib/turnip/runner_dsl.rb

@@ -0,0 +1,9 @@
+module Turnip
+  module RunnerDSL
+    attr_accessor :turnip_runner
+
+    def step(description, extra_arg = nil)
+      turnip_runner.run_steps([Turnip::Builder::Step.new(description, extra_arg)])
+    end
+  end
+end

data/lib/turnip/scenario_context.rb

@@ -0,0 +1,41 @@
+module Turnip
+  class ScenarioContext
+    attr_accessor :feature
+    attr_accessor :scenario
+
+    def initialize(feature, scenario)
+      self.feature = feature
+      self.scenario = scenario
+    end
+
+    def available_background_steps
+      available_steps_for(*feature_tags)
+    end
+
+    def available_scenario_steps
+      available_steps_for(*scenario_tags)
+    end
+
+    def backgrounds
+      feature.backgrounds
+    end
+
+    def modules
+      Turnip::StepModule.modules_for(*scenario_tags)
+    end
+
+    private
+
+    def available_steps_for(*tags)
+      Turnip::StepModule.all_steps_for(*tags)
+    end
+
+    def feature_tags
+      @feature_tags ||= feature.active_tags.uniq
+    end
+
+    def scenario_tags
+      @scenario_tags ||= (feature_tags + scenario.active_tags).uniq
+    end
+  end
+end

data/lib/turnip/scenario_runner.rb

@@ -0,0 +1,35 @@
+module Turnip
+  class ScenarioRunner
+    attr_accessor :available_steps
+    attr_accessor :context
+    attr_accessor :world
+
+    def initialize(world)
+      self.world = world
+    end
+
+    def load(context)
+      self.context = context
+      world.extend Turnip::RunnerDSL
+      world.turnip_runner = self
+      context.modules.each {|mod| world.extend mod }
+      self
+    end
+
+    def run
+      self.available_steps = context.available_background_steps
+      context.backgrounds.each do |background|
+        run_steps(background.steps)
+      end
+
+      self.available_steps = context.available_scenario_steps
+      run_steps(context.scenario.steps)
+    end
+
+    def run_steps(steps)
+      steps.each do |step|
+        Turnip::StepDefinition.execute(world, available_steps, step)
+      end
+    end
+  end
+end

data/lib/turnip/step_definition.rb

@@ -2,17 +2,16 @@ module Turnip
   class StepDefinition
     class Match < Struct.new(:step_definition, :params, :block)
       def expression; step_definition.expression; end
-      def options; step_definition.options; end
     end
 
     class Pending < StandardError; end
     class Ambiguous < StandardError; end
 
-    attr_reader :expression, :block, :options
+    attr_reader :expression, :block
 
     class << self
-      def execute(context, step)
-        match = find(step.description, context.example.metadata)
+      def execute(context, available_steps, step)
+        match = find(available_steps, step.description)
         params = match.params
         params << step.extra_arg if step.extra_arg
         context.instance_exec(*params, &match.block)
@@ -20,53 +19,38 @@ module Turnip
         context.pending "the step '#{step.description}' is not implemented"
       end
 
-      def add(expression, options={}, &block)
-        all << StepDefinition.new(expression, options, &block)
-      end
-
-      def find(description, metadata={})
-        found = all.map do |step|
-          step.match(description, metadata)
+      def find(available_steps, description)
+        found = available_steps.map do |step|
+          step.match(description)
         end.compact
         raise Pending, description if found.length == 0
         raise Ambiguous, description if found.length > 1
         found[0]
       end
-
-      def all
-        @all ||= []
-      end
     end
 
-    def initialize(expression, options={}, &block)
+    def initialize(expression, &block)
       @expression = expression
       @block = block
-      @options = options
     end
 
     def regexp
       @regexp ||= compile_regexp
     end
 
-    def match(description, metadata={})
-      if matches_metadata?(metadata)
-        result = description.match(regexp)
-        if result
-          params = result.captures
-          result.names.each_with_index do |name, index|
-            params[index] = Turnip::Placeholder.apply(name.to_sym, params[index])
-          end
-          Match.new(self, params, block)
+    def match(description)
+      result = description.match(regexp)
+      if result
+        params = result.captures
+        result.names.each_with_index do |name, index|
+          params[index] = Turnip::Placeholder.apply(name.to_sym, params[index])
         end
+        Match.new(self, params, block)
       end
     end
 
   protected
 
-    def matches_metadata?(metadata)
-      not options[:for] or [options[:for]].flatten.any? { |option| metadata.has_key?(option) }
-    end
-
     OPTIONAL_WORD_REGEXP = /(\\\s)?\\\(([^)]+)\\\)(\\\s)?/
     PLACEHOLDER_REGEXP = /:([\w]+)/
     ALTERNATIVE_WORD_REGEXP = /(\w+)((\/\w+)+)/