ianwhite-pickle 0.1.10 → 0.1.11

data/History.txt

@@ -1,3 +1,10 @@
+== 0.1.11 - 22 Feb 2009
+
+* 2 minor enhancements
+  * Pickle now supports multiple machinist blueprints
+  * Fix confusing adapter/adaptor comment generator comment 
+
+
 == 0.1.10 - 13 Feb 2009
 
 * 2 minor enhancements

data/README.rdoc

@@ -53,6 +53,9 @@ 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 
+earlier versions of machinist use pickle <= 0.1.10)
+
 In your <tt>features/support/env.rb</tt> add the following lines at the bottom
 
   require "#{Rails.root}/spec/blueprints" # or wherever they live

data/lib/pickle/adapter.rb

@@ -36,22 +36,21 @@ module Pickle
       def self.factories
         factories = []
         model_classes.each do |klass|
-          factories << new(klass, "make") if klass.instance_variable_get('@blueprint')
-          # if there are make_<special> methods, add blueprints for them
-          klass.methods.select{|m| m =~ /^make_/ && m !~ /_unsaved$/}.each do |method|
-            factories << new(klass, method)
+          if blueprints = klass.instance_variable_get('@blueprints')
+            blueprints.keys.each {|blueprint| factories << new(klass, blueprint)}
           end
         end
         factories
       end
       
-      def initialize(klass, method)
-        @klass, @method = klass, method
-        @name = (@method =~ /make_/ ? "#{@method.sub('make_','')}_" : "") + @klass.name.underscore.gsub('/','_')
+      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(@method, attrs)
+        @klass.send(:make, @blueprint, attrs)
       end
     end
     

data/lib/pickle/version.rb

@@ -2,7 +2,7 @@ module Pickle
   module Version
     Major = 0
     Minor = 1
-    Tiny  = 10
+    Tiny  = 11
     
     String = [Major, Minor, Tiny].join('.')
   end

data/rails_generators/pickle/templates/env.rb

@@ -4,7 +4,7 @@ require 'pickle/world'
 # Example of configuring pickle:
 #
 # Pickle.configure do |config|
-#   config.adaptors = [:machinist]
+#   config.adapters = [:machinist]
 #   config.map 'I', 'myself', 'me', 'my', :to => 'user: "me"'
 # end
 <%- end -%>

data/spec/lib/pickle_adapter_spec.rb

@@ -38,18 +38,22 @@ describe Pickle::Adapter do
     end
   end
   
-  describe '::ActiveRecord' do
+  describe "adapters: " do
     before do
-      # set up a fake object space
-      @klass1 = mock('One', :name => 'One')
-      @klass2 = mock('One::Two', :name => 'One::Two')
-      Pickle::Adapter::ActiveRecord.stub!(:model_classes).and_return([@klass1, @klass2])
+      @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 ".factories" do
-      it "should create one for each active record class" do
+    describe 'ActiveRecord' do
+      before do
+        Pickle::Adapter::ActiveRecord.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
       
@@ -57,100 +61,101 @@ describe Pickle::Adapter 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
-  end
   
-  describe '::FactoryGirl' do
-    before do
-      # set up a fake object space
-      @factory1 = mock('factory1', :factory_name => :one, :build_class => (@class1 = mock('Class1')))
-      @factory2 = mock('factory2', :factory_name => :two, :build_class => (@class2 = mock('Class2')))
-      Factory.stub!(:factories).and_return(:factory1 => @factory1, :factory2 => @factory2)
-    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
     
-    describe ".factories" do
-      it "should create one for each factory" do
+      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 == @class1
+          @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
-  end
   
-  describe '::Machinist' do
-    before do
-      # set up a fake object space
-      @klass1 = mock('One', :name => 'One', :make => true, :make_unsaved => true)
-      @klass1.instance_variable_set('@blueprint', true)
-      @klass2 = mock('Two', :name => 'Two')
-      @klass3 = mock('Two::Sub', :name => 'Two::Sub', :make_special => true, :make => true, :make_unsaved => true)
-      @klass3.instance_variable_set('@blueprint', true)
-      Pickle::Adapter::Machinist.stub!(:model_classes).and_return([@klass1, @klass2, @klass3])
-    end
-    
-    describe ".factories" do
-      it "should create one for each machinist make method, except make_unsaved" do
-        Pickle::Adapter::Machinist.should_receive(:new).with(@klass1, 'make').once
-        Pickle::Adapter::Machinist.should_receive(:new).with(@klass3, 'make').once
-        Pickle::Adapter::Machinist.should_receive(:new).with(@klass3, 'make_special').once
-        Pickle::Adapter::Machinist.factories
+    describe 'Machinist' do
+      before do
+        Pickle::Adapter::Machinist.stub!(:model_classes).and_return([@klass1, @klass2, @klass3])
+        
+        @klass1.blueprint {}
+        @klass3.blueprint {}
+        @klass3.blueprint(:special) {}
       end
       
-      describe ".new(Class, 'make')" do
+      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, 'make')
+          @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(attrs)" do
-          @klass1.should_receive(:make).with({:key => "val"})
+        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, 'make_special')" do
+      describe ".new(Class, :special)" do
         before do
-          @factory = Pickle::Adapter::Machinist.new(@klass3, 'make_special')
+          @factory = Pickle::Adapter::Machinist.new(@klass3, :special)
         end
         
         it "should have 'special_<Class name>' as #name" do
-          @factory.name.should == 'special_two_sub'
+          @factory.name.should == 'special_three'
         end
         
-        it "#create(attrs) should call Class.make_special(attrs)" do
-          @klass3.should_receive(:make_special).with({:key => "val"})
+        it "#create(attrs) should call Class.make(:special, attrs)" do
+          @klass3.should_receive(:make).with(:special, {:key => "val"})
           @factory.create(:key => "val")
         end
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ianwhite-pickle
 version: !ruby/object:Gem::Version 
-  version: 0.1.10
+  version: 0.1.11
 platform: ruby
 authors: 
 - Ian White
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-02-13 00:00:00 -08:00
+date: 2009-02-22 00:00:00 -08:00
 default_executable: 
 dependencies: []