turnip 0.1.1 → 0.2.0

data/.gitignore

@@ -2,3 +2,4 @@
 .bundle
 Gemfile.lock
 pkg/*
+.rvmrc

data/README.md

@@ -5,12 +5,6 @@ extension for RSpec. It allows you to write tests in Gherkin and run them
 through your RSpec environment. Basically you can write cucumber features in
 RSpec.
 
-## DISCLAIMER, READ THIS!!!
-
-Turnip is a proof of concept, there are currently VERY FEW TESTS, and there is
-a lot of cucumber's syntax it does NOT support. There are currently no tables,
-multiline string or scenario outlines.
-
 ## Installation
 
 Install the gem
@@ -92,6 +86,16 @@ Given there is a monster called Jonas
 And there is a monster called "Jonas Nicklas"
 ```
 
+You can also specify alternative words and optional parts of words, like this:
+
+``` ruby
+step "there is/are :count monster(s)" do |count|
+  @monsters = Array.new(count) { Monster.new }
+end
+```
+
+That will match both "there is X monster" or "there are X monsters".
+
 ## Defining placeholders
 
 But what if you want to be more specific in what to match in those
@@ -135,6 +139,42 @@ end
 These regular expressions must not use anchors, e.g. `^` or `$`. They may not
 contain named capture groups, e.g. `(?<color>blue|green)`.
 
+## Specific steps
+
+Sometimes you might want to limit where steps are matched. Turnip allows you to
+do this, through the `:for` option on your steps:
+
+``` ruby
+step "I do it", :for => :interface do
+  click_link('Do it')
+end
+
+step "I do it", :for => :database do
+  Do.it!
+end
+```
+
+Not you can use tags in your feature files to decide which step is going to get
+run:
+
+``` cucumber
+@interface
+Scenario: do it through the interface
+
+@database
+Scenario: do it through the database
+```
+
+If you have many steps for the same tag, you can use the `steps_for` helper:
+
+``` ruby
+steps_for :interface do
+  step "I do it" do
+    ...
+  end
+end
+```
+
 ## Using with Capybara
 
 Just require `turnip/capybara`, either in your `spec_helper` or by

data/examples/multiline_string.feature

@@ -0,0 +1,8 @@
+Feature: A feature with multiline strings
+  Scenario: This is a feature with multiline strings
+    When the monster sings the following song
+      """
+        Oh here be monsters
+        This is cool
+      """
+    Then the song should have 2 lines

data/examples/scenario_outline.feature

@@ -0,0 +1,10 @@
+Feature: using scenario outlines
+  Scenario Outline: a simple outline
+    Given there is a monster with <hp> hitpoints
+    When I attack the monster and do <damage> points damage
+    Then the monster should be <state>
+
+    Examples:
+      | hp   | damage | state   |
+      | 10   | 13     | dead    |
+      | 8    | 5      | alive   |

data/examples/steps.rb

@@ -0,0 +1,102 @@
+step "there is a monster" do
+  @monster = 1
+end
+
+step "there is a strong monster" do
+  @monster = 2
+end
+
+step "I attack it" do
+  @monster -= 1
+end
+
+step "it should die" do
+  @monster.should eq(0)
+end
+
+step "this is ambiguous" do
+end
+
+step "this is ambiguous" do
+end
+
+step "there is a monster called :name" do |name|
+  @monster_name = name
+end
+
+step 'it should be called "John Smith"' do
+  @monster_name.should == "John Smith"
+end
+
+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
+
+step "I attack the monster and do :count points damage" do |count|
+  @monster -= count
+end
+
+step "the monster should be alive" do
+  @monster.should > 0
+end
+
+step "the monster should be dead" do
+  @monster.should <= 0
+end
+
+step "there are the following monsters:" do |table|
+  @monsters = {}
+  table.hashes.each do |hash|
+    @monsters[hash['Name']] = hash['Hitpoints'].to_i
+  end
+end
+
+step ":name should have :count hitpoints" do |name, count|
+  @monsters[name].should eq(count.to_i)
+end
+
+step "the monster sings the following song" do |song|
+  @song = song
+end
+
+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
+  end
+end
+
+placeholder :color do
+  match /blue|green|red/ do |color|
+    color.to_sym
+  end
+end

data/examples/steps_for.feature

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

data/examples/table.feature

@@ -0,0 +1,8 @@
+Feature: A feature with tables
+  Scenario: This is a feature with a table
+    Given there are the following monsters:
+      | Name    | Hitpoints |
+      | Blaaarg | 23        |
+      | Moorg   | 12        |
+    Then "Blaaarg" should have 23 hitpoints
+    And "Moorg" should have 12 hitpoints

data/examples/with_comments.feature

@@ -0,0 +1,12 @@
+# Hi.
+Feature: some feature
+  Comments can be (almost) everywhere.
+  # And another comment
+
+  Scenario: some scenario
+    # Yet another one.
+    Given there is a monster
+    When I attack it
+    Then it should die
+    # Oh my, comments are everywhere.
+# Thank you for reading.

data/lib/turnip.rb

@@ -2,18 +2,47 @@ require "gherkin"
 require "gherkin/formatter/tag_count_formatter"
 
 require "turnip/version"
-require "turnip/loader"
-require "turnip/builder"
-require "turnip/run"
-require "turnip/step_definition"
-require "turnip/placeholder"
 require "turnip/dsl"
-require "turnip/rspec"
 
 module Turnip
+  autoload :Loader, 'turnip/loader'
+  autoload :Builder, 'turnip/builder'
+  autoload :StepDefinition, 'turnip/step_definition'
+  autoload :Placeholder, 'turnip/placeholder'
+  autoload :Table, 'turnip/table'
+
   class << self
     attr_accessor :type
+
+    def run(content)
+      Turnip::Builder.build(content).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
+            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
+
+self.extend Turnip::DSL

data/lib/turnip/builder.rb

@@ -49,7 +49,7 @@ module Turnip
       include Tags
       include Name
 
-      attr_reader :steps
+      attr_accessor :steps
 
       def initialize(raw)
         @raw = raw
@@ -57,16 +57,46 @@ module Turnip
       end
     end
 
-    class Step
+    class ScenarioOutline
+      include Tags
       include Name
 
+      attr_reader :steps
+
       def initialize(raw)
         @raw = raw
+        @steps = []
       end
+
+      def to_scenarios(examples)
+        rows = examples.rows.map(&:cells)
+        headers = rows.shift
+        rows.map do |row|
+          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)
+            end
+          end
+        end
+      end
+    end
+
+    class Step < Struct.new(:description, :extra_arg)
     end
 
     attr_reader :features
 
+    class << self
+      def build(content)
+        Turnip::Builder.new.tap do |builder|
+          formatter = Gherkin::Formatter::TagCountFormatter.new(builder, {})
+          parser = Gherkin::Parser::Parser.new(formatter, true, "root", false)
+          parser.parse(content, nil, 0)
+        end
+      end
+    end
+
     def initialize
       @features = []
     end
@@ -86,9 +116,21 @@ module Turnip
       @current_feature.scenarios << @current_step_context
     end
 
+    def scenario_outline(outline)
+      @current_step_context = ScenarioOutline.new(outline)
+    end
+
+    def examples(examples)
+      @current_feature.scenarios.push(*@current_step_context.to_scenarios(examples))
+    end
+
     def step(step)
-      @current_step = Step.new(step)
-      @current_step_context.steps << @current_step
+      if step.doc_string
+        extra_arg = step.doc_string.value
+      elsif step.rows
+        extra_arg = Turnip::Table.new(step.rows.map { |row| row.cells(&:value) })
+      end
+      @current_step_context.steps << Step.new(step.name, extra_arg)
     end
 
     def eof

data/lib/turnip/dsl.rb

@@ -1,7 +1,20 @@
 module Turnip
   module DSL
-    def step(description, &block)
-      Turnip::StepDefinition.add(description, &block)
+    class << self
+      attr_accessor :current_taggings
+    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)
+    end
+
+    def steps_for(*taggings)
+      Turnip::DSL.current_taggings = [taggings, *Turnip::DSL.current_taggings].compact.flatten
+      yield
+      Turnip::DSL.current_taggings = nil
     end
 
     def placeholder(name, &block)
@@ -9,5 +22,3 @@ module Turnip
     end
   end
 end
-
-self.extend Turnip::DSL

data/lib/turnip/step_definition.rb

@@ -1,62 +1,85 @@
 module Turnip
   class StepDefinition
-    class Match < Struct.new(:params, :block); end
+    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
+    attr_reader :expression, :block, :options
 
     class << self
-      def execute(context, description)
-        match = find(description)
-        context.instance_exec(*match.params, &match.block)
+      def execute(context, step)
+        match = find(step.description, context.example.metadata)
+        params = match.params
+        params << step.extra_arg if step.extra_arg
+        context.instance_exec(*params, &match.block)
       rescue Pending
-        context.pending "the step '#{description}' is not implemented"
+        context.pending "the step '#{step.description}' is not implemented"
       end
 
-      def add(expression, &block)
-        steps << StepDefinition.new(expression, &block)
+      def add(expression, options={}, &block)
+        all << StepDefinition.new(expression, options, &block)
       end
 
-      def find(description)
-        found = steps.map do |step|
-          step.match(description)
+      def find(description, metadata={})
+        found = all.map do |step|
+          step.match(description, metadata)
         end.compact
         raise Pending, description if found.length == 0
         raise Ambiguous, description if found.length > 1
         found[0]
       end
 
-      def steps
-        @steps ||= []
+      def all
+        @all ||= []
       end
     end
 
-    def initialize(expression, &block)
+    def initialize(expression, options={}, &block)
       @expression = expression
       @block = block
+      @options = options
     end
 
     def regexp
       @regexp ||= compile_regexp
     end
 
-    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])
+    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)
         end
-        Match.new(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+)+)/
+
     def compile_regexp
       regexp = Regexp.escape(expression)
-      regexp = expression.gsub(/:([\w]+)/) do |_|
+      regexp.gsub!(OPTIONAL_WORD_REGEXP) do |_|
+        [$1, $2, $3].compact.map { |m| "(#{m})?" }.join
+      end
+      regexp.gsub!(ALTERNATIVE_WORD_REGEXP) do |_|
+        "(#{$1}#{$2.tr('/', '|')})"
+      end
+      regexp.gsub!(PLACEHOLDER_REGEXP) do |_|
         "(?<#{$1}>#{Placeholder.resolve($1.to_sym)})"
       end
       Regexp.new("^#{regexp}$")

data/lib/turnip/table.rb

@@ -0,0 +1,28 @@
+module Turnip
+  class Table
+    attr_reader :raw
+    alias_method :to_a, :raw
+
+    include Enumerable
+
+    def initialize(raw)
+      @raw = raw
+    end
+
+    def headers
+      @raw.first
+    end
+
+    def rows
+      @raw.drop(1)
+    end
+
+    def hashes
+      rows.map { |row| Hash[headers.zip(row)] }
+    end
+
+    def each
+      @raw.each { |row| yield(row) }
+    end
+  end
+end

data/lib/turnip/version.rb

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

data/spec/builder_spec.rb

@@ -0,0 +1,30 @@
+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) { builder.features.first }
+
+
+    it "extracts scenarios" do
+      feature.scenarios.map(&:name).should eq([
+        'a simple outline',
+        'a simple outline'
+      ])
+    end
+
+    it "replaces placeholders in steps" do
+      feature.scenarios[0].steps.map(&:description).should eq([
+        "there is a monster with 10 hitpoints",
+        "I attack the monster and do 13 points damage",
+        "the monster should be dead"
+      ])
+      feature.scenarios[1].steps.map(&:description).should eq([
+        "there is a monster with 8 hitpoints",
+        "I attack the monster and do 5 points damage",
+        "the monster should be alive"
+      ])
+    end
+  end
+end

data/spec/dsl_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe Turnip::DSL do
+  before do
+    @context = stub
+    @context.extend(Turnip::DSL)
+  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
+
+    it 'sends through options' do
+      Turnip::StepDefinition.should_receive(:add).with('foo', {:for => [:monkey]})
+      @context.step 'foo', :for => [:monkey]
+    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]
+      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
+      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'
+    end
+  end
+end

data/spec/integration_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe 'The CLI', :type => :integration do
+  before do
+    @result = %x(rspec -fs examples/*.feature)
+  end
+
+  it "shows the correct description" do
+    @result.should include('A simple feature')
+    @result.should include('is a simple feature')
+  end
+
+  it "prints out failures and successes" do
+    @result.should include('16 examples, 1 failure, 1 pending')
+  end
+end

data/spec/spec_helper.rb

@@ -1,53 +1,5 @@
-step "there is a monster" do
-  @monster = 1
-end
-
-step "there is a strong monster" do
-  @monster = 2
-end
-
-step "I attack it" do
-  @monster -= 1
-end
-
-step "it should die" do
-  @monster.should eq(0)
-end
-
-step "this is ambiguous" do
-end
-
-step "this is ambiguous" do
-end
-
-step "there is a monster called :name" do |name|
-  @monster_name = name
-end
-
-step 'it should be called "John Smith"' do
-  @monster_name.should == "John Smith"
-end
-
-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
-
-placeholder :count do
-  match /\d+/ do |count|
-    count.to_i
-  end
-end
-
-placeholder :color do
-  match /blue|green|red/ do |color|
-    color.to_sym
+RSpec.configure do |config|
+  config.before(:each, :turnip => true) do
+    require File.expand_path('../examples/steps', File.dirname(__FILE__))
   end
 end

data/spec/step_definition_spec.rb

@@ -0,0 +1,118 @@
+describe Turnip::StepDefinition do
+  after do
+    Turnip::StepDefinition.all.clear
+  end
+
+  describe ".add" do
+    it "adds a step definition to the list of definitions" do
+      Turnip::StepDefinition.add "this is a test"
+      Turnip::StepDefinition.all.first.expression.should eq("this is a test")
+    end
+  end
+
+  describe ".find" do
+    it "returns a step definition that matches the description" do
+      Turnip::StepDefinition.add "there are :count monsters"
+      Turnip::StepDefinition.find("there are 23 monsters").expression.should eq("there are :count monsters")
+    end
+
+    it "respects the for option" do
+      Turnip::StepDefinition.add "alignment", :for => [:evil]
+      Turnip::StepDefinition.add "alignment", :for => [:good]
+      Turnip::StepDefinition.find("alignment", :evil => true, :bad => true).options[:for].should == [:evil]
+    end
+
+    it "raises an error if the match is ambiguous" do
+      Turnip::StepDefinition.add "there are :count monsters"
+      Turnip::StepDefinition.add "there are 23 monsters"
+      expect { Turnip::StepDefinition.find("there are 23 monsters") }.to raise_error(Turnip::StepDefinition::Ambiguous)
+    end
+
+    it "raises an error if there is no match" do
+      expect { Turnip::StepDefinition.find("there are 23 monsters") }.to raise_error(Turnip::StepDefinition::Pending)
+    end
+  end
+
+  describe ".execute" do
+    it "executes a step in the given context" do
+      context = stub(:example => stub(:metadata => {}))
+      Turnip::StepDefinition.add("there are :count monsters") { @testing = 123 }
+      Turnip::StepDefinition.execute(context, stub(:description => "there are 23 monsters", :extra_arg => nil))
+      context.instance_variable_get(:@testing).should == 123
+    end
+
+    it "tells the context that the step is pending" do
+      context = stub(:example => stub(:metadata => {}))
+      context.should_receive(:pending).with("the step 'there are 23 monsters' is not implemented")
+      Turnip::StepDefinition.execute(context, stub(:description => "there are 23 monsters", :extra_arg => nil))
+    end
+
+    it "sends along arguments" do
+      context = stub(:example => stub(:metadata => {}))
+      Turnip::StepDefinition.add("there are :count monsters") { |count| @testing = count.to_i }
+      Turnip::StepDefinition.execute(context, stub(:description => "there are 23 monsters", :extra_arg => nil))
+      context.instance_variable_get(:@testing).should == 23
+    end
+
+    it "sends along extra arguments" do
+      context = stub(:example => stub(:metadata => {}))
+      Turnip::StepDefinition.add("there are :count monsters") { |count, extra| @testing = extra }
+      Turnip::StepDefinition.execute(context, stub(:description => "there are 23 monsters", :extra_arg => 'foo'))
+      context.instance_variable_get(:@testing).should == 'foo'
+    end
+  end
+
+  describe "#match" do
+    it "matches a simple step" do
+      step = Turnip::StepDefinition.new("there are monsters") {}
+      step.should match("there are monsters")
+      step.should_not match("there are monsters around")
+      step.should_not match("there are people")
+    end
+
+    it "matches placeholders" do
+      Turnip::Placeholder.stub(:resolve).with(:count).and_return(/\d+/)
+      step = Turnip::StepDefinition.new("there are :count monsters") {}
+      step.should match("there are 4 monsters")
+      step.should match("there are 324 monsters")
+      step.should_not match("there are no monsters")
+    end
+
+    it "matches alternative words" do
+      step = Turnip::StepDefinition.new("there is/are monsters") {}
+      step.should match("there are monsters")
+      step.should match("there is monsters")
+      step.should_not match("there be monsters")
+    end
+
+    it "matches several alternative words" do
+      step = Turnip::StepDefinition.new("monsters are cool/nice/scary") {}
+      step.should match("monsters are cool")
+      step.should match("monsters are nice")
+      step.should match("monsters are scary")
+      step.should_not match("monsters are sexy")
+    end
+
+    it "matches optional parts of words" do
+      step = Turnip::StepDefinition.new("there is/are X monster(s)") {}
+      step.should match("there is X monster")
+      step.should_not match("there is X monsterQ")
+    end
+
+    it "matches optional words" do
+      step = Turnip::StepDefinition.new("there is a (scary) monster") {}
+      step.should match("there is a monster")
+      step.should match("there is a scary monster")
+      step.should_not match("there is a terrifying monster")
+
+      step = Turnip::StepDefinition.new("there is a monster (that is scary)") {}
+      step.should match("there is a monster that is scary")
+      step.should match("there is a monster")
+
+      step = Turnip::StepDefinition.new("(there is) a monster") {}
+      step.should match("there is a monster")
+      step.should match("a monster")
+    end
+  end
+end
+

data/spec/table_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe Turnip::Table do
+  describe '#raw' do
+    it 'returns the raw table' do
+      table = Turnip::Table.new([['foo', 'bar'], ['quox', '42']])
+      table.raw.should == [['foo', 'bar'], ['quox', '42']]
+    end
+  end
+
+  describe '#to_a' do
+    it 'returns the raw table' do
+      table = Turnip::Table.new([['foo', 'bar'], ['quox', '42']])
+      table.to_a.should == [['foo', 'bar'], ['quox', '42']]
+    end
+  end
+
+  describe '#headers' do
+    it 'returns the first row' do
+      table = Turnip::Table.new([['foo', 'bar'], ['quox', '42']])
+      table.headers.should == ['foo', 'bar']
+    end
+  end
+
+  describe '#rows' do
+    it 'returns the rows beyond the first' do
+      table = Turnip::Table.new([['foo', 'bar'], ['moo', '55'], ['quox', '42']])
+      table.rows.should == [['moo', '55'], ['quox', '42']]
+    end
+  end
+
+  describe '#hashes' do
+    it 'returns a list of hashe based on the headers' do
+      table = Turnip::Table.new([['foo', 'bar'], ['moo', '55'], ['quox', '42']])
+      table.hashes.should == [
+        {'foo' => 'moo', 'bar' => '55'},
+        {'foo' => 'quox', 'bar' => '42'}
+      ]
+    end
+  end
+
+  describe '#map' do
+    it 'iterates over the raw table' do
+      table = Turnip::Table.new([['moo', '55'], ['quox', '42']])
+      table.map(&:first).should == ['moo', 'quox']
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: turnip
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-10-25 00:00:00.000000000Z
+date: 2011-11-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &2153850520 !ruby/object:Gem::Requirement
+  requirement: &2152642360 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: '2.0'
   type: :runtime
   prerelease: false
-  version_requirements: *2153850520
+  version_requirements: *2152642360
 - !ruby/object:Gem::Dependency
   name: gherkin
-  requirement: &2153850100 !ruby/object:Gem::Requirement
+  requirement: &2152641940 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,7 +32,7 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *2153850100
+  version_requirements: *2152641940
 description: Provides the ability to define steps and run Gherkin files from with
   RSpec
 email:
@@ -46,24 +46,34 @@ files:
 - Gemfile
 - README.md
 - Rakefile
+- examples/ambiguous.feature
+- examples/backgrounds.feature
+- examples/interpolation.feature
+- examples/multiline_string.feature
+- examples/pending.feature
+- examples/scenario_outline.feature
+- examples/simple_feature.feature
+- examples/steps.rb
+- examples/steps_for.feature
+- examples/table.feature
+- examples/tags.feature
+- examples/with_comments.feature
 - lib/turnip.rb
 - lib/turnip/builder.rb
 - lib/turnip/capybara.rb
 - lib/turnip/dsl.rb
 - lib/turnip/loader.rb
 - lib/turnip/placeholder.rb
-- lib/turnip/rspec.rb
-- lib/turnip/run.rb
 - lib/turnip/step_definition.rb
+- lib/turnip/table.rb
 - lib/turnip/version.rb
-- spec/fixture/ambiguous.feature
-- spec/fixture/backgrounds.feature
-- spec/fixture/interpolation.feature
-- spec/fixture/pending.feature
-- spec/fixture/simple_feature.feature
-- spec/fixture/tags.feature
+- spec/builder_spec.rb
+- spec/dsl_spec.rb
+- spec/integration_spec.rb
 - spec/placeholder_spec.rb
 - spec/spec_helper.rb
+- spec/step_definition_spec.rb
+- spec/table_spec.rb
 - turnip.gemspec
 homepage: ''
 licenses: []
@@ -85,16 +95,15 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: turnip
-rubygems_version: 1.8.6
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: Gherkin extension for RSpec
 test_files:
-- spec/fixture/ambiguous.feature
-- spec/fixture/backgrounds.feature
-- spec/fixture/interpolation.feature
-- spec/fixture/pending.feature
-- spec/fixture/simple_feature.feature
-- spec/fixture/tags.feature
+- spec/builder_spec.rb
+- spec/dsl_spec.rb
+- spec/integration_spec.rb
 - spec/placeholder_spec.rb
 - spec/spec_helper.rb
+- spec/step_definition_spec.rb
+- spec/table_spec.rb

data/lib/turnip/rspec.rb

@@ -1,5 +0,0 @@
-RSpec::Core::Configuration.send(:include, Turnip::Loader)
-
-RSpec.configure do |config|
-  config.pattern << ",**/*.feature"
-end

data/lib/turnip/run.rb

@@ -1,27 +0,0 @@
-module Turnip
-  def self.run(content)
-    builder = Turnip::Builder.new
-    formatter = Gherkin::Formatter::TagCountFormatter.new(builder, {})
-    parser = Gherkin::Parser::Parser.new(formatter, true, "root", false)
-    parser.parse(content, nil, 0)
-
-    builder.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.name)
-            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.name)
-            end
-          end
-        end
-      end
-    end
-  end
-end