turnip 0.1.0 → 0.1.1

data/README.md

@@ -1,10 +1,15 @@
 # Turnip
 
-Turnip is a [Gherkin](https://github.com/cucumber/cucumber/wiki/Gherkin) 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.
+Turnip is a [Gherkin](https://github.com/cucumber/cucumber/wiki/Gherkin)
+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 NO TESTS, and there is a lot of cucumber's syntax it does NOT support. There are currently no tables, multiline string or scenario outlines.
+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
 
@@ -22,12 +27,17 @@ group :test do
 end
 ```
 
-Now edit the `.rspec` file in your project directory (create it if doesn't exist), and add the following line:
+Now edit the `.rspec` file in your project directory (create it if doesn't
+exist), and add the following line:
 
 ```
 -r turnip
 ```
 
+## Compatibility
+
+Turnip does not work on Ruby 1.8.X.
+
 ## Usage
 
 Add a feature file anywhere in your `spec` directory:
@@ -49,13 +59,16 @@ Now you can run it just like you would run any other rspec spec:
 rspec spec/acceptance/attack_monster.feature
 ```
 
-It will automatically be run if you run all your specs with `rake spec` or `rspec spec`.
+It will automatically be run if you run all your specs with `rake spec` or
+`rspec spec`.
 
 Yes, that's really it.
 
 ## Defining steps
 
-You might want to define some steps. You can put them anywhere. Turnip automatically requires your `spec_helper`, so you can add them there or put them in separate files (recommended). Define them like this:
+You might want to define some steps. You can put them anywhere. Turnip
+automatically requires your `spec_helper`, so you can add them there or put
+them in separate files (recommended). Define them like this:
 
 ``` ruby
 step "there is a monster" do
@@ -64,3 +77,94 @@ end
 ```
 
 Note that unlike Cucumber, Turnip does not support regexps in step definitions.
+You can however use placeholders in your step definitions, like this:
+
+``` ruby
+step "there is a monster called :name" do |name|
+  @monster = Monster.new(name)
+end
+```
+
+You can now put values in this placeholder, either quoted or not:
+
+``` cucumber
+Given there is a monster called Jonas
+And there is a monster called "Jonas Nicklas"
+```
+
+## Defining placeholders
+
+But what if you want to be more specific in what to match in those
+placeholders, and it is bothersome to have to constantly cast them to the
+correct type. Turnip's placeholder solve both problems, like this:
+
+``` ruby
+step "there are :count monsters" do |count|
+  count.times { Monster.new(name) }
+end
+
+placeholder :count do
+  match /\d+/ do |count|
+    count.to_i
+  end
+
+  match /no/ do
+    0
+  end
+end
+```
+
+You would now be able to use these steps like this:
+
+``` cucumber
+Given there are 4 monsters
+Given there are no monsters
+```
+
+Placeholders can extract matches from the regular expressions as well. For
+example:
+
+``` ruby
+placeholder :monster do
+  match /(blue|green|red) (furry|bald) monster/ do |color, hair|
+    Monster.new(color, hair)
+  end
+end
+```
+
+These regular expressions must not use anchors, e.g. `^` or `$`. They may not
+contain named capture groups, e.g. `(?<color>blue|green)`.
+
+## Using with Capybara
+
+Just require `turnip/capybara`, either in your `spec_helper` or by
+adding `-r turnip/capybara` to your `.rspec` file. You can now use the
+same tags you'd use in Cucumber to switch between drivers e.g.
+`@javascript` or `@selenium`. Your Turnip features will also be run
+with the `:type => :request` metadata, so that Capybara is included and
+also any other extensions you might want to add.
+
+## License
+
+(The MIT License)
+
+Copyright (c) 2011 Jonas Nicklas
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/turnip.rb

@@ -5,6 +5,15 @@ require "turnip/version"
 require "turnip/loader"
 require "turnip/builder"
 require "turnip/run"
-require "turnip/steps"
+require "turnip/step_definition"
+require "turnip/placeholder"
 require "turnip/dsl"
 require "turnip/rspec"
+
+module Turnip
+  class << self
+    attr_accessor :type
+  end
+end
+
+Turnip.type = :turnip

data/lib/turnip/builder.rb

@@ -1,61 +1,70 @@
 module Turnip
-  class Feature
-    attr_reader :scenarios, :backgrounds
-    def initialize(raw)
-      @raw = raw
-      @scenarios = []
-      @backgrounds = []
-    end
+  class Builder
+    module Tags
+      def tags
+        @raw.tags.map { |tag| tag.name.sub(/^@/, '') }
+      end
 
-    def name
-      @raw.name
-    end
-  end
+      def tags_hash
+        Hash[tags.map { |t| [t.to_sym, true] }]
+      end
 
-  class Background
-    attr_reader :steps
-    def initialize(raw)
-      @raw = raw
-      @steps = []
+      def metadata_hash
+        tags_hash
+      end
     end
-  end
 
-  class Scenario
-    attr_reader :name, :steps
-    def initialize(raw)
-      @raw = raw
-      @steps = []
+    module Name
+      def name
+        @raw.name
+      end
     end
 
-    def name
-      @raw.name
-    end
+    class Feature
+      include Tags
+      include Name
 
-    def tags
-      @raw.tags.map { |tag| tag.name.sub(/^@/, '').to_sym }
-    end
+      attr_reader :scenarios, :backgrounds
 
-    def tags_hash
-      Hash[tags.map { |t| [t, true] }]
+      def initialize(raw)
+        @raw = raw
+        @scenarios = []
+        @backgrounds = []
+      end
+
+      def metadata_hash
+        super.merge(:type => Turnip.type, :turnip => true)
+      end
     end
 
-    def metadata_hash
-      tags_hash
+    class Background
+      attr_reader :steps
+      def initialize(raw)
+        @raw = raw
+        @steps = []
+      end
     end
-  end
 
-  class Step
-    attr_reader :name
-    def initialize(raw)
-      @raw = raw
+    class Scenario
+      include Tags
+      include Name
+
+      attr_reader :steps
+
+      def initialize(raw)
+        @raw = raw
+        @steps = []
+      end
     end
 
-    def name
-      @raw.name
+    class Step
+      include Name
+
+      def initialize(raw)
+        @raw = raw
+      end
     end
-  end
 
-  class Builder
     attr_reader :features
 
     def initialize
@@ -63,22 +72,22 @@ module Turnip
     end
 
     def background(background)
-      @current_step_context = Turnip::Background.new(background)
+      @current_step_context = Background.new(background)
       @current_feature.backgrounds << @current_step_context
     end
 
     def feature(feature)
-      @current_feature = Turnip::Feature.new(feature)
+      @current_feature = Feature.new(feature)
       @features << @current_feature
     end
 
     def scenario(scenario)
-      @current_step_context = Turnip::Scenario.new(scenario)
+      @current_step_context = Scenario.new(scenario)
       @current_feature.scenarios << @current_step_context
     end
 
     def step(step)
-      @current_step = Turnip::Step.new(step)
+      @current_step = Step.new(step)
       @current_step_context.steps << @current_step
     end
 

data/lib/turnip/capybara.rb

@@ -0,0 +1,16 @@
+require 'capybara/rspec'
+
+Turnip.type = :request
+
+RSpec.configure do |config|
+  config.before do
+    if self.class.include?(Capybara::DSL) and example.metadata[:turnip]
+      Capybara.current_driver = Capybara.javascript_driver if example.metadata.has_key?(:javascript)
+      example.metadata.each do |tag, value|
+        if Capybara.drivers.has_key?(tag)
+          Capybara.current_driver = tag
+        end
+      end
+    end
+  end
+end

data/lib/turnip/dsl.rb

@@ -1,10 +1,13 @@
 module Turnip
   module DSL
     def step(description, &block)
-      Turnip::Steps.add_step(description, &block)
+      Turnip::StepDefinition.add(description, &block)
+    end
+
+    def placeholder(name, &block)
+      Turnip::Placeholder.add(name, &block)
     end
   end
 end
 
 self.extend Turnip::DSL
-

data/lib/turnip/placeholder.rb

@@ -0,0 +1,66 @@
+module Turnip
+  class Placeholder
+    class Match < Struct.new(:regexp, :block);end
+
+    class << self
+      def add(name, &block)
+        placeholders[name] = Placeholder.new(name, &block)
+      end
+
+      def resolve(name)
+        find(name).regexp
+      end
+
+      def apply(name, value)
+        find(name).apply(value)
+      end
+
+      def find(name)
+        placeholders[name] or default
+      end
+
+    private
+
+      def placeholders
+        @placeholders ||= {}
+      end
+
+      def default
+        @default ||= new(:default) do
+          match %r((?:"([^"]+)"|([a-zA-Z0-9_-]+))) do |first, second|
+            first or second
+          end
+        end
+      end
+    end
+
+    def initialize(name, &block)
+      @name = name
+      @matches = []
+      instance_eval(&block)
+    end
+
+    def apply(value)
+      match, params = find_match(value)
+      if match and match.block then match.block.call(*params) else value end
+    end
+
+    def match(regexp, &block)
+      @matches << Match.new(regexp, block)
+    end
+
+    def regexp
+      Regexp.new(@matches.map(&:regexp).join('|'))
+    end
+
+  private
+
+    def find_match(value)
+      @matches.each do |m|
+        result = value.scan(m.regexp)
+        return m, result.flatten unless result.empty?
+      end
+      nil
+    end
+  end
+end

data/lib/turnip/run.rb

@@ -6,18 +6,18 @@ module Turnip
     parser.parse(content, nil, 0)
 
     builder.features.each do |feature|
-      describe feature.name do
+      describe feature.name, feature.metadata_hash do
         feature.backgrounds.each do |background|
           before do
             background.steps.each do |step|
-              Turnip::Steps.execute_step(self, step.name)
+              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::Steps.execute_step(self, step.name)
+              Turnip::StepDefinition.execute(self, step.name)
             end
           end
         end

data/lib/turnip/step_definition.rb

@@ -0,0 +1,65 @@
+module Turnip
+  class StepDefinition
+    class Match < Struct.new(:params, :block); end
+    class Pending < StandardError; end
+    class Ambiguous < StandardError; end
+
+    attr_reader :expression, :block
+
+    class << self
+      def execute(context, description)
+        match = find(description)
+        context.instance_exec(*match.params, &match.block)
+      rescue Pending
+        context.pending "the step '#{description}' is not implemented"
+      end
+
+      def add(expression, &block)
+        steps << StepDefinition.new(expression, &block)
+      end
+
+      def find(description)
+        found = 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 steps
+        @steps ||= []
+      end
+    end
+
+    def initialize(expression, &block)
+      @expression = expression
+      @block = block
+    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])
+        end
+        Match.new(params, block)
+      end
+    end
+
+  protected
+
+    def compile_regexp
+      regexp = Regexp.escape(expression)
+      regexp = expression.gsub(/:([\w]+)/) do |_|
+        "(?<#{$1}>#{Placeholder.resolve($1.to_sym)})"
+      end
+      Regexp.new("^#{regexp}$")
+    end
+  end
+end

