turnip 0.2.0 → 0.3.0

data/lib/turnip/step_loader.rb

@@ -0,0 +1,27 @@
+module Turnip
+  module StepLoader
+    extend self
+
+    attr_accessor :steps_loaded
+
+    def load_steps
+      return if steps_loaded?
+      load_step_files
+      self.steps_loaded = true
+    end
+
+    def steps_loaded?
+      @steps_loaded
+    end
+
+    private
+
+    def load_step_files
+      Turnip::Config.step_dirs.each do |dir|
+        Pathname.glob(Pathname.new(dir) + '**' + "*steps.rb").each do |step_file|
+          load step_file, true
+        end
+      end
+    end
+  end
+end

data/lib/turnip/step_module.rb

@@ -0,0 +1,89 @@
+require 'pathname'
+
+module Turnip
+  module StepModule
+    module DSL
+      def placeholder(name, &block)
+        Turnip::Placeholder.add(name, &block)
+      end
+
+      def step(description, &block)
+        steps << Turnip::StepDefinition.new(description, &block)
+      end
+
+      def steps
+        @steps ||= []
+      end
+
+      def use_steps(*tags)
+        uses_steps.concat(tags)
+      end
+
+      def uses_steps
+        @uses_steps ||= []
+      end
+    end
+
+    class Entry < Struct.new(:for_tag, :step_module, :uses_steps)
+      def all_modules(already_visited = [])
+        if already_visited.include?(for_tag)
+          []
+        else
+          already_visited << for_tag
+          uses_modules(already_visited) << step_module
+        end
+      end
+
+      def uses_modules(already_visited)
+        uses_steps.map do |uses_tag|
+          StepModule.module_registry[uses_tag].map do |entry|
+            entry.all_modules(already_visited)
+          end
+        end.flatten.uniq
+      end
+    end
+
+    extend self
+
+    def all_steps_for(*taggings)
+      modules_for(*taggings).map do |step_module|
+        step_module.steps
+      end.flatten
+    end
+
+    def clear_module_registry
+      module_registry.clear
+    end
+
+    def modules_for(*taggings)
+      taggings.map do |tag|
+        module_registry[tag].map do |entry|
+          entry.all_modules
+        end
+      end.flatten.uniq
+    end
+
+    def module_registry
+      @module_registry ||= Hash.new { |hash, key| hash[key] = [] }
+    end
+
+    def registered?(module_name)
+      module_registry.has_key? module_name
+    end
+
+    def steps_for(tag, &block)
+      anon = step_module(&block)
+
+      entry = Entry.new(tag, anon, anon.uses_steps)
+
+      module_registry[tag] << entry
+    end
+
+    def step_module(&block)
+      anon = Module.new
+      anon.extend(Turnip::StepModule::DSL)
+      anon.module_eval(&block)
+      anon
+    end
+  end
+end

data/lib/turnip/table.rb

@@ -20,9 +20,21 @@ module Turnip
     def hashes
       rows.map { |row| Hash[headers.zip(row)] }
     end
+    
+    def rows_hash
+      return @rows_hash if @rows_hash
+      verify_table_width(2)
+      @rows_hash = self.class.new(raw.transpose).hashes[0]
+    end
 
     def each
       @raw.each { |row| yield(row) }
     end
+    
+    private
+    
+    def verify_table_width(width)
+      raise %{The table must have exactly #{width} columns} unless raw[0].size == width
+    end
   end
 end

data/lib/turnip/version.rb

@@ -1,3 +1,3 @@
 module Turnip
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/spec/builder_spec.rb

@@ -2,8 +2,8 @@ require 'spec_helper'
 
 describe Turnip::Builder do
   context "with scenario outlines" do
-    let(:gherkin) { File.read(File.expand_path('../examples/scenario_outline.feature', File.dirname(__FILE__))) }
-    let(:builder) { Turnip::Builder.build(gherkin) }
+    let(:feature_file) { Turnip::FeatureFile.new(File.expand_path('../examples/scenario_outline.feature', File.dirname(__FILE__))) }
+    let(:builder) { Turnip::Builder.build(feature_file) }
     let(:feature) { builder.features.first }
 
 
@@ -27,4 +27,43 @@ describe Turnip::Builder do
       ])
     end
   end
