pickle 0.2.12 → 0.3.0

data/lib/pickle/email.rb

@@ -11,7 +11,7 @@ module Pickle
       index = parse_index(match[1])
       email_has_fields?(@emails[index], fields) ? @emails[index] : nil
     end
-    
+
     def email_has_fields?(email, fields)
       parse_fields(fields).each do |key, val|
         return false unless (Array(email.send(key)) & Array(val)).any?
@@ -28,7 +28,7 @@ module Pickle
       request_uri = URI::parse(link).request_uri
       visit request_uri
     end
-  
+
   protected
     def open_in_browser(path) # :nodoc
       require "launchy"
@@ -36,7 +36,7 @@ module Pickle
     rescue LoadError
       warn "Sorry, you need to install launchy to open emails: `gem install launchy`"
     end
-  
+
     # Saves the emails out to RAILS_ROOT/tmp/ and opens it in the default
     # web browser if on OS X. (depends on webrat)
     def save_and_open_emails
@@ -76,4 +76,4 @@ module Pickle
     end
 
   end
-end
+end

data/lib/pickle/session.rb

@@ -26,6 +26,7 @@ module Pickle
       fields = fields.is_a?(Hash) ? parse_hash(fields) : parse_fields(fields)
       record = pickle_config.factories[factory].create(fields)
       store_model(factory, label, record)
+      record
     end
     
     # if a column exists in the table which matches the singular factory name, this is used as the pickle ref
@@ -39,12 +40,17 @@ module Pickle
 
     def find_model(a_model_name, fields = nil)
       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
-      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
+      fields      = fields.is_a?(Hash) ? parse_hash(fields) : parse_fields(fields)
+      conditions  = convert_models_to_attributes(model_class, fields)
+      record      = Pickle::Adapter.find_first_model(model_class, conditions)
+
+      store_model(factory, name, record) if record
+
+      record
     end
     
     def find_model!(a_model_name, fields = nil)
@@ -53,8 +59,11 @@ module Pickle
     
     def find_models(factory, fields = nil)
       models_by_index(factory).clear
+
       model_class = pickle_config.factories[factory].klass
-      records = model_class.find(:all, :conditions => convert_models_to_attributes(model_class, parse_fields(fields)))
+      conditions  = convert_models_to_attributes(model_class, parse_fields(fields))
+      records     = Pickle::Adapter.find_all_models(model_class, conditions)
+
       records.each {|record| store_model(factory, nil, record)}
     end
     
@@ -87,7 +96,9 @@ module Pickle
     
     # return a newly selected model
     def model(name)
-      (model = created_model(name)) && model.class.find(model.id)
+      model = created_model(name)
+      return nil unless model
+      Pickle::Adapter.get_model(model.class, model.id)
     end
     
     # predicate version which raises no errors
@@ -112,7 +123,9 @@ module Pickle
       
     # return all models of specified type (freshly selected from the database)
     def models(factory)
-      created_models(factory).map{|model| model.class.find(model.id) }
+      created_models(factory).map do |model|
+        Pickle::Adapter.get_model(model.class, model.id)
+      end
     end
     
     def respond_to_with_pickle_parser?(method, include_private = false)
@@ -136,14 +149,16 @@ module Pickle
     def pickle_parser
       @pickle_parser or self.pickle_parser = Pickle.parser
     end
-    
+
     def pickle_config
       pickle_parser.config
     end
 
     def convert_models_to_attributes(ar_class, attrs)
       attrs.each do |key, val|
-        if val.is_a?(ActiveRecord::Base) && ar_class.column_names.include?("#{key}_id")
+        if ((defined?(ActiveRecord::Base) && val.is_a?(ActiveRecord::Base)) ||
+          (defined?(DataMapper::Model) && val.is_a?(DataMapper::Model))) &&
+          Pickle::Adapter.column_names(ar_class).include?("#{key}_id")
           attrs["#{key}_id"] = val.id
           attrs["#{key}_type"] = val.class.base_class.name if ar_class.column_names.include?("#{key}_type")
           attrs.delete(key)

data/lib/pickle/world.rb

@@ -1,5 +1,9 @@
 require 'pickle'
 
+# auto require for active record and datamapper
+require 'pickle/adapters/active_record' if defined?(ActiveRecord::Base)
+require 'pickle/adapters/data_mapper'   if defined?(DataMapper::Resource)
+
 # make cucumber world pickle aware
 World(Pickle::Session)
 

