acts_as_dag 1.2.6 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 76bd0a144592c855b8a2f3303ab2412e84ee8639
-  data.tar.gz: 3aab8c46cea7f49f1ea05d1cad0a20692c73d431
+  metadata.gz: 7cdf416ca036dc48217c3248d88ca65c9b18f5f7
+  data.tar.gz: 2885cb66137fed85c3c8d4e5506525b37042ab08
 SHA512:
-  metadata.gz: 97fd0d24855ef52d68e847b3ea7aaa8c1f10b16847c523ec36265dead0dddf5e5c5a21d9293305844c54351ea974c1ed749156ba1b07cb333a0ccd88af08872b
-  data.tar.gz: b8bc1490c55efc9115d3951120a1418678768c1428d8a0430525818404d35b990ea50f965c8e2b7935d7d0617a7224313327984524d043db9b16af8d172952fb
+  metadata.gz: c913c0ea39c240b172ca8a2def8f58641b5b568cf66cd612a1872c94ee5272eb5a3b1711120c17ab3caf871ce4edb25400610c88a509fc9a3bafbfb536545d57
+  data.tar.gz: bc6587a3699810974d7d95a564c8986356e3b3889bf2d9baf1ac174d12bdf7dfd5cd253695033b14e5107be06022c2dbcfded1feb2f1df1028916f46dd425d53

data/README.md

@@ -0,0 +1,139 @@
+# ActsAsDAG
+
+Adds Directed Acyclic Graph functionality to ActiveRecord
+
+## Getting Started
+
+### Gemfile
+
+```ruby
+gem 'acts_as_dag'
+```
+
+### Migration
+
+```ruby
+class CreateActsAsDagTables < ActiveRecord::Migration
+  def change
+    create_table "acts_as_dag_descendants", :force => true do |t|
+      t.string :category_type
+      t.references :ancestor
+      t.references :descendant
+      t.integer :distance
+    end
+
+    create_table "acts_as_dag_links", :force => true do |t|
+      t.string :category_type
+      t.references :parent
+      t.references :child
+    end
+  end
+end
+```
+
+### Usage
+
+```ruby
+class Person < ActiveRecord::Base
+  acts_as_dag
+end
+
+
+# Defining links in an attributes hash
+mom = Person.new(:name => 'Mom')
+grandpa = Person.create(:name => 'Grandpa', :children => [mom])
+grandpa.children #=> #<ActiveRecord::Associations::CollectionProxy [#<Person id: 1, name: "mom">]>
+
+# Linking existing records manually
+suzy = Person.create(:name => 'Suzy')
+mom.add_child(suzy)
+mom.children #=> #<ActiveRecord::Associations::CollectionProxy [#<Person id: 3, name: "suzy">]>
+```
+
+## Mutators
+
+```
+add_parent      Adds the given record(s) as a parent of the receiver. Accepts multiple arguments or an array.
+add_child       Adds the given record(s) as a child of the receiver. Accepts multiple arguments or an array.
+remove_parent   Removes the given record as a parent of the receiver. Accepts a single record.
+remove_child    Removes the given record as a child of the receiver. Accepts a single record.
+```
+
+
+## Accessors
+
+```
+parent           Returns the parent of the record, nil for a root node
+parent_id        Returns the id of the parent of the record, nil for a root node
+root?            Returns true if the record is a root node, false otherwise
+ancestor_ids     Returns a list of ancestor ids, starting with the root id and ending with the parent id
+ancestors        Scopes the model on ancestors of the record
+path_ids         Returns a list the path ids, starting with the root id and ending with the node's own id
+path             Scopes model on path records of the record
+children         Scopes the model on children of the record
+child_ids        Returns a list of child ids
+descendants      Scopes the model on direct and indirect children of the record
+descendant_ids   Returns a list of a descendant ids
+subtree          Scopes the model on descendants and itself
+subtree_ids      Returns a list of all ids in the record's subtree
+```
+
+## Scopes
+
+```
+roots                   Nodes without parents
+leafs                   Nodes without children
+ancestors_of(node)      Ancestors of node, node can be either a record or an id
+children_of(node)       Children of node, node can be either a record or an id
+descendants_of(node)    Descendants of node, node can be either a record or an id
+subtree_of(node)        Subtree of node, node can be either a record or an id
+```
+
+
+## Options
+
+The default behaviour is to store data for all classes in the same two links and descendants tables.
+The category_type column is used to filter out relationships for other classes. These options can be
+used to choose which classes and tables store the graph data.
+
+```
+:link_class             The name of the class to use for storing parent-child relationships. Defaults to "#{self.name}Link", e.g. PersonLink
+:link_table             The table the link class stores data in. Defaults to "acts_as_dag_links"
+:descendant_class       The name of the class to use for storing ancestor-descendant relationships. Defaults to "#{self.name}Descendant", e.g PersonDescendant
+:descendant_table       The table the descendant class stores data in. Defaults to "acts_as_dag_descendants"
+:link_conditions        Conditions to use when fetching link and descendant records. Defaults to {:category_type => self.name}, e.g. {:category_type => 'Person'}
+```
+
+## Future development
+
+### Mutators
+
+```
+remove_parent   Removes the given record(s) as a parent of the receiver. Accepts a multiple arguments or an array.
+remove_child    Removes the given record(s) as a child of the receiver. Accepts a multiple arguments or an array.
+```
+
+### Accessors
+
+```
+root             Returns the root of the tree the record is in, self for a root node
+root_id          Returns the id of the root of the tree the record is in
+has_children?    Returns true if the record has any children, false otherwise
+is_childless?    Returns true is the record has no children, false otherwise
+siblings         Scopes the model on siblings of the record, the record itself is included*
+sibling_ids      Returns a list of sibling ids
+has_siblings?    Returns true if the record's parent has more than one child
+is_only_child?   Returns true if the record is the only child of its parent
+depth            Return the depth of the node, root nodes are at depth 0
+```
+
+### Scopes
+
+```
+siblings_of(node)       Siblings of node, node can be either a record or an id
+```
+
+
+## Credits
+
+Thanks you to the developers of the Ancestry gem for inspiring the list of accessors and scopes

