joinfix 0.1.0 → 0.1.1

data/README

@@ -37,7 +37,7 @@
 #     groups: admin_group       # => reference to the 'admin_group' entry
 #     
 #   jane:
-#     id: 3                       # => you can specify ids if you want
+#     id: 3                     # => you can specify ids if you want
 #     login: jane
 #     groups:                   # => an array of joins
 #       - admin_group

data/lib/joinfix/fixtures.rb

@@ -1,32 +1,32 @@
 class Fixtures
-	attr_reader :join_configs, :templates
+	attr_reader :klass, :attributes, :templates, :fixture_path
 	
+	alias join_fix_original_initialize initialize
+	def initialize(*args)
+		join_fix_original_initialize(*args)
+		@klass = Object.const_get(@class_name)
+		
+		# default attributes, constructed from reflecting on the active record table
+		@attributes = {}
+		@klass.columns.each do |column| 
+			@attributes[column.name] = column.default 
+		end
+		
+		@join_configs = {}
+	end
+
 	alias join_fix_original_insert_fixtures insert_fixtures
 	def insert_fixtures
 		Fixtures.template_all_loaded_fixtures if templates.nil?
 		join_fix_original_insert_fixtures
 	end
-	
-	@@entry_stack = []
-	
+
 	def template_fixtures
 		return unless templates.nil?
 		
-		begin
-			configure
-		rescue
-			raise "\nError configuring fixtures for: #{@class_name}\n#{$!.message}"
-		end
-		
 		extract_templates
-		
-		begin 
-			templates.each_pair do |entry_name, entry|
-				make_entry(entry_name, entry, true)
-			end
-		rescue
-			entry_str = "Entry:\n" + @@entry_stack.last.to_yaml
-			raise "Error making entry for: '#{@class_name}'\n#{entry_str}#{$!.message}"
+		templates.each_pair do |entry_name, entry|
+			make_entry(entry_name, entry, true)
 		end
 	end
 	
@@ -37,158 +37,62 @@ class Fixtures
 		# @connection. QUERY FOR NEXT ID
 	end
 	
+	def join_config(assoc_name)
+		@join_configs[assoc_name] ||= JoinFix.send("configure", klass, assoc_name)
+	end
+	
 	def each_pair(&block)
 		map { |entry_name, fixture| yield(entry_name, fixture) } 
 	end
 	
-	def config
-		configure unless @config
-		@config
+	def to_hash
+		hash = {}
+		each_pair do |name, fixture|
+		     hash[name] = fixture.to_hash
+		end
+		hash
 	end
 	
 	protected
 	