data/lib/turnip/version.rb

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

data/spec/fixture/interpolation.feature

@@ -0,0 +1,12 @@
+Feature: A simple feature
+  Scenario: Interpolation with quotes
+    Given there is a monster called "John Smith"
+    Then it should be called "John Smith"
+
+  Scenario: Interpolation without quotes
+    Given there is a monster called John
+    Then it should be called "John"
+
+  Scenario: Interpolation with customer regexp
+    Given there are 3 monkeys with blue hair
+    Then there should be 3 monkeys with blue hair

data/spec/placeholder_spec.rb

@@ -0,0 +1,67 @@
+require 'turnip/placeholder'
+
+describe Turnip::Placeholder do
+  def anchor(exp)
+    Regexp.new("^#{exp}$")
+  end
+
+  describe ".resolve" do
+    it "returns a regexp for the given placeholder" do
+      placeholder = Turnip::Placeholder.add(:test) { match(/foo/); match(/\d/) }
+      resolved = Turnip::Placeholder.resolve(:test)
+      "foo".should =~ anchor(resolved)
+      "5".should =~ anchor(resolved)
+      "bar".should_not =~ anchor(resolved)
+    end
+
+    it "fall through to using the standard placeholder regexp" do
+      resolved = Turnip::Placeholder.resolve(:does_not_exist)
+      "foo".should =~ anchor(resolved)
+      '"this is a test"'.should =~ anchor(resolved)
+      "foo bar".should_not =~ anchor(resolved)
+    end
+  end
+
+  describe ".apply" do
+    it "returns a regexp for the given placeholder" do
+      placeholder = Turnip::Placeholder.add(:test) do
+        match(/foo/) { :foo_bar }
+        match(/\d/) { |num| num.to_i }
+      end
+      Turnip::Placeholder.apply(:test, "foo").should eq(:foo_bar)
+      Turnip::Placeholder.apply(:test, "5").should eq(5)
+      Turnip::Placeholder.apply(:test, "bar").should eq("bar")
+    end
+
+    it "extracts any captured expressions and passes them to the block" do
+      placeholder = Turnip::Placeholder.add(:test) do
+        match(/mo(nk)(ey)/) { |nk, ey| nk.to_s.reverse + '|' + ey.to_s.upcase }
+      end
+      Turnip::Placeholder.apply(:test, "monkey").should eq('kn|EY')
+      Turnip::Placeholder.apply(:test, "bar").should eq("bar")
+    end
+  end
+
+  describe "#regexp" do
+    it "should match a given fragment" do
+      placeholder = Turnip::Placeholder.new(:test) { match(/foo/) }
+      "foo".should =~ placeholder.regexp
+    end
+
+    it "should match multiple fragments" do
+      placeholder = Turnip::Placeholder.new(:test) { match(/foo/); match(/\d/) }
+      "foo".should =~ placeholder.regexp
+      "5".should =~ placeholder.regexp
+    end
+
+    it "should not match an incorrect fragment" do
+      placeholder = Turnip::Placeholder.new(:test) { match(/foo/) }
+      "bar".should_not =~ placeholder.regexp
+    end
+
+    it "should not multiple incorrect fragments" do
+      placeholder = Turnip::Placeholder.new(:test) { match(/foo/); match(/\d/) }
+      "bar".should_not =~ placeholder.regexp
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -19,3 +19,35 @@ 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
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: turnip
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-10-21 00:00:00.000000000Z
+date: 2011-10-25 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &2153440840 !ruby/object:Gem::Requirement
+  requirement: &2153850520 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: '2.0'
   type: :runtime
   prerelease: false