data/lib/acts_as_dag.rb

@@ -1,5 +1,6 @@
 # Load the acts_as_dag files
 require 'acts_as_dag/acts_as_dag'
+require 'acts_as_dag/deprecated'
 
 # Load the act method
-ActiveRecord::Base.send :extend, ActsAsDAG::ActMethod
+ActiveRecord::Base.send :extend, ActsAsDAG::ActMethod

data/lib/acts_as_dag/acts_as_dag.rb

@@ -16,14 +16,21 @@ module ActsAsDAG
       class_eval <<-EOV
         class ::#{options[:link_class]} < ActsAsDAG::AbstractLink
           self.table_name = '#{options[:link_table]}'
-          belongs_to :parent,     :class_name => '#{self.name}', :foreign_key => :parent_id
-          belongs_to :child,      :class_name => '#{self.name}', :foreign_key => :child_id
+          belongs_to :parent,     :class_name => '#{self.name}', :foreign_key => :parent_id, :inverse_of => :child_links
+          belongs_to :child,      :class_name => '#{self.name}', :foreign_key => :child_id, :inverse_of => :parent_links
+
+          after_save Proc.new {|link| HelperMethods.update_transitive_closure_for_new_link(link) }
+          after_destroy Proc.new {|link| HelperMethods.update_transitive_closure_for_destroyed_link(link) }
+
+          def node_class; #{self.name} end
         end
 
         class ::#{options[:descendant_class]} < ActsAsDAG::AbstractDescendant
           self.table_name = '#{options[:descendant_table]}'
           belongs_to :ancestor,   :class_name => '#{self.name}', :foreign_key => :ancestor_id
           belongs_to :descendant, :class_name => '#{self.name}', :foreign_key => :descendant_id
+
+          def node_class; #{self.name} end
         end
 
         def self.link_class
@@ -56,26 +63,41 @@ module ActsAsDAG
       #  \ /
       #   D
       #
