pickle-has_many_support 0.3.1 → 0.4.2

data/.gitignore

@@ -3,3 +3,4 @@ doc/*
 .yardoc
 pickle-email*
 cucumber_test_app
+.bundle

data/Gemfile

@@ -0,0 +1,20 @@
+source "http://rubygems.org"
+
+gem "yard"
+gem "rake"
+gem "cucumber", ">=0.8"
+gem "rspec"
+
+group :test do
+  gem "rspec-rails"
+  gem "rails", "~>2.3"
+  gem "cucumber-rails", ">=0.3.2"
+  gem "factory_girl"
+  gem "machinist"
+  gem "jeweler"
+  gem "rcov"
+  gem "database_cleaner"
+  gem "capybara"
+  gem "webrat"
+  gem "sqlite3-ruby"
+end

data/Gemfile.lock

@@ -0,0 +1,98 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    actionmailer (2.3.8)
+      actionpack (= 2.3.8)
+    actionpack (2.3.8)
+      activesupport (= 2.3.8)
+      rack (~> 1.1.0)
+    activerecord (2.3.8)
+      activesupport (= 2.3.8)
+    activeresource (2.3.8)
+      activesupport (= 2.3.8)
+    activesupport (2.3.8)
+    builder (2.1.2)
+    capybara (0.3.9)
+      culerity (>= 0.2.4)
+      mime-types (>= 1.16)
+      nokogiri (>= 1.3.3)
+      rack (>= 1.0.0)
+      rack-test (>= 0.5.4)
+      selenium-webdriver (>= 0.0.3)
+    cucumber (0.8.5)
+      builder (~> 2.1.2)
+      diff-lcs (~> 1.1.2)
+      gherkin (~> 2.1.4)
+      json_pure (~> 1.4.3)
+      term-ansicolor (~> 1.0.4)
+    cucumber-rails (0.3.2)
+      cucumber (>= 0.8.0)
+    culerity (0.2.10)
+    database_cleaner (0.5.2)
+    diff-lcs (1.1.2)
+    factory_girl (1.3.2)
+    ffi (0.6.3)
+      rake (>= 0.8.7)
+    gemcutter (0.6.1)
+    gherkin (2.1.5)
+      trollop (~> 1.16.2)
+    git (1.2.5)
+    jeweler (1.4.0)
+      gemcutter (>= 0.1.0)
+      git (>= 1.2.5)
+      rubyforge (>= 2.0.0)
+    json_pure (1.4.6)
+    machinist (1.0.6)
+    mime-types (1.16)
+    nokogiri (1.4.3.1)
+    rack (1.1.0)
+    rack-test (0.5.4)
+      rack (>= 1.0)
+    rails (2.3.8)
+      actionmailer (= 2.3.8)
+      actionpack (= 2.3.8)
+      activerecord (= 2.3.8)
+      activeresource (= 2.3.8)
+      activesupport (= 2.3.8)
+      rake (>= 0.8.3)
+    rake (0.8.7)
+    rcov (0.9.8)
+    rspec (1.3.0)
+    rspec-rails (1.3.2)
+      rack (>= 1.0.0)
+      rspec (>= 1.3.0)
+    rubyforge (2.0.4)
+      json_pure (>= 1.1.7)
+    rubyzip (0.9.4)
+    selenium-webdriver (0.0.27)
+      ffi (>= 0.6.1)
+      json_pure
+      rubyzip
+    sqlite3-ruby (1.3.1)
+    term-ansicolor (1.0.5)
+    trollop (1.16.2)
+    webrat (0.7.1)
+      nokogiri (>= 1.2.0)
+      rack (>= 1.0)
+      rack-test (>= 0.5.3)
+    yard (0.5.8)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  capybara
+  cucumber (>= 0.8)
+  cucumber-rails (>= 0.3.2)
+  database_cleaner
+  factory_girl
+  jeweler
+  machinist
+  rails (~> 2.3)
+  rake
+  rcov
+  rspec
+  rspec-rails
+  sqlite3-ruby
+  webrat
+  yard

data/History.txt

@@ -1,3 +1,81 @@
+== 0.4.2
+
+* 1 bugfix
+  * Use mongoid finder syntax, which requires a :conditions key [Marc Lee]
+
+
+== 0.4.1
+Docfix
+
+* 1 improvement
+  * documentation fixes, and example of writing your own pickle steps
+  
+
+== 0.4.0
+Mongoid adapter, fallback ORM adapter for those not using machinist or active_record, bugfixes
+
+* 2 major improvements
+  * adapter for Mongoid [Sebastian Zuchmanski]
+  * replace ActiveRecord 'factory' adapter with Orm adapter.
+  
+      If you don't have machinist or factory_girl, the Orm factory adapter will fallback to your Orm to create classes.
+      
+      BC: if you have a line like this:
+        Pickle.configure do |config|
+          config.adapters = [:active_record]
+        end
+
+      You need to replace it with :orm
+        Pickle.configure do |config|
+          config.adapters = [:orm]
+        end
+      
+* 1 minor improvement
+  * Pickle::Session::ModelNotKnownError is raised instead of a generic RuntimeError
+  
+* 1 bugfix
+  * references to unknown models in fields now raise ModelNotKnownError instead of silently assigning nil
+
+
+== 0.3.5
+
+* 3 improvements
+  * bundler is used for setting up development dependencies
+  * gemspec specifies dependencies for using pickle
+  * Machinist 2 compatability [giddie]
+
+* 1 bugfix
+  * find_models now works with a factory name with spaces in it [#27]
+  
+
+== 0.3.4
+
+* 2 minor improvements
+  * Fix problem where email body is not a string, but is string like [#26] [Tom Meier]
+  * Minor code refactoring
+
+
+== 0.3.3
+
+* 1 minor improvement
+  * Pickle respects the default build strategy for factory girl. [Sean Hussey]
+  
+
+== 0.3.2
+
+* 3 minor improvements
+  * Document how to use machinist named blueprints [Christopher Darroch]
+  * Email links now visit the url, rather than just the path, this allows for features that
+    make use of the domain to function correctly
+  * Deprecation warnings for Rails 3 removed [Brian Rose & Kevin Olsen]
+
+
+== 0.3.1
+
+* 1 major improvement
+  * Rails 3 support for generators [H.J. Blok, szimek]
+
+
 == 0.3.0
 
 * 2 major improvements

data/README.rdoc

@@ -3,90 +3,80 @@
 Pickle gives you cucumber steps that create your models easily from factory-girl or
 machinist factories/blueprints.  You can also just use ActiveRecord as a factory but it's not as cool.
 
-Pickle can make use of different ORMs for finding records.  Currently ActiveRecord and DataMapper adapters are
+Pickle can make use of different ORMs for finding records.  Currently ActiveRecord, DataMapper, MongoID adapters are
 provided.  More adapters welcome!
 
 References to the models are stored in the current world, not necessarily for the purpose of checking the db
 (although you could use it for that), but for enabling easy reference to urls, and for
 building complex givens which require a bunch of models collaborating
 
-== Resources
+== Quickstart
 
-<b>Github</b> for code: http://github.com/ianwhite/pickle
+This is a quickstart guide for rails apps.  Firstly, install {cucumber-rails}[http://github.com/aslakhellesoy/cucumber-rails], and its dependencies.
+Then do the following:
 
-<b>Gemcutter</b> for the gem: http://gemcutter.org/gems/pickle
-
-<b>Rdoc.info</b> for docs: http://rdoc.info/projects/ianwhite/pickle
+=== Rails 3:
 
-<b>Google group</b> for questions: http://groups.google.com/group/pickle-cucumber
+Add the gem to your Gemfile:
 
-<b>Lighthouse</b> for bugs: http://ianwhite.lighthouseapp.com/projects/25941-pickle
+  gem 'pickle'
+  
+Then install with:
 
-<b>Railscast</b> presentation: http://railscasts.com/episodes/186-pickle-with-cucumber
+  bundle install
+  
+Discover the options for the generator:
 
-<b>Blog articles</b>: {dynamic50: Integration testing with cucumber and pickle}[http://blog.dynamic50.com/index.php/2009/04/integration-testing-with-cucumber-and-pickle/], {rubyflare: pickle my cucumber}[http://rubyflare.com/2009/10/28/pickle-my-cucumber/]
+  rails g pickle --help
 
-== Install
+Run the generator, e.g:
 
-Install pickle either as a rails plugin, or a gem
+  rails g pickle --paths --email
+  
+=== For Rails 2:
 
-  # gem from gemcutter
-  sudo gem install pickle
+Add the following to config/environments/cucumber:
 
-  # gem dependency (in config/environments/cucumber.rb)
   config.gem 'pickle'
 
-  # plugin
-  script/plugin install git://github.com/ianwhite/pickle.git
-
-  # or, plugin as submodule
-  git submodule add git://github.com/ianwhite/pickle.git vendor/plugins/pickle
+Install the gem with
 
-== CI
+  rake gems:install RAILS_ENV=cucumber
+  
+Run the generator with:
 
-It's tested against all stable branches of 2.x rails, and edge, with the latest versions of rspec, cucumber, factory_girl, machinist.
-
-== Run the tests
+  script/generate pickle [paths] [email]
 
-To run the specs do:
+== Resources
 
-  rake spec
+<b>Github</b> for code: http://github.com/ianwhite/pickle
 
-To run the features (rails 2.3 only ATM):
+<b>Gemcutter</b> for the gem: http://gemcutter.org/gems/pickle
 
-  rake cucumber
+<b>Rdoc.info</b> for docs: http://rdoc.info/projects/ianwhite/pickle
 
-== Contributors
+<b>Google group</b> for questions: http://groups.google.com/group/pickle-cucumber
 
-The following people have made Pickle better:
+<b>Lighthouse</b> for bugs: http://ianwhite.lighthouseapp.com/projects/25941-pickle
 
-* {Daniel Neighman}[http://github.com/hassox]
-* {Josh Bassett}[http://github.com/nullobject]
-* {Nick Rutherford}[http://github.com/nruth]
-* {Tobi Knaup}[http://github.com/guenter]
-* {Michael MacDonald}[http://github.com/schlick]
-* {Michael Moen}[http://github.com/UnderpantsGnome]
-* {Myron Marston}[http://github.com/myronmarston]
-* {Stephan Hagemann}[http://github.com/xing]
-* {Chris Flipse}[http://github.com/cflipse]
+<b>Railscast</b> presentation: http://railscasts.com/episodes/186-pickle-with-cucumber
 
-== Get Started
+<b>Blog articles</b>: {dynamic50: Integration testing with cucumber and pickle}[http://blog.dynamic50.com/index.php/2009/04/integration-testing-with-cucumber-and-pickle/], {rubyflare: pickle my cucumber}[http://rubyflare.com/2009/10/28/pickle-my-cucumber/]
 
-(you'd better install cucumber)
 
-  script/generate pickle [paths] [email]
+== Using Pickle
 
 Now have a look at <tt>features/step_definitions/pickle_steps.rb</tt>
 
-If you want path steps and email steps then just add 'paths' and/or 'email'.  The code/steps will be
-written to <tt>features/env/paths.rb</tt> and
+If you want path steps and email steps then just add the 'paths' and/or 'email' options to the generator.
+The code/steps will be written to <tt>features/env/paths.rb</tt> and
 <tt>features/step_definitions/email_steps.rb</tt> respectively.
 
-=== Using with plain ole Active Record or DataMapper
+=== Using with plain ole Active Record, DataMapper or Mongoid
 
-Pickle comes with adapters for Active Record and DataMapper.
+Pickle comes with ORM adapters for Active Record, DataMapper and Mongoid.
 
-If you have an AR/DM called 'Post', with required fields 'title', and 'body', then you can now write
+If you have a model called 'Post', with required fields 'title', and 'body', then you can now write
 steps like this
 
   Given a post exists with title: "My Post", body: "My body"
@@ -103,10 +93,7 @@ you've written, you can just do stuff like
   Then a user should exist with name: "Fred"
   And that user should be activated # this uses rspec predicate matchers
 
-==== Machinst: require your blueprints and reset Shams
-
-(The latest version of pickle supports {multiple blueprints}[http://github.com/notahat/machinist/commit/d6492e6927a8aa1819926e48b22377171fd20496], for
-earlier versions of machinist use pickle <= 0.1.10)
+==== Machinist: require your blueprints and reset Shams
 
 In your <tt>features/support/env.rb</tt> add the following lines at the bottom
 
@@ -122,16 +109,16 @@ If that doesn't solve loading issues then require your factories.rb file directl
   # example features/support/factory_girl.rb
   require File.dirname(__FILE__) + '/../../spec/factories'
 
-=== Using with an ORM other than ActiveRecord or DataMapper
+=== Using with an ORM other than ActiveRecord, DataMapper, or Mongoid
 
-Pickle can be used with any Modeling library provided there is an adapter written for it.
+Pickle can be used with any modelling library provided there is an adapter written for it.
 
 Adapters are very simple and exist a module or class with the name "PickleAdapter" available to the class.  For example
 
 User.const_get(:PickleAdapter) #=> should return a pickle adapter
 
 The Active Record and DataMapper ones can be found at
-ActiveRecord::Base::PickleAdapter and DataMapper::Resource::PickleAdapter respectively.
+ActiveRecord::Base::PickleAdapter, DataMapper::Resource::PickleAdapter, Mongoid::Document::PickleAdapter respectively.
 
 See how to implement one by looking at the ones provided in the pickle source in lib/pickle/adapters/*
 
@@ -146,13 +133,13 @@ In: <tt>features/support/pickle.rb</tt>
   require 'pickle/world'
 
   Pickle.configure do |config|
-    config.adapters = [:machinist, YourOwnAdapterClass]
+    config.adapters = [:machinist, :active_record, YourOwnAdapterClass]
     config.map 'me', 'myself', 'my', 'I', :to => 'user: "me"'
   end
 
-Out of the box pickle looks for machinist, then factory-girl, then finally active-record 'factories'.
-If you find that your steps aren't working with your factories, it's probably the case that your factory
-setup is not being included in your cucumber environment (see comments above regarding machinist and factory-girl).
+Out of the box pickle looks for machinist, factory-girl, then uses the ORM(s) that you're using to create models.
+
+If you find that your steps aren't working with your factories, it's probably the case that your factory setup is not being included in your cucumber environment (see comments above regarding machinist and factory-girl).
 
 == API
 
@@ -172,15 +159,30 @@ When you run <tt>script/generate pickle</tt> you get the following steps
 
   Given a user exists with name: "Fred"
   Given a user exists with name: "Fred", activated: false
+  
+This last step could be better expressed by using Machinist/FactoryGirl to create an activated user.  Then you can do
+
+  Given an activated user exists with name: "Fred"
 
 You can refer to other models in the fields
 
   Given a user exists
   And a post exists with author: the user
 
-  Given a person: "fred" exists
-  And a person: "ethel" exists
-  And a fatherhood exists with parent: user "fred", child: user "ethel"
+  Given a person "fred" exists
+  And a person "ethel" exists
+  And a fatherhood exists with parent: person "fred", child: person "ethel"
+  
+This last step is given by the default pickle steps, but it would be better written as:
+
+  And "fred" is the father of "ethel"
+  
+It is expected that you'll need to expand upon the default pickle steps to make your features readable.  To write the 
+above step, you could do something like:
+
+  Given /^"(\w+)" is the father of "(\w+)"$/ do |father, child|
+    Fatherhood.create! :father => model!("person: \"#{father}\""), :child => model!("person: \"#{child}\"")
+  end 
 
 "Given <b>n models</b> exist", e.g.
 
@@ -197,6 +199,35 @@ You can refer to other models in the fields
     | Fred  | false     |
     | Ethel | true      |
 
+===== Named machinist blueprints
+
+"Given <b> a <i>named</i> model</b> exists with <b>fields</b>"
+
+The latest version of pickle supports {named machinist blueprints}[http://github.com/notahat/machinist/commit/d6492e6927a8aa1819926e48b22377171fd20496].
+
+If you had the following blueprints:
+
+  User.blueprint do
+    name
+    email
+  end
+  
+  User.blueprint(:super_admin) do
+    role { "admin" }
+  end
+  
+  User.blueprint(:activated) do
+    activated { true }
+  end
+
+You could create a user with pickle by simply adding the name of the blueprint before the model:
+
+  Given a super admin user exists
+  And an activated user exists with name: "Fred"
+
+This is much nicer than having to set up common configurations in your steps all the time, and far more readable to boot.
+
+
 ==== Then steps
 
 ===== Asserting existence of models
@@ -297,3 +328,40 @@ can build up composite objects with ease
   # example of use
   Given a user exists
   And a post exists with author: the user # this step will assign the above user as :author on the post
+
+== Run the tests
+
+To get all the dependencies required for developing pickle, do the following
+
+  bundle install
+
+To run the specs do:
+
+  bundle exec rake spec
+
+To run the features (rails 2.3 only ATM):
+
+  bundle exec rake cucumber
+
+== Contributors
+
+The following people have made Pickle better:
+
+* {Marc Lee}[http://github.com/maleko]
+* {Sebastian Zuchmanski}[http://github.com/sebcioz]
+* {Paul Gideon Dann}[http://github.com/giddie]
+* {Tom Meier}[http://github.com/tommeier]
+* {Sean Hussey}[http://github.com/seanhussey]
+* Brian Rose & Kevin Olsen
+* {Christopher Darroch}[http://github.com/chrisdarroch]
+* {Szymon Nowak}[http://github.com/szimek]
+* {H.J. Blok}[http://github.com/hjblok]
+* {Daniel Neighman}[http://github.com/hassox]
+* {Josh Bassett}[http://github.com/nullobject]
+* {Nick Rutherford}[http://github.com/nruth]
+* {Tobi Knaup}[http://github.com/guenter]
+* {Michael MacDonald}[http://github.com/schlick]
+* {Michael Moen}[http://github.com/UnderpantsGnome]
+* {Myron Marston}[http://github.com/myronmarston]
+* {Stephan Hagemann}[http://github.com/xing]
+* {Chris Flipse}[http://github.com/cflipse]

data/Rakefile.d/{jeweller.rake → jeweler.rake}

@@ -9,6 +9,10 @@ Jeweler::Tasks.new do |s|
   s.email = "ian.w.white@gmail.com"
   s.homepage = "http://github.com/ianwhite/pickle/tree"
   s.authors = ["Ian White"]
+  s.add_dependency('rspec', ">=1.3")
+  s.add_dependency('cucumber', ">=0.8")
+  s.add_dependency('yard')
+  s.add_dependency('rake')
 end
 
 Jeweler::GemcutterTasks.new

data/VERSION

@@ -1 +1 @@
-0.3.0
+0.4.2

data/features/pickle/create_from_active_record.feature

@@ -4,7 +4,7 @@ Feature: I can easily create models from my blueprints
   I want to be able to create models with fields
   So that I can create models quickly and easily in my features
   
-  @wip
+
   Scenario: I create a user, and see if it looks right
     Given a user exists with name: "Fred", has_stale_password: true
     Then the user should not have a status

data/features/pickle/create_from_factory_girl.feature

@@ -56,4 +56,8 @@ Feature: I can easily create models from my factories
   Scenario: I create fork via a mapping
     Given killah fork exists
     Then the fork should be fancy
-    And the fancy fork: "of cornwood" should be fancy
+    And the fancy fork: "of cornwood" should be fancy
+    
+  Scenario: create a tine with a missing fork
+    Then the following should raise Pickle::Session::ModelNotKnownError: "Given a tine exists with fork: the fork"
+    

data/features/step_definitions/raise_error_steps.rb

@@ -0,0 +1,3 @@
+Then /^the following should raise Pickle::Session::ModelNotKnownError: "([^"]*)"$/ do |step|
+  lambda { steps step }.should raise_error(Pickle::Session::ModelNotKnownError)
+end

data/lib/generators/pickle_generator.rb

@@ -0,0 +1,69 @@
+require 'rails/generators'
+
+class PickleGenerator < Rails::Generators::Base
+  desc "Generates Pickle step files."
+
+  # Use the same templates as Rails 2 generator
+  source_root File.expand_path("../../../rails_generators/pickle/templates", __FILE__)
+
+  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"
+  end
+
+  def copy_pickle_steps_file
+    template "pickle_steps.rb", "features/step_definitions/pickle_steps.rb"
+    template "pickle.rb", "features/support/pickle.rb"
+  end
+
+  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
+  end
+
+  def copy_email_steps_file
+    return unless options.email?
+    template "email_steps.rb", "features/step_definitions/email_steps.rb"
+    template "email.rb", "features/support/email.rb"
+  end
+
+
+  private
+
+  # Compatibility methods for Rails 2 templates
+  def pickle_path
+    options.paths?
+  end
+
+  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

@@ -25,7 +25,7 @@ module Pickle
 
     self.model_classes = nil
 
-    # Include this module into your adapter
+    # Include this module into your ORM adapter
     # this will register the adapter with pickle and it will be picked up for you
     # To create an adapter you should create an inner constant "PickleAdapter"
     #
@@ -33,6 +33,7 @@ module Pickle
     #
     # @see pickle/adapters/active_record
     # @see pickle/adapters/datamapper
+    # @see pickle/adapters/mongoid
     module Base
       def self.included(base)
         adapters << base
@@ -69,6 +70,10 @@ module Pickle
       def find_all_models(klass, conditions)
         klass.const_get(:PickleAdapter).find_all_models(klass, conditions)
       end
+      
+      def create_model(klass, attributes)
+        klass.const_get(:PickleAdapter).create_model(klass, attributes)
+      end
     end
 
     # machinist adapter
@@ -90,7 +95,11 @@ module Pickle
       end
 
       def create(attrs = {})
-        @klass.send(:make, @blueprint, attrs)
+        if @klass.respond_to?('make!')
+          @klass.send(:make!, @blueprint, attrs)
+        else
+          @klass.send(:make, @blueprint, attrs)
+        end
       end
     end
 
@@ -105,14 +114,15 @@ module Pickle
       end
 
       def create(attrs = {})
-        Factory.create(@name, attrs)
+        Factory(@name, attrs)
       end
     end
 
-    # fallback active record adapter
-    class ActiveRecord < Adapter
+    # ORM adapter.  If you have no factory adapter, you can use this adapter to
+    # use your orm as 'factory' - ie create objects
+    class Orm < Adapter
       def self.factories
-        ::ActiveRecord::Base::PickleAdapter.model_classes.map{|k| new(k)}
+        model_classes.map{|k| new(k)}
       end
 
       def initialize(klass)
@@ -120,7 +130,7 @@ module Pickle
       end
 
       def create(attrs = {})
-        @klass.send(:create!, attrs)
+        Pickle::Adapter.create_model(@klass, attrs)
       end
     end
   end