pickle 0.2.12 → 0.3.0

data/History.txt

@@ -1,3 +1,10 @@
+== 0.3.0
+
+* 2 major improvements
+  * Mechanism for registering ORM adapters for pickle [Daniel Neighman]
+  * Adapters for ActiveRecord and DataMapper [Josh Bassett, Daniel Neighman]
+
+
 == 0.2.12
 
 * 1 bugfix

data/README.rdoc

@@ -1,7 +1,10 @@
 = pickle
 
 Pickle gives you cucumber steps that create your models easily from factory-girl or
-machinist factories/blueprints.  You can also just use ActiveRecord but it's not as cool.
+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
+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
@@ -35,7 +38,7 @@ Install pickle either as a rails plugin, or a gem
 
   # 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
 
@@ -48,7 +51,7 @@ It's tested against all stable branches of 2.x rails, and edge, with the latest
 To run the specs do:
 
   rake spec
-  
+
 To run the features (rails 2.3 only ATM):
 
   rake cucumber
@@ -57,6 +60,8 @@ To run the features (rails 2.3 only ATM):
 
 The following people have made Pickle better:
 
+* {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]
@@ -77,9 +82,11 @@ If you want path steps and email steps then just add 'paths' and/or 'email'.  Th
 written to <tt>features/env/paths.rb</tt> and
 <tt>features/step_definitions/email_steps.rb</tt> respectively.
 
-=== Using with plain ole Active Record
+=== Using with plain ole Active Record or DataMapper
+
+Pickle comes with adapters for Active Record and DataMapper.
 
-If you have an AR called 'Post', with required fields 'title', and 'body', then you can now write 
+If you have an AR/DM 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"
@@ -98,7 +105,7 @@ you've written, you can just do stuff like
 
 ==== Machinst: require your blueprints and reset Shams
 