-      has_many :ancestors,        :through => :ancestor_links, :source => :ancestor
-      has_many :descendants,      :through => :descendant_links, :source => :descendant
+      has_many :ancestors,        lambda { order("#{descendant_class.table_name}.distance DESC") }, :through => :ancestor_links, :source => :ancestor
+      has_many :descendants,      lambda { order("#{descendant_class.table_name}.distance ASC") }, :through => :descendant_links, :source => :descendant
+
+      has_many :path,             lambda { order("#{descendant_class.table_name}.distance DESC") }, :through => :path_links, :source => :ancestor
+      has_many :subtree,          lambda { order("#{descendant_class.table_name}.distance ASC") }, :through => :subtree_links, :source => :descendant
+
+      has_many :ancestor_links,   lambda { where(options[:link_conditions]).where("ancestor_id != descendant_id") }, :class_name => descendant_class, :foreign_key => 'descendant_id'
+      has_many :descendant_links, lambda { where(options[:link_conditions]).where("descendant_id != ancestor_id") }, :class_name => descendant_class, :foreign_key => 'ancestor_id'
 
-      has_many :ancestor_links,   lambda { where(options[:link_conditions]).order("distance DESC") }, :class_name => descendant_class, :foreign_key => 'descendant_id', :dependent => :delete_all
-      has_many :descendant_links, lambda { where(options[:link_conditions]).order("distance ASC") }, :class_name => descendant_class, :foreign_key => 'ancestor_id', :dependent => :delete_all
+      has_many :path_links,       lambda { where options[:link_conditions] }, :class_name => descendant_class, :foreign_key => 'descendant_id', :dependent => :delete_all
+      has_many :subtree_links,    lambda { where options[:link_conditions] }, :class_name => descendant_class, :foreign_key => 'ancestor_id', :dependent => :delete_all
 
       has_many :parents,          :through => :parent_links, :source => :parent
       has_many :children,         :through => :child_links, :source => :child
-      has_many :parent_links,     lambda { where options[:link_conditions] }, :class_name => link_class, :foreign_key => 'child_id', :dependent => :delete_all
-      has_many :child_links,      lambda { where options[:link_conditions] }, :class_name => link_class, :foreign_key => 'parent_id', :dependent => :delete_all
+
+      has_many :parent_links,     lambda { where options[:link_conditions] }, :class_name => link_class, :foreign_key => 'child_id', :dependent => :delete_all, :inverse_of => :child
+      has_many :child_links,      lambda { where options[:link_conditions] }, :class_name => link_class, :foreign_key => 'parent_id', :dependent => :delete_all, :inverse_of => :parent
 
       # NOTE: Use select to prevent ActiveRecord::ReadOnlyRecord if the returned records are modified
-      scope :roots,               lambda { select("#{table_name}.*").joins(:parent_links).where(link_class.table_name => {:parent_id => nil}) }
-      scope :children,            lambda { select("#{table_name}.*").joins(:parent_links).where.not(link_class.table_name => {:parent_id => nil}).uniq }
+      scope :roots,               lambda { joins(:parent_links).where(link_class.table_name => {:parent_id => nil}) }
+      scope :leafs,               lambda { joins("LEFT OUTER JOIN #{link_class.table_name} ON #{table_name}.id = parent_id").where(link_class.table_name => {:child_id => nil}).uniq }
+      scope :children,            lambda { joins(:parent_links).where.not(link_class.table_name => {:parent_id => nil}).uniq }
+      scope :parent_records,      lambda { joins(:child_links).where.not(link_class.table_name => {:child_id => nil}).uniq }
+
+      scope :ancestors_of,        lambda {|record| joins(:descendant_links).where("descendant_id = ?", record) }
+      scope :descendants_of,      lambda {|record| joins(:ancestor_links).where("ancestor_id = ?", record) }
+      scope :path_of,             lambda {|record| joins(:subtree_links).where("descendant_id = ?", record) }
+      scope :subtree_of,          lambda {|record| joins(:path_links).where("ancestor_id = ?", record) }
 
-      after_create :initialize_links
-      after_create :initialize_descendants
+      after_create :initialize_dag
 
       extend ActsAsDAG::ClassMethods
       include ActsAsDAG::InstanceMethods
+      extend ActsAsDAG::Deprecated::ClassMethods
+      include ActsAsDAG::Deprecated::InstanceMethods
     end
   end
 
@@ -84,57 +106,17 @@ module ActsAsDAG
       true
     end
 
