square-cucumber 0.3.12.2 → 0.3.93.1

data/rails_generators/cucumber/cucumber_generator.rb

@@ -20,7 +20,7 @@ class CucumberGenerator < Rails::Generator::Base
 
       m.directory 'features/support'
 
-      if options[:spork]
+      if spork?
         m.template  'spork_env.rb',     'features/support/env.rb'
       else
         m.template  'env.rb',           'features/support/env.rb'
@@ -40,6 +40,10 @@ class CucumberGenerator < Rails::Generator::Base
   def framework
     options[:framework] || :rspec
   end
+  
+  def spork?
+    options[:spork]
+  end
 
 protected
 

data/rails_generators/cucumber/templates/cucumber

@@ -3,6 +3,7 @@ begin
   load File.expand_path(File.dirname(__FILE__) + "/../vendor/plugins/cucumber/bin/cucumber")
 rescue LoadError => e
   raise unless e.to_s =~ /cucumber/  
-  require "rubygems"
-  load File.join(Gem.bindir, "cucumber")
+  require 'rubygems'
+  require 'cucumber'
+  load Cucumber::BINARY
 end

data/rails_generators/cucumber/templates/cucumber.rake

@@ -4,15 +4,27 @@ unless ARGV.any? {|a| a =~ /^gems/}
 
 begin
   require 'cucumber/rake/task'
+  namespace :cucumber do
+    Cucumber::Rake::Task.new({:ok => 'db:test:prepare'}, 'Run features that should pass (no @wip tag)') do |t|
+      t.fork = true # You may get faster startup if you set this to false
+      t.cucumber_opts = "--tags ~@wip --strict --format #{ENV['CUCUMBER_FORMAT'] || 'pretty'}<%= spork? ? ' --drb' : '' %>"
+    end
 
-  Cucumber::Rake::Task.new(:features) do |t|
-    t.fork = true
-    t.cucumber_opts = [<%= options[:spork] ? "'--drb', " : "" %>'--format', (ENV['CUCUMBER_FORMAT'] || 'pretty')]
+    Cucumber::Rake::Task.new({:wip => 'db:test:prepare'}, 'Run @wip features (not passing yet)') do |t|
+      t.fork = true # You may get faster startup if you set this to false
+      t.cucumber_opts = "--tags @wip --wip --format #{ENV['CUCUMBER_FORMAT'] || 'pretty'}<%= spork? ? ' --drb' : '' %>"
+    end
+
+    desc 'Run all features'
+    task :all => [:ok, :wip]
+  end
+
+  task :features => 'cucumber:ok' do
+    STDERR.puts "*** The 'features' task is deprecated. See rake -T cucumber ***"
   end
-  task :features => 'db:test:prepare'
 rescue LoadError
-  desc 'Cucumber rake task not available'
-  task :features do
+  desc 'cucumber rake task not available (cucumber not installed)'
+  task :cucumber do
     abort 'Cucumber rake task is not available. Be sure to install cucumber as a gem or plugin'
   end
 end

data/rails_generators/cucumber/templates/cucumber_environment.rb

@@ -15,9 +15,12 @@ config.action_controller.allow_forgery_protection    = false
 # ActionMailer::Base.deliveries array.
 config.action_mailer.delivery_method = :test
 
-config.gem "cucumber",    :lib => false,        :version => ">=<%= cucumber_version %>" unless File.directory?(File.join(Rails.root, 'vendor/plugins/cucumber'))
-config.gem "webrat",      :lib => false,        :version => ">=0.4.4" unless File.directory?(File.join(Rails.root, 'vendor/plugins/webrat'))
+config.gem 'cucumber',    :lib => false,        :version => '>=<%= cucumber_version %>' unless File.directory?(File.join(Rails.root, 'vendor/plugins/cucumber'))
+config.gem 'webrat',      :lib => false,        :version => '>=0.4.4' unless File.directory?(File.join(Rails.root, 'vendor/plugins/webrat'))
 <% if framework == :rspec -%>