-(The latest version of pickle supports {multiple blueprints}[http://github.com/notahat/machinist/commit/d6492e6927a8aa1819926e48b22377171fd20496], for 
+(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)
 
 In your <tt>features/support/env.rb</tt> add the following lines at the bottom
@@ -115,6 +122,19 @@ 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
+
+Pickle can be used with any Modeling 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.
+
+See how to implement one by looking at the ones provided in the pickle source in lib/pickle/adapters/*
+
 === Configuring Pickle
 
 You can tell pickle to use another factory adapter (see Pickle::Adapter), or
@@ -129,7 +149,7 @@ In: <tt>features/support/pickle.rb</tt>
     config.adapters = [:machinist, 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).
@@ -147,29 +167,29 @@ When you run <tt>script/generate pickle</tt> you get the following steps
   Given a user exists
   Given a user: "fred" exists
   Given the user exists
-  
+
 "Given <b>a model</b> exists with <b>fields</b>",  e.g.
 
   Given a user exists with name: "Fred"
   Given a user exists with name: "Fred", activated: false
-  
+
 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 <b>n models</b> exist", e.g.
-  
+
   Given 10 users exist
-  
+
 "Given <b>n models</b> exist with <b>fields</b>", examples:
 
   Given 10 users exist with activated: false
-  
+
 "Given the following <b>models</b> exist:", examples:
 
   Given the following users exist
@@ -188,21 +208,21 @@ You can refer to other models in the fields
 "Then <b>a model</b> should exist with <b>fields</b>", e.g.
 
   Then a user: "fred" should exist with name: "Fred" # we can label the found user for later use
-  
+
 You can use other models, booleans, numerics, and strings as fields
 
   Then a person should exist with child: person "ethel"
   Then a user should exist with activated: false
   Then a user should exist with activated: true, email: "fred@gmail.com"
-  
+
 "Then <b>n models</b> should exist", e.g.
 
   Then 10 events should exist
-  
+
 "Then <b>n models</b> should exist with <b>fields</b>", e.g.
 
   Then 2 people should exist with father: person "fred"
-  
+
 "Then the following <b>models</b> exist". This allows the creation of multiple models
 using a table syntax. Using a column with the singularized name of the model creates a referenceable model. E.g.
 
@@ -213,30 +233,30 @@ using a table syntax. Using a column with the singularized name of the model cre
   Then the following users exist:
     | user | name   | activated |
     | Fred | Freddy | false     |
-  
+
 ===== Asserting associations
 
 One-to-one assocs: "Then <b>a model</b> should be <b>other model</b>'s <b>association</b>", e.g.
 
   Then the person: "fred" should be person: "ethel"'s father
-  
+
 Many-to-one assocs: "Then <b>a model</b> should be [in|one of] <b>other model</b>'s <b>association</b>", e.g.
 
   Then the person: "ethel" should be one of person: "fred"'s children
   Then the comment should be in the post's comments
-  
+
 ===== Asserting predicate methods
 
 "Then <b>a model</b> should [be|have] [a|an] <b>predicate</b>", e.g.
-  
+
   Then the user should have a status # => user.status.should be_present
   Then the user should have a stale password # => user.should have_stale_password
   Then the car: "batmobile" should be fast # => car.should be_fast
-  
+
 "Then <b>a model</b> should not [be|have] [a|an] <b>predicate</b>", e.g.
 
   Then person: "fred" should not be childless # => fred.should_not be_childless
-  
+
 === Regexps for use in your own steps
 
 By default you get some regexps available in the main namespace for use
@@ -263,7 +283,7 @@ Pickle::Parser::Matchers for the methods available)
     post = model!(post)
     forum = model!(forum)
     forum.posts.should include(post)
-  end 
+  end
 
 *capture_fields*
 
@@ -276,4 +296,4 @@ 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
+  And a post exists with author: the user # this step will assign the above user as :author on the post

data/VERSION

@@ -1 +1 @@
-0.2.12
+0.3.0

data/lib/pickle/adapter.rb

@@ -4,7 +4,7 @@ module Pickle
   # Abstract Factory adapter class, if you have a factory type setup, you
   # can easily create an adaptor to make it work with Pickle.
   #
-  # The factory adaptor must have a #factories class method that returns 
+  # The factory adaptor must have a #factories class method that returns
   # its instances, and each instance must respond to:
   #
   #   #name : identifies the factory by name (default is attr_reader)
@@ -12,40 +12,65 @@ module Pickle
   #   #create(attrs = {}) : returns a newly created object
   class Adapter
     attr_reader :name, :klass
-    
+
     def create(attrs = {})
       raise NotImplementedError, "create and return an object with the given attributes"
     end
-  
+
     if respond_to?(:class_attribute)
       class_attribute :model_classes
     else
       cattr_writer :model_classes
     end
-    
+
     self.model_classes = nil
-    
+
+    # Include this module into your 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"
+    #
+    # e.g. ActiveRecord::Base::PickleAdapter
+    #
+    # @see pickle/adapters/active_record
+    # @see pickle/adapters/datamapper
+    module Base
+      def self.included(base)
+        adapters << base
+      end
+
+      # A collection of registered adapters
+      def self.adapters
+        @@adapters ||= []
+      end
+    end
+
     class << self
       def factories
         raise NotImplementedError, "return an array of factory adapter objects"
       end
 
       def model_classes
-        @@model_classes ||= ::ActiveRecord::Base.send(:subclasses).select {|klass| suitable_for_pickle?(klass)}
+        @@model_classes ||= self::Base.adapters.map{ |a| a.model_classes }.flatten
       end
-      
-      # return true if a klass should be used by pickle
-      def suitable_for_pickle?(klass)
-        !klass.abstract_class? && klass.table_exists? && !framework_class?(klass)
+
+      # Returns the column names for the given ORM model class.
+      def column_names(klass)
+        klass.const_get(:PickleAdapter).column_names(klass)
       end
 
-      # return true if the passed class is a special framework class
-      def framework_class?(klass)
-        ((defined?(CGI::Session::ActiveRecordStore::Session) && klass == CGI::Session::ActiveRecordStore::Session)) ||
-        ((defined?(::ActiveRecord::SessionStore::Session) && klass == ::ActiveRecord::SessionStore::Session))
+      def get_model(klass, id)
+        klass.const_get(:PickleAdapter).get_model(klass, id)
+      end
+
+      def find_first_model(klass, conditions)
+        klass.const_get(:PickleAdapter).find_first_model(klass, conditions)
+      end
+
+      def find_all_models(klass, conditions)
+        klass.const_get(:PickleAdapter).find_all_models(klass, conditions)
       end
     end
-  
+
     # machinist adapter
     class Machinist < Adapter
       def self.factories
@@ -57,37 +82,37 @@ module Pickle
         end
         factories
       end
-      
+
       def initialize(klass, blueprint)
         @klass, @blueprint = klass, blueprint
         @name = @klass.name.underscore.gsub('/','_')
         @name = "#{@blueprint}_#{@name}" unless @blueprint == :master
       end
-      
+
       def create(attrs = {})
         @klass.send(:make, @blueprint, attrs)
       end
     end
-    
+
     # factory-girl adapter
     class FactoryGirl < Adapter
       def self.factories
         (::Factory.factories.values rescue []).map {|factory| new(factory)}
       end
-      
+
       def initialize(factory)
         @klass, @name = factory.build_class, factory.factory_name.to_s
       end
-    
+
       def create(attrs = {})
         Factory.create(@name, attrs)
       end
     end
-        
+
     # fallback active record adapter
     class ActiveRecord < Adapter
       def self.factories
-        model_classes.map {|klass| new(klass) }
+        ::ActiveRecord::Base::PickleAdapter.model_classes.map{|k| new(k)}
       end
 
       def initialize(klass)
@@ -99,4 +124,4 @@ module Pickle
       end
     end
   end
-end
+end

data/lib/pickle/adapters/active_record.rb

@@ -0,0 +1,46 @@
+begin
+  require 'activerecord'
+rescue LoadError
+  require 'active_record'
+end
+
+class ActiveRecord::Base
+  module PickleAdapter
+    include Pickle::Adapter::Base
+
+    # Do not consider these to be part of the class list
+    def self.except_classes
+      @@except_classes ||= [
+        "CGI::Session::ActiveRecordStore::Session",
+        "ActiveRecord::SessionStore::Session"
+      ]
+    end
+
+    # Gets a list of the available models for this adapter
+    def self.model_classes
+      ::ActiveRecord::Base.__send__(:subclasses).select do |klass|
+        !klass.abstract_class? && klass.table_exists? && !except_classes.include?(klass.name)
+      end
+    end
+
+    # get a list of column names for a given class
+    def self.column_names(klass)
+      klass.column_names
+    end
+
+    # Get an instance by id of the model
+    def self.get_model(klass, id)
+      klass.find(id)
+    end
+
+    # Find the first instance matching conditions
+    def self.find_first_model(klass, conditions)
+      klass.find(:first, :conditions => conditions)
+    end
+
+    # Find all models matching conditions
+    def self.find_all_models(klass, conditions)
+      klass.find(:all, :conditions => conditions)
+    end
+  end
+end

data/lib/pickle/adapters/data_mapper.rb

@@ -0,0 +1,37 @@
+require 'dm-core'
+
+module DataMapper::Resource
+  module PickleAdapter
+    include Pickle::Adapter::Base
+
+    # Do not consider these to be part of the class list
+    def self.except_classes
+      @@except_classes ||= []
+    end
+
+    # Gets a list of the available models for this adapter
+    def self.model_classes
+      ::DataMapper::Model.descendants.to_a.select{|k| !except_classes.include?(k.name)}
+    end
+
+    # get a list of column names for a given class
+    def self.column_names(klass)
+      klass.properties.map(&:name)
+    end
+
+    # Get an instance by id of the model
+    def self.get_model(klass, id)
+      klass.get(id)
+    end
+
+    # Find the first instance matching conditions
+    def self.find_first_model(klass, conditions)
+      klass.first(conditions)
+    end
+
+    # Find all models matching conditions
+    def self.find_all_models(klass, conditions)
+      klass.all(conditions)
+    end
+  end
+end

data/lib/pickle/config.rb

@@ -28,7 +28,7 @@ module Pickle
     
     def predicates
       @predicates ||= Pickle::Adapter.model_classes.map do |k|
-        k.public_instance_methods.select{|m| m =~ /\?$/} + k.column_names
+        k.public_instance_methods.select {|m| m =~ /\?$/} + Pickle::Adapter.column_names(k)
       end.flatten.uniq
     end
     
@@ -45,4 +45,4 @@ module Pickle
       end
     end
   end
-end
+end