acts-as-dag 1.1.0

data/README.rdoc

@@ -0,0 +1,282 @@
+= Acts As Dag
+
+Acts As Dag, short for Acts As Directed Acyclic Graph, is a plugin which allows you to represent DAG hierarchy using your ActiveRecord models. 
+
+== Basic Information
+
+Say you have been using one of the many great plugins that allow for Tree hierarchy like: acts_as_tree or acts_as_nested_set, acts_as_better_nested_set, etc. Yet, you feel something is missing. Tree's are just not good enough. You want to allow each record to have multiple parent objects within a hierarchy as well as multiple children. Then you are going to need a DAG instead of a tree, and thats were this plugin becomes useful.
+
+=== What's a DAG?
+
+http://en.wikipedia.org/wiki/Directed_acyclic_graph
+
+=== Aren't there plugins for this already?
+
+Yes, but I think they aren't as fast or feature filled. Flogic has a good simple acts_as_dag plugin on github which would be similar to acts_as_tree.
+
+== Features
+
+* DAG graph functionality
+* STI support
+* Polymorphic graphs
+* Association injection for graph nodes
+* Instance method injections (root?,leaf?) for graph nodes
+* O(1) lookups, no breath or depth first searching
+* O(x*y) insert, update and delete, where x & y are the number of ancestors and descendants of a node.
+ 
+== Requirements
+
+This uses named_scope so your going to need Rails 2.1 or above.
+
+Currently tested using Rails 2.3.8. Working on a separate version of acts-as-dag that is based on Rails 3.x and use all of the new ActiveRecord goodness found there.
+
+== Installation
+
+	gem install acts-as-dag
+	
+== Terminology
+
+- Node: A source or destination of a link or edge in the graph.
+- Edge: A direct connection between two nodes. These can only be created by your application.
+- Link: A indirect connection between two nodes. Denotes the existence of a path. These can only be created by the plugin internally.
+	
+== Singleton Methods
+
+This section outlines the two methods that need to be included in your ActiveRecord models. In general this whole plugin can be thought of as one big has_many association.
+
+=== acts_as_dag_links
+
+This singleton class method needs to be called in your ActiveRecord model that represents the links for the DAG graph. For non-polymorphic graphs it has a required parameter:
+
+	acts_as_dag_links :node_class_name => 'Class Name of the node model'
+
+If the graph is polymorphic :node_class_name is unnecessary. A polymorphic call would be:
+
+	acts_as_dag_links :polymorphic => true
+
+==== Optional Parameters
+
+- :ancestor_id_column. By default, 'ancestor_id', column to use for the ancestor reference
+- :descendant_id_column. By default, 'descendant_id', column to use for the descendant reference
+- :direct_column. By default, 'direct', boolean column that represents whether the link is an edge (direct)
+- :count_column. By default, 'count', represents the number of ways to get from A to B.
+- :polymorphic. By default, false, If you want polymorphic graphs see below.
+
+With polymorphic graphs we also have...
+
+- :ancestor_type_column. By default, 'ancestor_type', column to use for the ancestor type reference
+- :descendant_type_column. By default, 'descendant_type', column to use for the descendant type reference
+
+==== Required Table Columns
+
+Each of the optional column parameters needs a field in the link table. Hence for non-polymorphic graphs a migration would look like...
+
+	create_table :links, do |t|
+		t.integer :ancestor_id
+		t.integer :descendant_id
+		t.boolean :direct
+		t.integer :count
+	end
+	
+And for polymorphic graphs...
+
+	create_table :links, do |t|
+		t.integer :ancestor_id
+		t.string  :ancestor_type
+		t.integer :descendant_id
+		t.string  :descendant_type
+		t.boolean :direct
+		t.integer :count
+	end
+	
+==== Injected Associations
+
+Calling acts_as_dag_links method in the class definition injects the following associations.
+
+	belongs_to :ancestor
+	belongs_to :descendant
+	
+==== Injected Named Scopes
+
+The recieves the following named scopes. The following two scopes narrows a query to only links with a certain ancestor or descendant
+
+	named_scope :with_ancestor(ancestor_instance)
+	named_scope :with_descendant(descendant_instance)
+	
+The scopes below narrow queries to direct or indirect links
+
+	named_scope :direct
+	named_scope :indirect
+	
+The scopes below attach the actual ancestor or descendant nodes
+
+	named_scope :ancestor_nodes, :joins => :ancestor
+	named_scope :descendant_nodes, :joins => :descendant
+	
+==== Injected Class Methods
+
+Several class methods get added to the link model to make it easier to find and create edges, and find links.
+
+	#Finds an edge of returns nil
+	self.find_edge(ancestor,descendant)
+	#Returns true if an edge exists
+	self.edge?(ancestor,descendant)
+	self.direct?(ancestor,descendant)
+	
+	#Finds a link or returns nil
+	self.find_link(ancestor,descendant)
+	#Returns true if a link exists
+	self.connected?(ancestor,descendant)
+	
+	#Creates an edge between an ancestor and descendant
+	self.create_edge(ancestor,descendant)
+	self.connect(ancestor,descendant)
+	
+	#Creates an edge using save! between an ancestor and descendant
+	self.create_edge!(ancestor,descendant)
+	self.connect!(ancestor,descendant)
+	
+	#Builds an edge between an ancestor and descendant, returning an unsaved edge
+	self.build_edge(ancestor,descendant)
+	
+	#Finds and returns the edge if it exists, or calls build_edge
+	self.find_or_build_edge(ancestor,descendant)
+	
+==== Injected Instance Methods
+
+Here is a sample of some of the important instance methods that get added to the link model.
+
+	#whether the current edge can be destroyed. If the edge also has a link, ie it can be made indirectly, then it cannot be 	destroyed.	
+	destroyable?()
+	
+	#Make the edge indirect. Removes the direct edge but keeps the indirect links
+	make_indirect()
+	
+	#Makes the link direct. Adds a direct edge onto a link.
+	make_direct()
+	
+	#Number of unique ways to get from the ancestor to the descendant
+	count()
+	
+=== has_dag_links
+
+This singleton class method can be optionally called from the node ActiveRecord model. If you do not call it you don't get all the nice associations within the node model, yet everything will still work fine. It takes the required parameter:
+
+	has_dag_links :link_class_name => 'Class Name of the link model'
+
+==== Optional Parameters
+
+- :prefix. By default, ''. Use a prefix if your model calls has_dag_links for multiple link classes.
+
+If your link class holds a polymorphic graph you also have...
+
+- :ancestor_class_names. By default [], array of class names that are ancestors to this class.
+- :descendant_class_names. By default [], array of class names that are descendants to this class.
+
+==== Injected Associations
+
+has_dag_links provides a number of has_many and has_many_through associations.
+
+- links_as_ancestor: Has many association that finds the links with the current instance as ancestor
+- links_as_descendant: Has many association that finds the links with the current instance as descendant
+- links_as_parent: Has many association that finds direct links (edges) with the current instance as ancestor
+- links_as_child: Has many association that finds direct links (edges) with the current instance as descendant
+
+Note that if a record is in links_as_parent it will be in links_as_ancestor. Also note that adding records to either produces the same result as you can only add direct links (edges). Currently there is also an error if a record exists for links_as_ancestor and you try to add it to links_as_parent. The correct way is to use the make_direct method on the link instance.
+
+For non-polymorphic graphs you also get the following associations. These find the actual ancestors as opposed to the link instances.
+
+- ancestors
+- descendants
+- parents
+- children
+
+For polymorphic graphs where the ancestor_class_names or descendant_class_names includes the specified class names the following associations are also built. For each ancestor_class_name:
+
+-links_as_descendant_for_#{ancestor_class_name.tableize}
+-links_as_child_for_#{ancestor_class_name.tableize}
+-ancestor_#{ancestor_class_name.tableize}
+-parent_#{ancestor_class_name.tableize}
+
+For each descendant_class_name
+
+-links_as_ancestor_for_#{ancestor_class_name.tableize}
+-links_as_parent_for_#{ancestor_class_name.tableize}
+-descendant_#{ancestor_class_name.tableize}
+-child_#{ancestor_class_name.tableize}
+
+==== Injected Instance Methods
+
+Along with the above associations a number of instance methods are defined.
+
+-leaf? , Boolean value as to whether the current node is a leaf (no descendants)
+-root? , Boolean value as to whether the current node is a root (no ancestors)
+
+With polymorphic graphs for each ancestor_class_name another method is defined.
+
+-root_for_#{ancestor_class_name.tableize}? , Returns true if the node has no ancestors of the represented type.
+
+Likewise for each descendant_class_name.
+
+-leaf_for_#{descendent_class_name.tableize}? , Returns true if the node has no descendants of the represented type.
+
+== Usage
+
+This section goes over some basic usage examples and presents some caveats.
+
+=== Basic Non-polymorphic Graphs.
+
+	class Node < ActiveRecord::Base
+		has_dag_links :link_class_name => 'Link'
+	end
+	
+	class Link < ActiveRecord::Base
+		acts_as_dag_links :node_class_name => 'Node'
+	end
+	
+	#Adding an edge
+	parent_node = Node.create!
+	child_node = Node.create!
+	parent_node.children << child_node
+	
+	#Removing it
+	link = Link.find_link(parent_node,child_node)
+	if link.destroyable?
+		link.destory
+	else
+		link.make_indirect
+		link.save!
+	end
+
+=== Caveats for Adding, Updating, Deleting Links
+
+Due to the algorithm used there are some caveats for modifying links. Don't worry if you try to do something illegal because it will raise exceptions and not muck the graph up.
+
+You can only create new edges where a link doesn't already exist. If the link exists and you want to make it direct you need to promote it using make_direct instance method. Also you can only create direct links. This makes sense because indirect links are dependent on direct links. An indirect link by itself makes no sense to the algorithm. In reverse, you can only delete links which are direct and have no indirect nature. Hence the link only exists because it is direct and not through a sequence of other links. Instead of deleting these types of links you can downgrade them using make_indirect. This will remove the direct edge A -> C and leave the transitive edge from A -> B and B -> C. So just remember before you add, check if it exists, or use one of the link class method create_edge! which will always work.
+
+== The Algorithm
+
+This section briefly explains how the plugin works. For a really detailed understanding look at the perpetuate function which is used to fix up the graph when its changed.
+
+To start there is some terminology:
+
+- Node is a point on the graph
+- Edge is a direct connection between two nodes.
+- Link is a connection using one or more edges.
+
+This implementation works by storing every possible link as a record in the database. The links originate at the ancestor and end at the descendant. Hence checking if X is a descendant of Y can be accomplished in one SQL query. Likewise finding all descendants or ancestors of Y can also be done in a single query. There are simple queries that don't use recursive stored procedures that you would need with a parent child model. Hence getting information out of the database is really fast. You can also find out the number of unique ways X is connected to Y and whether it has a direct connection. This allows the finding of all parents or children of a node with one query.
+
+The downside to this implementation, besides the large storage requirements, is that updating the graph by adding or removing nodes or edges is not trivial. When edges are added a sort of cross product between the parent and child nodes ancestors and descendants is done that updates the counts and creates new links as necessary. Hence the complexity of an update, add, or deletion, matters heavily on how your graph is arranged and what nodes you are connecting.
+
+== Thanks
+
+Whoever did the awesome_nested_set plugin. This is my first plugin and I used that as a base. The Rails Way was also a great book that essentially taught me Rails. 
+
+== Credit
+
+Authors:: Matthew Leventi, Robert Schmitt
+
+Algorithm and plugin designed by Matthew Leventi Email:(first letter of my first name followed by my last name @gmail.com). Im open to questions, very open to bugs, and even more receptive of bug fixes. I am also currently (August 2008) looking for a job just having graduated University of Rochester.
+
+Robert Schmitt: I have modified the Rake system to support Jeweler to build this as a Ruby gem that can be installed and managed through the gem system.
+

