pickle 0.4.11 → 0.5.0

data/features/step_definitions/fork_steps.rb

@@ -1,4 +1,4 @@
 # example of making your own matcher with the pickle backend
 Then(/^#{capture_model} should be tine of #{capture_model}$/) do |tine, fork|
-  model(fork).tines.should include(model(tine))
-end
+  expect(model(fork).tines).to include(model(tine))
+end

data/features/step_definitions/generator_steps.rb

@@ -8,11 +8,15 @@ After('@gen') do
 end
 
 Given(/^cucumber has been freshly generated$/) do
-  `cd #{Rails.root}; rails g cucumber:install -f --capybara`
+  Bundler.with_clean_env do
+    `cd #{Rails.root}; rails g cucumber:install -f --capybara`
+  end
 end
 
 Given(/^pickle path email has been freshly generated$/) do
-  `cd #{Rails.root}; rails g pickle paths email -f`
+  Bundler.with_clean_env do
+    `cd #{Rails.root}; rails g pickle paths email -f`
+  end
 end
 
 Given(/^env\.rb already requires (.+)$/) do |file|
@@ -22,25 +26,27 @@ Given(/^env\.rb already requires (.+)$/) do |file|
 end
 
 When(/^I run "(.*)"$/) do |command|
-  @output = `cd #{Rails.root}; #{command}`
+  Bundler.with_clean_env do
+    @output = `cd #{Rails.root}; #{command}`
+  end
 end
 
 Then(/^I should see "(.*)"$/) do |text|
-  @output.should include(text)
+  expect(@output).to include(text)
 end
 
 Then(/^the file (.+?) should exist$/) do |file|
-  File.exist?("#{Rails.root}/#{file}").should == true
+  expect(File.exist?("#{Rails.root}/#{file}")).to eq(true)
 end
 
 Then(/^the file (.+?) should match \/(.*?)\/$/) do |file, regexp|
-  File.read("#{Rails.root}/#{file}").should match(/#{regexp}/m)
+  expect(File.read("#{Rails.root}/#{file}")).to match(/#{regexp}/m)
 end
 
 Then(/^the file (.+?) should not match \/(.*?)\/$/) do |file, regexp|
-  File.read("#{Rails.root}/#{file}").should_not match(/#{regexp}/m)
+  expect(File.read("#{Rails.root}/#{file}")).not_to match(/#{regexp}/m)
 end
 
 Then /^the file ([^ ]+) should be identical to the local (.+)$/ do |generated_file, source_file|
-  File.read("#{Rails.root}/#{generated_file}").should == File.read("#{File.dirname(__FILE__)}/../#{source_file}")
-end
+  expect(File.read("#{Rails.root}/#{generated_file}")).to eq(File.read("#{File.dirname(__FILE__)}/../#{source_file}"))
+end

data/features/step_definitions/path_steps.rb

@@ -2,7 +2,7 @@ require File.expand_path(File.join(File.dirname(__FILE__), "..", "support", "pat
 
 Then(/^(.+?) should match route \/(.+?)$/) do |page, route|
   regexp = route.gsub(/:(\w*?)id/,'\d+')
-  path_to(page).should =~ /#{regexp}/
+  expect(path_to(page)).to match(/#{regexp}/)
 end
 
 When(/^I go to (.+)$/) do |page|
@@ -10,5 +10,5 @@ When(/^I go to (.+)$/) do |page|
 end
 
 Then(/^I should be at (.+)$/) do |page|
-  current_url.should =~ /#{path_to(page)}/
-end
+  expect(current_url).to match(/#{path_to(page)}/)
+end

data/features/step_definitions/pickle_steps.rb

@@ -22,79 +22,79 @@ end
 
 # not find a model
 Then(/^#{capture_model} should not exist(?: with #{capture_fields})?$/) do |name, fields|
-  find_model(name, fields).should be_nil
+  expect(find_model(name, fields)).to be_nil
 end
 
 # find models with a table
 Then(/^the following #{capture_plural_factory} should exists?:?$/) do |plural_factory, table|
-  find_models_from_table(plural_factory, table).should_not be_any(&:nil?)
+  expect(find_models_from_table(plural_factory, table)).not_to be_any(&:nil?)
 end
 
 # find exactly n models
 Then(/^(\d+) #{capture_plural_factory} should exist(?: with #{capture_fields})?$/) do |count, plural_factory, fields|
-  find_models(plural_factory.singularize, fields).size.should == count.to_i
+  expect(find_models(plural_factory.singularize, fields).size).to eq(count.to_i)
 end
 
 # assert equality of models
 Then(/^#{capture_model} should be #{capture_model}$/) do |a, b|
-  model!(a).should == model!(b)
+  expect(model!(a)).to eq(model!(b))
 end
 
 # assert model is in another model's has_many assoc
 Then(/^#{capture_model} should be (?:in|one of|amongst) #{capture_model}(?:'s)? (\w+)$/) do |target, owner, association|
-  model!(owner).send(association).should include(model!(target))
+  expect(model!(owner).send(association)).to include(model!(target))
 end
 
 # assert model is not in another model's has_many assoc
 Then(/^#{capture_model} should not be (?:in|one of|amongst) #{capture_model}(?:'s)? (\w+)$/) do |target, owner, association|
-  model!(owner).send(association).should_not include(model!(target))
+  expect(model!(owner).send(association)).not_to include(model!(target))
 end
 
 # assert model is another model's has_one/belongs_to assoc
 Then(/^#{capture_model} should be #{capture_model}(?:'s)? (\w+)$/) do |target, owner, association|
-  model!(owner).send(association).should == model!(target)
+  expect(model!(owner).send(association)).to eq(model!(target))
 end
 
 # assert model is not another model's has_one/belongs_to assoc
 Then(/^#{capture_model} should not be #{capture_model}(?:'s)? (\w+)$/) do |target, owner, association|
-  model!(owner).send(association).should_not == model!(target)
+  expect(model!(owner).send(association)).not_to eq(model!(target))
 end
 
 # assert model.predicate? 
 Then(/^#{capture_model} should (?:be|have) (?:an? )?#{capture_predicate}$/) do |name, predicate|
   if model!(name).respond_to?("has_#{predicate.gsub(' ', '_')}")
-    model!(name).should send("have_#{predicate.gsub(' ', '_')}")
+    expect(model!(name)).to send("have_#{predicate.gsub(' ', '_')}")
   else
-    model!(name).should send("be_#{predicate.gsub(' ', '_')}")
+    expect(model!(name)).to send("be_#{predicate.gsub(' ', '_')}")
   end
 end
 
 # assert not model.predicate?
 Then(/^#{capture_model} should not (?:be|have) (?:an? )?#{capture_predicate}$/) do |name, predicate|
   if model!(name).respond_to?("has_#{predicate.gsub(' ', '_')}")
-    model!(name).should_not send("have_#{predicate.gsub(' ', '_')}")
+    expect(model!(name)).not_to send("have_#{predicate.gsub(' ', '_')}")
   else
-    model!(name).should_not send("be_#{predicate.gsub(' ', '_')}")
+    expect(model!(name)).not_to send("be_#{predicate.gsub(' ', '_')}")
   end
 end
 
-# model.attribute.should eql(value)
-# model.attribute.should_not eql(value)
+# expect(model.attribute).to eq(value)
+# expect(model.attribute).not_to eq(value)
 Then(/^#{capture_model}'s (\w+) (should(?: not)?) be #{capture_value}$/) do |name, attribute, expectation, expected|
   actual_value  = model(name).send(attribute)
-  expectation   = expectation.gsub(' ', '_')
+  expectation   = expectation.gsub("should", "to").gsub(" ", "_")
   
   case expected
   when 'nil', 'true', 'false'
-    actual_value.send(expectation, send("be_#{expected}"))
+    expect(actual_value).send(expectation, eq(eval(expected)))
   when /^[+-]?[0-9_]+(\.\d+)?$/
-    actual_value.send(expectation, eql(expected.to_f))
+    expect(actual_value).send(expectation, eq(expected.to_f))
   else
-    actual_value.to_s.send(expectation, eql(eval(expected)))
+    expect(actual_value.to_s).send(expectation, eq(eval(expected)))
   end
 end
 
 # assert size of association
 Then /^#{capture_model} should have (\d+) (\w+)$/ do |name, size, association|
-  model!(name).send(association).size.should == size.to_i
+  expect(model!(name).send(association).size).to eq(size.to_i)
 end

data/features/step_definitions/raise_error_steps.rb

@@ -1,7 +1,7 @@
 Then /^the following should raise an? ([\w:]+):$/ do |error, step|
-  lambda { steps step }.should raise_error(error.constantize)
+  expect { steps step }.to raise_error(error.constantize)
 end
 
 Then /^the following should raise an? ([\w:]+) with "([^"]*)":$/ do |error, message, step|
-  lambda { steps step }.should raise_error(error.constantize, message)
-end
+  expect { steps step }.to raise_error(error.constantize, message)
+end

data/features/support/pickle.rb

@@ -6,7 +6,6 @@
 #
 #    require 'machinist/active_record' # or your chosen adaptor
 #    require File.dirname(__FILE__) + '/../../spec/blueprints' # or wherever your blueprints are
-#    Before { Sham.reset } # to reset Sham's seed between scenarios so each run has same random sequences
 #
 # For FactoryGirl add: features/support/factory_girl.rb
 #

data/lib/generators/pickle_generator.rb

@@ -9,15 +9,6 @@ class PickleGenerator < Rails::Generators::Base
   class_option :paths, :desc => "Generate features/support/paths.rb file.", :type => :boolean
   class_option :email, :desc => "Generate features/step_definitions/email_steps.rb file", :type => :boolean
 
-  def initialize(args = [], options = {}, config = {})
-    super
-
-    if self.options.paths? && !File.exists?("features/support/paths.rb")
-      say "features/support/paths.rb not found, is your cucumber up to date?", :red
-      exit
-    end
-  end
-
   def create_directories
     empty_directory "features/step_definitions"
     empty_directory "features/support"
@@ -30,15 +21,7 @@ class PickleGenerator < Rails::Generators::Base
 
   def copy_paths_file
     return unless options.paths?
-
-    current_paths = File.read("features/support/paths.rb")
-    unless current_paths.include?('#{capture_model}')
-      if current_paths =~ /^(.*)(\n\s+else\n\s+raise "Can't find.*".*$)/m
-        @current_paths_header = $1
-        @current_paths_footer = $2
-      end
-      template "paths.rb", "features/support/paths.rb"
-    end
+    template "paths.rb", "features/support/paths.rb"
   end
 
   def copy_email_steps_file
@@ -58,12 +41,4 @@ class PickleGenerator < Rails::Generators::Base
   def pickle_email
     options.email?
   end
-
-  def current_paths_header
-    @current_paths_header
-  end
-
-  def current_paths_footer
-    @current_paths_footer
-  end
 end

data/lib/pickle/adapter.rb

@@ -95,11 +95,7 @@ module Pickle
       end
 
       def create(attrs = {})
-        if @klass.respond_to?('make!')
-          @klass.send(:make!, @blueprint, attrs)
-        else
-          @klass.send(:make, @blueprint, attrs)
-        end
+        @klass.send(:make!, @blueprint, attrs)
       end
     end
 
@@ -136,8 +132,8 @@ module Pickle
     class Fabrication < Adapter
       def self.factories
         if defined? ::Fabrication
-          ::Fabrication::Support.find_definitions if ::Fabrication::Fabricator.schematics.empty?
-          ::Fabrication::Fabricator.schematics.collect{|v| new(v)}
+          ::Fabrication.manager.load_definitions if ::Fabrication.manager.schematics.empty?
+          ::Fabrication.manager.schematics.map { |name, klass| new([name, klass]) }
         else
           []
         end
@@ -151,9 +147,7 @@ module Pickle
 
       def create(attrs = {})
         if defined? ::Fabrication
-          ::Fabrication::Fabricator.generate(@name.to_sym, {
-              :save => true
-              }, attrs)
+          Fabricate(@name.to_sym, attrs)
         end
       end
     end

data/lib/pickle/version.rb

@@ -1,3 +1,3 @@
 module Pickle
-  VERSION = "0.4.11"
-end
+  VERSION = "0.5.0"
+end

data/pickle.gemspec

@@ -5,11 +5,12 @@ Gem::Specification.new do |s|
   s.name = "pickle"
   s.version = Pickle::VERSION.dup
   s.platform = Gem::Platform::RUBY
-  s.authors = ["Ian White"]
+  s.licenses = ["MIT"]
+  s.authors = ["Ian White", "James Le Cuirot", "Niklas Hofer"]
   s.description = "Easy model creation and reference in your cucumber features"
   s.summary = "Easy model creation and reference in your cucumber features."
-  s.email = "ian.w.white@gmail.com"
-  s.homepage = "http://github.com/ianwhite/pickle"
+  s.email = ["ian.w.white@gmail.com", "chewi@aura-online.co.uk", "niklas+dev@lanpartei.de"]
+  s.homepage = "https://github.com/ianwhite/pickle"
 
   s.rubyforge_project = "pickle"
   s.required_rubygems_version = ">= 1.3.6"
@@ -25,12 +26,12 @@ Gem::Specification.new do |s|
   s.add_development_dependency "bundler"
   s.add_development_dependency "git"
   s.add_development_dependency "yard"
-  s.add_development_dependency "rspec-rails", "~>2.6.0"
+  s.add_development_dependency "rspec-rails", "~>3.0"
   s.add_development_dependency "rails", "~>3.1.0"
   s.add_development_dependency "cucumber-rails"
   s.add_development_dependency "factory_girl"
-  s.add_development_dependency "fabrication"
-  s.add_development_dependency "machinist"
+  s.add_development_dependency "fabrication", '~> 2.0'
+  s.add_development_dependency "machinist", "~>2.0"
   s.add_development_dependency "database_cleaner"
   s.add_development_dependency "capybara"
   s.add_development_dependency "sqlite3-ruby"

data/rails_generators/pickle/pickle_generator.rb

@@ -2,9 +2,7 @@ class PickleGenerator < Rails::Generator::Base
   def initialize(args, options)
     super(args, options)
     @generate_email_steps = args.include?('email')
-    if @generate_path_steps = args.include?('path') || args.include?('paths')
-      File.exists?('features/support/paths.rb') or raise "features/support/paths.rb not found, is your cucumber up to date?"
-    end
+    @generate_path_steps = args.include?('path')
   end
   
   def manifest
@@ -30,4 +28,4 @@ class PickleGenerator < Rails::Generator::Base
       m.template 'pickle.rb', File.join('features/support', 'pickle.rb'), :assigns => pickle_assigns
     end
   end
-end
+end

data/rails_generators/pickle/templates/email_steps.rb

@@ -15,7 +15,7 @@ Given(/^all emails? (?:have|has) been delivered$/) do
 end
 
 Given(/^(\d)+ emails? should be delivered$/) do |count|
-  emails.size.should == count.to_i
+  expect(emails.size).to eq(count.to_i)
 end
 
 When(/^(?:I|they) follow "([^"]*?)" in #{capture_email}$/) do |link, email_ref|
@@ -27,37 +27,37 @@ When(/^(?:I|they) click the first link in #{capture_email}$/) do |email_ref|
 end
 
 Then(/^(\d)+ emails? should be delivered to (.*)$/) do |count, to|
-  emails("to: \"#{email_for(to)}\"").size.should == count.to_i
+  expect(emails("to: \"#{email_for(to)}\"").size).to eq(count.to_i)
 end
 
 Then(/^(\d)+ emails? should be delivered with #{capture_fields}$/) do |count, fields|
-  emails(fields).size.should == count.to_i
+  expect(emails(fields).size).to eq(count.to_i)
 end
 
 Then(/^#{capture_email} should be delivered to (.+)$/) do |email_ref, to|
-  email(email_ref, "to: \"#{email_for(to)}\"").should_not be_nil
+  expect(email(email_ref, "to: \"#{email_for(to)}\"")).not_to be_nil
 end
 
 Then(/^#{capture_email} should not be delivered to (.+)$/) do |email_ref, to|
-  email(email_ref, "to: \"#{email_for(to)}\"").should be_nil
+  expect(email(email_ref, "to: \"#{email_for(to)}\"")).to be_nil
 end
 
 Then(/^#{capture_email} should have #{capture_fields}$/) do |email_ref, fields|
-  email(email_ref, fields).should_not be_nil
+  expect(email(email_ref, fields)).not_to be_nil
 end
 
 Then(/^#{capture_email} should contain "(.*)"$/) do |email_ref, text|
-  email(email_ref).body.should =~ /#{text}/
+  expect(email(email_ref).body).to match(/#{text}/)
 end
 
 Then(/^#{capture_email} should not contain "(.*)"$/) do |email_ref, text|
-  email(email_ref).body.should_not =~ /#{text}/
+  expect(email(email_ref).body).not_to match(/#{text}/)
 end
 
 Then(/^#{capture_email} should link to (.+)$/) do |email_ref, page|
-  email(email_ref).body.should =~ /#{path_to(page)}/
+  expect(email(email_ref).body).to match(/#{path_to(page)}/)
 end
 
 Then(/^show me the emails?$/) do
    save_and_open_emails
-end
+end

data/rails_generators/pickle/templates/pickle.rb

@@ -6,7 +6,6 @@
 #
 #    require 'machinist/active_record' # or your chosen adaptor
 #    require File.dirname(__FILE__) + '/../../spec/blueprints' # or wherever your blueprints are
-#    Before { Sham.reset } # to reset Sham's seed between scenarios so each run has same random sequences
 #
 # For FactoryGirl add: features/support/factory_girl.rb
 #

data/rails_generators/pickle/templates/pickle_steps.rb

@@ -22,79 +22,79 @@ end
 
 # not find a model
 Then(/^#{capture_model} should not exist(?: with #{capture_fields})?$/) do |name, fields|
-  find_model(name, fields).should be_nil
+  expect(find_model(name, fields)).to be_nil
 end
 
 # find models with a table
 Then(/^the following #{capture_plural_factory} should exists?:?$/) do |plural_factory, table|
-  find_models_from_table(plural_factory, table).should_not be_any(&:nil?)
+  expect(find_models_from_table(plural_factory, table)).not_to be_any(&:nil?)
 end
 
 # find exactly n models
 Then(/^(\d+) #{capture_plural_factory} should exist(?: with #{capture_fields})?$/) do |count, plural_factory, fields|
-  find_models(plural_factory.singularize, fields).size.should == count.to_i
+  expect(find_models(plural_factory.singularize, fields).size).to eq(count.to_i)
 end
 
 # assert equality of models
 Then(/^#{capture_model} should be #{capture_model}$/) do |a, b|
-  model!(a).should == model!(b)
+  expect(model!(a)).to eq(model!(b))
 end
 
 # assert model is in another model's has_many assoc
 Then(/^#{capture_model} should be (?:in|one of|amongst) #{capture_model}(?:'s)? (\w+)$/) do |target, owner, association|
-  model!(owner).send(association).should include(model!(target))
+  expect(model!(owner).send(association)).to include(model!(target))
 end
 
 # assert model is not in another model's has_many assoc
 Then(/^#{capture_model} should not be (?:in|one of|amongst) #{capture_model}(?:'s)? (\w+)$/) do |target, owner, association|
-  model!(owner).send(association).should_not include(model!(target))
+  expect(model!(owner).send(association)).not_to include(model!(target))
 end
 
 # assert model is another model's has_one/belongs_to assoc
 Then(/^#{capture_model} should be #{capture_model}(?:'s)? (\w+)$/) do |target, owner, association|
-  model!(owner).send(association).should == model!(target)
+  expect(model!(owner).send(association)).to eq(model!(target))
 end
 
 # assert model is not another model's has_one/belongs_to assoc
 Then(/^#{capture_model} should not be #{capture_model}(?:'s)? (\w+)$/) do |target, owner, association|
-  model!(owner).send(association).should_not == model!(target)
+  expect(model!(owner).send(association)).not_to eq(model!(target))
 end
 
 # assert model.predicate? 
 Then(/^#{capture_model} should (?:be|have) (?:an? )?#{capture_predicate}$/) do |name, predicate|
   if model!(name).respond_to?("has_#{predicate.gsub(' ', '_')}")
-    model!(name).should send("have_#{predicate.gsub(' ', '_')}")
+    expect(model!(name)).to send("have_#{predicate.gsub(' ', '_')}")
   else
-    model!(name).should send("be_#{predicate.gsub(' ', '_')}")
+    expect(model!(name)).to send("be_#{predicate.gsub(' ', '_')}")
   end
 end
 
 # assert not model.predicate?
 Then(/^#{capture_model} should not (?:be|have) (?:an? )?#{capture_predicate}$/) do |name, predicate|
   if model!(name).respond_to?("has_#{predicate.gsub(' ', '_')}")
-    model!(name).should_not send("have_#{predicate.gsub(' ', '_')}")
+    expect(model!(name)).not_to send("have_#{predicate.gsub(' ', '_')}")
   else
-    model!(name).should_not send("be_#{predicate.gsub(' ', '_')}")
+    expect(model!(name)).not_to send("be_#{predicate.gsub(' ', '_')}")
   end
 end
 
-# model.attribute.should eql(value)
-# model.attribute.should_not eql(value)
+# expect(model.attribute).to eq(value)
+# expect(model.attribute).not_to eq(value)
 Then(/^#{capture_model}'s (\w+) (should(?: not)?) be #{capture_value}$/) do |name, attribute, expectation, expected|
   actual_value  = model(name).send(attribute)
-  expectation   = expectation.gsub(' ', '_')
+  expectation   = expectation.gsub("should", "to").gsub(" ", "_")
   
   case expected
   when 'nil', 'true', 'false'
-    actual_value.send(expectation, send("be_#{expected}"))
+    expect(actual_value).send(expectation, eq(eval(expected)))
   when /^[+-]?[0-9_]+(\.\d+)?$/
-    actual_value.send(expectation, eql(expected.to_f))
+    expect(actual_value).send(expectation, eq(expected.to_f))
   else
-    actual_value.to_s.send(expectation, eql(eval(expected)))
+    expect(actual_value.to_s).send(expectation, eq(eval(expected)))
   end
 end
 
 # assert size of association
 Then /^#{capture_model} should have (\d+) (\w+)$/ do |name, size, association|
-  model!(name).send(association).size.should == size.to_i
+  expect(model!(name).send(association).size).to eq(size.to_i)
 end