-config.gem "rspec",       :lib => false,        :version => ">=1.2.6" unless File.directory?(File.join(Rails.root, 'vendor/plugins/rspec'))
-config.gem "rspec-rails", :lib => 'spec/rails', :version => ">=1.2.6" unless File.directory?(File.join(Rails.root, 'vendor/plugins/rspec-rails'))
+config.gem 'rspec',       :lib => false,        :version => '>=1.2.6' unless File.directory?(File.join(Rails.root, 'vendor/plugins/rspec'))
+config.gem 'rspec-rails', :lib => 'spec/rails', :version => '>=1.2.6' unless File.directory?(File.join(Rails.root, 'vendor/plugins/rspec-rails'))
+<% end %>
+<% if spork? -%>
+config.gem 'spork',       :lib => false,        :version => '>=0.5.7' unless File.directory?(File.join(Rails.root, 'vendor/plugins/spork'))
 <% end %>

data/rails_generators/cucumber/templates/env.rb

@@ -15,6 +15,7 @@ Cucumber::Rails.use_transactional_fixtures
 Cucumber::Rails.bypass_rescue
 
 require 'webrat'
+require 'cucumber/webrat/table_locator' # Lets you do table.diff!(table_at('#my_table').to_a)
 
 Webrat.configure do |config|
   config.mode = :rails

data/rails_generators/cucumber/templates/spork_env.rb

@@ -7,6 +7,7 @@ Spork.prefork do
   require File.expand_path(File.dirname(__FILE__) + '/../../config/environment')
  
   require 'webrat'
+  require 'cucumber/webrat/table_locator' # Lets you do table.diff!(table_at('#my_table').to_a)
  
   Webrat.configure do |config|
     config.mode = :rails

data/rails_generators/cucumber/templates/webrat_steps.rb

@@ -19,6 +19,10 @@ When /^I follow "([^\"]*)"$/ do |link|
   click_link(link)
 end
 
+When /^I follow "([^\"]*)" within "([^\"]*)"$/ do |link, parent|
+  click_link_within(parent, link)
+end
+
 When /^I fill in "([^\"]*)" with "([^\"]*)"$/ do |field, value|
   fill_in(field, :with => value) 
 end
@@ -98,6 +102,15 @@ Then /^I should see "([^\"]*)"$/ do |text|
 <% end -%>
 end
 
+Then /^I should see \/([^\/]*)\/$/ do |regexp|
+  regexp = Regexp.new(regexp)
+<% if framework == :rspec -%>
+  response.should contain(regexp)
+<% else -%>
+  assert_contain regexp
+<% end -%>
+end
+
 Then /^I should not see "([^\"]*)"$/ do |text|
 <% if framework == :rspec -%>
   response.should_not contain(text)
@@ -106,6 +119,15 @@ Then /^I should not see "([^\"]*)"$/ do |text|
 <% end -%>
 end
 
+Then /^I should not see \/([^\/]*)\/$/ do |regexp|
+  regexp = Regexp.new(regexp)
+<% if framework == :rspec -%>
+  response.should_not contain(regexp)
+<% else -%>
+  assert_not_contain regexp
+<% end -%>
+end
+
 Then /^the "([^\"]*)" field should contain "([^\"]*)"$/ do |field, value|
 <% if framework == :rspec -%>
   field_labeled(field).value.should =~ /#{value}/

data/rails_generators/feature/templates/feature.erb

@@ -25,7 +25,7 @@ Feature: Manage <%= plural_name %>
 <% end -%>
     When I delete the 3rd <%= singular_name %>
     Then I should see the following <%= plural_name %>:
-      |<%= named_args.map(&:name).join('|') %>|
+      |<%= named_args.map{|arg| arg.name.humanize}.join('|') %>|
 <% [1,2,4].each do |n| -%>
       |<%= named_args.map{|arg| arg.value(n)}.join('|') %>|
 <% end -%>

data/rails_generators/feature/templates/steps.erb

@@ -9,12 +9,6 @@ When /^I delete the (\d+)(?:st|nd|rd|th) <%= singular_name %>$/ do |pos|
   end
 end
 
-Then /^I should see the following <%= plural_name %>:$/ do |<%= plural_name %>|
-  <%= plural_name %>.rows.each_with_index do |row, i|
-    row.each_with_index do |cell, j|
-      response.should have_selector("table > tr:nth-child(#{i+2}) > td:nth-child(#{j+1})") { |td|
-        td.inner_text.should == cell
-      }
-    end
-  end
+Then /^I should see the following <%= plural_name %>:$/ do |expected_<%= plural_name %>_table|
+  expected_<%= plural_name %>_table.diff!(table_at('table').to_a)
 end