data/lib/active_record/acts/dag.rb

@@ -0,0 +1,800 @@
+module ActiveRecord
+	module Acts
+		module Dag
+			def self.included(base)
+				base.extend(SingletonMethods)
+			end
+			module SingletonMethods
+				#Sets up a model to act as dag links for models specified under the :for option
+				def acts_as_dag_links(options = {})
+					conf = {
+						:ancestor_id_column => 'ancestor_id',
+						:ancestor_type_column => 'ancestor_type', 
+						:descendant_id_column => 'descendant_id',
+						:descendant_type_column => 'descendant_type', 
+						:direct_column => 'direct', 
+						:count_column => 'count',
+						:polymorphic => false,
+						:node_class_name => nil}
+					conf.update(options)
+					
+					unless conf[:polymorphic]
+						if conf[:node_class_name].nil?
+							raise ActiveRecord::ActiveRecordError, 'Nonpolymorphic graphs need to specify :node_class_name with the recieving class like belong_to'
+						end 
+					end
+					
+					write_inheritable_attribute :acts_as_dag_options, conf
+					class_inheritable_reader :acts_as_dag_options
+					
+					extend Columns
+					include Columns
+					
+					#access to _changed? and _was for (edge,count) if not default
+					unless direct_column_name == 'direct'
+						module_eval <<-"end_eval",__FILE__, __LINE__
+						def direct_changed?
+							self.#{direct_column_name}_changed?
+						end
+						def direct_was
+							self.#{direct_column_name}_was
+						end
+						end_eval
+					end
+					
+					unless count_column_name == 'count'
+						module_eval <<-"end_eval",__FILE__, __LINE__
+						def count_changed?
+							self.#{count_column_name}_changed?
+						end
+						def count_was
+							self.#{count_column_name}_was
+						end
+						end_eval
+					end
+					
+					internal_columns = [ancestor_id_column_name,descendant_id_column_name]
+					edge_class_name = self.to_s
+					
+					direct_column_name.intern
+					count_column_name.intern
+					
+					#links to ancestor and descendant
+					if acts_as_dag_polymorphic?
+						extend PolyColumns
+						include PolyColumns
+						
+						internal_columns << ancestor_type_column_name
+						internal_columns << descendant_type_column_name
+						
+						belongs_to :ancestor, :polymorphic => true
+						belongs_to :descendant, :polymorphic => true
+						
+						validates_presence_of ancestor_type_column_name, descendant_type_column_name
+						validates_uniqueness_of ancestor_id_column_name, :scope => [ancestor_type_column_name,descendant_type_column_name,descendant_id_column_name]
+						
+						named_scope :with_ancestor, lambda {|ancestor| {:conditions => {ancestor_id_column_name => ancestor.id, ancestor_type_column_name => ancestor.class.to_s}}}
+						named_scope :with_descendant, lambda {|descendant| {:conditions => {descendant_id_column_name => descendant.id, descendant_type_column_name => descendant.class.to_s}}}
+						
+						named_scope :with_ancestor_point, lambda {|point| {:conditions => {ancestor_id_column_name => point.id, ancestor_type_column_name => point.type}}}
+						named_scope :with_descendant_point, lambda {|point| {:conditions => {descendant_id_column_name => point.id, descendant_type_column_name => point.type}}}
+						
+						extend PolyEdgeClassMethods
+						include PolyEdgeClasses
+						include PolyEdgeInstanceMethods  
+					else
+						belongs_to :ancestor, :foreign_key => ancestor_id_column_name, :class_name => acts_as_dag_options[:node_class_name]
+						belongs_to :descendant, :foreign_key => descendant_id_column_name, :class_name => acts_as_dag_options[:node_class_name]
+						
+						validates_uniqueness_of ancestor_id_column_name, :scope => [descendant_id_column_name]
+						
+						named_scope :with_ancestor, lambda {|ancestor| {:conditions => {ancestor_id_column_name => ancestor.id}}}
+						named_scope :with_descendant, lambda {|descendant| {:conditions => {descendant_id_column_name => descendant.id}}}
+						
+						named_scope :with_ancestor_point, lambda {|point| {:conditions => {ancestor_id_column_name => point.id}}}
+						named_scope :with_descendant_point, lambda {|point| {:conditions => {descendant_id_column_name => point.id}}}
+						
+						extend NonPolyEdgeClassMethods
+						include NonPolyEdgeClasses
+						include NonPolyEdgeInstanceMethods
+					end
+					
+					named_scope :direct, :conditions => {:direct => true}
+					named_scope :indirect, :conditions => {:direct => false}
+					
+					named_scope :ancestor_nodes, :joins => :ancestor
+					named_scope :descendant_nodes, :joins => :descendant
+					
+					validates_presence_of ancestor_id_column_name, descendant_id_column_name
+					validates_numericality_of ancestor_id_column_name, descendant_id_column_name
+					
+					extend EdgeClassMethods
+					include EdgeInstanceMethods
+					
+					before_destroy :destroyable!, :perpetuate
+					before_save :perpetuate
+					before_validation_on_update :field_check, :fill_defaults
+					before_validation_on_create :fill_defaults
+					
+					#internal fields
+					code = 'def field_check ' + "\n"
+					internal_columns.each do |column|
+						code +=  "if " + column + "_changed? \n" + ' raise ActiveRecord::ActiveRecordError, "Column: '+column+' cannot be changed for an existing record it is immutable"' + "\n end \n"
+					end
+					code += 'end'
+					module_eval code
+					
+					[count_column_name].each do |column|
+						module_eval <<-"end_eval", __FILE__, __LINE__
+						def #{column}=(x)
+							raise ActiveRecord::ActiveRecordError, "Unauthorized assignment to #{column}: it's an internal field handled by acts_as_dag code."
+						end
+						end_eval
+					end       
+				end      
+				def has_dag_links(options = {})
+					conf = {
+						:class_name => nil,
+						:prefix => '',
+						:ancestor_class_names => [],
+						:descendant_class_names => []
+					}
+					conf.update(options)
+					
+					#check that class_name is filled
+					if conf[:link_class_name].nil?
+						raise ActiveRecord::ActiveRecordError, "has_dag must be provided with :link_class_name option"
+					end
+					
+					#add trailing '_' to prefix
+					unless conf[:prefix] == ''
+						conf[:prefix] += '_'
+					end
+					
+					prefix = conf[:prefix]
+					dag_link_class_name = conf[:link_class_name]
+					dag_link_class = conf[:link_class_name].constantize        
+					
+					if dag_link_class.acts_as_dag_polymorphic?
+						self.class_eval <<-EOL
+              has_many :#{prefix}links_as_ancestor, :as => :ancestor, :class_name => '#{dag_link_class_name}'
+              has_many :#{prefix}links_as_descendant, :as => :descendant, :class_name => '#{dag_link_class_name}'
+            
+              has_many :#{prefix}links_as_parent, :as => :ancestor, :class_name => '#{dag_link_class_name}', :conditions => {'#{dag_link_class.direct_column_name}' => true}
+              has_many :#{prefix}links_as_child, :as => :descendant, :class_name => '#{dag_link_class_name}', :conditions => {'#{dag_link_class.direct_column_name}' => true}
+              
+            EOL
+						
+						ancestor_table_names = []
+						parent_table_names = []
+						conf[:ancestor_class_names].each do |class_name|
+							table_name = class_name.tableize
+							self.class_eval <<-EOL2
+                has_many :#{prefix}links_as_descendant_for_#{table_name}, :as => :descendant, :class_name => '#{dag_link_class_name}', :conditions => {'#{dag_link_class.ancestor_type_column_name}' => '#{class_name}'}
+                has_many :#{prefix}ancestor_#{table_name}, :through => :#{prefix}links_as_descendant_for_#{table_name}, :source => :ancestor, :source_type => '#{class_name}'
+                has_many :#{prefix}links_as_child_for_#{table_name}, :as => :descendant, :class_name => '#{dag_link_class_name}', :conditions => {'#{dag_link_class.ancestor_type_column_name}' => '#{class_name}','#{dag_link_class.direct_column_name}' => true}
+                has_many :#{prefix}parent_#{table_name}, :through => :#{prefix}links_as_child_for_#{table_name}, :source => :ancestor, :source_type => '#{class_name}'
+              
+              	def #{prefix}root_for_#{table_name}?
+									return self.links_as_descendant_for_#{table_name}.empty?
+            		end
+              EOL2
+							ancestor_table_names << (prefix+'ancestor_'+table_name)
+							parent_table_names << (prefix+'parent_'+table_name)
+							unless conf[:descendant_class_names].include?(class_name)
+								#this apparently is only one way is we can create some aliases making things easier
+								self.class_eval "has_many :#{prefix}#{table_name}, :through => :#{prefix}links_as_descendant_for_#{table_name}, :source => :ancestor, :source_type => '#{class_name}'"   
+							end
+						end
+						
+						unless conf[:ancestor_class_names].empty?
+							self.class_eval <<-EOL25
+								def #{prefix}ancestors
+									return #{ancestor_table_names.join(' + ')}
+								end
+								def #{prefix}parents
+									return #{parent_table_names.join(' + ')}
+								end
+							EOL25
+						else
+							self.class_eval <<-EOL26
+								def #{prefix}ancestors
+									a = []
+									#{prefix}links_as_descendant.each do |link|
+										a << link.ancestor
+									end
+									return a
+								end
+								def #{prefix}parents
+									a = []
+									#{prefix}links_as_child.each do |link|
+										a << link.ancestor
+									end
+									return a
+								end
+							EOL26
+						end
+						
+						descendant_table_names = []
+						child_table_names = []
+						conf[:descendant_class_names].each do |class_name|
+							table_name = class_name.tableize
+							self.class_eval <<-EOL3
+                has_many :#{prefix}links_as_ancestor_for_#{table_name}, :as => :ancestor, :class_name => '#{dag_link_class_name}', :conditions => {'#{dag_link_class.descendant_type_column_name}' => '#{class_name}'}
+                has_many :#{prefix}descendant_#{table_name}, :through => :#{prefix}links_as_ancestor_for_#{table_name}, :source => :descendant, :source_type => '#{class_name}'
+            
+                has_many :#{prefix}links_as_parent_for_#{table_name}, :as => :ancestor, :class_name => '#{dag_link_class_name}', :conditions => {'#{dag_link_class.descendant_type_column_name}' => '#{class_name}','#{dag_link_class.direct_column_name}' => true}
+                has_many :#{prefix}child_#{table_name}, :through => :#{prefix}links_as_parent_for_#{table_name}, :source => :descendant, :source_type => '#{class_name}'
+								
+								def #{prefix}leaf_for_#{table_name}?
+                	return self.links_as_ancestor_for_#{table_name}.empty?
+              	end
+              EOL3
+							descendant_table_names << (prefix+'descendant_'+table_name)
+							child_table_names << (prefix+'child_'+table_name)
+							unless conf[:ancestor_class_names].include?(class_name)
+								self.class_eval "has_many :#{prefix}#{table_name}, :through => :#{prefix}links_as_ancestor_for_#{table_name}, :source => :descendant, :source_type => '#{class_name}'"
+							end
+						end
+						
+						unless conf[:descendant_class_names].empty?
+							self.class_eval <<-EOL35
+								def #{prefix}descendants
+									return #{descendant_table_names.join(' + ')}
+								end
+								def #{prefix}children
+									return #{child_table_names.join(' + ')}
+								end
+							EOL35
+						else
+							self.class_eval <<-EOL36
+								def #{prefix}descendants
+									d = []
+									#{prefix}links_as_ancestor.each do |link|
+										d << link.descendant
+									end
+									return d
+								end
+								def #{prefix}children
+									d = []
+									#{prefix}links_as_parent.each do |link|
+										d << link.descendant
+									end
+									return d
+								end
+							EOL36
+						end
+					else
+						self.class_eval <<-EOL4
+              has_many :#{prefix}links_as_ancestor, :foreign_key => '#{dag_link_class.ancestor_id_column_name}', :class_name => '#{dag_link_class_name}'
+              has_many :#{prefix}links_as_descendant, :foreign_key => '#{dag_link_class.descendant_id_column_name}', :class_name => '#{dag_link_class_name}'
+            
+              has_many :#{prefix}ancestors, :through => :#{prefix}links_as_descendant, :source => :ancestor
+              has_many :#{prefix}descendants, :through => :#{prefix}links_as_ancestor, :source => :descendant
+            
+              has_many :#{prefix}links_as_parent, :foreign_key => '#{dag_link_class.ancestor_id_column_name}', :class_name => '#{dag_link_class_name}', :conditions => {'#{dag_link_class.direct_column_name}' => true}
+              has_many :#{prefix}links_as_child, :foreign_key => '#{dag_link_class.descendant_id_column_name}', :class_name => '#{dag_link_class_name}', :conditions => {'#{dag_link_class.direct_column_name}' => true}
+                        
+              has_many :#{prefix}parents, :through => :#{prefix}links_as_child, :source => :ancestor
+              has_many :#{prefix}children, :through => :#{prefix}links_as_parent, :source => :descendant
+              
+            EOL4
+					end
+					self.class_eval <<-EOL5
+            def #{prefix}leaf?
+              return self.#{prefix}links_as_ancestor.empty?
+						end
+						def #{prefix}root?
+							return self.#{prefix}links_as_descendant.empty?
+						end
+					EOL5
+				end
+			end
+			
+			
+			
+			
+			#Methods that show the columns for polymorphic DAGs
+			module PolyColumns
+				def ancestor_type_column_name
+					acts_as_dag_options[:ancestor_type_column]
+				end
+				
+				def descendant_type_column_name
+					acts_as_dag_options[:descendant_type_column]
+				end
+			end
+			
+			#Methods that show columns
+			module Columns
+				def ancestor_id_column_name
+					acts_as_dag_options[:ancestor_id_column]
+				end
+				
+				def descendant_id_column_name
+					acts_as_dag_options[:descendant_id_column]
+				end
+				
+				def direct_column_name
+					acts_as_dag_options[:direct_column]
+				end
+				
+				def count_column_name
+					acts_as_dag_options[:count_column]
+				end
+				
+				def acts_as_dag_polymorphic?
+					acts_as_dag_options[:polymorphic]
+				end
+			end
+			
+			#Contains class methods that extend the link model for polymorphic DAGs
+			module PolyEdgeClassMethods
+				#Builds a hash that describes a link from a source and a sink
+				def conditions_for(source,sink)
+					{
+						ancestor_id_column_name => source.id,
+						ancestor_type_column_name => source.type,
+						descendant_id_column_name => sink.id,
+						descendant_type_column_name => sink.type
+					}
+				end
+			end
+			#Contains nested classes in the link model for polymorphic DAGs 
+			module PolyEdgeClasses
+				#Encapsulates the necessary information about a graph node
+				class EndPoint
+					#Does the endpoint match a model or another endpoint   
+					def matches?(other)
+						return (self.id == other.id) && (self.type == other.type) if other.is_a?(EndPoint)
+						return (self.id == other.id) && (self.type == other.class.to_s)
+					end
+					
+					#Factory Construction method that creates an EndPoint instance from a model
+					def self.from_resource(resource)
+						self.new(resource.id,resource.class.to_s)
+					end
+					
+					#Factory Construction method that creates an EndPoint instance from a model if necessary
+					def self.from(obj)
+						return obj if obj.kind_of?(EndPoint)
+						return self.from_resource(obj)
+					end
+					
+					#Initializes the EndPoint instance with an id and type
+					def initialize(id,type)
+						@id = id
+						@type = type
+					end
+					
+					attr_reader :id, :type
+				end
+				
+				#Encapsulates information about the source of a link
+				class Source < EndPoint
+					#Factory Construction method that generates a source from a link
+					def self.from_edge(edge)
+						self.new(edge.ancestor_id,edge.ancestor_type)
+					end
+				end
+				
+				#Encapsulates information about the sink (destination) of a link
+				class Sink < EndPoint
+					#Factory Construction method that generates a sink from a link
+					def self.from_edge(edge)
+						self.new(edge.descendant_id,edge.descendant_type)
+					end
+				end
+			end
+			
+			#Contains class methods that extend the link model for a nonpolymorphic DAG
+			module NonPolyEdgeClassMethods
+				#Builds a hash that describes a link from a source and a sink
+				def conditions_for(source,sink)
+					{
+						ancestor_id_column_name => source.id,
+						descendant_id_column_name => sink.id
+					}
+				end
+			end
+			#Contains nested classes in the link model for a nonpolymorphic DAG
+			module NonPolyEdgeClasses 
+				#Encapsulates the necessary information about a graph node    
+				class EndPoint
+					#Does an endpoint match another endpoint or model instance
+					def matches?(other)
+						return (self.id == other.id)
+					end
+					
+					#Factory Construction method that creates an endpoint from a model
+					def self.from_resource(resource)
+						self.new(resource.id)
+					end
+					
+					#Factory Construction method that creates an endpoint from a model if necessary
+					def self.from(obj)
+						return obj if obj.kind_of?(EndPoint)
+						return self.from_resource(obj)
+					end
+					
+					#Initializes an endpoint based on an Id
+					def initialize(id)
+						@id = id
+					end
+					
+					attr_reader :id
+				end
+				
+				#Encapsulates information about the source of a link
+				class Source < EndPoint
+					#Factory Construction method creates a source instance from a link
+					def self.from_edge(edge)
+						return self.new(edge.ancestor_id)
+					end
+				end
+				#Encapsulates information about the sink of a link
+				class Sink < EndPoint
+					#Factory Construction method creates a sink instance from a link
+					def self.from_edge(edge)
+						return self.new(edge.descendant_id)
+					end
+				end
+			end
+			
+			#Class methods that extend the link model for both polymorphic and nonpolymorphic graphs
+			module EdgeClassMethods
+				
+				#Returns a new edge between two points
+				def build_edge(ancestor,descendant)
+					source = self::EndPoint.from(ancestor)
+					sink = self::EndPoint.from(descendant)
+					conditions = self.conditions_for(source,sink)
+					path = self.new(conditions)
+					path.make_direct
+					return path
+				end
+				
+				#Finds an edge between two points, Must be direct
+				def find_edge(ancestor,descendant)
+					source = self::EndPoint.from(ancestor)
+					sink = self::EndPoint.from(descendant)
+					edge = self.find(:first,:conditions => self.conditions_for(source,sink).merge!({direct_column_name => true}))
+					return edge
+				end
+				
+				#Finds a link between two points
+				def find_link(ancestor,descendant)
+					source = self::EndPoint.from(ancestor)
+					sink = self::EndPoint.from(descendant)
+					link = self.find(:first,:conditions => self.conditions_for(source,sink))
+					return link
+				end 
+				
+				#Finds or builds an edge between two points
+				def find_or_build_edge(ancestor,descendant)
+					edge = self.find_edge(ancestor,descendant)
+					return edge unless edge.nil?
+					return build_edge(ancestor,descendant)
+				end
+				
+				#Creates an edge between two points using save
+				def create_edge(ancestor,descendant)
+					link = self.find_link(ancestor,descendant)
+					if link.nil?
+						edge = self.build_edge(ancestor,descendant)
+						return edge.save
+					else
+						link.make_direct
+						return link.save
+					end
+				end
+				
+				#Creates an edge between two points using save! Returns created edge
+				def create_edge!(ancestor,descendant)
+					link = self.find_link(ancestor,descendant)
+					if link.nil?
+						edge = self.build_edge(ancestor,descendant)
+						edge.save!
+						return edge
+					else
+						link.make_direct
+						link.save!
+						return link
+					end
+				end
+				
+				#Alias for create_edge
+				def connect(ancestor,descendant)
+					return self.create_edge(ancestor,descendant)
+				end
+				
+				#Alias for create_edge!
+				def connect!(ancestor,descendant)
+					return self.create_edge!(ancestor,descendant)
+				end
+				
+				#Determines if a link exists between two points
+				def connected?(ancestor,descendant)
+					return !self.find_link(ancestor,descendant).nil?
+				end
+				
+				#Finds the longest path between ancestor and descendant returning as an array
+				def longest_path_between(ancestor,descendant,path=[])
+					longest = []
+					ancestor.children.each do |child|
+						if child == descendent
+							temp = path.clone
+							temp << child
+							if temp.length > longest.length
+								longest = temp
+							end
+						elsif self.connected?(child,descendant)
+							temp = path.clone
+							temp << child
+							temp = self.longest_path_between(child,descendant,temp)
+							if temp.length > longest.length
+								longest = temp
+							end
+						end
+					end
+					return longest
+				end
+				
+				#Determines if an edge exists between two points
+				def edge?(ancestor,descendant)
+					return !self.find_edge(ancestor,descendant).nil?
+				end
+				
+				#Alias for edge
+				def direct?(ancestor,descendant)
+					return self.edge?(ancestor,descendant)
+				end        
+			end
+			
+			#Instance methods included into link model for a polymorphic DAG
+			module PolyEdgeInstanceMethods
+				def ancestor_type
+					return self[ancestor_type_column_name]
+				end
+				
+				def descendant_type
+					return self[descendant_type_column_name]
+				end
+			end
+			
+			#Instance methods included into the link model for a nonpolymorphic DAG
+			module NonPolyEdgeInstanceMethods
+			end
+			
+			#Instance methods included into the link model for polymorphic and nonpolymorphic DAGs
+			module EdgeInstanceMethods
+				
+				attr_accessor :do_not_perpetuate
+
+				#Validations on model instance creation. Ensures no duplicate links, no cycles, and correct count and direct attributes
+				def validate_on_create
+					#make sure no duplicates
+					if self.class.find_link(self.source,self.sink)
+						self.errors.add_to_base('Link already exists between these points')
+					end
+					#make sure no long cycles
+					if self.class.find_link(self.sink,self.source)
+						self.errors.add_to_base('Link already exists in the opposite direction')
+					end
+					#make sure no short cycles
+					if self.sink.matches?(self.source)
+						self.errors.add_to_base('Link must start and end in different places')
+					end
+					#make sure not impossible
+					if self.direct?
+						if self.count != 0
+							self.errors.add_to_base('Cannot create a direct link with a count other than 0')
+						end
+					else
+						if self.count < 1
+							self.errors.add_to_base('Cannot create an indirect link with a count less than 1')
+						end
+					end          
+				end
+				
+				#Validations on update. Makes sure that something changed, that not making a lonely link indirect, and count is correct.
+				def validate_on_update
+					unless self.changed?
+						self.errors.add_to_base('No changes')
+					end
+					if direct_changed?
+						if count_changed?
+							self.errors.add_to_base('Do not manually change the count value')
+						end
+						if !self.direct?
+							if self.count == 1
+								self.errors.add_to_base('Cannot make a direct link with count 1 indirect')
+							end
+						end
+					end
+				end
+				
+				#Fill default direct and count values if necessary. In place of after_initialize method
+				def fill_defaults
+					self[direct_column_name] = true if self[direct_column_name].nil?
+					self[count_column_name] = 0 if self[count_column_name].nil?
+				end
+				
+				#Whether the edge can be destroyed
+				def destroyable?
+				(self.count == 0) || (self.direct? && self.count == 1)
+				end
+				
+				#Raises an exception if the edge is not destroyable. Otherwise makes the edge indirect before destruction to cleanup graph.
+				def destroyable!
+					raise ActiveRecord::ActiveRecordError, 'Cannot destroy this edge' unless destroyable?
+					#this triggers rewiring on destruction via perpetuate
+					if self.direct?
+						self[direct_column_name] = false
+					end
+					return true
+				end
+				
+				#Analyzes the changes in a model instance and rewires as necessary.
+				def perpetuate
+					#flag set by links that were modified in association
+					return true if self.do_not_perpetuate
+					
+					#if edge changed this was manually altered
+					if direct_changed?
+						if self.direct?
+							self[count_column_name] += 1
+						else
+							self[count_column_name] -= 1
+						end
+						self.wiring
+					end
+				end
+				
+				#Id of the ancestor
+				def ancestor_id
+					return self[ancestor_id_column_name]
+				end
+				
+				#Id of the descendant
+				def descendant_id
+					return self[descendant_id_column_name]
+				end
+				
+				#Count of the edge, ie the edge exists in X ways
+				def count
+					return self[count_column_name]
+				end
+				
+				#Changes the count of the edge. DO NOT CALL THIS OUTSIDE THE PLUGIN
+				def internal_count=(val)
+					self[count_column_name] = val      
+				end
+				
+				#Whether the link is direct, ie manually created
+				def direct?
+					return self[direct_column_name]
+				end
+				
+				#Whether the link is an edge?
+				def edge?
+					return self[direct_column_name]
+				end 
+				
+				#Makes the link direct, ie an edge
+				def make_direct
+					self[direct_column_name] = true
+				end
+				
+				#Makes an edge indirect, ie a link. 
+				def make_indirect
+					self[direct_column_name] = false
+				end
+				
+				#Source of the edge, creates if necessary
+				def source
+					@source = self.class::Source.from_edge(self) if @source.nil?
+					return @source
+				end
+				
+				#Sink (destination) of the edge, creates if necessary
+				def sink
+					@sink = self.class::Sink.from_edge(self) if @sink.nil?
+					return @sink
+				end
+				
+				#All links that end at the source
+				def links_to_source
+					self.class.with_descendant_point(self.source)
+				end
+				
+				#all links that start from the sink
+				def links_from_sink
+					self.class.with_ancestor_point(self.sink)
+				end
+				
+				protected
+				
+				#Changes on a wire based on the count (destroy! or save!) (should not be called outside this plugin)        
+				def push_associated_modification!(edge)
+					raise ActiveRecord::ActiveRecordError, 'Cannot modify ourself in this way' if edge == self
+					edge.do_not_perpetuate = true
+					if edge.count == 0
+						edge.destroy!
+					else
+						edge.save!
+					end
+				end
+				
+				#Updates the wiring of edges that dependent on the current one
+				def rewire_crossing(above_leg,below_leg)
+					if above_leg.count_changed?
+						was = above_leg.count_was
+						was = 0 if was.nil?
+						above_leg_count = above_leg.count - was
+						if below_leg.count_changed?
+							raise ActiveRecord::ActiveRecordError, 'ERROR: both legs cannot 0 normal count change'
+						else
+							below_leg_count = below_leg.count
+						end
+					else
+						above_leg_count = above_leg.count
+						if below_leg.count_changed?
+							was = below_leg.count_was
+							was = 0 if was.nil?
+							below_leg_count = below_leg.count - was
+						else
+							raise ActiveRecord::ActiveRecordError, 'ERROR: both legs cannot have count changes'
+						end
+					end
+					count = above_leg_count * below_leg_count
+					source = above_leg.source
+					sink = below_leg.sink
+					bridging_leg = self.class.find_link(source,sink)
+					if bridging_leg.nil?
+						bridging_leg = self.class.new(self.class.conditions_for(source,sink))
+						bridging_leg.make_indirect
+						bridging_leg.internal_count = 0
+					end
+					bridging_leg.internal_count = bridging_leg.count + count
+					return bridging_leg                     
+				end
+				
+				#Find the edges that need to be updated
+				def wiring
+					source = self.source
+					sink = self.sink
+					above_sources = []
+					self.links_to_source.each do |edge|
+						above_sources << edge.source
+					end
+					below_sinks = []
+					self.links_from_sink.each do |edge|
+						below_sinks << edge.sink
+					end
+					above_bridging_legs = []
+					#everything above me tied to my sink
+					above_sources.each do |above_source|
+						above_leg = self.class.find_link(above_source,source)
+						above_bridging_leg = self.rewire_crossing(above_leg,self)
+						above_bridging_legs << above_bridging_leg unless above_bridging_leg.nil? 
+					end
+					
+					#everything beneath me tied to my source
+					below_sinks.each do |below_sink|
+						below_leg = self.class.find_link(sink,below_sink)
+						below_bridging_leg = self.rewire_crossing(self,below_leg) 
+						self.push_associated_modification!(below_bridging_leg)
+						above_bridging_legs.each do |above_bridging_leg|
+							long_leg = self.rewire_crossing(above_bridging_leg,below_leg)
+							self.push_associated_modification!(long_leg)
+						end
+					end         
+					above_bridging_legs.each do |above_bridging_leg|
+						self.push_associated_modification!(above_bridging_leg)
+					end
+				end  
+			end
+		end
+	end
+end