-	def configure
-		klass = @class_name.constantize
-		file_base = @class_name.underscore.singularize
-			
-		# default attributes, constructed from reflecting on the active record table
-		attributes = {}
-		klass.columns.each do |column| 
-			next if JoinFix.preserves?(column.name)
-			attributes[column.name] = column.default 
-		end
-		
-		# default associations, constructed from reflecting on the active record class
-		associations = {}
-		klass.reflect_on_all_associations.each do |association|
-			begin
-				config = {:macro => association.macro}.merge(association.options)
-					
-				# get the child table name either by reflecting on the association class
-				config[:class_name] ||= association.class_name
-				config[:table_name] = config[:class_name].constantize.table_name unless config[:polymorphic]
-
-				associations[association.name] = config
-			rescue
-				# known failure retrieving class name for has_many :through if the join model doesn't
-				# have a 'belongs_to' pointing to the source model
-				raise "Could not reflect on association: #{association.name}\n" +
-					"Check that your join models are properly configured.\n" + 
-					$!.message
-			end
-		end
-
-		# merge the defaults with the file configurations 
-		@config = {
-			'class_name' => klass.class_name,
-			'table_name' => klass.table_name,
-			'attributes' => attributes, 
-			'associations' => associations
-			# FUTURE! bring back if you start running methods
-			#'modules' => [JoinFix, "#{@class_name}Template"]
-		}.with_indifferent_access
-			
-		@join_configs = {}.with_indifferent_access
-		parent_config = @config
-		associations.each_pair do |association, child_config|
-			# define shared parameters
-			join_config = {
-				:parent_table => parent_config[:table_name],
-				:child_table => child_config[:table_name],
-				:macro => child_config[:macro]
-			}.with_indifferent_access
-				
-			case join_config[:macro].to_sym
-			when :belongs_to 
-				if child_config[:polymorphic]
-					join_config[:polymorphic] = true
-					join_config[:associable] = association.to_s
-					join_config[:foreign_key] =  child_config[:foreign_key] || "#{association}_id"
-					join_config.delete(:child_table) # not necessary, but reflects the fact that the polymorphic entry must specify this directly
-				else
-					join_config[:foreign_key] = child_config[:foreign_key] || "#{join_config[:child_table].singularize}_id"
-				end
-			when :has_one
-				join_config[:foreign_key] = child_config[:foreign_key] || "#{join_config[:parent_table].singularize}_id"
-			when :has_many
-				if child_config[:as]
-					join_config[:as] = child_config[:as]
-					join_config[:foreign_key] = child_config[:foreign_key] || "#{child_config[:as]}_id"
-					join_config[:parent_class] = parent_config[:class_name]
-				elsif child_config[:through]
-					join_config[:through] = child_config[:through]
-					join_config[:join_table] = associations[child_config[:through]][:table_name]
-					join_config[:foreign_key] = "#{join_config[:parent_table].singularize}_id"
-					join_config[:association_foreign_key] = "#{join_config[:child_table].singularize}_id"
-				else
-					join_config[:foreign_key] = child_config[:foreign_key] || "#{join_config[:parent_table].singularize}_id"
-				end
-			when :has_and_belongs_to_many
-				join_config[:join_table] = child_config[:join_table] || (join_config[:parent_table] < join_config[:child_table] ? "#{join_config[:parent_table]}_#{join_config[:child_table]}" : "#{join_config[:child_table]}_#{join_config[:parent_table]}") # echos the way join tables are guessed by ActiveRecord
-				join_config[:foreign_key] = child_config[:foreign_key] || "#{join_config[:parent_table].singularize}_id"
-				join_config[:association_foreign_key] = child_config[:association_foreign_key] ||  "#{join_config[:child_table].singularize}_id"
-			else
-				raise ArgumentError, "Unknown join type '#{join_config[:macro]}'."
-			end
-			
-			join_config[:attributes] = Fixtures.fixture(join_config[:join_table]).config[:attributes]  if join_config.has_key?(:join_table)
-			@join_configs[association] = join_config
-		end
-	end
-	
 	def extract_templates
 		# fixture is a template if it contains an association
 		@templates = {}
-		associations = config[:associations].keys
+		assoc_names = klass.reflect_on_all_associations.collect {|assoc| assoc.name.to_s}
 		each do |entry_name, fixture|
-			#next if key.to_s !~ /[=|!]$/  # FUTURE! bring back if you start running methods
 			entry = fixture.to_hash
-			next if (entry.keys & associations).empty?
+			next if (entry.keys & assoc_names).empty?
 			@templates[entry_name] = entry
 		end
 		delete_if do |entry_name, fixture|
 			@templates.has_key?(entry_name)
 		end
 	end
-	
-	def make_entry(entry_name, entry, add_entry_on_complete)
-		@@entry_stack << entry.dup
+
+	def make_entry(entry_name, entry_template, add_entry_on_complete)
+		raise NoEntryNameError.new(self, entry_name, entry_template) unless entry_template.kind_of?(Hash)
 		
-		attributes = config[:attributes]
-		#modules = config[:modules] # FUTURE! bring back if you start running methods
-	
-		entry = attributes.merge(entry)
+		entry = attributes.merge(entry_template)
 		entry.extend JoinFix	
 		entry.entry_name = entry_name
 		
-		# FUTURE! bring back if you start running methods
-		#modules.each do |module_name| 
-		#	mod = get_module(module_name, module_options)
-		#	template.extend(mod) if mod
-		#end
-	
 		# extract templates for entries that will be joined to the current entry
 		#   Associated entries are indicated by any key undeclared in attributes, that also does not
 		#   match one of the reseved key patterns... ie 'id' or keys ending in '_id'.  Additionally includes
 		#   join references, which will all be arrays.
-		associated_entries = entry.extract_unless(attributes.keys) do |key, value| 
-			JoinFix.preserves?(key) || key.kind_of?(Array)
+		assoc_entries = entry.extract_unless(attributes.keys) do |key, value| 
+			key == "id" || key.kind_of?(Array)
 		end
 			
 		# also extract templates for entries that have an array value.  These entries indicate a set of
 		# associated entries that should each be joined to the current entry