data/pickle.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{pickle}
-  s.version = "0.2.12"
+  s.version = "0.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Ian White"]
@@ -54,6 +54,8 @@ Gem::Specification.new do |s|
      "init.rb",
      "lib/pickle.rb",
      "lib/pickle/adapter.rb",
+     "lib/pickle/adapters/active_record.rb",
+     "lib/pickle/adapters/data_mapper.rb",
      "lib/pickle/config.rb",
      "lib/pickle/email.rb",
      "lib/pickle/email/parser.rb",

data/spec/pickle/adapter_spec.rb

@@ -3,176 +3,156 @@ require File.dirname(__FILE__) + '/../spec_helper'
 require 'active_record'
 require 'factory_girl'
 require 'machinist/active_record'
+require 'pickle/adapters/active_record'
 
 describe Pickle::Adapter do
   it ".factories should raise NotImplementedError" do
     lambda{ Pickle::Adapter.factories }.should raise_error(NotImplementedError)
   end
-  
+
   it "#create should raise NotImplementedError" do
     lambda{ Pickle::Adapter.new.create }.should raise_error(NotImplementedError)
   end
-  
-  describe ".suitable_for_pickle?(klass)" do
-    let :klass do
-      mock('Class', :abstract_class? => false, :table_exists? => true)
-    end
-    
-    before do
-      Pickle::Adapter.stub!(:framework_class?).and_return(false)
-    end
-    
-    it "a non abstract class that has a table, and is not a framework class, is suitable_for_pickle" do
-      Pickle::Adapter.should be_suitable_for_pickle(klass)
-    end
-    
-    it "an abtract_class is not suitable_for_pickle" do
-      klass.stub!(:abstract_class?).and_return(true)
-      Pickle::Adapter.should_not be_suitable_for_pickle(klass)
-    end
-    
-    it "a class with no table is not suitable_for_pickle" do
-      klass.stub!(:table_exists?).and_return(false)
-      Pickle::Adapter.should_not be_suitable_for_pickle(klass)
-    end
-    
-    it "an frame_work class is not suitable_for_pickle" do
-      Pickle::Adapter.should_receive(:framework_class?).with(klass).and_return(true)
-      Pickle::Adapter.should_not be_suitable_for_pickle(klass)
-    end
-  end
-  
+
   describe ".model_classes" do
     before do
       Pickle::Adapter.model_classes = nil
     end
-    
+
     it "should only include #suitable_for_pickle classes" do
       klass1 = Class.new(ActiveRecord::Base)
       klass2 = Class.new(ActiveRecord::Base)
-      Pickle::Adapter.should_receive(:suitable_for_pickle?).with(klass1).and_return(true)
-      Pickle::Adapter.should_receive(:suitable_for_pickle?).with(klass2).and_return(false)
-      Pickle::Adapter.model_classes.should include(klass1)
-      Pickle::Adapter.model_classes.should_not include(klass2)
+      klass3 = Class.new(ActiveRecord::Base)
+      klass4 = Class.new(ActiveRecord::Base)
+      klass5 = Class.new(ActiveRecord::Base)
+      klass6 = Class.new(ActiveRecord::Base)
+      [klass1, klass2,klass3,klass4, klass5, klass6].each{|k| k.stub!(:table_exists?).and_return(true)}
+
+      klass2.stub!(:name).and_return("CGI::Session::ActiveRecordStore::Session")
+      klass3.stub!(:name).and_return("ActiveRecord::SessionStore::Session")
+      klass4.stub!(:table_exists?).and_return(false)
+      klass5.stub!(:abstract_class?).and_return(true)
+      Pickle::Adapter.model_classes.should include(klass1, klass6)
+      Pickle::Adapter.model_classes.should_not include(klass2, klass3, klass4, klass5)
     end
   end
-  
+
   describe "adapters: " do
     before do
       @klass1 = returning(Class.new(ActiveRecord::Base)) {|k| k.stub!(:name).and_return('One')}
       @klass2 = returning(Class.new(ActiveRecord::Base)) {|k| k.stub!(:name).and_return('One::Two')}
       @klass3 = returning(Class.new(ActiveRecord::Base)) {|k| k.stub!(:name).and_return('Three')}
     end
-    
+
     describe 'ActiveRecord' do
       before do