-    # Reorganizes the entire class of records based on their name, first resetting the hierarchy, then reoganizing
-    # Can pass a list of categories and only those will be reorganized
-    def reorganize(categories_to_reorganize = self.all)
-      return if categories_to_reorganize.empty?
-
-      reset_hierarchy(categories_to_reorganize)
-
-      word_count_groups = categories_to_reorganize.group_by{|category| ActsAsDAG::HelperMethods.word_count(category)}.sort
-      roots_categories = word_count_groups.first[1].dup.sort_by(&:name)  # We will build up a list of plinko targets, we start with the group of categories with the shortest word count
-
-      # Now plinko the next shortest word group into those targets
-      # If we can't plinko one, then it gets added as a root
-      word_count_groups[1..-1].each do |word_count, categories|
-        categories_with_no_parents = []
-
-        # Try drop each category into each root
-        categories.sort_by(&:name).each do |category|
-          ActiveRecord::Base.benchmark "Analyze #{category.name}" do
-            suitable_parent = false
-            roots_categories.each do |root|
-              suitable_parent = true if ActsAsDAG::HelperMethods.plinko(root, category)
-            end
-            unless suitable_parent
-              ActiveRecord::Base.logger.info { "Plinko couldn't find a suitable parent for #{category.name}" }
-              categories_with_no_parents << category
-            end
-          end
-        end
-
-        # Add all categories from this group without suitable parents to the roots
-        if categories_with_no_parents.present?
-          ActiveRecord::Base.logger.info { "Adding #{categories_with_no_parents.collect(&:name).join(', ')} to roots" }
-          roots_categories.concat categories_with_no_parents
-        end
-      end
-    end
-
     # Remove all hierarchy information for this category
     # Can pass a list of categories to reset
     def reset_hierarchy(categories_to_reset = self.all)
       ids = categories_to_reset.collect(&:id)
 
-      ActiveRecord::Base.logger.info { "Clearing #{self.name} hierarchy links" }
       link_table_entries.where("parent_id IN (?) OR child_id IN (?)", ids, ids).delete_all
 
-      ActiveRecord::Base.logger.info { "Clearing #{self.name} hierarchy descendants" }
       descendant_table_entries.where("descendant_id IN (?) OR ancestor_id IN (?)", ids, ids).delete_all
 
       categories_to_reset.each do |category|
-        category.send :initialize_links
-        category.send :initialize_descendants
+        category.send :initialize_dag
       end
     end
   end
@@ -142,24 +124,48 @@ module ActsAsDAG
   module InstanceMethods
     # Returns true if this record is a root node
     def root?
-      self.class.roots.exists? self
+      parents.empty?
+    end
+
+    def leaf?
+      children.empty?
     end
 
     def make_root
       ancestor_links.delete_all
       parent_links.delete_all
-      send :initialize_links
-      send :initialize_descendants
+      initialize_dag
+    end
+
+    # NOTE: Parents that are removed will not trigger the destroy callback on their link, so we need to remove them manually
+    def parents=(parents)
+      (self.parents - parents).each do |parent_to_remove|
+        remove_parent(parent_to_remove)
+      end
+      super
     end
 
+    # NOTE: Children that are removed will not trigger the destroy callback on their link, so we need to remove them manually
+    def children=(children)
+      (self.children - children).each do |child_to_remove|
+        remove_child(child_to_remove)
+      end
+      super
+    end
+
+
     # Adds a category as a parent of this category (self)
-    def add_parent(parent)
-      ActsAsDAG::HelperMethods.link(parent, self)
+    def add_parent(*parents)
+      parents.flatten.each do |parent|
+        ActsAsDAG::HelperMethods.link(parent, self)
+      end
     end
 
     # Adds a category as a child of this category (self)
-    def add_child(child)
-      ActsAsDAG::HelperMethods.link(self, child)
+    def add_child(*children)
+      children.flatten.each do |child|
+        ActsAsDAG::HelperMethods.link(self, child)
+      end
     end
 
     # Removes a category as a child of this category (self)
@@ -176,14 +182,24 @@ module ActsAsDAG
       return parent
     end
 
+    # Returns true if the category's children include *self*
+    def child_of?(category, options = {})
+      category.children.exists?(id)
+    end
+
+    # Returns true if the category's parents include *self*
+    def parent_of?(category, options = {})
+      category.parents.exists?(id)
+    end
+
     # Returns true if the category's descendants include *self*
     def descendant_of?(category, options = {})
-      ancestors.exists?(category)
+      category.descendants.exists?(id)
     end
 
     # Returns true if the category's descendants include *self*
     def ancestor_of?(category, options = {})
-      descendants.exists?(category)
+      category.ancestors.exists?(id)
     end
 
     # Returns the class used for links
