ianwhite-pickle 0.1.5 → 0.1.6

data/rails_generators/pickle/templates/pickle_steps.rb

@@ -17,12 +17,11 @@ end
 
 # find exactly n models
 Then(/^(\d+) #{capture_plural_factory} should exist(?: with #{capture_fields})?$/) do |count, plural_factory, fields|
-  clear_models(plural_factory.singularize)
   find_models(plural_factory.singularize, fields).size.should == count.to_i
 end
 
 # assert model is in another model's has_many assoc
-Then(/^#{capture_model} should be in #{capture_model}'s (\w+)$/) do |target, owner, association|
+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
 

data/spec/lib/pickle_adapter_spec.rb

@@ -9,8 +9,16 @@ describe Pickle::Adapter do
     lambda{ Pickle::Adapter.new.create }.should raise_error(NotImplementedError)
   end
   
-  it ".model_classes should not include CGI::Session::ActiveRecordStore" do
-    Pickle::Adapter.model_classes.should_not include(CGI::Session::ActiveRecordStore)
+  if defined?(CGI::Session::ActiveRecordStore::Session)
+    it ".model_classes should not include CGI::Session::ActiveRecordStore::Session" do
+      Pickle::Adapter.model_classes.should_not include(CGI::Session::ActiveRecordStore)
+    end
+  end
+  
+  if defined?(ActiveRecord::SessionStore::Session)
+    it ".model_classes should not include ActiveRecord::SessionStore::Session" do
+      Pickle::Adapter.model_classes.should_not include(ActiveRecord::SessionStore::Session)
+    end
   end
   
   describe '::ActiveRecord' do

data/spec/lib/pickle_config_spec.rb

@@ -48,17 +48,12 @@ describe Pickle::Config do
     end
   end
   
-  it "#factory_names should be keys of #factories" do
-    @config.should_receive(:factories).and_return('one' => nil, 'two' => nil)
-    @config.factory_names.sort.should == ['one', 'two'].sort
-  end
-  
   it "#mappings should default to []" do
     @config.mappings.should == []
   end
 
   describe '#predicates' do
-    it "should be list of all ? public instance methods + columns methods of Adapter.model_classes" do
+    it "should be list of all non object ? public instance methods + columns methods of Adapter.model_classes" do
       class1 = mock('Class1', :public_instance_methods => ['nope', 'foo?', 'bar?'], :column_names => ['one', 'two'])
       class2 = mock('Class2', :public_instance_methods => ['not', 'foo?', 'faz?'], :column_names => ['two', 'three'])
       Pickle::Adapter.stub!(:model_classes).and_return([class1, class2])
@@ -87,8 +82,9 @@ describe Pickle::Config do
       @config.map 'foo', 'bar', :to => 'faz'
     end
     
-    it "should create OpenStruct(search: '(?:foo|bar)', replace: 'faz') mapping" do
-      @config.mappings.first.should == OpenStruct.new(:search => '(?:foo|bar)', :replace => 'faz')
+    it "should create 2 mappings" do
+      @config.mappings.first.should == OpenStruct.new(:search => 'foo', :replace => 'faz')
+      @config.mappings.last.should == OpenStruct.new(:search => 'bar', :replace => 'faz')
     end
   end
   

data/spec/lib/pickle_email_parser_spec.rb

@@ -0,0 +1,49 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../spec_helper'))
+
+describe Pickle::Email::Parser do
+  include Pickle::Parser::Matchers
+  include Pickle::Email::Parser
+  
+  describe "#match_email" do
+    it "should match 'the email'" do
+      'the email'.should match(/^#{match_email}$/)
+    end
+    
+    it "should match 'the first email'" do
+      'the first email'.should match(/^#{match_email}$/)
+    end
+    
+    it "should match 'the last email'" do
+      'the last email'.should match(/^#{match_email}$/)
+    end
+    
+    it "should match 'the 3rd email'" do
+      'the 3rd email'.should match(/^#{match_email}$/)
+    end
+    
+    it "should match 'an email'" do
+      'an email'.should match(/^#{match_email}$/)
+    end
+  end
+  
+  it "#capture_email should just capture match_email" do
+    capture_email.should == "(#{match_email})"
+  end
+  
+  describe "#capture_index_in_email" do
+    it "should extract the '2nd' from 'the 2nd email'" do
+      match = 'the 2nd email'.match(/^#{capture_index_in_email}$/)
+      match[1].should == '2nd'
+    end
+    
+    it "should extract nil from 'the email'" do
+      match = 'the email'.match(/^#{capture_index_in_email}$/)
+      match[1].should == nil
+    end
+    
+    it "should extract the 'last' from 'the last email'" do
+      match = 'the last email'.match(/^#{capture_index_in_email}$/)
+      match[1].should == 'last'
+    end
+  end
+end

data/spec/lib/pickle_email_spec.rb

@@ -0,0 +1,131 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../spec_helper'))
+
+describe Pickle::Email do
+  include Pickle::Session
+  include Pickle::Email
+  include Pickle::Email::Parser
+
+  before do
+    @email1 = mock("Email 1")
+    @email2 = mock("Email 2")
+    ActionMailer::Base.stub!(:deliveries).and_return([@email1, @email2])
+  end
+  
+  describe "#emails" do
+    it "should return ordered deliveries" do
+      emails.should == [@email1, @email2]
+    end
+    
+    describe "(after)" do
+      before do
+        emails
+      end
+      
+      it "#email('the email') should return the last delivery" do
+        email('the email').should == @email2
+      end
+      
+      it "#email('the 1st email') should return the first delivery" do
+        email('the 1st email').should == @email1
+      end
+
+      it "#email('the first email') should return the first delivery" do
+        email('the first email').should == @email1
+      end
+
+      it "#email('the 2nd email') should return the second delivery" do
+        email('the 2nd email').should == @email2
+      end
+      
+      it "#email('the last email') should return the second delivery" do
+        email('the last email').should == @email2
+      end
+      
+      it "#email2('the 3rd email') should be nil" do
+        email('the 3rd email').should == nil
+      end
+    end
+    
+    describe "when email1 is to fred & joe, and email2 is to joe" do
+      before do
+        @email1.stub!(:to).and_return(['fred@gmail.com', 'joe@gmail.com'])
+        @email2.stub!(:to).and_return('joe@gmail.com')
+      end
+      
+      it "#emails('to: \"fred@gmail.com\"') should just return email1" do
+        emails('to: "fred@gmail.com"').should == [@email1]
+      end
+      
+      describe "after #emails('to: \"fred@gmail.com\"')" do
+        before do
+          emails('to: "fred@gmail.com"')
+        end
+        
+        it "#email('first') should be #email('last')" do
+          email('first email').should == email('last email')
+          email('first email').should == @email1
+        end
+        
+        it "#email('the email', 'to: \"blah\") should be nil" do
+          email('the email', 'to: "blah"').should == nil
+        end
+
+        it "#email('the email', 'to: \"fred@gmail.com\") should be email1" do
+          email('the email', 'to: "fred@gmail.com"').should == @email1
+        end
+      end
+      
+      it "#emails('to: \"joe@gmail.com\"') should return both emails" do
+        emails('to: "joe@gmail.com"').should == [@email1, @email2]
+      end
+      
+      describe "and emails have subjects 'email1', 'email2'" do
+        before do
+          @email1.stub!(:subject).and_return('email1')
+          @email2.stub!(:subject).and_return('email2')
+        end
+        
+        it "#emails('to: \"joe@gmail.com\", subject: \"email1\"') should return email1" do
+          emails('to: "joe@gmail.com", subject: "email1"').should == [@email1]
+        end
+        
+        it "#emails('to: \"fred@gmail.com\", subject: \"email2\"') should return empty array" do
+          emails('to: "fred@gmail.com", subject: "email2"').should == []
+        end
+      end
+    end
+  end
+  
+  describe "#save_and_open_emails" do
+    before do
+      stub!(:open_in_browser)
+      stub!(:emails).and_return(["Contents of Email 1"])
+      @now = "2008-01-01".to_time
+      Time.stub!(:now).and_return(@now)
+    end
+    
+    it "should call #emails to get emails" do
+      should_receive(:emails).and_return([])
+      save_and_open_emails
+    end
+    
+    describe "when emails have been already been found" do
+      before { @emails = [] }
+      
+      it "should not call #emails" do
+        should_not_receive(:emails)
+        save_and_open_emails
+      end
+    end
+    
+    it "should create a file in Rails/tmp with the emails in it" do
+      save_and_open_emails
+      File.read("#{RAILS_ROOT}/tmp/webrat-email-#{@now.to_i}.html").should == "<h1>Email 1</h1><pre>Contents of Email 1</pre><hr />"
+    end
+
+    it "should call open_in_browser on created tmp file" do
+      should_receive(:open_in_browser).with("#{RAILS_ROOT}/tmp/webrat-email-#{@now.to_i}.html")
+      save_and_open_emails
+    end
+  end
+end

data/spec/lib/pickle_path_spec.rb

@@ -0,0 +1,68 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../spec_helper'))
+
+describe Pickle::Path do
+  include Pickle::Path
+  
+  before do
+    stub!(:model).and_return(@user = mock_model(User))
+  end
+  
+  describe "#pickle_path" do
+    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')
+      pickle_path 'a user', 'the user: "fred"'
+    end
+    
+    it "('a user', :action => 'foo') should return foo_user_path(<user>)" do
+      should_receive(:foo_user_path).with(@user).and_return('the path')
+      pickle_path('a user', :action => '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 { pickle_path('a user', :action => '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')
+      pickle_path('a user', :segment => 'foo').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 { pickle_path('a user', :segment => 'foo') }.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')
+      pickle_path('a user', :segment => 'comment', :action => 'new').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 { pickle_path('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 return new_user_comment_path(<user>)" do
+      should_receive(:new_user_comment_path).with(@user).and_return('the path')
+      pickle_path('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 { pickle_path('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_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 { pickle_path('a user', :extra => 'new ish comment') }.should raise_error(Exception, /Could not figure out a path for/)
+      end
+    end
+  end
+end

data/spec/lib/pickle_session_spec.rb

@@ -1,26 +1,52 @@
 require File.expand_path(File.join(File.dirname(__FILE__), '../spec_helper'))
 
 describe Pickle::Session do
-  before do
-    @session = Pickle::Session.new
+  include Pickle::Session
+  
+  describe "Pickle::Session proxy missing methods to parser", :shared => true do
+    it "should forward to pickle_parser it responds_to them" do
+      @it.pickle_parser.should_receive(:parse_model)
+      @it.parse_model
+    end
+
+    it "should raise error if pickle_parser don't know about em" do
+      lambda { @it.parse_infinity }.should raise_error
+    end
+  end
+
+  describe "including Pickle::Session" do
+    before do 
+      @it = self
+    end
+    
+    it_should_behave_like "Pickle::Session proxy missing methods to parser"
+  end
+
+  describe "extending Pickle::Session" do
+    before do 
+      @it = Object.new
+      @it.extend Pickle::Session
+    end
+    
+    it_should_behave_like "Pickle::Session proxy missing methods to parser"
   end
 
   describe "after storing a single user", :shared => true do
     it "created_models('user') should be array containing the original user" do
-      @session.created_models('user').should == [@user]
+      created_models('user').should == [@user]
     end
 
     describe "the original user should be retrievable with" do
       it "created_model('the user')" do
-        @session.created_model('the user').should == @user
+        created_model('the user').should == @user
       end
 
       it "created_model('1st user')" do
-        @session.created_model('1st user').should == @user
+        created_model('1st user').should == @user
       end
 
       it "created_model('last user')" do
-        @session.created_model('last user').should == @user
+        created_model('last user').should == @user
       end
     end
 
@@ -31,20 +57,20 @@ describe Pickle::Session do
       end
     
       it "models('user') should be array containing user" do
-        @session.models('user').should == [@user_from_db]
+        models('user').should == [@user_from_db]
       end
   
       describe "user should be retrievable with" do
         it "model('the user')" do
-          @session.model('the user').should == @user_from_db
+          model('the user').should == @user_from_db
         end
 
         it "model('1st user')" do
-          @session.model('1st user').should == @user_from_db
+          model('1st user').should == @user_from_db
         end
 
         it "model('last user')" do
-          @session.model('last user').should == @user_from_db
+          model('last user').should == @user_from_db
         end
       end
     end
@@ -58,7 +84,7 @@ describe Pickle::Session do
     
     describe "('a user')" do
       def do_create_model
-        @session.create_model('a user')
+        create_model('a user')
       end
   
       it "should call Factory.create('user', {})" do
@@ -75,7 +101,7 @@ describe Pickle::Session do
     
     describe "('1 user', 'foo: \"bar\", baz: \"bing bong\"')" do
       def do_create_model
-        @session.create_model('1 user', 'foo: "bar", baz: "bing bong"')
+        create_model('1 user', 'foo: "bar", baz: "bing bong"')
       end
   
       it "should call Factory.create('user', {'foo' => 'bar', 'baz' => 'bing bong'})" do
@@ -92,7 +118,7 @@ describe Pickle::Session do
 
     describe "('an user: \"fred\")" do
       def do_create_model
-        @session.create_model('an user: "fred"')
+        create_model('an user: "fred"')
       end
   
       it "should call Factory.create('user', {})" do
@@ -106,15 +132,15 @@ describe Pickle::Session do
         it_should_behave_like "after storing a single user"
               
         it "created_model('the user: \"fred\"') should retrieve the user" do
-          @session.created_model('the user: "fred"').should == @user
+          created_model('the user: "fred"').should == @user
         end
       
         it "created_model?('the user: \"shirl\"') should be false" do
-          @session.created_model?('the user: "shirl"').should == false
+          created_model?('the user: "shirl"').should == false
         end
         
         it "model?('the user: \"shirl\"') should be false" do
-          @session.model?('the user: "shirl"').should == false
+          model?('the user: "shirl"').should == false
         end
       end
     end  
@@ -127,7 +153,7 @@ describe Pickle::Session do
     end
     
     def do_find_model
-      @session.find_model('a user', 'hair: "pink"')
+      find_model('a user', 'hair: "pink"')
     end
     
     it "should call User.find :first, :conditions => {'hair' => 'pink'}" do
@@ -149,7 +175,7 @@ describe Pickle::Session do
     end
 
     def do_find_models
-      @session.find_models('user', 'hair: "pink"')
+      find_models('user', 'hair: "pink"')
     end
 
     it "should call User.find :all, :conditions => {'hair' => 'pink'}" do
@@ -163,16 +189,6 @@ describe Pickle::Session do
       it_should_behave_like "after storing a single user"
     end
   end
-  
-  describe '#clear_models(<factory_name>)' do
-    it "should clear the storage for that factory name" do
-      @session.send :store_model, 'user', nil, mock('user')
-      @session.send :store_model, 'car', nil, mock('user')
-      @session.clear_models('user')
-      @session.created_models('user').size.should == 0
-      @session.created_models('car').size.should == 1
-    end
-  end
     
   describe 'creating \'a super admin: "fred"\', then \'a user: "shirl"\', \'then 1 super_admin\'' do
     before do
@@ -183,9 +199,9 @@ describe Pickle::Session do
     end
     
     def do_create_users
-      @session.create_model('a super admin: "fred"')
-      @session.create_model('a user: "shirl"')
-      @session.create_model('1 super_admin')
+      create_model('a super admin: "fred"')
+      create_model('a user: "shirl"')
+      create_model('1 super_admin')
     end
     
     it "should call Factory.create with <'super_admin'>, <'user'>, <'super_admin'>" do
@@ -200,44 +216,44 @@ describe Pickle::Session do
       end
       
       it "created_models('user') should == [@fred, @shirl, @noname]" do
-        @session.created_models('user').should == [@fred, @shirl, @noname]
+        created_models('user').should == [@fred, @shirl, @noname]
       end
       
       it "created_models('super_admin') should == [@fred, @noname]" do
-        @session.created_models('super_admin').should == [@fred, @noname]
+        created_models('super_admin').should == [@fred, @noname]
       end
       
       describe "#created_model" do
         it "'that user' should be @noname (the last user created - as super_admins are users)" do
-          @session.created_model('that user').should == @noname
+          created_model('that user').should == @noname
         end
 
         it "'the super admin' should be @noname (the last super admin created)" do
-          @session.created_model('that super admin').should == @noname
+          created_model('that super admin').should == @noname
         end
         
         it "'the 1st super admin' should be @fred" do
-          @session.created_model('the 1st super admin').should == @fred
+          created_model('the 1st super admin').should == @fred
         end
         
         it "'the first user' should be @fred" do
-          @session.created_model('the first user').should == @fred
+          created_model('the first user').should == @fred
         end
         
         it "'the 2nd user' should be @shirl" do
-          @session.created_model('the 2nd user').should == @shirl
+          created_model('the 2nd user').should == @shirl
         end
         
         it "'the last user' should be @noname" do
-          @session.created_model('the last user').should == @noname
+          created_model('the last user').should == @noname
         end
         
         it "'the user: \"fred\" should be @fred" do
-          @session.created_model('the user: "fred"').should == @fred
+          created_model('the user: "fred"').should == @fred
         end
         
         it "'the user: \"shirl\" should be @shirl" do
-          @session.created_model('the user: "shirl"').should == @shirl
+          created_model('the user: "shirl"').should == @shirl
         end
       end
     end
@@ -248,37 +264,36 @@ describe Pickle::Session do
       @user = mock_model(User)
       User.stub!(:find).and_return(@user)
       Factory.stub!(:create).and_return(@user)
-      parser = Pickle::Parser.new(:config => Pickle::Config.new {|c| c.map 'I', 'myself', :to => 'user: "me"'})
-      @session = Pickle::Session.new(:parser => parser)
-      @session.create_model('the user: "me"')
+      self.pickle_parser = Pickle::Parser.new(:config => Pickle::Config.new {|c| c.map 'I', 'myself', :to => 'user: "me"'})
+      create_model('the user: "me"')
     end
   
     it 'model("I") should return the user' do
-      @session.model('I').should == @user
+      model('I').should == @user
     end
 
     it 'model("myself") should return the user' do
-      @session.model('myself').should == @user
+      model('myself').should == @user
     end
     
     it "#parser.parse_fields 'author: user \"JIM\"' should raise Error, as model deos not refer" do
-      lambda { @session.send(:parser).parse_fields('author: user "JIM"') }.should raise_error
+      lambda { pickle_parser.parse_fields('author: user "JIM"') }.should raise_error
     end
     
     it "#parser.parse_fields 'author: the user' should return {\"author\" => <user>}" do
-      @session.send(:parser).parse_fields('author: the user').should == {"author" => @user}
+      pickle_parser.parse_fields('author: the user').should == {"author" => @user}
     end
 
     it "#parser.parse_fields 'author: myself' should return {\"author\" => <user>}" do
-      @session.send(:parser).parse_fields('author: myself').should == {"author" => @user}
+      pickle_parser.parse_fields('author: myself').should == {"author" => @user}
     end
     
     it "#parser.parse_fields 'author: the user, approver: I, rating: \"5\"' should return {'author' => <user>, 'approver' => <user>, 'rating' => '5'}" do
-      @session.send(:parser).parse_fields('author: the user, approver: I, rating: "5"').should == {'author' => @user, 'approver' => @user, 'rating' => '5'}
+      pickle_parser.parse_fields('author: the user, approver: I, rating: "5"').should == {'author' => @user, 'approver' => @user, 'rating' => '5'}
     end
     
     it "#parser.parse_fields 'author: user: \"me\", approver: \"\"' should return {'author' => <user>, 'approver' => \"\"}" do
-      @session.send(:parser).parse_fields('author: user: "me", approver: ""').should == {'author' => @user, 'approver' => ""}
+      pickle_parser.parse_fields('author: user: "me", approver: ""').should == {'author' => @user, 'approver' => ""}
     end
   end
   
@@ -293,7 +308,7 @@ describe Pickle::Session do
       end
       
       it "should return {'user_id' => <the user.id>}" do
-        @session.send(:convert_models_to_attributes, @ar_class, :user => @user).should == {'user_id' => @user.id}
+        convert_models_to_attributes(@ar_class, :user => @user).should == {'user_id' => @user.id}
       end
     end
     
@@ -303,7 +318,7 @@ describe Pickle::Session do
       end
       
       it "should return {'user_id' => <the user.id>, 'user_type' => <the user.type>}" do
-        @session.send(:convert_models_to_attributes, @ar_class, :user => @user).should == {'user_id' => @user.id, 'user_type' => @user.class.name}
+        convert_models_to_attributes(@ar_class, :user => @user).should == {'user_id' => @user.id, 'user_type' => @user.class.name}
       end
     end
   end