-		associated_entries.merge( entry.extract_if { |key, value| value.kind_of?(Array) } )
-		associated_entries.each_pair do |association, association_templates| 
-			# ensure that association_templates is an array of template
-			association_templates = [association_templates] unless association_templates.kind_of?(Array)
+		assoc_entries.merge( entry.extract_if { |key, value| value.kind_of?(Array) } )
+		assoc_entries.each_pair do |assoc_name, assoc_array| 
+			# ensure that assoc_array is an array of template
+			assoc_array = [assoc_array] unless assoc_array.kind_of?(Array)
 		
 			# translate the association configuration into a join configuration
-			join_config = join_configs[association]
-			unless join_config
-				raise ArgumentError, "Unknown association '#{association}' for '#{table_name}'." 
-			end
-				
+			join_config = join_config(assoc_name)	
 			join_table = join_config[:join_table]
 			macro = join_config[:macro]
 			
@@ -197,22 +101,25 @@ class Fixtures
 			if join_config[:polymorphic] == true
 				join_config = join_config.dup
 				
-				associable_type = "#{join_config[:associable]}_type"
-				unless entry.has_key?(associable_type)
-					raise ArgumentError, "Polymorphic type '#{associable_type}' missing in entry '#{entry_name}' for '#{table_name}'." 
-				end
-				
+				associable_type = join_config[:associable_type]
 				associable_class = entry[associable_type]
+				
+				unless associable_class
+					raise MissingPolymorphicTypeError.new(self, entry_name, entry_template,
+						"No <#{associable_type}> was specified.")
+				end
+					
 				join_config[:child_class] = associable_class
-				join_config[:child_table] = associable_class.constantize.table_name
+				join_config[:child_table] = Object.const_get(associable_class).table_name
 			end
 			
 			# raise an error if the macro doesn't allow for multiple joins, but multiple associated entries are specified
-			unless association_templates.length == 1 || JoinFix.macro_allows_multiple(macro)
-				raise ArgumentError, "Multiple associated entries specified for the single-association macro '#{macro}' in table '#{table_name}'."
+			unless assoc_array.length == 1 || JoinFix.macro_allows_multiple(macro)
+				raise MultipleChildrenError.new(self, entry_name, entry_template,
+					"Multiple joined entries specified for the single-join macro '#{macro}'.")
 			end
 					
-			association_templates.each do |template|
+			assoc_array.each do |template|
 				# template is a reference to another entry
 				template = {template => JoinFix.new(template)} if template.kind_of?(String)
 				
@@ -229,14 +136,13 @@ class Fixtures
 					#   Note: join is sent through the make_entry machinery before adding... this ensures that the 
 					#   join entry will be processed according to the wizard modules specified for the join table.
 					child_fixture.add_entry(child_name, child) 
-					Fixtures.fixture(join_table).make_entry(join_name(entry_name, child_name), join, true) if join
+					Fixtures.fixture(join_table).make_entry(join.entry_name, join, true) if join
 				end
 			end
 		end	
 
 		# add the entry if flagged and return the entry
 		add_entry(entry_name, entry) if add_entry_on_complete
-		@@entry_stack.pop
 		entry
 	end
 	
@@ -245,27 +151,96 @@ class Fixtures
 		#return unless entry.addable?  
 		
 		# remove any attributes that are equal to their default
-		attributes = config[:attributes]
 		entry.delete_if do |attribute, value|
 			default = attributes[attribute]
 			value == default
 		end
 		
 		# create a new fixture if one by the entry_name doesn't exist
-		existing = self[entry_name] ||= Fixture.new({}, config[:class_name])
+		existing = self[entry_name] ||= Fixture.new({}, klass.class_name)
 		
 		# merge new data, checking for data collissions
 		entry.each_pair do |attribute, value|
 			if existing.has_key?(attribute) && existing[attribute] != value
-				raise ArgumentError, 
-					"Data collision: #{@table_name}(:#{entry_name}).#{attribute}\n" + 
-					"<#{existing[attribute]}> is not equal to\n<#{value}>"
+				raise EntryCollisionError.new(self, entry_name, entry,
+					"<#{value}> is not equal to the existing '#{attribute}'\n<#{existing[attribute]}>")
 			end
 			existing[attribute] = value
 		end
 	end
