pickle 0.3.5 → 0.4.0

data/History.txt

@@ -1,3 +1,29 @@
+== 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

data/README.rdoc

@@ -3,7 +3,7 @@
 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
@@ -72,11 +72,11 @@ If you want path steps and email steps then just add the 'paths' and/or 'email'
 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 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"
@@ -118,7 +118,7 @@ Adapters are very simple and exist a module or class with the name "PickleAdapte
 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/*
 
@@ -133,13 +133,11 @@ 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, then factory-girl. If you want to use active-record 'factories' you should add ":active_record" to adapters. 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
 
@@ -332,6 +330,7 @@ To run the features (rails 2.3 only ATM):
 
 The following people have made Pickle better:
 
+* {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]
@@ -347,4 +346,4 @@ The following people have made Pickle better:
 * {Michael Moen}[http://github.com/UnderpantsGnome]
 * {Myron Marston}[http://github.com/myronmarston]
 * {Stephan Hagemann}[http://github.com/xing]
-* {Chris Flipse}[http://github.com/cflipse]
+* {Chris Flipse}[http://github.com/cflipse]

data/VERSION

@@ -1 +1 @@
-0.3.5
+0.4.0

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/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
@@ -113,10 +118,11 @@ module Pickle
       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)
@@ -124,7 +130,7 @@ module Pickle
       end
 
       def create(attrs = {})
-        @klass.send(:create!, attrs)
+        Pickle::Adapter.create_model(@klass, attrs)
       end
     end
   end

data/lib/pickle/adapters/active_record.rb

@@ -48,5 +48,10 @@ class ActiveRecord::Base
     def self.find_all_models(klass, conditions)
       klass.find(:all, :conditions => conditions)
     end
+    
+    # Create a model using attributes
+    def self.create_model(klass, attributes)
+      klass.create!(attributes)
+    end
   end
 end

data/lib/pickle/adapters/data_mapper.rb

@@ -33,5 +33,10 @@ module DataMapper::Resource
     def self.find_all_models(klass, conditions)
       klass.all(conditions)
     end
+    
+    # Create a model using attributes
+    def self.create_model(klass, attributes)
+      klass.create(attributes)
+    end
   end
 end

data/lib/pickle/adapters/mongoid.rb

@@ -0,0 +1,44 @@
+require 'mongoid'
+
+module Mongoid
+  module Document
+    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
+        ObjectSpace.each_object(Class).to_a.select {|klass| klass.ancestors.include? Mongoid::Document}
+      end
+
+      # get a list of column names for a given class
+      def self.column_names(klass)
+        klass.fields.keys
+      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.first(conditions)
+      end
+
+      # Find all models matching conditions
+      def self.find_all_models(klass, conditions)
+        klass.all(conditions)
+      end
+      
+      # Create a model with given attributes
+      def self.create_model(klass, attributes)
+        klass.create!(attributes)
+      end
+    end
+  end
+end

data/lib/pickle/config.rb

@@ -11,7 +11,7 @@ module Pickle
     end
     
     def adapters
-      @adapters ||= [:machinist, :factory_girl, :active_record]
+      @adapters ||= [:machinist, :factory_girl, :orm]
     end
     
     def adapter_classes

data/lib/pickle/session.rb

@@ -1,5 +1,18 @@
 module Pickle
   module Session
+    class ModelNotKnownError < RuntimeError
+      attr_reader :name
+      
+      def initialize(name, message = nil)
+        @name = name
+        @message = message || "The model: '#{name}' is not known in this scenario.  Use #create_model to create, or #find_model to find, and store a reference in this scenario."
+      end
+      
+      def to_s
+        @message
+      end
+    end
+    
     class << self
       def included(world_class)
         proxy_to_pickle_parser(world_class)
@@ -53,8 +66,8 @@ module Pickle
       record
     end
     
-    def find_model!(a_model_name, fields = nil)
-      find_model(a_model_name, fields) or raise "Can't find pickle model: '#{a_model_name}' in this scenario"
+    def find_model!(name, fields = nil)
+      find_model(name, fields) or raise ModelNotKnownError, name
     end
     
     def find_models(factory, fields = nil)
@@ -87,7 +100,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 "Can't find pickle model: '#{name}' in this scenario"
+        models_by_name(factory)[name_or_index] or raise ModelNotKnownError, name
       end
     end
 
@@ -110,12 +123,12 @@ module Pickle
     
     # like model, but raise an error if it can't be found
     def model!(name)
-      model(name) or raise "Can't find pickle model: '#{name}' in this scenario"
+      model(name) or raise ModelNotKnownError, name
     end
     
     # like created_model, but raise an error if it can't be found
     def created_model!(name)
-      created_model(name) or raise "Can't find pickle model: '#{name}' in this scenario"
+      created_model(name) or raise ModelNotKnownError, name
     end
     
     # return all original models of specified type

data/lib/pickle/session/parser.rb

@@ -14,7 +14,7 @@ module Pickle
 
       def parse_field_with_model(field)
         if session && field =~ /^(\w+): #{capture_model}$/
-          {$1 => session.model($2)}
+          {$1 => session.model!($2)}
         else
           parse_field_without_model(field)
         end

data/lib/pickle/world.rb

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

data/pickle.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{pickle}
-  s.version = "0.3.5"
+  s.version = "0.4.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Ian White"]
-  s.date = %q{2010-08-12}
+  s.date = %q{2010-08-19}
   s.description = %q{Easy model creation and reference in your cucumber features}
   s.email = %q{ian.w.white@gmail.com}
   s.extra_rdoc_files = [
@@ -48,6 +48,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/step_definitions/raise_error_steps.rb",
      "features/support/email.rb",
      "features/support/env.rb",
      "features/support/paths.rb",
@@ -59,6 +60,7 @@ Gem::Specification.new do |s|
      "lib/pickle/adapter.rb",
      "lib/pickle/adapters/active_record.rb",
      "lib/pickle/adapters/data_mapper.rb",
+     "lib/pickle/adapters/mongoid.rb",
      "lib/pickle/config.rb",
      "lib/pickle/email.rb",
      "lib/pickle/email/parser.rb",

data/spec/pickle/adapter_spec.rb

@@ -66,19 +66,19 @@ describe Pickle::Adapter do
 
       describe 'with class stubs' do
         before do
-          ActiveRecord::Base::PickleAdapter.stub!(:model_classes).and_return([@klass1, @klass2, @klass3])
+          Pickle::Adapter::Orm.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
+          Pickle::Adapter::Orm.should_receive(:new).with(@klass1).once
+          Pickle::Adapter::Orm.should_receive(:new).with(@klass2).once
+          Pickle::Adapter::Orm.should_receive(:new).with(@klass3).once
+          Pickle::Adapter::Orm.factories.length.should == 3
         end
 
         describe ".new(Class)" do
           before do
-            @factory = Pickle::Adapter::ActiveRecord.new(@klass2)
+            @factory = Pickle::Adapter::Orm.new(@klass2)
           end
 
           it "should have underscored (s/_) name of Class as #name" do

data/spec/pickle/config_spec.rb

@@ -5,12 +5,12 @@ describe Pickle::Config 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]
+  it "#adapters should default to :machinist, :factory_girl, :orm" do
+    @config.adapters.should == [:machinist, :factory_girl, :orm]
   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]
+  it "#adapter_classes should default to Adapter::Machinist, Adapter::FactoryGirl, Adapter::Orm" do
+    @config.adapter_classes.should == [Pickle::Adapter::Machinist, Pickle::Adapter::FactoryGirl, Pickle::Adapter::Orm]
   end
 
   describe "setting adapters to [:machinist, SomeAdapter]" do
@@ -29,22 +29,22 @@ describe Pickle::Config do
     it "should call adaptor.factories for each adaptor" do
       Pickle::Adapter::Machinist.should_receive(:factories).and_return([])
       Pickle::Adapter::FactoryGirl.should_receive(:factories).and_return([])
-      Pickle::Adapter::ActiveRecord.should_receive(:factories).and_return([])
+      Pickle::Adapter::Orm.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}
+      Pickle::Adapter::Orm.should_receive(:factories).and_return([@orm = mock('orm', :name => 'orm')])
+      @config.factories.should == {'machinist' => @machinist, 'factory_girl' => @factory_girl, 'orm' => @orm}
     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')])
-      Pickle::Adapter::ActiveRecord.should_receive(:factories).and_return([@active_record_two = mock('two', :name => 'two'), @active_record_three = mock('three', :name => 'three')])
-      @config.factories.should == {'one' => @machinist_one, 'two' => @factory_girl_two, 'three' => @active_record_three}
+      Pickle::Adapter::Orm.should_receive(:factories).and_return([@orm_two = mock('two', :name => 'two'), @orm_three = mock('three', :name => 'three')])
+      @config.factories.should == {'one' => @machinist_one, 'two' => @factory_girl_two, 'three' => @orm_three}
     end
   end
 

data/spec/pickle/session_spec.rb

@@ -23,7 +23,7 @@ describe Pickle::Session do
   end
 
   let :user_factory do
-    Pickle::Adapter::ActiveRecord.new(user_class)
+    Pickle::Adapter::Orm.new(user_class)
   end
 
   before do
@@ -257,7 +257,7 @@ describe Pickle::Session do
 
     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(RuntimeError, "Can't find pickle model: 'name' in this scenario")
+      lambda { find_model!('name', 'fields') }.should raise_error(Pickle::Session::ModelNotKnownError)
     end
   end
 
@@ -425,10 +425,10 @@ describe Pickle::Session do
   end
 
   it "#model!('unknown') should raise informative error message" do
-    lambda { model!('unknown') }.should raise_error("Can't find pickle model: 'unknown' in this scenario")
+    lambda { model!('unknown') }.should raise_error(Pickle::Session::ModelNotKnownError, "The model: 'unknown' is not known in this scenario.  Use #create_model to create, or #find_model to find, and store a reference in this scenario.")
   end
 
   it "#created_model!('unknown') should raise informative error message" do
-    lambda { created_model!('unknown') }.should raise_error("Can't find pickle model: 'unknown' in this scenario")
+    lambda { created_model!('unknown') }.should raise_error(Pickle::Session::ModelNotKnownError)
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: pickle
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 15
   prerelease: false
   segments: 
   - 0
-  - 3
-  - 5
-  version: 0.3.5
+  - 4
+  - 0
+  version: 0.4.0
 platform: ruby
 authors: 
 - Ian White
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-12 00:00:00 +01:00
+date: 2010-08-19 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -117,6 +117,7 @@ files:
 - features/step_definitions/generator_steps.rb
 - features/step_definitions/path_steps.rb
 - features/step_definitions/pickle_steps.rb
+- features/step_definitions/raise_error_steps.rb
 - features/support/email.rb
 - features/support/env.rb
 - features/support/paths.rb
@@ -128,6 +129,7 @@ files:
 - lib/pickle/adapter.rb
 - lib/pickle/adapters/active_record.rb
 - lib/pickle/adapters/data_mapper.rb
+- lib/pickle/adapters/mongoid.rb
 - lib/pickle/config.rb
 - lib/pickle/email.rb
 - lib/pickle/email/parser.rb