+  
+  describe "taggings" do
+    let(:feature_file) { Turnip::FeatureFile.new(File.expand_path('../examples/autoload_steps.feature', File.dirname(__FILE__))) }
+    let(:builder) { Turnip::Builder.build(feature_file) }
+    let(:feature) { builder.features.first }
+    
+    context "for features" do
+      it 'should automatically include the :global tag for features' do
+        feature.active_tags.should include(:global)
+      end
+      
+      it 'should automatically include the feature name tag for features' do
+        feature.active_tags.should include(:autoload_steps)
+      end
+    end
+    
+    context "for scenarios" do
+      it 'should only include scenario tags' do
+        feature.scenarios.first.active_tags.should eq([:scenario_tag])
+      end
+    end
+    
+    context "autotag features disabled" do
+      before(:each) { Turnip::Config.autotag_features = false }
+      after(:each) { Turnip::Config.autotag_features = true }
+      
+      let(:feature_file) { Turnip::FeatureFile.new(File.expand_path('../examples/autoload_steps.feature', File.dirname(__FILE__))) }
+      let(:builder) { Turnip::Builder.build(feature_file) }
+      let(:feature) { builder.features.first }
+      
+      it 'should automatically include the :global tag for features' do
+        feature.active_tags.should include(:global)
+      end
+      
+      it 'should not automatically include the feature name tag for features' do
+        feature.active_tags.should_not include(:autoload_steps)
+      end
+    end
+  end
 end

data/spec/dsl_spec.rb

@@ -2,53 +2,41 @@ require 'spec_helper'
 
 describe Turnip::DSL do
   before do
-    @context = stub
-    @context.extend(Turnip::DSL)
+    Turnip::StepModule.clear_module_registry
   end
 
-  describe '#step' do
-    it 'adds a step to the list of step definitions' do
-      Turnip::StepDefinition.should_receive(:add).with('this is a :thing test', {})
-      @context.step 'this is a :thing test'
-    end
+  let(:context) { stub.tap { |s| s.extend(Turnip::DSL) }}
 
-    it 'sends through options' do
-      Turnip::StepDefinition.should_receive(:add).with('foo', {:for => [:monkey]})
-      @context.step 'foo', :for => [:monkey]
+  describe '.steps_for' do
+    it 'delegates to StepModule' do
+      Turnip::StepModule.should_receive(:steps_for).with(:example)
+      context.steps_for(:example) {}
     end
   end
 
-  describe '#steps_for' do
-    it 'executes the given block and adds steps with for set' do
-      Turnip::StepDefinition.should_receive(:add).with('foo', {:for => [:gorilla]})
-      @context.steps_for :gorilla do
-        @context.step 'foo'
-      end
-    end
-
-    it 'combines step for option and block options' do
-      Turnip::StepDefinition.should_receive(:add).with('foo', {:for => [:a, :b, :gorilla]})
-      @context.steps_for :gorilla do
-        @context.step 'foo', :for => [:a, :b]
+  describe '.step' do
+    context 'first step defined globally' do
+      it 'creates a new global entry' do
+        context.step('this is a test') {}
+        Turnip::StepModule.should be_registered(:global)
       end
     end
 
-    it 'can be nested' do
-      Turnip::StepDefinition.should_receive(:add).with('foo', {:for => [:c, :b, :a]})
-      @context.steps_for :a do
-        @context.steps_for :b do
-          @context.step 'foo', :for => :c
-        end
+    context 'all other steps defined globally' do
+      it 'adds more steps to the :global step module' do
+        context.step('this is a test') {}
+        context.step('this is another test') {}
+        Turnip::StepModule.module_registry[:global].first.step_module.steps.size.should eq(2)
       end
     end
   end
 
-  describe '#placeholder' do
-    it 'adds a placeholder to the list of placeholders' do
-      @context.placeholder :quox do
-        match(/foo/) { 'bar' }
-      end
-      Turnip::Placeholder.apply(:quox, 'foo').should == 'bar'
+  describe '.placeholder' do
+    before { Turnip::Placeholder.send(:placeholders).clear }
+
+    it 'registers the placeholder globally' do
+      context.placeholder('example') { true }
+      Turnip::Placeholder.send(:placeholders).should have_key('example')
     end
   end
 end

data/spec/feature_file_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Turnip::FeatureFile do
+  let(:file_name) {File.expand_path('../examples/with_comments.feature', File.dirname(__FILE__))}
+  let(:feature_file) {Turnip::FeatureFile.new(file_name)}
+  
+  describe '.feature_name' do
+    it 'allows access to short name for the feature based on the file name' do
+      feature_file.feature_name.should == 'with_comments'
+    end
+  end
+  
+  describe '.content' do
+    it 'allows access to the content in the feature file' do
+      feature_file.content.should be
+    end
+  end
+end

data/spec/integration_spec.rb

@@ -11,6 +11,6 @@ describe 'The CLI', :type => :integration do
   end
 
   it "prints out failures and successes" do
-    @result.should include('16 examples, 1 failure, 1 pending')
+    @result.should include('23 examples, 1 failure, 2 pending')
   end
 end