@@ -197,98 +213,29 @@ module ActsAsDAG
     end
 
     # Returns an array of ancestors and descendants
-    def relatives
-      (ancestors + descendants).uniq
+    def lineage
+      lineage_links = self.class.descendant_table_entries
+                                  .select("(CASE ancestor_id WHEN #{id} THEN descendant_id ELSE ancestor_id END) AS id, ancestor_id, descendant_id, distance")
+                                  .where('ancestor_id = :id OR descendant_id = :id', :id => id)
+                                  .where('ancestor_id != descendant_id')                        # Don't include self
+
+      self.class.joins("JOIN (#{lineage_links.to_sql}) lineage_links ON #{self.class.table_name}.id = lineage_links.id").order("CASE ancestor_id WHEN #{id} THEN distance ELSE -distance END") # Ensure the links are orders furthest ancestor to furthest descendant
     end
 
     private
 
     # CALLBACKS
-    def initialize_links
-      self.class.link_table_entries.create!(:parent_id => nil, :child_id => self.id) # Root link
-    end
 
-    def initialize_descendants
-      self.class.descendant_table_entries.create!(:ancestor_id => self.id, :descendant_id => self.id, :distance => 0) # Self Descendant
+    def initialize_dag
+      subtree_links.first_or_create!(:descendant_id => self.id, :distance => 0) # Self Descendant
+      parent_links.first_or_create!(:parent_id => nil) # Root link
     end
   end
 
   module HelperMethods
-    # Searches all descendants for the best parent for the other
-    # i.e. it lets you drop the category in at the top and it drops down the list until it finds its final resting place
-    def self.plinko(current, other)
-      # ActiveRecord::Base.logger.info { "Plinkoing '#{other.name}' into '#{current.name}'..." }
-      if should_descend_from?(current, other)
-        # Find the descendants of the current category that +other+ should descend from
-        descendants_other_should_descend_from = current.descendants.select{|descendant| should_descend_from?(descendant, other) }
-        # Of those, find the categories with the most number of matching words and make +other+ their child
-        # We find all suitable candidates to provide support for categories whose names are permutations of each other
-        # e.g. 'goat wool fibre' should be a child of 'goat wool' and 'wool goat' if both are present under 'goat'
-        new_parents_group = descendants_other_should_descend_from.group_by{|category| matching_word_count(other, category)}.sort.reverse.first
-        if new_parents_group.present?
-          for new_parent in new_parents_group[1]
-            ActiveRecord::Base.logger.info { "  '#{other.name}' landed under '#{new_parent.name}'" }
-            other.add_parent(new_parent)
-
-            # We've just affected the associations in ways we can not possibly imagine, so let's clear the association cache
-            current.clear_association_cache
-          end
-          return true
-        end
-      end
-    end
-
-    # Convenience method for plinkoing multiple categories
-    # Plinko's multiple categories from shortest to longest in order to prevent the need for reorganization
-    def self.plinko_multiple(current, others)
-      groups = others.group_by{|category| word_count(category)}.sort
-      groups.each do |word_count, categories|
-        categories.each do |category|
-          unless plinko(current, category)
-          end
-        end
-      end
-    end
-
-    # Returns the portion of this category's name that is not present in any of it's parents
-    def self.unique_name_portion(current)
-      unique_portion = current.name.split
-      for parent in current.parents
-        for word in parent.name.split
-          unique_portion.delete(word)
-        end
-      end
-
-      return unique_portion.empty? ? nil : unique_portion.join(' ')
-    end
-
-    # Checks if other should descend from +current+ based on name matching
-    # Returns true if other contains all the words from +current+, but has words that are not contained in +current+
-    def self.should_descend_from?(current, other)
-      return false if current == other
-
-      other_words = other.name.split
-      current_words = current.name.split
-
-      # (other contains all the words from current and more) && (current contains no words that are not also in other)
-      return (other_words - (current_words & other_words)).count > 0 && (current_words - other_words).count == 0
-    end
-
-    def self.word_count(current)
-      current.name.split.count
-    end
-
-    def self.matching_word_count(current, other)
-      other_words = other.name.split
-      self_words = current.name.split
-      return (other_words & self_words).count
-    end
-
     # creates a single link in the given link_class's link table between parent and
     # child object ids and creates the appropriate entries in the descendant table
     def self.link(parent, child)