-  version_requirements: *2153440840
+  version_requirements: *2153850520
 - !ruby/object:Gem::Dependency
   name: gherkin
-  requirement: &2153440340 !ruby/object:Gem::Requirement
+  requirement: &2153850100 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,7 +32,7 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *2153440340
+  version_requirements: *2153850100
 description: Provides the ability to define steps and run Gherkin files from with
   RSpec
 email:
@@ -46,20 +46,23 @@ files:
 - Gemfile
 - README.md
 - Rakefile
-- lib/carrot.rb
 - 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/steps.rb
+- lib/turnip/step_definition.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/placeholder_spec.rb
 - spec/spec_helper.rb
 - turnip.gemspec
 homepage: ''
@@ -89,7 +92,9 @@ 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/placeholder_spec.rb
 - spec/spec_helper.rb

data/lib/carrot.rb

@@ -1,10 +0,0 @@
-require "gherkin"
-require "gherkin/formatter/tag_count_formatter"
-
-require "carrot/version"
-require "carrot/loader"
-require "carrot/builder"
-require "carrot/run"
-require "carrot/steps"
-require "carrot/dsl"
-require "carrot/rspec"

data/lib/turnip/steps.rb

@@ -1,31 +0,0 @@
-module Turnip
-  module Steps
-    class Pending < StandardError; end
-    class Ambiguous < StandardError; end
-
-    extend self
-
-    def execute_step(context, description)
-      context.instance_eval(&find_step(description))
-    rescue Pending
-      context.pending "the step '#{description}' is not implemented"
-    end
-
-    def add_step(description, &block)
-      steps << [description, block]
-    end
-
-    def find_step(description)
-      found = steps.select do |step|
-        step.first == description
-      end
-      raise Pending, description if found.length == 0
-      raise Ambiguous, description if found.length > 1
-      found[0][1]
-    end
-
-    def steps
-      @steps ||= []
-    end
-  end
-end