+end
+
+class MakeEntryError < RuntimeError # :nodoc:
+	attr_reader :fixtures, :entry_name, :entry, :msg
+	attr_accessor :advice
 	
-	def join_name(entry_name, child_name)
-		entry_name < child_name ? "#{entry_name}_#{child_name}" : "#{child_name}_#{entry_name}"
+	def initialize(fixtures, entry_name, entry, msg=nil)
+		@fixtures = fixtures
+		@entry_name = entry_name
+		@entry = entry
+		@msg =msg
+	end
+				
+	def message
+		"Error making <#{fixtures.klass.table_name}(:#{entry_name})> in <#{fixtures.fixture_path}>.\n" + 
+		{entry_name => entry}.to_yaml +
+		(msg.nil? ? '' : "\n#{msg}\n") +
+		(advice.nil? ? '' : "#{advice}\n")
+	end
+end
+
+class EntryCollisionError < MakeEntryError # :nodoc:
+end
+
+class NoEntryNameError < MakeEntryError # :nodoc:
+	def advice
+		%Q{
+This error occurs when an entry is not named as in:
+---
+dog:
+  title: Dog
+  author:
+    # <an entry name like 'ferlinghetti' is missing here>
+    full_name: Lawrence Ferlinghetti
+    ...}
+	end
+end
+
+class MultipleChildrenError < MakeEntryError # :nodoc:
+	def advice
+		%Q{
+Single entry joins should specify a single entry, not an array of entries.
+Use a different association if you need multiple joined entries.
+---
+poem:
+  title: Slave's Dream
+  author: 
+    longfellow:
+      full_name: Henry Wadsworth Longfellow}
+	end
+end
+
+class MissingPolymorphicTypeError < MakeEntryError # :nodoc:
+	def advice
+		%Q{
+When specifying a belongs_to :polymorphic join, the type
+of the joined entry must be specified because it cannot be
+inferred from association itself.  Use something like:
+--
+book_I_read:
+  opinion: Great!
+  readable_type: Book
+  readable:
+    the_jungle_books:
+      author: Rudyard Kipling
+      title: The Jungle Books
+
+poem_I_read:
+  opinion: Essential!
+  readable_type: Poem
+  readable:
+    sea_fever:
+      poet: John Masefield 
+      title: Sea-Fever}
 	end
 end

data/lib/joinfix/fixtures_class.rb

@@ -23,25 +23,29 @@ class Fixtures
 		# not yet been loaded.
 		def fixture(table_name)
 			fixture = all_loaded_fixtures[table_name.to_s]
-			raise ArgumentError, "No fixture loaded for: #{table_name}" unless fixture
+			raise MissingFixtureError.new(table_name) unless fixture
 			fixture
 		end
 		   
 		protected
 
+		# Sets the primary key in each of the input fixtures, beginning one-past fixtures.offset
+		# (generally this is 1).  If a fixture already has an id assigned, it will be skipped.
 		def index_fixtures(fixtures)
+			id = fixtures.klass.primary_key
+			
 			# first find entries with an id and record the ids so that they will be skipped
 			skip_indicies = []
 			fixtures.each_pair do |name, fixture|
-				skip_indicies << fixture["id"].to_i if fixture.has_key?("id")
+				skip_indicies << fixture[id].to_i if fixture.has_key?(id)
 			end
 					
 			# next find and index entries that do not have an id defined
 			index = fixtures.offset
 			fixtures.each_pair do |name, fixture|
 				# skip entries that already have an id defined
-				next if fixture.has_key?("id")
-			
+				next if fixture.has_key?(id)
+	
 				# find the next available index
 				# note this must happen before the id assignment,
 				# in case index 1 is marked for skipping
@@ -50,12 +54,13 @@ class Fixtures
 					break unless skip_indicies.include?(index)
 				end
 		
-				fixture["id"] = index
+				fixture[id] = index
 			end
 		end
 		
+		# Resolves each join reference in the input fixtures
 		def resolve_references(fixtures)
-			fixtures.each_pair do |name, fixture|
+			fixtures.each_pair do |entry_name, fixture|
 				# search the fixture for join references
 				fixture.each_pair do |join_ref, join_name|
 					# next if the key isn't a join reference
@@ -63,35 +68,38 @@ class Fixtures
 					
 					foreign_key = join_ref.first
 					join_table_name = join_ref.last