-      #      ActiveRecord::Base.logger.info { "link(hierarchy_link_table = #{child.link_class}, hierarchy_descendant_table = #{child.descendant_class}, parent = #{parent.name}, child = #{child.name})" }
-
       # Sanity check
       raise "Parent has no ID" if parent.id.nil?
       raise "Child has no ID" if child.id.nil?
@@ -296,28 +243,34 @@ module ActsAsDAG
 
       klass = child.class
 
-      # Create a new parent-child link
       # Return if the link already exists because we can assume that the proper descendants already exist too
-      if klass.link_table_entries.where(:parent_id => parent.id, :child_id => child.id).exists?
-        ActiveRecord::Base.logger.info { "Skipping #{child.descendant_class} update because the link already exists" }
-        return
-      else
-        klass.link_table_entries.create!(:parent_id => parent.id, :child_id => child.id)
-      end
+      return if klass.link_table_entries.where(:parent_id => parent.id, :child_id => child.id).exists?
+
+      # Create a new parent-child link
+      klass.link_table_entries.create!(:parent_id => parent.id, :child_id => child.id)
 
       # If we have been passed a parent, find and destroy any existing links from nil (root) to the child as it can no longer be a top-level node
       unlink(nil, child) if parent
+    end
+
+    def self.update_transitive_closure_for_new_link(new_link)
+      klass = new_link.node_class
+
+      # If we're passing :parents or :children to a new record as part of #create, transitive closure on the nested records will
+      # be updated before the new record's after save calls :initialize_dag. We ensure it's been initalized before we start querying
+      # its descendant_table or it won't appear as an ancestor or descendant until too late.
+      new_link.parent.send(:initialize_dag) if new_link.parent && new_link.parent.id_changed?
+      new_link.child.send(:initialize_dag) if new_link.child && new_link.child.id_changed?
+
 
       # The parent and all its ancestors need to be added as ancestors of the child
       # The child and all its descendants need to be added as descendants of the parent
+      ancestor_ids_and_distance = klass.descendant_table_entries.where(:descendant_id => new_link.parent_id).pluck(:ancestor_id, :distance) # (totem => totem pole), (totem_pole => totem_pole)
+      descendant_ids_and_distance = klass.descendant_table_entries.where(:ancestor_id => new_link.child_id).pluck(:descendant_id, :distance) # (totem pole model => totem pole model)
 
-      # get parent ancestor id list
-      parent_ancestor_links = klass.descendant_table_entries.where(:descendant_id => parent.id) # (totem => totem pole), (totem_pole => totem_pole)
-      # get child descendant id list
-      child_descendant_links = klass.descendant_table_entries.where(:ancestor_id => child.id) # (totem pole model => totem pole model)
-      for parent_ancestor_link in parent_ancestor_links
-        for child_descendant_link in child_descendant_links
-          klass.descendant_table_entries.find_or_create_by!(:ancestor_id => parent_ancestor_link.ancestor_id, :descendant_id => child_descendant_link.descendant_id, :distance => parent_ancestor_link.distance + child_descendant_link.distance + 1)
+      ancestor_ids_and_distance.each do |ancestor_id, ancestor_distance|
+        descendant_ids_and_distance.each do |descendant_id, descendant_distance|
+          klass.descendant_table_entries.find_or_create_by!(:ancestor_id => ancestor_id, :descendant_id => descendant_id, :distance => ancestor_distance + descendant_distance + 1)
         end
       end
     end
@@ -325,20 +278,16 @@ module ActsAsDAG
     # breaks a single link in the given hierarchy_link_table between parent and
     # child object id. Updates the appropriate Descendants table entries
     def self.unlink(parent, child)
-      descendant_table_string = child.descendant_class.to_s
-      #      ActiveRecord::Base.logger.info { "unlink(hierarchy_link_table = #{child.link_class}, hierarchy_descendant_table = #{descendant_table_string}, parent = #{parent ? parent.name : 'nil'}, child = #{child.name})" }
-
       # Raise an exception if there is no child
       raise "Child cannot be nil when deleting a category_link" unless child
 
       klass = child.class
 