-        Pickle::Adapter::ActiveRecord.stub!(:model_classes).and_return([@klass1, @klass2, @klass3])
+        ActiveRecord::Base::PickleAdapter.stub!(:model_classes).and_return([@klass1, @klass2, @klass3])
       end
-      
+
       it ".factories should create one for each active record class" do
         Pickle::Adapter::ActiveRecord.should_receive(:new).with(@klass1).once
         Pickle::Adapter::ActiveRecord.should_receive(:new).with(@klass2).once
         Pickle::Adapter::ActiveRecord.should_receive(:new).with(@klass3).once
         Pickle::Adapter::ActiveRecord.factories
       end
-      
+
       describe ".new(Class)" do
         before do
           @factory = Pickle::Adapter::ActiveRecord.new(@klass2)
         end
-      
+
         it "should have underscored (s/_) name of Class as #name" do
           @factory.name.should == 'one_two'
         end
-      
+
         it "#create(attrs) should call Class.create!(attrs)" do
           @klass2.should_receive(:create!).with({:key => "val"})
           @factory.create(:key => "val")
         end
       end
     end
-  
+
     describe 'FactoryGirl' do
       before do
         Pickle::Adapter::FactoryGirl.stub!(:model_classes).and_return([@klass1, @klass2, @klass3])
         @orig_factories, Factory.factories = Factory.factories, {}
-        
+
         Factory.define(:one, :class => @klass1) {}
         Factory.define(:two, :class => @klass2) {}
         @factory1 = Factory.factories[:one]
         @factory2 = Factory.factories[:two]
       end
-      
+
       after do
         Factory.factories = @orig_factories
       end
-    
+
       it ".factories should create one for each factory" do
         Pickle::Adapter::FactoryGirl.should_receive(:new).with(@factory1).once
         Pickle::Adapter::FactoryGirl.should_receive(:new).with(@factory2).once
         Pickle::Adapter::FactoryGirl.factories
       end
-    
+
       describe ".new(factory)" do
         before do
           @factory = Pickle::Adapter::FactoryGirl.new(@factory1)
         end
-      
+
         it "should have name of factory_name" do
           @factory.name.should == 'one'
         end
-      
+
         it "should have klass of build_class" do
           @factory.klass.should == @klass1
         end
-      
+
         it "#create(attrs) should call Factory(<:key>, attrs)" do
           Factory.should_receive(:create).with("one", {:key => "val"})
           @factory.create(:key => "val")
         end
       end
     end
-  
+
     describe 'Machinist' do
       before do
         Pickle::Adapter::Machinist.stub!(:model_classes).and_return([@klass1, @klass2, @klass3])
-        
+
         @klass1.blueprint {}
         @klass3.blueprint {}
         @klass3.blueprint(:special) {}
       end
-      
+
       it ".factories should create one for each master blueprint, and special case" do
         Pickle::Adapter::Machinist.should_receive(:new).with(@klass1, :master).once
         Pickle::Adapter::Machinist.should_receive(:new).with(@klass3, :master).once
         Pickle::Adapter::Machinist.should_receive(:new).with(@klass3, :special).once
         Pickle::Adapter::Machinist.factories
       end
-        
+
       describe ".new(Class, :master)" do
         before do
           @factory = Pickle::Adapter::Machinist.new(@klass1, :master)
         end
-        
+
         it "should have underscored (s/_) name of Class as #name" do
           @factory.name.should == 'one'
         end
-        
+
         it "#create(attrs) should call Class.make(:master, attrs)" do
           @klass1.should_receive(:make).with(:master, {:key => "val"})
           @factory.create(:key => "val")
         end
       end
-      
+
       describe ".new(Class, :special)" do
         before do
           @factory = Pickle::Adapter::Machinist.new(@klass3, :special)
         end
-        
+
         it "should have 'special_<Class name>' as #name" do
           @factory.name.should == 'special_three'
         end
-        
+
         it "#create(attrs) should call Class.make(:special, attrs)" do
           @klass3.should_receive(:make).with(:special, {:key => "val"})
           @factory.create(:key => "val")
@@ -180,4 +160,4 @@ describe Pickle::Adapter do
       end
     end
   end
-end
+end

data/spec/pickle/config_spec.rb

@@ -4,27 +4,27 @@ describe Pickle::Config do
   before do
     @config = Pickle::Config.new
   end
