From 5e4c25bf0b9006cef7130da6bd195398c2105c73 Mon Sep 17 00:00:00 2001
From: Ian White <ian.w.white@gmail.com>
Date: Tue, 9 Mar 2010 10:57:03 +0000
Subject: [PATCH] Renamed create_model_from_table => create_models_from_table,
 refactored some of xing's code, and added specs to bring coverage to 100%

---
 lib/pickle/session.rb                         | 31 +++++--------------
 .../pickle/templates/pickle_steps.rb          |  2 +-
 spec/lib/pickle_session_spec.rb               | 26 ++++++++++++++++
 3 files changed, 35 insertions(+), 24 deletions(-)

diff --git a/lib/pickle/session.rb b/lib/pickle/session.rb
index 9b2dd4b6..c36457b0 100644
--- a/lib/pickle/session.rb
+++ b/lib/pickle/session.rb
@@ -20,20 +20,21 @@ def proxy_to_pickle_parser(world_class)
       end
     end
     
-    def create_model(a_model_name, fields = nil)
-      factory, label = *parse_model(a_model_name)
+    def create_model(pickle_ref, fields = nil)
+      factory, label = *parse_model(pickle_ref)
       raise ArgumentError, "Can't create with an ordinal (e.g. 1st user)" if label.is_a?(Integer)
       fields = fields.is_a?(Hash) ? parse_hash(fields) : parse_fields(fields)
       record = pickle_config.factories[factory].create(fields)
       store_model(factory, label, record)
     end
     
-    def create_model_from_table(plural_factory, table)
-      model_class = model_class_for_factory(plural_factory)
-
+    # if a column exists in the table which matches the singular factory name, this is used as the pickle ref
+    def create_models_from_table(plural_factory, table)
+      factory = plural_factory.singularize
       table.hashes.each do |hash|
-        name = construct_name_from_pickleref_and_factory(hash.delete(plural_factory.singularize), plural_factory)
-        create_model(name, hash)
+        pickle_ref = factory
+        pickle_ref += ' "' + hash.delete(factory) + '"' if hash[factory] 
+        create_model(pickle_ref, hash)
       end
     end
 
@@ -109,22 +110,6 @@ def models(factory)
     def respond_to_with_pickle_parser?(method, include_private = false)
       respond_to_without_pickle_parser?(method, include_private) || pickle_parser.respond_to?(method, include_private)
     end
-
-    private
-
-      def model_class_for_factory(factory_name)
-        name = factory_name.singularize
-        factory, name_or_index = *parse_model(name)
-        pickle_config.factories[factory].klass
-      end
-
-      def construct_name_from_pickleref_and_factory(pickle_ref, plural_factory)
-        if pickle_ref && !pickle_ref.empty?
-          'the ' + plural_factory.singularize + ": \"#{pickle_ref}\""
-        else
-          plural_factory.singularize
-        end
-      end
     
   protected
     def method_missing_with_pickle_parser(method, *args, &block)
diff --git a/rails_generators/pickle/templates/pickle_steps.rb b/rails_generators/pickle/templates/pickle_steps.rb
index 7256a5b5..ae4564fe 100755
--- a/rails_generators/pickle/templates/pickle_steps.rb
+++ b/rails_generators/pickle/templates/pickle_steps.rb
@@ -12,7 +12,7 @@
 
 # create models from a table
 Given(/^the following #{capture_plural_factory} exists?:?$/) do |plural_factory, table|
-  create_model_from_table(plural_factory, table)
+  create_models_from_table(plural_factory, table)
 end
 
 # find a model
diff --git a/spec/lib/pickle_session_spec.rb b/spec/lib/pickle_session_spec.rb
index 7bc07453..d27f689c 100644
--- a/spec/lib/pickle_session_spec.rb
+++ b/spec/lib/pickle_session_spec.rb
@@ -207,6 +207,32 @@ def do_create_model
     end
   end
   
+  describe "#create_models_from_table(plural_factory, table)" do
+    context "when given a table without a matching pickle ref column" do
+      before do
+        @table = mock(:hashes => [{'name' => 'Fred'}, {'name' => 'Betty'}])
+      end
+      
+      it "should call create_model for each of the table hashes with plain factory name" do
+        should_receive(:create_model).with("user", 'name' => "Fred").once.ordered
+        should_receive(:create_model).with("user", 'name' => "Betty").once.ordered
+        create_models_from_table("users", @table)
+      end
+    end
+    
+    context "when given a table with a matching pickle ref column" do
+      before do
+        @table = mock(:hashes => [{'user' => "fred", 'name' => 'Fred'}, {'user' => "betty", 'name' => 'Betty'}])
+      end
+      
+      it "should call create_model for each of the table hashes with labelled pickle ref" do
+        should_receive(:create_model).with("user \"fred\"", 'name' => "Fred").once.ordered
+        should_receive(:create_model).with("user \"betty\"", 'name' => "Betty").once.ordered
+        create_models_from_table("users", @table)
+      end
+    end
+  end
+  
   describe "#find_model!" do
     it "should call find_model" do
       should_receive(:find_model).with('name', 'fields').and_return(mock('User'))