-      # delete the links
-      klass.link_table_entries.where(:parent_id => parent.try(:id), :child_id => child.id).delete_all
-
-      # If the parent was nil, we don't need to update descendants because there are no descendants of nil
-      return unless parent
+      # delete the link if it exists
+      klass.link_table_entries.where(:parent_id => parent.try(:id), :child_id => child.id).destroy_all
+    end
 
+    def self.update_transitive_closure_for_destroyed_link(destroyed_link)
       # We have unlinked C and D
       #                 A   F
       #                / \ /
@@ -348,42 +297,45 @@ module ActsAsDAG
       #                \ /
       #                 E
       #
-      # Now destroy all affected descendant_links (ancestors of parent (C), descendants of child (D))
-      klass.descendant_table_entries.where(:ancestor_id => parent.ancestor_ids, :descendant_id => child.descendant_ids).delete_all
+      klass = destroyed_link.node_class
+      parent = destroyed_link.parent
+      child = destroyed_link.child
+
+      # If the parent was nil, we don't need to update descendants because there are no descendants of nil
+      return unless parent
 
-      # Now iterate through all ancestors of the descendant_links that were deleted and pick only those that have no parents, namely (A, D)
+      # Now destroy all affected subtree_links (ancestors of parent (C), descendants of child (D))
+      klass.descendant_table_entries.where(:ancestor_id => parent.path_ids, :descendant_id => child.subtree_ids).delete_all
+
+      # Now iterate through all ancestors of the subtree_links that were deleted and pick only those that have no parents, namely (A, D)
       # These will be the starting points for the recreation of descendant links
-      starting_points = klass.find(parent.ancestor_ids + child.descendant_ids).select{|node| node.parents.empty? || node.parents == [nil] }
-      ActiveRecord::Base.logger.info {"starting points are #{starting_points.collect(&:name).to_sentence}" }
+      starting_points = klass.find(parent.path_ids + child.subtree_ids).select{|node| node.parents.empty? || node.parents == [nil] }
 
       # POSSIBLE OPTIMIZATION: The two starting points may share descendants. We only need to process each node once, so if we could skip dups, that would be good
-      starting_points.each{|node| rebuild_descendant_links(node)}
+      starting_points.each{|node| rebuild_subtree_links(node)}
     end
 
+
     # Create a descendant link to iteself, then iterate through all children
     # We add this node to the ancestor array we received
     # Then we create a descendant link between it and all nodes in the array we were passed (nodes traversed between it and all its ancestors affected by the unlinking).
     # Then iterate to all children of the current node passing the ancestor array along
-    def self.rebuild_descendant_links(current, ancestors = [])
-      indent = Array.new(ancestors.size, "  ").join
+    def self.rebuild_subtree_links(current, path = [])
+      indent = Array.new(path.size, "  ").join
       klass = current.class
 
-      ActiveRecord::Base.logger.info {"#{indent}Rebuilding descendant links of #{current.name}"}
       # Add current to the list of traversed nodes that we will pass to the children we decide to recurse to
-      ancestors << current
+      path << current
 
       # Create descendant links to each ancestor in the array (including itself)
-      ancestors.reverse.each_with_index do |ancestor, index|
-        ActiveRecord::Base.logger.info {"#{indent}#{ancestor.name} is an ancestor of #{current.name} with distance #{index}"}
-        klass.descendant_table_entries.find_or_create_by!(:ancestor_id => ancestor.id, :descendant_id => current.id, :distance => index)
+      path.reverse.each_with_index do |record, index|
+        klass.descendant_table_entries.find_or_create_by!(:ancestor_id => record.id, :descendant_id => current.id, :distance => index)
       end
 
       # Now check each child to see if it is a descendant, or if we need to recurse
       for child in current.children
-        ActiveRecord::Base.logger.info {"#{indent}Recursing to #{child.name}"}
-        rebuild_descendant_links(child, ancestors.dup)
+        rebuild_subtree_links(child, path.dup)
       end
-      ActiveRecord::Base.logger.info {"#{indent}Done recursing"}
     end
   end
 
@@ -391,11 +343,10 @@ module ActsAsDAG
   class AbstractLink < ActiveRecord::Base
     self.abstract_class = true
 
-    validates_presence_of :child_id
     validate :not_self_referential
 
     def not_self_referential
-      errors.add_to_base("Self referential links #{self.class} cannot be created.") if parent_id == child_id
+      errors.add(:base, "Self referential links #{self.class} cannot be created.") if parent_id == child_id
     end
   end