data/spec/runner_dsl_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Turnip::RunnerDSL do
+  describe '#step' do
+    include Turnip::RunnerDSL
+
+    it 'runs the step' do
+      self.turnip_runner = Class.new do
+        attr_accessor :args
+        def run_steps(steps)
+          self.args << steps
+        end
+      end.new
+      self.turnip_runner.args = []
+
+      step('description', 'extra_arg')
+      step = turnip_runner.args.flatten.first
+      step.should be_kind_of(Turnip::Builder::Step)
+      step.description.should eq('description')
+      step.extra_arg.should eq('extra_arg')
+    end
+  end
+end

data/spec/scenario_context_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe Turnip::ScenarioContext do
+  let(:context) { Turnip::ScenarioContext.new(feature, scenario) }
+  let(:feature) { stub(:active_tags => feature_tags) }
+  let(:feature_tags) { %w(feature both) }
+  let(:scenario) { stub(:active_tags => scenario_tags) }
+  let(:scenario_tags) { %w(scenario both) }
+  let(:unique_tags) { (feature_tags + scenario_tags).uniq }
+
+  describe '#initialize' do
+    let(:feature) { stub }
+    let(:scenario) { stub }
+
+    it 'keeps track of the feature' do
+      Turnip::ScenarioContext.new(feature, scenario).feature.should eq(feature)
+    end
+
+    it 'keeps track of the scenario' do
+      Turnip::ScenarioContext.new(feature, scenario).scenario.should eq(scenario)
+    end
+  end
+
+  describe '#available_background_steps' do
+    it 'gathers the steps for the feature tags' do
+      Turnip::StepModule.should_receive(:all_steps_for).with(*feature_tags)
+      context.available_background_steps
+    end
+  end
+
+  describe '#available_scenario_steps' do
+    it 'gathers the steps for the unique scenario and feature tags' do
+      Turnip::StepModule.should_receive(:all_steps_for).with(*unique_tags)
+      context.available_scenario_steps
+    end
+  end
+
+  describe '#backgrounds' do
+    it 'delegates to the feature' do
+      feature.should_receive :backgrounds
+      context.backgrounds
+    end
+  end
+
+  describe '#modules' do
+    it 'gathers the modules for the unique scenario and feature tags' do
+      Turnip::StepModule.should_receive(:modules_for).with(*unique_tags)
+      context.modules
+    end
+  end
+end

data/spec/scenario_runner_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+describe Turnip::ScenarioRunner do
+  let(:runner) { Turnip::ScenarioRunner.new(world) }
+  let(:world) { Object.new }
+
+  describe '#initialize' do
+    it 'keeps track of the world' do
+      Turnip::ScenarioRunner.new(world).world.should eq(world)
+    end
+  end
+
+  describe '#load' do
+    let(:context) { stub(:modules => [some_module]) }
+    let(:some_module) { Module.new }
+
+    it 'is chainable' do
+      runner.load(context).should eq(runner)
+    end
+
+    it 'keeps track of the scenario context' do
+      runner.load(context).context.should eq(context)
+    end
+
+    it 'loads the given modules into the world' do
+      runner.load(context).world.should be_kind_of(some_module)
+    end
+
+    it 'loads the DSL module into the world' do
+      runner.load(context).world.should be_kind_of(Turnip::RunnerDSL)
+    end
+
+    it 'adds the runner to the world' do
+      runner.load(context).world.turnip_runner.should eq(runner)
+    end
+  end
+
+  describe '#run' do
+    it 'iterates over the background steps' do
+      runner.context = stub(:backgrounds => (0..2).map { stub(:steps => [stub]) },
+                                 :available_background_steps => [],
+                                 :available_scenario_steps => [],
+                                 :scenario => stub(:steps => []))
+
+      Turnip::StepDefinition.should_receive(:execute).exactly(3).times
+      runner.run
+    end
+
+    it 'iterates over the scenario steps' do
+      runner.context = stub(:backgrounds => [],
+                                 :available_background_steps => [],
+                                 :available_scenario_steps => [],
+                                 :scenario => stub(:steps => (0..3)))
+
+      Turnip::StepDefinition.should_receive(:execute).exactly(4).times
+      runner.run
+    end
+  end
+
+  describe '#run_steps' do
+    let(:available_steps) { stub }
+
+    it 'executes the steps with the current world' do
+      step = stub
+      steps = [step]
+      runner.available_steps = available_steps
+
+      Turnip::StepDefinition.should_receive(:execute).with(world, available_steps, step)
+      runner.run_steps(steps)
+    end
+
+    it 'iterates over the steps' do
+      steps = (0..2)
+
+      Turnip::StepDefinition.should_receive(:execute).exactly(3).times
+      runner.run_steps(steps)
+    end
+  end
+end