-		
-					# next if the foreign key is already defined
-					next if fixture.has_key?(foreign_key)
-							
-					begin 
-						# raise an error if the join table isn't loaded; the reference cannot be resolved
-						unless Fixtures.all_loaded_fixtures.has_key?(join_table_name)
-							raise ArgumentError, "The join table '#{join_table_name}' has not been loaded." 
-						end
-								
-						join_fixtures = Fixtures.all_loaded_fixtures[join_table_name]
+				
+					# raise an error if the join table isn't loaded; the reference cannot be resolved
+					unless Fixtures.all_loaded_fixtures.has_key?(join_table_name)
+						raise ResolveJoinReferenceError.new(fixtures, entry_name, join_table_name, join_name,
+							"The join table '#{join_table_name}' has not been loaded.")
+					end
 								
-						# raise an error if the join entry isn't in the join table; the reference cannot be resolved
-						unless join_fixtures.has_key?(join_name)
-							raise ArgumentError, "The join entry '#{join_name}' doesn't exist in '#{join_table_name}'." 
-						end
+					join_fixtures = Fixtures.all_loaded_fixtures[join_table_name]
+					id = join_fixtures.klass.primary_key
+						
+					# raise an error if the join entry isn't in the join table; the reference cannot be resolved
+					unless join_fixtures.has_key?(join_name)
+						raise ResolveJoinReferenceError.new(fixtures, entry_name, join_table_name, join_name,
+							"The join entry '#{join_name}' doesn't exist in '#{join_table_name}'.")
+					end
 			
-						join_entry = join_fixtures[join_name]
+					join_entry = join_fixtures[join_name]
 								
-						# raise an exception if a join_id was not found
-						unless join_entry.has_key?("id")
-							raise ArgumentError, "No id present in join entry '#{join_name}'."
-						end
-					rescue
-						raise ArgumentError, "Cannot resolve reference '#{join_reference} => #{join_name}' in '#{@table_name}.#{name}'. #{$!}"
+					# raise an exception if a join_id was not found
+					unless join_entry.has_key?(id)
+						raise ResolveJoinReferenceError.new(fixtures, entry_name, join_table_name, join_name,
+							"No #{id} present in join entry '#{join_name}'.")
+					end
+	
+					# raise an exception if the foreign key is already set
+					unless fixture[foreign_key].nil?
+						raise ForeignKeySetError.new(fixtures, entry_name, join_table_name, join_name,
+							"Foreign key <#{foreign_key}> is already set!")
 					end
-							
+						
 					# set the join id
-					fixture[foreign_key] = join_entry["id"]
+					fixture[foreign_key] = join_entry[id]
 				end
 						
 				# delete the join references
@@ -100,3 +108,60 @@ class Fixtures
 		end
 	end
 end
+
+class MissingFixtureError < RuntimeError # :nodoc:
+	attr_reader :table_name
+	def initialize(table_name)
+		@table_name = table_name
+	end
+	
+	def message
+		"No fixture loaded for <#{table_name}>\n" +
+		(advice.nil? ? '' : "#{advice}\n")
+	end
+	
+	def advice
+		%Q{}
+	end
+end
+
+class ResolveJoinReferenceError < RuntimeError # :nodoc:
+	attr_reader :fixtures, :entry_name, :join_table_name, :join_name, :msg
+	attr_accessor :advice
+	
+	def initialize(fixtures, entry_name, join_table_name, join_name, msg=nil)
+		@fixtures = fixtures
+		@entry_name = entry_name
+		@join_table_name = join_table_name
+		@join_name = join_name
+		@msg =msg
+	end
+				
+	def message
+		"Cannot resolve reference to <#{join_table_name}(:#{join_name})> " + 
+		"for <#{fixtures.klass.table_name}(:#{entry_name})> " + 
+		"in <#{fixtures.fixture_path}>.\n" +
+		(msg.nil? ? '' : "\n#{msg}\n") +
+		(advice.nil? ? '' : "#{advice}\n")
+	end
+end
+
+class ForeignKeySetError < ResolveJoinReferenceError # :nodoc:
+	def advice
+		%Q{
+This error occurs when you specifiy the foreign key, as well as a join entry.  
+---
+poem:
+  title: Poetry of Departures
+  author_id: 8
+  author: larkin
+
+If you need to specify the foreign key, do so within the entry.
+---
+poem:
+  title: Poetry of Departures
+  author: 
+    larkin:
+      id: 8}
+	end
+end