turnip 0.3.1 → 1.0.0

data/examples/alignment_steps.rb

@@ -1,7 +0,0 @@
-steps_for :alignment do
-  attr_accessor :alignment
-
-  step "that alignment should be :alignment" do |expected_alignment|
-    alignment.should eq(expected_alignment)
-  end
-end

data/examples/backtick_steps.rb

@@ -1,4 +0,0 @@
-step "I run `:cmd`" do |cmd|
-  step('I attack it') if cmd == 'killall monsters'
-end
-

data/examples/dragon_steps.rb

@@ -1,17 +0,0 @@
-steps_for :dragon do
-  use_steps :knight
-
-  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

data/examples/evil_steps.rb

@@ -1,7 +0,0 @@
-steps_for :evil do
-  use_steps :alignment
-
-  step "the monster has an alignment" do
-    self.alignment = 'Evil'
-  end
-end

data/examples/neutral_steps.rb

@@ -1,7 +0,0 @@
-steps_for :neutral do
-  use_steps :alignment
-
-  step "the monster has an alignment" do
-    self.alignment = 'Neutral'
-  end
-end

data/examples/red_dragon_steps.rb

@@ -1,18 +0,0 @@
-steps_for :red_dragon do
-  use_steps :dragon
-
-  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

data/lib/turnip/config.rb

@@ -1,18 +0,0 @@
-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/feature_file.rb

@@ -1,20 +0,0 @@
-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

@@ -1,16 +0,0 @@
-module Turnip
-  module Loader
-    def load(*a, &b)
-      if a.first.end_with?('.feature')
-        begin
-          require 'spec_helper'
-        rescue LoadError
-        end
-        Turnip::StepLoader.load_steps
-        Turnip.run(Turnip::FeatureFile.new(a.first))
-      else
-        super
-      end
-    end
-  end
-end

data/lib/turnip/runner_dsl.rb

@@ -1,9 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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_loader.rb

@@ -1,27 +0,0 @@
-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

@@ -1,89 +0,0 @@
-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/spec/feature_file_spec.rb

@@ -1,18 +0,0 @@
-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/runner_dsl_spec.rb

@@ -1,23 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

@@ -1,79 +0,0 @@
-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