pickle 0.1.23 → 0.2.0

data/History.txt

@@ -1,3 +1,35 @@
+== 0.2.0 - 24 Nov 2009
+
+* 4 major improvements
+  * Added support for finding models using tables
+    Example:
+      Then the following users should exist:
+        | name  |
+        | Fred  |
+        | Ethel |
+      And the 1st user should be male
+      And the 2nd user should be female
+      
+  * tables now support pickle refs in cells (see features/pickle/create_from_factory_girl.rb#37)
+  
+  * features/support/email.rb adds an email helper for mapping names to email addresses (similar to NavigationHelper in paths.rb)
+  
+  * Added ability for path_to_pickle to handle arbitrary segments
+    Example:
+      path_to_pickle('account', 'the enquiry') => account_enquiry_path(<enquiry>)
+
+* 2 minor improvements
+  * fail faster in pickle steps when a pickle ref can't be found, by using model! in most places
+
+  * generated pickle steps are less picky about possessives so that pickle mappings accepted in more places
+    e.g. when you have
+        config.map 'my', 'I', 'myself', :to => 'user: "me"'
+      you can now do
+        Given I exist
+        ...
+        Then the project should be one of my assigned projects
+
+
 == 0.1.23 - 22 Nov 2009
 
 * 1 major improvement

data/Todo.txt

@@ -1,4 +1,3 @@
-* Add email_for (same concept as path_to)
+* cleanup path_to_pickle and paths.rb (maybe have poly_pickle_path with same semantics as polymorphic_path, but accepting pickle refs)
 * fix problem with save_and_open_emails
 * Translations
-* Investigate using Treetop for pre-parsing

data/VERSION

@@ -1 +1 @@
-0.1.23
+0.2.0

data/features/generator/generators.feature

@@ -1,13 +1,9 @@
+@gen
 Feature: allow pickle to generate steps
   In order to get going with pickle
   As a dev
   I want to be able to generate steps
 
-  # Do we care anymore?
-  # Scenario: cucumber is not yet installed
-  #   When I run "script/generate pickle"
-  #   Then I should see "try running script/generate cucumber"
-
   Scenario: script/generate pickle on fresh cuke install
     Given cucumber has been freshly generated
     When I run "script/generate pickle"
@@ -32,6 +28,7 @@ Feature: allow pickle to generate steps
     And the file features/support/pickle.rb should match /require 'pickle\/email\/world'/
     And the file features/step_definitions/pickle_steps.rb should be identical to the local step_definitions/pickle_steps.rb
     And the file features/step_definitions/email_steps.rb should be identical to the local step_definitions/email_steps.rb
+    And the file features/support/email.rb should be identical to the local support/email.rb
 
   Scenario: script/generate pickle path email on fresh cuke install
     Given cucumber has been freshly generated
@@ -44,6 +41,7 @@ Feature: allow pickle to generate steps
     And the file features/step_definitions/pickle_steps.rb should be identical to the local step_definitions/pickle_steps.rb
     And the file features/support/paths.rb should be identical to the local support/paths.rb
     And the file features/step_definitions/email_steps.rb should be identical to the local step_definitions/email_steps.rb
+    And the file features/support/email.rb should be identical to the local support/email.rb
 
   Scenario: regenerating pickle
     Given cucumber has been freshly generated
@@ -58,3 +56,4 @@ Feature: allow pickle to generate steps
     But the file features/support/pickle.rb should not match /require 'pickle\/world'.*require 'pickle\/world'/
     And the file features/support/pickle.rb should not match /require 'pickle\/path\/world'.*require 'pickle\/path\/world'/
     And the file features/support/pickle.rb should not match /require 'pickle\/email\/world'.*require 'pickle\/email\/world'/
+    And the file features/support/email.rb should be identical to the local support/email.rb

data/features/pickle/create_from_active_record.feature

@@ -24,4 +24,20 @@ Feature: I can easily create models from my blueprints
     And another user exists with name: "Ethel", attitude_score: -1.46
     Then 2 users should exist
     And the 1st user should be a positive person
-    And the 2nd user should not be a positive person
+    And the 2nd user should not be a positive person
+    
+  Scenario: create and find using tables
+    Given the following users exist:
+      | name       | status                   |
+      | Jim        | married                  |
+      | Ethel      | in a relationship with x |
+    Then the following users should exist:
+      | name  |
+      | Jim   |
+      | Ethel |
+    And the following users should exist:
+      | status                   |
+      | married                  |
+      | in a relationship with x |
+    And the 1st user should be the 3rd user
+    And the 2nd user should be the last user

data/features/pickle/create_from_factory_girl.feature

@@ -39,8 +39,15 @@ Feature: I can easily create models from my factories
     And a tine exists with fork: the fork
     
     Then a tine should exist with fork: the fork
-
-    And the fork should be the tine's fork
+  
+  Scenario: create a tine with fork refs in a table
+    Given 2 forks exist
+    And the following tines exist:
+      | fork         |
+      | the 1st fork |
+      | the 2nd fork |
+    Then the 1st tine should be in the 1st fork's tines
+    And the 2nd tine should be in the 2nd fork's tines
 
   Scenario: I create fork via a mapping
     Given killah fork exists

data/features/step_definitions/email_steps.rb

@@ -1,4 +1,6 @@
 # this file generated by script/generate pickle email
+#
+# add email mappings in features/support/email.rb
 
 ActionMailer::Base.delivery_method = :test
 ActionMailer::Base.perform_deliveries = true
@@ -7,6 +9,7 @@ Before do
   ActionMailer::Base.deliveries.clear
 end
 
+# Clear the deliveries array, useful if your background sends email that you want to ignore
 Given(/^all emails? (?:have|has) been delivered$/) do
   ActionMailer::Base.deliveries.clear
 end
@@ -16,8 +19,7 @@ Given(/^(\d)+ emails? should be delivered$/) do |count|
 end
 
 Then(/^(\d)+ emails? should be delivered to (.*)$/) do |count, to|
-  to =~ /^#{capture_model}$/ && to = model($1).email
-  emails("to: \"#{to}\"").size.should == count.to_i
+  emails("to: \"#{email_for(to)}\"").size.should == count.to_i
 end
 
 Then(/^(\d)+ emails? should be delivered with #{capture_fields}$/) do |count, fields|
@@ -25,8 +27,7 @@ Then(/^(\d)+ emails? should be delivered with #{capture_fields}$/) do |count, fi
 end
 
 Then(/^#{capture_email} should be delivered to (.+)$/) do |email_ref, to|
-  to =~ /^#{capture_model}$/ && to = model($1).email
-  email(email_ref, "to: \"#{to}\"").should_not be_nil
+  email(email_ref, "to: \"#{email_for(to)}\"").should_not be_nil
 end
 
 Then(/^#{capture_email} should have #{capture_fields}$/) do |email_ref, fields|

data/features/step_definitions/generator_steps.rb

@@ -1,8 +1,8 @@
-Before do
+Before('@gen') do
   `mv #{Rails.root}/features/ #{Rails.root}/features.orig/ > /dev/null 2>&1`
 end
 
-After do
+After('@gen') do
   `rm -rf #{Rails.root}/features`
   `mv #{Rails.root}/features.orig/ #{Rails.root}/features/ > /dev/null 2>&1`
 end

data/features/step_definitions/pickle_steps.rb

@@ -11,14 +11,14 @@ Given(/^(\d+) #{capture_plural_factory} exist(?: with #{capture_fields})?$/) do
 end
 
 # create models from a table
-Given /^the following #{capture_plural_factory} exist$/ do |plural_factory, table|
+Given(/^the following #{capture_plural_factory} exists?:?$/) do |plural_factory, table|
   name = plural_factory.singularize
   table.hashes.each { |hash| create_model(name, hash) }
 end
 
 # find a model
 Then(/^#{capture_model} should exist(?: with #{capture_fields})?$/) do |name, fields|
-  find_model(name, fields).should_not be_nil
+  find_model!(name, fields)
 end
 
 # not find a model
@@ -26,37 +26,48 @@ Then(/^#{capture_model} should not exist(?: with #{capture_fields})?$/) do |name
   find_model(name, fields).should be_nil
 end
 
+# find models with a table
+Then(/^the following #{capture_plural_factory} should exists?:?$/) do |plural_factory, table|
+  name = plural_factory.singularize
+  table.hashes.each { |hash| find_model!(name, hash)}
+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
 end
 
+# assert equality of models
+Then(/^#{capture_model} should be #{capture_model}$/) do |a, b|
+  model!(a).should == 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))
+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))
 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))
+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))
 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)
+Then(/^#{capture_model} should be #{capture_model}(?:'s)? (\w+)$/) do |target, owner, association|
+  model!(owner).send(association).should == 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)
+Then(/^#{capture_model} should not be #{capture_model}(?:'s)? (\w+)$/) do |target, owner, association|
+  model!(owner).send(association).should_not == model!(target)
 end
 
 # assert model.predicate? 
 Then(/^#{capture_model} should (?:be|have) (?:an? )?#{capture_predicate}$/) do |name, predicate|
-  model(name).should send("be_#{predicate.gsub(' ', '_')}")
+  model!(name).should send("be_#{predicate.gsub(' ', '_')}")
 end
 
 # assert not model.predicate?
 Then(/^#{capture_model} should not (?:be|have) (?:an? )?#{capture_predicate}$/) do |name, predicate|
-  model(name).should_not send("be_#{predicate.gsub(' ', '_')}")
+  model!(name).should_not send("be_#{predicate.gsub(' ', '_')}")
 end

data/features/support/email.rb

@@ -0,0 +1,21 @@
+module EmailHelpers
+  # Maps a name to an email address. Used by email_steps
+
+  def email_for(to)
+    case to
+  
+    # add your own name => email address mappings here
+  
+    when /^#{capture_model}$/
+      model($1).email
+  
+    when /^"(.*)"$/
+      $1
+  
+    else
+      to
+    end
+  end
+end
+
+World(EmailHelpers)

data/lib/pickle/path.rb

@@ -13,31 +13,32 @@ module Pickle
     #   path_to_pickle 'the user', :extra => 'new comment' # => /users/3/comments/new
     def path_to_pickle(*pickle_names)
       options = pickle_names.extract_options!
-      models = pickle_names.map{|m| model!(m)}
+      resources = pickle_names.map{|n| model(n) || n.to_sym}
       if options[:extra]
         parts = options[:extra].underscore.gsub(' ','_').split("_")
-        find_pickle_path_using_action_segment_combinations(models, parts)
+        find_pickle_path_using_action_segment_combinations(resources, parts)
       else
-        pickle_path_for_models_action_segment(models, options[:action], options[:segment])
+        pickle_path_for_resources_action_segment(resources, options[:action], options[:segment])
       end or raise "Could not figure out a path for #{pickle_names.inspect} #{options.inspect}"
     end
     
   protected
-    def find_pickle_path_using_action_segment_combinations(models, parts)
+    def find_pickle_path_using_action_segment_combinations(resources, parts)
       path = nil
       (0..parts.length).each do |idx|
         action  = parts.slice(0, idx).join('_')
         segment = parts.slice(idx, parts.length).join('_')
-        path = pickle_path_for_models_action_segment(models, action, segment) and break
+        path = pickle_path_for_resources_action_segment(resources, action, segment) and break
       end
       path
     end
     
-    def pickle_path_for_models_action_segment(models, action, segment)
+    def pickle_path_for_resources_action_segment(resources, action, segment)
       action.blank? or action = action.downcase.gsub(' ','_')
       segment.blank? or segment = segment.downcase.gsub(' ','_')
-      model_names = models.map{|m| m.class.name.underscore}.join("_")
-      parts = [action, model_names, segment].reject(&:blank?)
+      resource_names = resources.map{|s| s.is_a?(Symbol) ? s.to_s : s.class.name.underscore}.join("_")
+      models = resources.reject{|s| s.is_a?(Symbol)}
+      parts = [action, resource_names, segment].reject(&:blank?)
       send("#{parts.join('_')}_path", *models) rescue nil
     end
   end

data/lib/pickle/session.rb

@@ -23,7 +23,7 @@ module Pickle
     def create_model(a_model_name, fields = nil)
       factory, label = *parse_model(a_model_name)
       raise ArgumentError, "Can't create with an ordinal (e.g. 1st user)" if label.is_a?(Integer)
-      fields = fields.instance_of?(Hash) ? fields.dup : parse_fields(fields)
+      fields = fields.is_a?(Hash) ? parse_hash(fields) : parse_fields(fields)
       record = pickle_config.factories[factory].create(fields)
       store_model(factory, label, record)
     end
@@ -32,11 +32,16 @@ module Pickle
       factory, name = *parse_model(a_model_name)
       raise ArgumentError, "Can't find a model with an ordinal (e.g. 1st user)" if name.is_a?(Integer)
       model_class = pickle_config.factories[factory].klass
-      if record = model_class.find(:first, :conditions => convert_models_to_attributes(model_class, parse_fields(fields)))
+      fields = fields.is_a?(Hash) ? parse_hash(fields) : parse_fields(fields)
+      if record = model_class.find(:first, :conditions => convert_models_to_attributes(model_class, fields))
         store_model(factory, name, record)
       end
     end
     
+    def find_model!(a_model_name, fields = nil)
+      find_model(a_model_name, fields) or raise "Can't find pickle model: '#{name}' in this scenario"
+    end
+    
     def find_models(factory, fields = nil)
       models_by_index(factory).clear
       model_class = pickle_config.factories[factory].klass
@@ -53,7 +58,7 @@ module Pickle
       elsif name_or_index.is_a?(Integer)
         models_by_index(factory)[name_or_index]
       else
-        models_by_name(factory)[name_or_index] or raise "model: #{name} does not refer to known model in this scenario"
+        models_by_name(factory)[name_or_index] or raise "Can't find pickle model: '#{name}' in this scenario"
       end
     end
 

data/lib/pickle/session/parser.rb

@@ -19,6 +19,16 @@ module Pickle
           parse_field_without_model(field)
         end
       end    
+      
+      def parse_hash(hash)
+        hash.inject({}) do |parsed, (key, val)|
+          if session && val =~ /^#{capture_model}$/
+            parsed.merge(key => session.model($1))
+          else
+            parsed.merge(key => val)
+          end
+        end
+      end
     end
   end
 end

data/pickle.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{pickle}
-  s.version = "0.1.23"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Ian White"]
-  s.date = %q{2009-11-22}
+  s.date = %q{2009-11-24}
   s.description = %q{Easy model creation and reference in your cucumber features}
   s.email = %q{ian.w.white@gmail.com}
   s.extra_rdoc_files = [
@@ -41,6 +41,7 @@ Gem::Specification.new do |s|
      "features/step_definitions/generator_steps.rb",
      "features/step_definitions/path_steps.rb",
      "features/step_definitions/pickle_steps.rb",
+     "features/support/email.rb",
      "features/support/env.rb",
      "features/support/paths.rb",
      "features/support/pickle.rb",
@@ -63,6 +64,7 @@ Gem::Specification.new do |s|
      "lib/pickle/world.rb",
      "pickle.gemspec",
      "rails_generators/pickle/pickle_generator.rb",
+     "rails_generators/pickle/templates/email.rb",
      "rails_generators/pickle/templates/email_steps.rb",
      "rails_generators/pickle/templates/paths.rb",
      "rails_generators/pickle/templates/pickle.rb",

data/rails_generators/pickle/pickle_generator.rb

@@ -30,6 +30,7 @@ class PickleGenerator < Rails::Generator::Base
       if @generate_email_steps
         pickle_assigns[:pickle_email] = true
         m.template 'email_steps.rb', File.join('features/step_definitions', 'email_steps.rb')
+        m.template 'email.rb', File.join('features/support', 'email.rb')
       end
 
       m.template 'pickle_steps.rb', File.join('features/step_definitions', 'pickle_steps.rb')      

data/rails_generators/pickle/templates/email.rb

@@ -0,0 +1,21 @@
+module EmailHelpers
+  # Maps a name to an email address. Used by email_steps
+
+  def email_for(to)
+    case to
+  
+    # add your own name => email address mappings here
+  
+    when /^#{capture_model}$/
+      model($1).email
+  
+    when /^"(.*)"$/
+      $1
+  
+    else
+      to
+    end
+  end
+end
+
+World(EmailHelpers)

data/rails_generators/pickle/templates/email_steps.rb

@@ -1,4 +1,6 @@
 # this file generated by script/generate pickle email
+#
+# add email mappings in features/support/email.rb
 
 ActionMailer::Base.delivery_method = :test
 ActionMailer::Base.perform_deliveries = true
@@ -7,6 +9,7 @@ Before do
   ActionMailer::Base.deliveries.clear
 end
 
+# Clear the deliveries array, useful if your background sends email that you want to ignore
 Given(/^all emails? (?:have|has) been delivered$/) do
   ActionMailer::Base.deliveries.clear
 end
@@ -16,8 +19,7 @@ Given(/^(\d)+ emails? should be delivered$/) do |count|
 end
 
 Then(/^(\d)+ emails? should be delivered to (.*)$/) do |count, to|
-  to =~ /^#{capture_model}$/ && to = model($1).email
-  emails("to: \"#{to}\"").size.should == count.to_i
+  emails("to: \"#{email_for(to)}\"").size.should == count.to_i
 end
 
 Then(/^(\d)+ emails? should be delivered with #{capture_fields}$/) do |count, fields|
@@ -25,8 +27,7 @@ Then(/^(\d)+ emails? should be delivered with #{capture_fields}$/) do |count, fi
 end
 
 Then(/^#{capture_email} should be delivered to (.+)$/) do |email_ref, to|
-  to =~ /^#{capture_model}$/ && to = model($1).email
-  email(email_ref, "to: \"#{to}\"").should_not be_nil
+  email(email_ref, "to: \"#{email_for(to)}\"").should_not be_nil
 end
 
 Then(/^#{capture_email} should have #{capture_fields}$/) do |email_ref, fields|

data/rails_generators/pickle/templates/pickle_steps.rb

@@ -11,14 +11,14 @@ Given(/^(\d+) #{capture_plural_factory} exist(?: with #{capture_fields})?$/) do
 end
 
 # create models from a table
-Given /^the following #{capture_plural_factory} exist$/ do |plural_factory, table|
+Given(/^the following #{capture_plural_factory} exists?:?$/) do |plural_factory, table|
   name = plural_factory.singularize
   table.hashes.each { |hash| create_model(name, hash) }
 end
 
 # find a model
 Then(/^#{capture_model} should exist(?: with #{capture_fields})?$/) do |name, fields|
-  find_model(name, fields).should_not be_nil
+  find_model!(name, fields)
 end
 
 # not find a model
@@ -26,37 +26,48 @@ Then(/^#{capture_model} should not exist(?: with #{capture_fields})?$/) do |name
   find_model(name, fields).should be_nil
 end
 
+# find models with a table
+Then(/^the following #{capture_plural_factory} should exists?:?$/) do |plural_factory, table|
+  name = plural_factory.singularize
+  table.hashes.each { |hash| find_model!(name, hash)}
+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
 end
 
+# assert equality of models
+Then(/^#{capture_model} should be #{capture_model}$/) do |a, b|
+  model!(a).should == 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))
+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))
 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))
+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))
 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)
+Then(/^#{capture_model} should be #{capture_model}(?:'s)? (\w+)$/) do |target, owner, association|
+  model!(owner).send(association).should == 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)
+Then(/^#{capture_model} should not be #{capture_model}(?:'s)? (\w+)$/) do |target, owner, association|
+  model!(owner).send(association).should_not == model!(target)
 end
 
 # assert model.predicate? 
 Then(/^#{capture_model} should (?:be|have) (?:an? )?#{capture_predicate}$/) do |name, predicate|
-  model(name).should send("be_#{predicate.gsub(' ', '_')}")
+  model!(name).should send("be_#{predicate.gsub(' ', '_')}")
 end
 
 # assert not model.predicate?
 Then(/^#{capture_model} should not (?:be|have) (?:an? )?#{capture_predicate}$/) do |name, predicate|
-  model(name).should_not send("be_#{predicate.gsub(' ', '_')}")
+  model!(name).should_not send("be_#{predicate.gsub(' ', '_')}")
 end

data/spec/lib/pickle_path_spec.rb

@@ -5,72 +5,87 @@ describe Pickle::Path do
   
   describe "#path_to_pickle, when the model doesn't exist" do
     before do
-      stub!(:model!).and_raise("foo")
+      stub!(:model).and_return(nil)
     end
     it "('that user', :extra => 'new comment') should raise the error raised by model!" do
-      lambda { path_to_pickle "that user", "new comment" }.should raise_error("foo")
+      lambda { path_to_pickle "that user", "new comment" }.should raise_error(RuntimeError, 'Could not figure out a path for ["that user", "new comment"] {}')
     end
     
   end
   
   describe "#path_to_pickle" do
-    before do
-      stub!(:model!).and_return(@user = mock_model(User))
-    end
-    it "('a user', 'the user: \"fred\"') should retrieve 'a user', and 'the user: \"fred\"' models" do
-      should_receive(:model!).with('a user')
-      should_receive(:model!).with('the user: "fred"')
-      stub!(:user_user_path).and_return('the path')
-      path_to_pickle 'a user', 'the user: "fred"'
-    end
+    describe "when model returns a user" do
+      before do
+        stub!(:model).and_return(@user = mock_model(User))
+      end
     
-    it "('a user', :action => 'foo') should return foo_user_path(<user>)" do
-      should_receive(:foo_user_path).with(@user).and_return('the path')
-      path_to_pickle('a user', :action => 'foo').should == 'the path'
-    end
+      it "('a user', 'the user: \"fred\"') should retrieve 'a user', and 'the user: \"fred\"' models" do
+        should_receive(:model).with('a user')
+        should_receive(:model).with('the user: "fred"')
+        stub!(:user_user_path).and_return('the path')
+        path_to_pickle('a user', 'the user: "fred"').should == 'the path'
+      end
     
-    it "('a user', :action => 'foo') should raise informative error if foo_user_path not defined" do
-      should_receive(:foo_user_path).with(@user).and_raise(NoMethodError)
-      lambda { path_to_pickle('a user', :action => 'foo') }.should raise_error(Exception, /Could not figure out a path for/)
-    end
+      it "('a user', :action => 'foo') should return foo_user_path(<user>)" do
+        should_receive(:foo_user_path).with(@user).and_return('the path')
+        path_to_pickle('a user', :action => 'foo').should == 'the path'
+      end
     
-    it "('a user', :segment => 'foo') should return user_foo_path(<user>)" do
-      should_receive(:user_foo_path).with(@user).and_return('the path')
-      path_to_pickle('a user', :segment => 'foo').should == 'the path'
-    end
+      it "('a user', :action => 'foo') should raise informative error if foo_user_path not defined" do
+        should_receive(:foo_user_path).with(@user).and_raise(NoMethodError)
+        lambda { path_to_pickle('a user', :action => 'foo') }.should raise_error(Exception, /Could not figure out a path for/)
+      end
     
-    it "('a user', :segment => 'foo') should raise informative error if foo_user_path not defined" do
-      should_receive(:user_foo_path).with(@user).and_raise(NoMethodError)
-      lambda { path_to_pickle('a user', :segment => 'foo') }.should raise_error(Exception, /Could not figure out a path for/)
-    end
+      it "('a user', :segment => 'foo') should return user_foo_path(<user>)" do
+        should_receive(:user_foo_path).with(@user).and_return('the path')
+        path_to_pickle('a user', :segment => 'foo').should == 'the path'
+      end
     
-    it "('a user', :action => 'new', :segment => 'comment') should return new_user_comment_path(<user>)" do
-      should_receive(:new_user_comment_path).with(@user).and_return('the path')
-      path_to_pickle('a user', :segment => 'comment', :action => 'new').should == 'the path'
-    end
+      it "('a user', :segment => 'foo') should raise informative error if foo_user_path not defined" do
+        should_receive(:user_foo_path).with(@user).and_raise(NoMethodError)
+        lambda { path_to_pickle('a user', :segment => 'foo') }.should raise_error(Exception, /Could not figure out a path for/)
+      end
     
-    it "('a user', :action => 'new', :segment => 'comment') should raise informative error if new_user_comment_path not defined" do
-      should_receive(:new_user_comment_path).with(@user).and_raise(NoMethodError)
-      lambda { path_to_pickle('a user', :action => 'new', :segment => 'comment') }.should raise_error(Exception, /Could not figure out a path for/)
-    end
+      it "('a user', :action => 'new', :segment => 'comment') should return new_user_comment_path(<user>)" do
+        should_receive(:new_user_comment_path).with(@user).and_return('the path')
+        path_to_pickle('a user', :segment => 'comment', :action => 'new').should == 'the path'
+      end
     
-    it "('a user', :extra => 'new comment') should return new_user_comment_path(<user>)" do
-      should_receive(:new_user_comment_path).with(@user).and_return('the path')
-      path_to_pickle('a user', :extra => 'new comment').should == 'the path'
-    end
+      it "('a user', :action => 'new', :segment => 'comment') should raise informative error if new_user_comment_path not defined" do
+        should_receive(:new_user_comment_path).with(@user).and_raise(NoMethodError)
+        lambda { path_to_pickle('a user', :action => 'new', :segment => 'comment') }.should raise_error(Exception, /Could not figure out a path for/)
+      end
     
-    it "('a user', :extra => 'new comment') should raise informative error if new_user_comment_path not defined" do
-      should_receive(:new_user_comment_path).with(@user).and_raise(NoMethodError)
-      lambda { path_to_pickle('a user', :extra => 'new comment') }.should raise_error(Exception, /Could not figure out a path for/)
+      it "('a user', :extra => 'new comment') should return new_user_comment_path(<user>)" do
+        should_receive(:new_user_comment_path).with(@user).and_return('the path')
+        path_to_pickle('a user', :extra => 'new comment').should == 'the path'
+      end
+    
+      it "('a user', :extra => 'new comment') should raise informative error if new_user_comment_path not defined" do
+        should_receive(:new_user_comment_path).with(@user).and_raise(NoMethodError)
+        lambda { path_to_pickle('a user', :extra => 'new comment') }.should raise_error(Exception, /Could not figure out a path for/)
+      end
+      
+      describe "(private API)" do
+        it "('a user', :extra => 'new ish comment') should try combinations of 'new', 'ish', 'comment'" do
+          should_receive(:pickle_path_for_resources_action_segment).with([@user], '', 'new_ish_comment').once
+          should_receive(:pickle_path_for_resources_action_segment).with([@user], 'new', 'ish_comment').once
+          should_receive(:pickle_path_for_resources_action_segment).with([@user], 'new_ish', 'comment').once
+          should_receive(:pickle_path_for_resources_action_segment).with([@user], 'new_ish_comment', '').once
+          lambda { path_to_pickle('a user', :extra => 'new ish comment') }.should raise_error(Exception, /Could not figure out a path for/)
+        end
+      end
     end
     
-    describe "(private API)" do
-      it "('a user', :extra => 'new ish comment') should try combinations of 'new', 'ish', 'comment'" do
-        should_receive(:pickle_path_for_models_action_segment).with([@user], '', 'new_ish_comment').once
-        should_receive(:pickle_path_for_models_action_segment).with([@user], 'new', 'ish_comment').once
-        should_receive(:pickle_path_for_models_action_segment).with([@user], 'new_ish', 'comment').once
-        should_receive(:pickle_path_for_models_action_segment).with([@user], 'new_ish_comment', '').once
-        lambda { path_to_pickle('a user', :extra => 'new ish comment') }.should raise_error(Exception, /Could not figure out a path for/)
+    describe "when args is a list of pickle and non pickle models" do
+      before do
+        stub!(:model).with("account").and_return(nil)
+        stub!(:model).with("the user").and_return(@user = mock_model(User))
+      end
+      
+      it "('account', 'the user') should return account_user_path(<user>)" do
+        should_receive(:account_user_path).with(@user).and_return("the path")
+        path_to_pickle('account', 'the user').should == 'the path'
       end
     end
   end

data/spec/lib/pickle_session_spec.rb

@@ -188,6 +188,35 @@ describe Pickle::Session do
       
       it_should_behave_like "after storing a single user"
     end
+    
+    describe "with hash" do
+      def do_create_model
+        find_model('a user', {'foo' => 'bar'})
+      end
+  
+      it "should call User.find('user', {'foo' => 'bar'})" do
+        User.should_receive(:find).with(:first, :conditions => {'foo' => 'bar'}).and_return(@user)
+        do_create_model
+      end
+      
+      describe "after find," do
+        before { do_find_model }
+        
+        it_should_behave_like "after storing a single user"
+      end
+    end
+  end
+  
+  describe "#find_model!" do
+    it "should call find_model" do
+      should_receive(:find_model).with('name', 'fields').and_return(mock('User'))
+      find_model!('name', 'fields')
+    end
+
+    it "should call raise error if find_model returns nil" do
+      should_receive(:find_model).with('name', 'fields').and_return(nil)
+      lambda { find_model!('name', 'fields') }.should raise_error
+    end
   end
   
   describe "#find_models" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: pickle
 version: !ruby/object:Gem::Version 
-  version: 0.1.23
+  version: 0.2.0
 platform: ruby
 authors: 
 - Ian White
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-22 00:00:00 +00:00
+date: 2009-11-24 00:00:00 +00:00
 default_executable: 
 dependencies: []
 
@@ -47,6 +47,7 @@ files:
 - features/step_definitions/generator_steps.rb
 - features/step_definitions/path_steps.rb
 - features/step_definitions/pickle_steps.rb
+- features/support/email.rb
 - features/support/env.rb
 - features/support/paths.rb
 - features/support/pickle.rb
@@ -69,6 +70,7 @@ files:
 - lib/pickle/world.rb
 - pickle.gemspec
 - rails_generators/pickle/pickle_generator.rb
+- rails_generators/pickle/templates/email.rb
 - rails_generators/pickle/templates/email_steps.rb
 - rails_generators/pickle/templates/paths.rb
 - rails_generators/pickle/templates/pickle.rb