data/spec/cucumber/ast/table_spec.rb

@@ -1,3 +1,4 @@
+# encoding: utf-8
 require File.dirname(__FILE__) + '/../../spec_helper'
 require 'cucumber/ast/table'
 
@@ -100,6 +101,11 @@ module Cucumber
         table2.hashes.first[:three].should == '4444'
       end
 
+      it "should allow renaming columns using regexp" do
+        table2 = @table.map_headers(/one|uno/ => :three)
+        table2.hashes.first[:three].should == '4444'
+      end
+
       it "should copy column mappings when mapping headers" do
         @table.map_column!('one') { |v| v.to_i }
         table2 = @table.map_headers('one' => 'three')
@@ -168,6 +174,169 @@ module Cucumber
 
       end
       
+      describe "diff!" do
+        it "should detect a complex diff" do
+          t1 = table(%{
+            | 1         | 22          | 333         | 4444         |
+            | 55555     | 666666      | 7777777     | 88888888     |
+            | 999999999 | 0000000000  | 01010101010 | 121212121212 |
+            | 4000      | ABC         | DEF         | 50000        |
+          })
+          
+          t2 = table(%{
+            | a     | 4444     | 1         | 
+            | bb    | 88888888 | 55555     | 
+            | ccc   | xxxxxxxx | 999999999 | 
+            | dddd  | 4000     | 300       |
+            | e     | 50000    | 4000      |
+          })
+          lambda{t1.diff!(t2)}.should raise_error
+          t1.to_s(:indent => 12, :color => false).should == %{
+            |     1         | (-) 22         | (-) 333         |     4444         | (+) a    |
+            |     55555     | (-) 666666     | (-) 7777777     |     88888888     | (+) bb   |
+            | (-) 999999999 | (-) 0000000000 | (-) 01010101010 | (-) 121212121212 | (+)      |
+            | (+) 999999999 | (+)            | (+)             | (+) xxxxxxxx     | (+) ccc  |
+            | (+) 300       | (+)            | (+)             | (+) 4000         | (+) dddd |
+            |     4000      | (-) ABC        | (-) DEF         |     50000        | (+) e    |
+          }
+        end
+
+        it "should not change table when diffed with identical" do
+          t = table(%{
+            |a|b|c|
+            |d|e|f|
+            |g|h|i|
+          })
+          t.diff!(t.dup)
+          t.to_s(:indent => 12, :color => false).should == %{
+            |     a |     b |     c |
+            |     d |     e |     f |
+            |     g |     h |     i |
+          }
+        end
+
+        it "should inspect missing and surplus cells" do
+          t1 = Table.new([
+            ['name',  'male', 'lastname', 'swedish'],
+            ['aslak', 'true', 'hellesøy', 'false']
+          ])
+          t2 = Table.new([
+            ['name',  'male', 'lastname', 'swedish'],
+            ['aslak', true,   'hellesøy', false]
+          ])
+          lambda{t1.diff!(t2)}.should raise_error
+          t1.to_s(:indent => 12, :color => false).should == %{
+            |     name  |     male       |     lastname |     swedish     |
+            | (-) aslak | (-) (i) "true" | (-) hellesøy | (-) (i) "false" |
+            | (+) aslak | (+) (i) true   | (+) hellesøy | (+) (i) false   |
+          }
+        end
+
+        it "should allow column mapping of target before diffing" do
+          t1 = Table.new([
+            ['name',  'male'],
+            ['aslak', 'true']
+          ])
+          t1.map_column!('male') { |m| m == 'true' }
+          t2 = Table.new([
+            ['name',  'male'],
+            ['aslak', true]
+          ])
+          t1.diff!(t2)
+          t1.to_s(:indent => 12, :color => false).should == %{
+            |     name  |     male |
+            |     aslak |     true |
+          }
+        end
+
+        it "should allow column mapping of argument before diffing" do
+          t1 = Table.new([
+            ['name',  'male'],
+            ['aslak', true]
+          ])
+          t1.map_column!('male') { 
+            'true'
+          }
+          t2 = Table.new([
+            ['name',  'male'],
+            ['aslak', 'true']
+          ])
+          t2.diff!(t1)
+          t1.to_s(:indent => 12, :color => false).should == %{
+            |     name  |     male |
+            |     aslak |     true |
+          }
+        end
+
+        it "should allow header mapping before diffing" do
+          t1 = Table.new([
+            ['Name',  'Male'],
+            ['aslak', 'true']
+          ])
+          t1.map_headers!('Name' => 'name', 'Male' => 'male')
+          t1.map_column!('male') { |m| m == 'true' }
+          t2 = Table.new([
+            ['name',  'male'],
+            ['aslak', true]
+          ])
+          t1.diff!(t2)
+          t1.to_s(:indent => 12, :color => false).should == %{
+            |     name  |     male |
+            |     aslak |     true |
+          }
+        end
+        
+        describe "raising" do
+          before do
+            @t = table(%{
+              | a | b |
+              | c | d |
+            })
+          end
+          
+          it "should raise on missing rows" do
+            t = table(%{
+              | a | b |
+            })
+            lambda { @t.dup.diff!(t) }.should raise_error
+            lambda { @t.dup.diff!(t, :missing_row => false) }.should_not raise_error
+          end
+
+          it "should raise on surplus rows" do
+            t = table(%{
+              | a | b |
+              | c | d |
+              | e | f |
+            })
+            lambda { @t.dup.diff!(t) }.should raise_error
+            lambda { @t.dup.diff!(t, :surplus_row => false) }.should_not raise_error
+          end
+
+          it "should raise on missing columns" do
+            t = table(%{
+              | a |
+              | c |
+            })
+            lambda { @t.dup.diff!(t) }.should raise_error
+            lambda { @t.dup.diff!(t, :missing_col => false) }.should_not raise_error
+          end
+
+          it "should not raise on surplus columns" do
+            t = table(%{
+              | a | b | x |
+              | c | d | y |
+            })
+            lambda { @t.dup.diff!(t) }.should_not raise_error
+            lambda { @t.dup.diff!(t, :surplus_col => true) }.should raise_error
+          end
+        end
+
+        def table(text, file=nil, line_offset=0)
+          @table_parser ||= Parser::TableParser.new
+          @table_parser.parse_or_fail(text.strip, file, line_offset)
+        end
+      end
+      
       it "should convert to sexp" do
         @table.to_sexp.should == 
           [:table, 

data/spec/cucumber/cli/configuration_spec.rb

@@ -17,13 +17,25 @@ module Cli
     end
 
     before(:each) do
+      #given_cucumber_yml_defined_as({'default' => '-q'})
+      File.stub!(:exist?).and_return(false) # Meaning, no cucumber.yml exists
       Kernel.stub!(:exit).and_return(nil)
     end
 
+    def config
+      @config ||= Configuration.new(@out = StringIO.new, @error = StringIO.new)
+    end
+
+    def reset_config
+      @config = nil
+    end
+
+    attr_reader :out, :error
+
+
     it "should require files in support paths first" do
       given_the_following_files("/features/step_definitions/foo.rb","/features/support/bar.rb")
 
-      config = Configuration.new(StringIO.new)
       config.parse!(%w{--require /features})
 
       config.files_to_require.should == [
@@ -35,7 +47,6 @@ module Cli
     it "should require env.rb files first" do
       given_the_following_files("/features/support/a_file.rb","/features/support/env.rb")
 
-      config = Configuration.new(StringIO.new)
       config.parse!(%w{--require /features})
 
       config.files_to_require.should == [
@@ -47,7 +58,6 @@ module Cli
     it "should not require env.rb files when --dry-run" do
       given_the_following_files("/features/support/a_file.rb","/features/support/env.rb")
 
-      config = Configuration.new(StringIO.new)
       config.parse!(%w{--require /features --dry-run})
 
       config.files_to_require.should == [
@@ -55,12 +65,23 @@ module Cli
       ]
     end
 
+    it "should require files in vendor/{plugins,gems}/*/cucumber/*.rb" do
+      given_the_following_files("/vendor/plugins/plugin_a/cucumber/foo.rb",
+                                "/vendor/gems/gem_a/cucumber/bar.rb")
+
+      config.parse!(%w{--require /features})
+
+      config.files_to_require.should == [
+        "/vendor/plugins/plugin_a/cucumber/foo.rb",
+        "/vendor/gems/gem_a/cucumber/bar.rb"
+      ]
+    end
+
     describe "--exclude" do
 
       it "excludes a ruby file from requiring when the name matches exactly" do
         given_the_following_files("/features/support/a_file.rb","/features/support/env.rb")
 
-        config = Configuration.new(StringIO.new)
         config.parse!(%w{--require /features --exclude a_file.rb})
 
         config.files_to_require.should == [
@@ -73,7 +94,6 @@ module Cli
                                   "/features/support/food.rb","/features/blah.rb",
                                   "/features/support/fooz.rb")
 
-        config = Configuration.new(StringIO.new)
         config.parse!(%w{--require /features --exclude foo[df] --exclude blah})
 
         config.files_to_require.should == [
@@ -85,29 +105,23 @@ module Cli
 
     describe '#drb?' do
       it "indicates whether the --drb flag was passed in or not" do
-        config = Configuration.new(StringIO.new)
-
         config.parse!(%w{features})
-        config.drb?.should == false
+        config.should_not be_drb
 
 
         config.parse!(%w{features --drb})
-        config.drb?.should == true
+        config.should be_drb
       end
     end
 
     context '--drb' do
       it "removes the --drb flag from the args" do
-        config = Configuration.new(StringIO.new)
-
         args = %w{features --drb}
         config.parse!(args)
         args.should == %w{features}
       end
 
       it "keeps all other flags intact" do
-        config = Configuration.new(StringIO.new)
-
         args = %w{features --drb --format profile}
         config.parse!(args)
         args.should == %w{features --format profile}
@@ -118,7 +132,6 @@ module Cli
     context '--drb in a profile' do
       it "removes the --drb flag from the args" do
         given_cucumber_yml_defined_as({'server' => '--drb features'})
-        config = Configuration.new(StringIO.new)
 
         args = %w{--profile server}
         config.parse!(args)
@@ -129,11 +142,9 @@ module Cli
         given_cucumber_yml_defined_as({'server' => '--drb features --profile nested',
                                        'nested' => '--verbose'})
 
-        config = Configuration.new(StringIO.new)
-
         args = %w{--profile server --format profile}
         config.parse!(args)
-        args.should == %w{features --verbose --format profile}
+        args.should == %w{--format profile features --verbose}
       end
 
     end
@@ -141,35 +152,40 @@ module Cli
     context '--drb in the default profile and no arguments specified' do
       it "expands the profile's arguments into the args excpet for --drb" do
         given_cucumber_yml_defined_as({'default' => '--drb features --format pretty'})
-        config = Configuration.new(StringIO.new)
         args = []
         config.parse!(args)
         args.should == %w{features --format pretty}
       end
     end
 
-    it "should expand args from YAML file" do
-      given_cucumber_yml_defined_as({'bongo' => '--require from/yml'})
+    it "uses the default profile when no profile is defined" do
+      given_cucumber_yml_defined_as({'default' => '--require some_file'})
 
-      config = Configuration.new
-      config.parse!(%w{--format progress --profile bongo})
-      config.options[:formats].should == [['progress', STDOUT]]
-      config.options[:require].should == ['from/yml']
+      config.parse!(%w{--format progress})
+      config.options[:require].should include('some_file')
     end
 
-    it "should expand args from YAML file's default if there are no args" do
-      given_cucumber_yml_defined_as({'default' => '--require from/yml'})
+    context '--profile' do
 
-      config = Configuration.new
-      config.parse!([])
-      config.options[:require].should == ['from/yml']
-    end
+      it "expands args from profiles in the cucumber.yml file" do
+        given_cucumber_yml_defined_as({'bongo' => '--require from/yml'})
+
+        config.parse!(%w{--format progress --profile bongo})
+        config.options[:formats].should == [['progress', out]]
+        config.options[:require].should == ['from/yml']
+      end
 
-    it "should provide a helpful error message when a specified profile does not exists in YAML file" do
-      given_cucumber_yml_defined_as({'default' => '--require from/yml', 'html_report' =>  '--format html'})
+      it "expands args from the default profile when no flags are provided" do
+        given_cucumber_yml_defined_as({'default' => '--require from/yml'})
+
+        config.parse!([])
+        config.options[:require].should == ['from/yml']
+      end
 
-      config = Configuration.new(StringIO.new, error = StringIO.new)
-      expected_message = <<-END_OF_MESSAGE
+      it "provides a helpful error message when a specified profile does not exists in cucumber.yml" do
+        given_cucumber_yml_defined_as({'default' => '--require from/yml', 'html_report' =>  '--format html'})
+
+        expected_message = <<-END_OF_MESSAGE
 Could not find profile: 'i_do_not_exist'
 
 Defined profiles in cucumber.yml:
@@ -177,141 +193,175 @@ Defined profiles in cucumber.yml:
   * html_report
 END_OF_MESSAGE
 
-      lambda{config.parse!(%w{--profile i_do_not_exist})}.should raise_error(expected_message)
-    end
+        lambda{config.parse!(%w{--profile i_do_not_exist})}.should raise_error(ProfileNotFound, expected_message)
+      end
 
-    it "should allow array as profile" do
-      given_cucumber_yml_defined_as({'foo' => [1,2,3]})
+      it "allows profiles to be defined in arrays" do
+        given_cucumber_yml_defined_as({'foo' => [1,2,3]})
 
-      config = Configuration.new(StringIO.new, error = StringIO.new)
-      config.parse!(%w{--profile foo})
-      config.paths.should == [1,2,3]
-    end
+        config.parse!(%w{--profile foo})
+        config.paths.should == [1,2,3]
+      end
 
-    it "should provide a helpful error message when a specified profile exists but is nil or blank" do
-      [nil, '   '].each do |bad_input|
-        given_cucumber_yml_defined_as({'foo' => bad_input})
+      it "notifies the user that an individual profile is being used" do
+        given_cucumber_yml_defined_as({'foo' => [1,2,3]})
 
-        config = Configuration.new(StringIO.new, error = StringIO.new)
-        expected_error = /The 'foo' profile in cucumber.yml was blank.  Please define the command line arguments for the 'foo' profile in cucumber.yml./
-        lambda{config.parse!(%w{--profile foo})}.should raise_error(expected_error)
+        config.parse!(%w{--profile foo})
+        out.string.should =~ /Using the foo profile...\n/
       end
-    end
 
-    it "should provide a helpful error message when no YAML file exists and a profile is specified" do
-      File.should_receive(:exist?).with('cucumber.yml').and_return(false)
+      it "notifies the user when multiple profiles are being used" do
+        given_cucumber_yml_defined_as({'foo' => [1,2,3], 'bar' => ['v'], 'dog' => ['v']})
 
-      config = Configuration.new(StringIO.new, error = StringIO.new)
-      expected_error = /cucumber.yml was not found.  Please refer to cucumber's documentation on defining profiles in cucumber.yml./
-      lambda{config.parse!(%w{--profile i_do_not_exist})}.should raise_error(expected_error)
-    end
+        config.parse!(%w{--profile foo --profile bar})
+        out.string.should =~ /Using the foo and bar profiles...\n/
+
+        reset_config
 
-    it "should provide a helpful error message when cucumber.yml is blank or malformed" do
-        expected_error_message = /cucumber.yml was found, but was blank or malformed. Please refer to cucumber's documentation on correct profile usage./
+        config.parse!(%w{--profile foo --profile bar --profile dog})
+        out.string.should =~ /Using the foo, bar and dog profiles...\n/
+      end
 
-      ['', 'sfsadfs', "--- \n- an\n- array\n", "---dddfd"].each do |bad_input|
-        given_cucumber_yml_defined_as(bad_input)
+      it "disregards paths in profiles when other paths are passed in (via cmd line)" do
+        given_cucumber_yml_defined_as({'foo' => %w[-v features]})
 
-        config = Configuration.new(StringIO.new, error = StringIO.new)
-        lambda{config.parse!([])}.should raise_error(expected_error_message)
+        config.parse!(%w{--profile foo features/specific.feature --format pretty})
+        config.paths.should == ['features/specific.feature']
+      end
+
+      it "disregards default STDOUT formatter defined in profile when another is passed in (via cmd line)" do
+        given_cucumber_yml_defined_as({'foo' => %w[--format pretty]})
+        config.parse!(%w{--format progress --profile foo})
+        config.options[:formats].should == [['progress', out]]#, ['pretty', 'pretty.txt']]
+      end
+
+
+
+      ["--no-profile", "-P"].each do |flag|
+
+        context 'when none is specified with #{flag}' do
+
+          it "disables profiles" do
+            given_cucumber_yml_defined_as({'default' => '-v --require file_specified_in_default_profile.rb'})
+
+            config.parse!("#{flag} --require some_file.rb".split(" "))
+            config.options[:require].should == ['some_file.rb']
+          end
+
+          it "notifies the user that the profiles are being disabled" do
+            given_cucumber_yml_defined_as({'default' => '-v'})
+
+            config.parse!("#{flag} --require some_file.rb".split(" "))
+            out.string.should =~ /Disabling profiles.../
+          end
+
+        end
+
+      end
+
+
+
+      it "issues a helpful error message when a specified profile exists but is nil or blank" do
+        [nil, '   '].each do |bad_input|
+          given_cucumber_yml_defined_as({'foo' => bad_input})
+
+          expected_error = /The 'foo' profile in cucumber.yml was blank.  Please define the command line arguments for the 'foo' profile in cucumber.yml./
+          lambda{config.parse!(%w{--profile foo})}.should raise_error(expected_error)
+        end
+      end
+
+      it "issues a helpful error message when no YAML file exists and a profile is specified" do
+        File.should_receive(:exist?).with('cucumber.yml').and_return(false)
+
+        expected_error = /cucumber.yml was not found.  Please refer to cucumber's documentation on defining profiles in cucumber.yml./
+        lambda{config.parse!(%w{--profile i_do_not_exist})}.should raise_error(expected_error)
+      end
+
+      it "issues a helpful error message when cucumber.yml is blank or malformed" do
+          expected_error_message = /cucumber.yml was found, but was blank or malformed. Please refer to cucumber's documentation on correct profile usage./
+
+        ['', 'sfsadfs', "--- \n- an\n- array\n", "---dddfd"].each do |bad_input|
+          given_cucumber_yml_defined_as(bad_input)
+          lambda{config.parse!([])}.should raise_error(expected_error_message)
+          reset_config
+        end
       end
-    end
 
-    it "should procide a helpful error message when the YAML can not be parsed" do
-      expected_error_message = /cucumber.yml was found, but could not be parsed. Please refer to cucumber's documentation on correct profile usage./
+      it "issues a helpful error message when cucumber.yml can not be parsed" do
+        expected_error_message = /cucumber.yml was found, but could not be parsed. Please refer to cucumber's documentation on correct profile usage./
 
-      given_cucumber_yml_defined_as("input that causes an exception in YAML loading")
-      YAML.should_receive(:load).and_raise ArgumentError
+        given_cucumber_yml_defined_as("input that causes an exception in YAML loading")
+        YAML.should_receive(:load).and_raise ArgumentError
 
-      config = Configuration.new(StringIO.new, error = StringIO.new)
-      lambda{config.parse!([])}.should raise_error(expected_error_message)
+        lambda{config.parse!([])}.should raise_error(expected_error_message)
+      end
     end
 
+
     it "should accept --dry-run option" do
-      config = Configuration.new(StringIO.new)
       config.parse!(%w{--dry-run})
       config.options[:dry_run].should be_true
     end
 
     it "should accept --no-source option" do
-      config = Configuration.new
       config.parse!(%w{--no-source})
 
       config.options[:source].should be_false
     end
 
     it "should accept --no-snippets option" do
-      config = Configuration.new
       config.parse!(%w{--no-snippets})
 
       config.options[:snippets].should be_false
     end
 
     it "should set snippets and source to false with --quiet option" do
-      config = Configuration.new
       config.parse!(%w{--quiet})
 
-      config.options[:snippets].should be_nil
-      config.options[:source].should be_nil
+      config.options[:snippets].should be_false
+      config.options[:source].should be_false
     end
 
     it "should accept --verbose option" do
-      config = Configuration.new
       config.parse!(%w{--verbose})
 
       config.options[:verbose].should be_true
     end
 
     it "should accept --out option" do
-      config = Configuration.new(StringIO.new)
       config.parse!(%w{--out jalla.txt})
       config.options[:formats].should == [['pretty', 'jalla.txt']]
     end
 
     it "should accept multiple --out options" do
-      config = Configuration.new(StringIO.new)
       config.parse!(%w{--format progress --out file1 --out file2})
       config.options[:formats].should == [['progress', 'file2']]
     end
 
     it "should accept multiple --format options and put the STDOUT one first so progress is seen" do
-      io = StringIO.new
-      config = Configuration.new(io)
       config.parse!(%w{--format pretty --out pretty.txt --format progress})
-      config.options[:formats].should == [['progress', io], ['pretty', 'pretty.txt']]
+      config.options[:formats].should == [['progress', out], ['pretty', 'pretty.txt']]
     end
 
     it "should not accept multiple --format options when both use implicit STDOUT" do
-      io = StringIO.new
-      config = Configuration.new(io)
       lambda do
         config.parse!(%w{--format pretty --format progress})
       end.should raise_error("All but one formatter must use --out, only one can print to STDOUT")
     end
 
     it "should associate --out to previous --format" do
-      config = Configuration.new(StringIO.new)
       config.parse!(%w{--format progress --out file1 --format profile --out file2})
       config.options[:formats].should == [["progress", "file1"], ["profile" ,"file2"]]
     end
 
     it "should accept --color option" do
       Term::ANSIColor.should_receive(:coloring=).with(true)
-      config = Configuration.new(StringIO.new)
       config.parse!(['--color'])
     end
 
     it "should accept --no-color option" do
       Term::ANSIColor.should_receive(:coloring=).with(false)
-      config = Configuration.new(StringIO.new)
-      config.parse!(['--no-color'])
-    end
-
-    it "should parse tags" do
-      config = Configuration.new(nil)
-      includes, excludes = config.parse_tags("one,~two,@three,~@four")
-      includes.should == ['one', 'three']
-      excludes.should == ['two', 'four']
+      config.parse!(%w[--no-color])
     end
 
     describe "--backtrace" do
@@ -336,12 +386,10 @@ END_OF_MESSAGE
     describe "diff output" do
 
       it "is enabled by default" do
-        config = Configuration.new
         config.diff_enabled?.should be_true
       end
 
       it "is disabled when the --no-diff option is supplied" do
-        config = Configuration.new
         config.parse!(%w{--no-diff})
 
         config.diff_enabled?.should be_false
@@ -350,7 +398,6 @@ END_OF_MESSAGE
     end
 
     it "should accept multiple --name options" do
-      config = Configuration.new
       config.parse!(['--name', "User logs in", '--name', "User signs up"])
 
       config.options[:name_regexps].should include(/User logs in/)
@@ -358,7 +405,6 @@ END_OF_MESSAGE
     end
 
     it "should accept multiple -n options" do
-      config = Configuration.new
       config.parse!(['-n', "User logs in", '-n', "User signs up"])
 
       config.options[:name_regexps].should include(/User logs in/)
@@ -370,22 +416,19 @@ END_OF_MESSAGE
       Dir.should_receive(:[]).with("feature_directory/**/*.feature").
         any_number_of_times.and_return(["cucumber.feature"])
 
-      config = Configuration.new(StringIO)
       config.parse!(%w{feature_directory/})
 
       config.feature_files.should == ["cucumber.feature"]
     end
 
     it "should allow specifying environment variables on the command line" do
-      config = Configuration.new
       config.parse!(["foo=bar"])
       ENV["foo"].should == "bar"
       config.feature_files.should == []
     end
-    
+
     it "should allow specifying environment variables in profiles" do
       given_cucumber_yml_defined_as({'selenium' => 'RAILS_ENV=selenium'})
-      config = Configuration.new
       config.parse!(["--profile", "selenium"])
       ENV["RAILS_ENV"].should == "selenium"
       config.feature_files.should == []