-  
+
   it "#adapters should default to :machinist, :factory_girl, :active_record" do
     @config.adapters.should == [:machinist, :factory_girl, :active_record]
   end
-  
+
   it "#adapter_classes should default to Adapter::Machinist, Adapter::FactoryGirl, Adapter::ActiveRecord" do
     @config.adapter_classes.should == [Pickle::Adapter::Machinist, Pickle::Adapter::FactoryGirl, Pickle::Adapter::ActiveRecord]
   end
-  
+
   describe "setting adapters to [:machinist, SomeAdapter]" do
     class SomeAdapter; end
-    
+
     before do
       @config.adapters = [:machinist, SomeAdapter]
     end
-    
+
     it "#adapter_classes should be Adapter::Machinist, SomeAdapter" do
       @config.adapter_classes.should == [Pickle::Adapter::Machinist, SomeAdapter]
     end
   end
-  
+
   describe "#factories" do
     it "should call adaptor.factories for each adaptor" do
       Pickle::Adapter::Machinist.should_receive(:factories).and_return([])
@@ -32,14 +32,14 @@ describe Pickle::Config do
       Pickle::Adapter::ActiveRecord.should_receive(:factories).and_return([])
       @config.factories
     end
-    
+
     it "should aggregate factories into a hash using factory name as key" do
       Pickle::Adapter::Machinist.should_receive(:factories).and_return([@machinist = mock('machinist', :name => 'machinist')])
       Pickle::Adapter::FactoryGirl.should_receive(:factories).and_return([@factory_girl = mock('factory_girl', :name => 'factory_girl')])
       Pickle::Adapter::ActiveRecord.should_receive(:factories).and_return([@active_record = mock('active_record', :name => 'active_record')])
       @config.factories.should == {'machinist' => @machinist, 'factory_girl' => @factory_girl, 'active_record' => @active_record}
     end
-    
+
     it "should give preference to adaptors first in the list" do
       Pickle::Adapter::Machinist.should_receive(:factories).and_return([@machinist_one = mock('one', :name => 'one')])
       Pickle::Adapter::FactoryGirl.should_receive(:factories).and_return([@factory_girl_one = mock('one', :name => 'one'), @factory_girl_two = mock('two', :name => 'two')])
@@ -47,51 +47,59 @@ describe Pickle::Config do
       @config.factories.should == {'one' => @machinist_one, 'two' => @factory_girl_two, 'three' => @active_record_three}
     end
   end
-  
+
   it "#mappings should default to []" do
     @config.mappings.should == []
   end
 
   describe '#predicates' 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'])
+      class1 = mock('Class1',
+                    :public_instance_methods => ['nope', 'foo?', 'bar?'],
+                    :column_names => ['one', 'two'],
+                    :const_get => ::ActiveRecord::Base::PickleAdapter
+      )
+      class2 = mock('Class2',
+                    :public_instance_methods => ['not', 'foo?', 'faz?'],
+                    :column_names => ['two', 'three'],
+                    :const_get => ::ActiveRecord::Base::PickleAdapter
+      )
       Pickle::Adapter.stub!(:model_classes).and_return([class1, class2])
-      
+
       @config.predicates.to_set.should == ['foo?', 'faz?', 'bar?', 'one', 'two', 'three'].to_set
     end
-    
+
     it "should be overridable" do
       @config.predicates = %w(lame?)
       @config.predicates.should == %w(lame?)
     end
   end
-  
+
   describe "#map 'foo', :to => 'faz'" do
     before do
       @config.map 'foo', :to => 'faz'
     end
-    
+
     it "should create OpenStruct(search: 'foo', replace: 'faz') mapping" do
       @config.mappings.first.should == OpenStruct.new(:search => 'foo', :replacement => 'faz')
     end
   end
-  
+
   describe "#map 'foo', 'bar' :to => 'faz'" do
     before do
       @config.map 'foo', 'bar', :to => 'faz'
     end
-    
+
     it "should create 2 mappings" do
       @config.mappings.first.should == OpenStruct.new(:search => 'foo', :replacement => 'faz')
       @config.mappings.last.should == OpenStruct.new(:search => 'bar', :replacement => 'faz')
     end
   end
-  
+
   it "#configure(&block) should execiute on self" do
     @config.should_receive(:foo).with(:bar)
     @config.configure do |c|
       c.foo :bar
     end
   end
-end
+end