acts_as_dag 1.0.5 → 1.1.0

data/lib/acts_as_dag/acts_as_dag.rb

@@ -0,0 +1,388 @@
+# options[:link_conditions] used to apply constraint on the links and descendants tables. Default assumes links for all classes are in the same table, similarly for descendants. Can be cleared to allow setup of individual tables for each acts_as_dag class's links and descendants
+module ActsAsDAG
+  module ActMethod
+    def acts_as_dag(options = {})
+      class_attribute :acts_as_dag_options
+      options.assert_valid_keys :link_class, :descendant_class, :link_table, :descendant_table, :link_conditions
+      options.reverse_merge!(
+        :link_class => "#{self.name}Link",
+        :link_table => "acts_as_dag_links",
+        :descendant_class => "#{self.name}Descendant",
+        :descendant_table => "acts_as_dag_descendants",
+        :link_conditions => {:category_type => self.name})
+      self.acts_as_dag_options = options
+
+      # Create Link and Descendant Classes
+      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'
+        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"
+        end
+
+        def self.link_class
+          ::#{options[:link_class]}
+        end
+
+        def self.descendant_class
+          ::#{options[:descendant_class]}
+        end
+      EOV
+
+      # Returns a relation scoping to only link table entries that match the link conditions
+      def self.link_table_entries
+        link_class.where(acts_as_dag_options[:link_conditions])
+      end
+
+      # Returns a relation scoping to only descendant table entries table entries that match the link conditions
+      def self.descendant_table_entries
+        descendant_class.where(acts_as_dag_options[:link_conditions])
+      end
+
+
+      # Ancestors and descendants returned *include* self, e.g. A's descendants are [A,B,C,D]
+      # Ancestors must always be returned in order of most distant to least
+      # Descendants must always be returned in order of least distant to most
+      # NOTE: multiple instances of the same descendant/ancestor may be returned if there are multiple paths from ancestor to descendant
+      #   A
+      #  / \
+      # B   C
+      #  \ /
+      #   D
+      #
+      has_many :ancestor_links, :class_name => descendant_class, :foreign_key => 'descendant_id', :conditions => options[:link_conditions], :dependent => :delete_all
+      has_many :descendant_links, :class_name => descendant_class, :foreign_key => 'ancestor_id', :conditions => options[:link_conditions], :dependent => :delete_all
+      has_many :ancestors, :through => :ancestor_links, :source => :ancestor, :order => "distance DESC"
+      has_many :descendants, :through => :descendant_links, :source => :descendant, :order => "distance ASC"
+
+      has_many :parent_links, :class_name => link_class, :foreign_key => 'child_id', :conditions => options[:link_conditions], :dependent => :delete_all
+      has_many :child_links, :class_name => link_class, :foreign_key => 'parent_id', :conditions => options[:link_conditions], :dependent => :delete_all
+      has_many :parents, :through => :parent_links, :source => :parent
+      has_many :children, :through => :child_links, :source => :child
+
+      after_create :initialize_links
+      after_create :initialize_descendants
+
+      scope :roots, joins(:parent_links).where(link_class.table_name => {:parent_id => nil})
+
+      extend ActsAsDAG::ClassMethods
+      include ActsAsDAG::InstanceMethods      
+    end
+  end
+
+  module ClassMethods
+    def acts_like_dag?
+      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)
+      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|
+          suitable_parent = false
+          roots_categories.each do |root|
+            suitable_parent = true if ActsAsDAG::HelperMethods.plinko(root, category)
+          end
+          unless suitable_parent
+            logger.info "Plinko couldn't find a suitable parent for #{category.name} in #{categories.collect(&:name).join(', ')}"
+            categories_with_no_parents << category       
+          end
+        end
+
+        # Add all categories from this group without suitable parents to the roots
+        if categories_with_no_parents.present?
+          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)
+
+      logger.info "Clearing #{self.name} hierarchy links"
+      link_table_entries.where("parent_id IN (?) OR child_id IN (?)", ids, ids).delete_all
+
+      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
+      end
+    end    
+  end
+
+  module InstanceMethods
+    # Returns true if this record is a root node
+    def root?
+      self.class.roots.exists? self
+    end
+
+    # Adds a category as a parent of this category (self)
+    def add_parent(parent)
+      ActsAsDAG::HelperMethods.link(parent, self)
+    end
+
+    # Adds a category as a child of this category (self)
+    def add_child(child)
+      ActsAsDAG::HelperMethods.link(self, child)
+    end
+
+    # Removes a category as a child of this category (self)
+    # Returns the child
+    def remove_child(child)
+      ActsAsDAG::HelperMethods.unlink(self, child)
+      return child
+    end
+
+    # Removes a category as a parent of this category (self)
+    # Returns the parent
+    def remove_parent(parent)
+      ActsAsDAG::HelperMethods.unlink(parent, self)
+      return parent
+    end
+
+    # Returns true if the category's descendants include *self*
+    def descendant_of?(category, options = {})
+      ancestors.exists?(category)
+    end
+
+    # Returns true if the category's descendants include *self*
+    def ancestor_of?(category, options = {})
+      descendants.exists?(category)
+    end
+
+    # Returns the class used for links
+    def link_class
+      self.class.link_class
+    end
+
+    # Returns the class used for descendants
+    def descendant_class
+      self.class.descendant_class
+    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
+    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)
+      current.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]
+            current.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)
+      #      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?
+      raise "Parent and child must be the same class" if parent.class != child.class
+
+      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?
+        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
+
+      # 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
+
+      # 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
+
+      # 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.where(:ancestor_id => parent_ancestor_link.ancestor_id, :descendant_id => child_descendant_link.descendant_id, :distance => parent_ancestor_link.distance + child_descendant_link.distance + 1).first_or_create!
+        end
+      end
+    end
+
+    # 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
+      #      parent.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 ? parent.id : nil), :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
+
+      # We have unlinked C and D
+      #                 A   F
+      #                / \ /
+      #               B   C
+      #               |   
+      #               |   D
+      #                \ /
+      #                 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
+
+      # Now iterate through all ancestors of the descendant_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] }
+      parent.logger.info {"starting points are #{starting_points.collect(&:name).to_sentence}" }
+
+      # 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)}
+    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
+      klass = current.class
+
+      current.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
+
+      # Create descendant links to each ancestor in the array (including itself)
+      ancestors.reverse.each_with_index do |ancestor, index|
+        current.logger.info {"#{indent}#{ancestor.name} is an ancestor of #{current.name} with distance #{index}"}
+        klass.descendant_table_entries.where(:ancestor_id => ancestor.id, :descendant_id => current.id, :distance => index).first_or_create!
+      end
+
+      # Now check each child to see if it is a descendant, or if we need to recurse
+      for child in current.children
+        current.logger.info {"#{indent}Recursing to #{child.name}"}
+        rebuild_descendant_links(child, ancestors.dup)
+      end
+      current.logger.info {"#{indent}Done recursing"}
+    end
+  end
+
+  # CLASSES (for providing hooks)
+  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
+    end
+  end
+
+  class AbstractDescendant < ActiveRecord::Base
+    self.abstract_class = true
+
+    validates_presence_of :ancestor_id, :descendant_id
+  end
+end

data/lib/acts_as_dag.rb

@@ -1,388 +1,5 @@
-module ActsAsDAG
-  def self.included(base)
-    def base.acts_as_dag(options = {})
-      link_class = "#{self.name}Link"
-      descendant_class = "#{self.name}Descendant"
+# Load the acts_as_dag files
+require 'acts_as_dag/acts_as_dag'
 
-      class_eval <<-EOV
-      class ::#{link_class} < ActiveRecord::Base
-        include ActsAsDAG::LinkClassInstanceMethods
-
-        validate :not_circular_link
-
-        belongs_to :parent, :class_name => '#{self.name}', :foreign_key => 'parent_id'
-        belongs_to :child, :class_name => '#{self.name}', :foreign_key => 'child_id'
-      end
-
-      class ::#{descendant_class} < ActiveRecord::Base
-        belongs_to :ancestor, :class_name => '#{self.name}', :foreign_key => "ancestor_id"
-        belongs_to :descendant, :class_name => '#{self.name}', :foreign_key => "descendant_id"
-      end
-
-      def acts_as_dag_class
-        ::#{self.name}
-      end
-
-      def self.link_type
-        ::#{link_class}
-      end
-
-      def self.descendant_type
-        ::#{descendant_class}
-      end
-      EOV
-
-      has_many :parent_links, :class_name => link_class, :foreign_key => 'child_id', :dependent => :destroy
-      has_many :parents, :through => :parent_links, :source => :parent
-      has_many :child_links, :class_name => link_class, :foreign_key => 'parent_id', :dependent => :destroy
-      has_many :children, :through => :child_links, :source => :child
-
-      # Ancestors must always be returned in order of most distant to least
-      # Descendants must always be returned in order of least distant to most
-      # NOTE: multiple instances of the same descendant/ancestor may be returned if there are multiple paths from ancestor to descendant
-      #   A
-      #  / \
-      # B   C
-      #  \ /
-      #   D
-      #
-      has_many :ancestor_links, :class_name => descendant_class, :foreign_key => 'descendant_id', :dependent => :destroy
-      has_many :ancestors, :through => :ancestor_links, :source => :ancestor, :order => "distance DESC"
-      has_many :descendant_links, :class_name => descendant_class, :foreign_key => 'ancestor_id', :dependent => :destroy
-      has_many :descendants, :through => :descendant_links, :source => :descendant, :order => "distance ASC"      
-
-      after_create :initialize_links
-      after_create :initialize_descendants
-      
-      scope :roots, joins(:parent_links).where(link_type.table_name => {:parent_id => nil})
-      
-      extend ActsAsDAG::ClassMethods
-      include ActsAsDAG::InstanceMethods        
-    end
-  end
-
-  module ClassMethods
-    def acts_like_dag?; 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)
-      reset_hierarchy(categories_to_reorganize)
-
-      word_count_groups = categories_to_reorganize.group_by(&:word_count).sort
-      roots = 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|
-          suitable_parent = false
-          roots.each do |root|
-            suitable_parent = true if root.plinko(category)
-          end
-          unless suitable_parent
-            logger.info "Plinko couldn't find a suitable parent for #{category.name}"
-            categories_with_no_parents << category       
-          end
-        end
-
-        # Add all categories from this group without suitable parents to the roots
-        if categories_with_no_parents.present?
-          logger.info "Adding #{categories_with_no_parents.collect(&:name).join(', ')} to roots"
-          roots.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)
-      logger.info "Clearing #{self.name} hierarchy links"
-      link_type.delete_all(:parent_id => ids)
-      link_type.delete_all(:child_id => ids)
-      categories_to_reset.each(&:initialize_links)
-
-      logger.info "Clearing #{self.name} hierarchy descendants"
-      descendant_type.delete_all(:descendant_id => ids)
-      descendant_type.delete_all(:ancestor_id => ids)
-      categories_to_reset.each(&:initialize_descendants)
-    end
-  end
-
-  module InstanceMethods
-    # Returns true if this record is a root node
-    def root?
-      self.class.roots.exists? self
-    end
-
-    # 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 plinko(other)
-      if other.should_descend_from?(self)
-        logger.info "Plinkoing '#{other.name}' into '#{self.name}'..."
-
-        # Find the descendants of this category that +other+ should descend from 
-        descendants_other_should_descend_from = self.descendants.select{|descendant| other.should_descend_from?(descendant)}
-
-        # 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| other.matching_word_count(category)}.sort.reverse.first
-        if new_parents_group.present?
-          for new_parent in new_parents_group[1]
-            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
-            self.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 plinko_multiple(others)
-      groups = others.group_by(&:word_count).sort
-      groups.each do |word_count, categories|
-        categories.each do |category|
-          unless plinko(category)
-          end
-        end
-      end    
-    end
-
-    # Adds a category as a parent of this category (self)
-    def add_parent(parent)
-      link(parent, self)
-    end
-
-    # Adds a category as a child of this category (self)
-    def add_child(child)
-      link(self, child)
-    end
-
-    # Removes a category as a child of this category (self)
-    # Returns the child
-    def remove_child(child)
-      unlink(self, child)
-      return child
-    end
-
-    # Removes a category as a parent of this category (self)
-    # Returns the parent
-    def remove_parent(parent)
-      unlink(parent, self)
-      return parent
-    end
-
-    # Returns the portion of this category's name that is not present in any of it's parents
-    def unique_name_portion
-      unique_portion = name.split
-      for parent in parents
-        for word in parent.name.split
-          unique_portion.delete(word)
-        end
-      end
-
-      return unique_portion.empty? ? nil : unique_portion.join(' ')
-    end
-
-    # Returns true if the category's descendants include *self*
-    def descendant_of?(category, options = {})
-      ancestors.exists?(category)
-    end
-
-    # Returns true if the category's descendants include *self*
-    def ancestor_of?(category, options = {})
-      descendants.exists?(category)
-    end
-
-    # Checks if self should descend from +other+ based on name matching
-    # Returns true if self contains all the words from +other+, but has words that are not contained in +other+
-    def should_descend_from?(other)
-      return false if self == other
-
-      other_words = other.name.split
-      self_words = self.name.split
-
-      # (self contains all the words from other and more) && (other contains no words that are not also in self)
-      return (self_words - (other_words & self_words)).count > 0 && (other_words - self_words).count == 0
-    end
-
-    def word_count
-      self.name.split.count
-    end
-
-    def matching_word_count(other)
-      other_words = other.name.split
-      self_words = self.name.split
-      return (other_words & self_words).count
-    end
-
-    def link_type
-      self.class.link_type
-    end
-
-    def descendant_type
-      self.class.descendant_type
-    end
-
-    # CALLBACKS
-    def initialize_links
-      link_type.new(:parent_id => nil, :child_id => id).save!
-    end
-
-    def initialize_descendants
-      descendant_type.new(:ancestor_id => id, :descendant_id => id, :distance => 0).save!
-    end
-    # END CALLBACKS
-
-    private
-
-    # LINKING FUNCTIONS
-
-    # creates a single link in the given link_type's link table between parent and
-    # child object ids and creates the appropriate entries in the descendant table
-    def link(parent, child)
-      #      logger.info "link(hierarchy_link_table = #{link_type}, hierarchy_descendant_table = #{descendant_type}, parent = #{parent.name}, child = #{child.name})"
-
-      # Check if parent and child have id's
-      raise "Parent has no ID" if parent.id.nil?
-      raise "Child has no ID" if child.id.nil?
-
-      # Create a new parent-child link
-      # Return if the link already exists because we can assume that the proper descendants already exist too
-      if link_type.where(:parent_id => parent.id, :child_id => child.id).exists?
-        logger.info "Skipping #{descendant_type} update because the link already exists"
-        return
-      else
-        link_type.create!(:parent_id => parent.id, :child_id => child.id)
-      end
-
-      # 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
-
-      # 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
-
-      # get parent ancestor id list
-      parent_ancestor_links = descendant_type.where(:descendant_id => parent.id) # (totem => totem pole), (totem_pole => totem_pole)
-      # get child descendant id list
-      child_descendant_links = descendant_type.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
-          descendant_type.find_or_initialize_by_ancestor_id_and_descendant_id_and_distance(parent_ancestor_link.ancestor_id, child_descendant_link.descendant_id, parent_ancestor_link.distance + child_descendant_link.distance + 1).save!
-        end
-      end
-    end
-
-    # breaks a single link in the given hierarchy_link_table between parent and
-    # child object id. Updates the appropriate Descendants table entries
-    def unlink(parent, child)
-      descendant_table_string = descendant_type.to_s
-      #      logger.info "unlink(hierarchy_link_table = #{link_type}, 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
-
-      # delete the links
-      link_type.delete_all(:parent_id => (parent ? parent.id : nil), :child_id => child.id)
-
-      # If the parent was nil, we don't need to update descendants because there are no descendants of nil
-      return unless parent
-
-      # We have unlinked C and D
-      #                 A   F
-      #                / \ /
-      #               B   C
-      #               |   
-      #               |   D
-      #                \ /
-      #                 E
-      #
-      # Now destroy all affected descendant_links (ancestors of parent (C), descendants of child (D))
-      descendant_type.delete_all(:ancestor_id => parent.ancestor_ids, :descendant_id => child.descendant_ids)
-
-      # Now iterate through all ancestors of the descendant_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 = self.class.find(parent.ancestor_ids + child.descendant_ids).select{|node| node.parents.empty? || node.parents == [nil] }
-      logger.info {"starting points are #{starting_points.collect(&:name).to_sentence}" }
-
-      # 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| node.send(:rebuild_descendant_links)}
-    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 rebuild_descendant_links(ancestors = [])
-      indent = ""
-      ancestors.size.times do |index|
-        indent << "  "
-      end
-
-      logger.info {"#{indent}Rebuilding descendant links of #{self.name}"}
-      # Add self to the list of traversed nodes that we will pass to the children we decide to recurse to
-      ancestors << self
-
-      # Create descendant links to each ancestor in the array (including itself)
-      ancestors.reverse.each_with_index do |ancestor, index|
-        logger.info {"#{indent}#{ancestor.name} is an ancestor of #{self.name} with distance #{index}"}
-        descendant_type.find_or_initialize_by_ancestor_id_and_descendant_id_and_distance(:ancestor_id => ancestor.id, :descendant_id => self.id, :distance => index).save!
-      end
-
-      # Now check each child to see if it is a descendant, or if we need to recurse
-      for child in children
-        logger.info {"#{indent}Recursing to #{child.name}"}
-        child.send(:rebuild_descendant_links, ancestors.dup)
-      end
-      logger.info {"#{indent}Done recursing"}
-    end
-
-    # END LINKING FUNCTIONS
-
-    # GARBAGE COLLECTION
-    # Remove all entries from this object's table that are not associated in some way with an item
-    def self.garbage_collect
-      table_prefix = self.class.name.tableize
-      root_locations = self.class.includes("#{table_prefix}_parents").where("#{table_prefix}_links.parent_id IS NULL")
-      for root_location in root_locations
-        root_location.garbage_collect
-      end
-    end
-
-    def garbage_collect
-      # call garbage collect on all children,
-      # Return false if any of those are unsuccessful, thus cancelling the recursion chain
-      for child in children
-        return false unless child.garbage_collect
-      end
-
-      if events.blank?
-        destroy
-        logger.info "Deleted RRN #{self.class} ##{id} (#{name}) during garbage collection"
-        return true
-      else
-        return false
-      end
-    end
-    # END GARBAGE COLLECTION
-  end
-
-  module LinkClassInstanceMethods
-    def not_circular_link
-      errors.add_to_base("Circular #{self.class} cannot be created.") if parent_id == child_id
-    end
-  end
-end
-
-if Object.const_defined?("ActiveRecord")
-  ActiveRecord::Base.send(:include, ActsAsDAG)
-end
+# Load the act method
+ActiveRecord::Base.send :extend, ActsAsDAG::ActMethod

data/spec/acts_as_dag_spec.rb

@@ -1,225 +1,264 @@
 require 'spec_helper'
 
 describe 'acts_as_dag' do
-  before(:each) do
-    MyModel.destroy_all # Because we're using sqlite3 and it doesn't support transactional specs (afaik)
-  end
-  
-  describe "Basics" do
+  shared_examples_for "DAG Model" do
     before(:each) do
-      @grandpa = MyModel.create(:name => 'grandpa')
-      @dad = MyModel.create(:name => 'dad')
-      @mom = MyModel.create(:name => 'mom')
-      @child = MyModel.create(:name => 'child')
+      @klass.destroy_all # Because we're using sqlite3 and it doesn't support transactional specs (afaik)
     end
+    
+    describe "and" do
+      before(:each) do
+        @grandpa = @klass.create(:name => 'grandpa')
+        @dad = @klass.create(:name => 'dad')
+        @mom = @klass.create(:name => 'mom')
+        @child = @klass.create(:name => 'child')
+      end
 
-    it "should be a root node immediately after saving" do
-      @grandpa.parents.should be_empty
-    end
+      it "should be a root node immediately after saving" do
+        @grandpa.parents.should be_empty
+        @grandpa.root?.should be_true
+      end
 
-    it "should be descendant of itself immediately after saving" do
-      @grandpa.descendants.should == [@grandpa]
-    end
+      it "should be descendant of itself immediately after saving" do
+        @grandpa.descendants.should == [@grandpa]
+      end
 
-    it "should be ancestor of itself immediately after saving" do
-      @grandpa.ancestors.should == [@grandpa]
-    end
+      it "should be ancestor of itself immediately after saving" do
+        @grandpa.ancestors.should == [@grandpa]
+      end
 
-    it "should be able to add a child" do
-      @grandpa.add_child(@dad)
+      it "should be able to add a child" do
+        @grandpa.add_child(@dad)
 
-      @grandpa.children.should == [@dad]
-    end
+        @grandpa.children.should == [@dad]
+      end
 
-    it "should be able to add a parent" do
-      @child.add_parent(@dad)
+      it "should be able to add a parent" do
+        @child.add_parent(@dad)
 
-      @child.parents.should == [@dad]
-    end
+        @child.parents.should == [@dad]
+      end
 
-    it "should be able to add multiple parents" do
-      @child.add_parent(@dad)
-      @child.add_parent(@mom)
+      it "should be able to add multiple parents" do
+        @child.add_parent(@dad)
+        @child.add_parent(@mom)
 
-      @child.parents.sort_by(&:id).should == [@dad, @mom].sort_by(&:id)
-    end
+        @child.parents.sort_by(&:id).should == [@dad, @mom].sort_by(&:id)
+      end
 
-    it "should be able to add multiple children" do
-      @grandpa.add_child(@dad)
-      @grandpa.add_child(@mom)
+      it "should be able to add multiple children" do
+        @grandpa.add_child(@dad)
+        @grandpa.add_child(@mom)
 
-      @grandpa.children.sort_by(&:id).should == [@dad, @mom].sort_by(&:id)
-    end
+        @grandpa.children.sort_by(&:id).should == [@dad, @mom].sort_by(&:id)
+      end
 
-    it "should be able to add ancestors (top down)" do
-      @grandpa.add_child(@dad)
-      @dad.add_child(@child)
+      it "should be able to add ancestors (top down)" do
+        @grandpa.add_child(@dad)
+        @dad.add_child(@child)
 
-      @grandpa.children.should == [@dad]
-      @grandpa.descendants.sort_by(&:id).should == [@grandpa, @dad, @child].sort_by(&:id)
-      @dad.descendants.should == [@dad, @child]
-      @dad.children.should == [@child]
-    end
+        @grandpa.children.should == [@dad]
+        @grandpa.descendants.sort_by(&:id).should == [@grandpa, @dad, @child].sort_by(&:id)
+        @dad.descendants.should == [@dad, @child]
+        @dad.children.should == [@child]
+      end
 
-    it "should be able to add ancestors (bottom up)" do
-      @dad.add_child(@child)
-      @grandpa.add_child(@dad)
+      it "should be able to add ancestors (bottom up)" do
+        @dad.add_child(@child)
+        @grandpa.add_child(@dad)
 
-      @grandpa.children.should == [@dad]
-      @grandpa.descendants.sort_by(&:id).should == [@grandpa, @dad, @child].sort_by(&:id)
-      @dad.descendants.should == [@dad,@child]
-      @dad.children.should == [@child]
+        @grandpa.children.should == [@dad]
+        @grandpa.descendants.sort_by(&:id).should == [@grandpa, @dad, @child].sort_by(&:id)
+        @dad.descendants.should == [@dad,@child]
+        @dad.children.should == [@child]
+      end
+      
+      it "should be able to test descent" do
+        @dad.add_child(@child)
+        @grandpa.add_child(@dad)
+
+        @grandpa.ancestor_of?(@child).should be_true
+        @child.descendant_of?(@grandpa).should be_true
+        @child.ancestor_of?(@grandpa).should be_false
+        @grandpa.descendant_of?(@child).should be_false
+      end    
     end
-    
-    it "should be able to test descent" do
-      @dad.add_child(@child)
-      @grandpa.add_child(@dad)
-
-      @grandpa.ancestor_of?(@child).should be_true
-      @child.descendant_of?(@grandpa).should be_true
-      @child.ancestor_of?(@grandpa).should be_false
-      @grandpa.descendant_of?(@child).should be_false
-    end    
-  end
 
-  describe "reorganization" do
-    before(:each) do
-      @totem = MyModel.create(:name => "totem")
-      @totem_pole = MyModel.create(:name => "totem pole")
-      @big_totem_pole = MyModel.create(:name => "big totem pole")
-      @big_model_totem_pole = MyModel.create(:name => "big model totem pole")
-      @big_red_model_totem_pole = MyModel.create(:name => "big red model totem pole")      
-    end
+    describe "reorganization" do
+      before(:each) do
+        @totem = @klass.create(:name => "totem")
+        @totem_pole = @klass.create(:name => "totem pole")
+        @big_totem_pole = @klass.create(:name => "big totem pole")
+        @big_model_totem_pole = @klass.create(:name => "big model totem pole")
+        @big_red_model_totem_pole = @klass.create(:name => "big red model totem pole")      
+      end
 
-    it "should be able to determine whether one category is an ancestor of the other by inspecting the name" do 
-      @totem_pole.should_descend_from?(@big_totem_pole).should be_false
-      @big_totem_pole.should_descend_from?(@totem_pole).should be_true
-    end
+      it "should reinitialize links and descendants after resetting the hierarchy" do
+        @klass.reset_hierarchy
+        @big_totem_pole.parents.should == []
+        @big_totem_pole.children.should == []
+        @big_totem_pole.ancestors.should == [@big_totem_pole]
+        @big_totem_pole.descendants.should == [@big_totem_pole]
+      end
 
-    it "should arrange the categories correctly when not passed any arguments" do
-      MyModel.reorganize
-      
-      @totem.children.should == [@totem_pole]
-      @totem_pole.children.should == [@big_totem_pole]
-      @big_totem_pole.children.should == [@big_model_totem_pole]
-      @big_model_totem_pole.children.should == [@big_red_model_totem_pole]
-    end
+      it "should be able to determine whether one category is an ancestor of the other by inspecting the name" do 
+        ActsAsDAG::HelperMethods.should_descend_from?(@totem_pole, @big_totem_pole).should be_true
+        ActsAsDAG::HelperMethods.should_descend_from?(@big_totem_pole, @totem_pole).should be_false
+      end
 
-    it "should arrange the categories correctly when passed a set of nodes to reorganize" do
-      MyModel.reorganize [@totem, @totem_pole, @big_totem_pole, @big_model_totem_pole, @big_red_model_totem_pole]
-      
-      @totem.reload.children.should == [@totem_pole]
-      @totem_pole.reload.children.should == [@big_totem_pole]
-      @big_totem_pole.reload.children.should == [@big_model_totem_pole]
-      @big_model_totem_pole.reload.children.should == [@big_red_model_totem_pole]
-    end
+      it "should be able to determine the number of matching words in two categories names" do 
+        ActsAsDAG::HelperMethods.matching_word_count(@totem_pole, @big_totem_pole).should == 2
+      end
 
-    it "should arrange the categories correctly when inserting a category into an existing chain" do
-      @totem.add_child(@big_totem_pole)
+      it "should arrange the categories correctly when not passed any arguments" do
+        @klass.reorganize
+        
+        @totem.children.should == [@totem_pole]
+        @totem_pole.children.should == [@big_totem_pole]
+        @big_totem_pole.children.should == [@big_model_totem_pole]
+        @big_model_totem_pole.children.should == [@big_red_model_totem_pole]
+      end
 
-      MyModel.reorganize
+      it "should arrange the categories correctly when passed a set of nodes to reorganize" do
+        @klass.reorganize [@totem, @totem_pole, @big_totem_pole, @big_model_totem_pole, @big_red_model_totem_pole]
+        
+        @totem.reload.children.should == [@totem_pole]
+        @totem_pole.reload.children.should == [@big_totem_pole]
+        @big_totem_pole.reload.children.should == [@big_model_totem_pole]
+        @big_model_totem_pole.reload.children.should == [@big_red_model_totem_pole]
+      end
 
-      @totem.children.should == [@totem_pole]
-      @totem_pole.children.should == [@big_totem_pole]
-      @big_totem_pole.children.should == [@big_model_totem_pole]
-      @big_model_totem_pole.reload.children.should == [@big_red_model_totem_pole]
-    end
-  
-    it "should still work when there are categories that are permutations of each other" do
-      @big_totem_pole_model = MyModel.create(:name => "big totem pole model")
+      it "should arrange the categories correctly when inserting a category into an existing chain" do
+        @totem.add_child(@big_totem_pole)
 
-      MyModel.reorganize [@totem, @totem_pole, @big_totem_pole, @big_model_totem_pole, @big_red_model_totem_pole, @big_totem_pole_model]
+        @klass.reorganize
 
-      @totem.children.should == [@totem_pole]
-      @totem_pole.children.should == [@big_totem_pole]
-      (@big_totem_pole.children - [@big_model_totem_pole, @big_totem_pole_model]).should == []
-      @big_model_totem_pole.reload.children.should == [@big_red_model_totem_pole]
-      @big_totem_pole_model.reload.children.should == [@big_red_model_totem_pole]
-    end  
+        @totem.children.should == [@totem_pole]
+        @totem_pole.children.should == [@big_totem_pole]
+        @big_totem_pole.children.should == [@big_model_totem_pole]
+        @big_model_totem_pole.reload.children.should == [@big_red_model_totem_pole]
+      end
+    
+      it "should still work when there are categories that are permutations of each other" do
+        @big_totem_pole_model = @klass.create(:name => "big totem pole model")
 
-    describe "when there is a single long inheritance chain" do
-      before(:each) do
-        @totem.add_child(@totem_pole)
-        @totem_pole.add_child(@big_totem_pole)
-        @big_totem_pole.add_child(@big_model_totem_pole)
-        @big_model_totem_pole.add_child(@big_red_model_totem_pole)
-      end
-
-      describe "and we are reorganizing the middle of the chain" do
-        # Totem
-        #   |
-        # Totem Pole
-        #  *|*       \
-        #  *|*      Big Totem Pole
-        #  *|*       /
-        # Big Model Totem Pole
-        #   |
-        # Big Red Model Totem Pole
-        #
+        @klass.reorganize [@totem, @totem_pole, @big_totem_pole, @big_model_totem_pole, @big_red_model_totem_pole, @big_totem_pole_model]
+
+        @totem.children.should == [@totem_pole]
+        @totem_pole.children.should == [@big_totem_pole]
+        (@big_totem_pole.children - [@big_model_totem_pole, @big_totem_pole_model]).should == []
+        @big_model_totem_pole.reload.children.should == [@big_red_model_totem_pole]
+        @big_totem_pole_model.reload.children.should == [@big_red_model_totem_pole]
+      end  
+
+      describe "when there is a single long inheritance chain" do
         before(:each) do
-          @totem_pole.add_child(@big_model_totem_pole)
+          @totem.add_child(@totem_pole)
+          @totem_pole.add_child(@big_totem_pole)
+          @big_totem_pole.add_child(@big_model_totem_pole)
+          @big_model_totem_pole.add_child(@big_red_model_totem_pole)
         end
 
-        it "should return multiple instances of descendants before breaking the old link" do
-          @totem.descendants.sort_by(&:id).should == [@totem, @totem_pole, @big_totem_pole, @big_model_totem_pole, @big_model_totem_pole, @big_red_model_totem_pole, @big_red_model_totem_pole].sort_by(&:id)        
+        describe "and we are reorganizing the middle of the chain" do
+          # Totem
+          #   |
+          # Totem Pole
+          #  *|*       \
+          #  *|*      Big Totem Pole
+          #  *|*       /
+          # Big Model Totem Pole
+          #   |
+          # Big Red Model Totem Pole
+          #
+          before(:each) do
+            @totem_pole.add_child(@big_model_totem_pole)
+          end
+
+          it "should return multiple instances of descendants before breaking the old link" do
+            @totem.descendants.sort_by(&:id).should == [@totem, @totem_pole, @big_totem_pole, @big_model_totem_pole, @big_model_totem_pole, @big_red_model_totem_pole, @big_red_model_totem_pole].sort_by(&:id)        
+          end
+
+          it "should return the correct inheritance chain after breaking the old link" do
+            @totem_pole.remove_child(@big_model_totem_pole)
+
+            @totem_pole.children.sort_by(&:id).should == [@big_totem_pole].sort_by(&:id)        
+            @totem.descendants.sort_by(&:id).should == [@totem, @totem_pole, @big_totem_pole, @big_model_totem_pole, @big_red_model_totem_pole].sort_by(&:id)        
+          end
+
+          it "should return the correct inheritance chain after breaking the old link when there is are two ancestor root nodes" do
+            pole = @klass.create(:name => "pole")
+            @totem_pole.add_parent(pole)
+            @totem_pole.remove_child(@big_model_totem_pole)
+
+            pole.descendants.sort_by(&:id).should == [pole, @totem_pole, @big_totem_pole, @big_model_totem_pole, @big_red_model_totem_pole].sort_by(&:id)
+            @totem_pole.children.sort_by(&:id).should == [@big_totem_pole].sort_by(&:id)
+            @totem.descendants.sort_by(&:id).should == [@totem, @totem_pole, @big_totem_pole, @big_model_totem_pole, @big_red_model_totem_pole].sort_by(&:id)
+          end
         end
+      end    
+    end
 
-        it "should return the correct inheritance chain after breaking the old link" do
-          @totem_pole.remove_child(@big_model_totem_pole)
+    describe "and two paths of the same length exist to the same node" do
+      before(:each) do
+        @grandpa = @klass.create(:name => 'grandpa')
+        @dad = @klass.create(:name => 'dad')
+        @mom = @klass.create(:name => 'mom')
+        @child = @klass.create(:name => 'child')
+
+        # nevermind the incest
+        @grandpa.add_child(@dad)
+        @dad.add_child(@child)
+        @child.add_parent(@mom)
+        @mom.add_parent(@grandpa)      
+      end
 
-          @totem_pole.children.sort_by(&:id).should == [@big_totem_pole].sort_by(&:id)        
-          @totem.descendants.sort_by(&:id).should == [@totem, @totem_pole, @big_totem_pole, @big_model_totem_pole, @big_red_model_totem_pole].sort_by(&:id)        
-        end
+      it "descendants should not return multiple instances of a child" do
+        @grandpa.descendants.sort_by(&:id).should == [@grandpa, @dad, @mom, @child].sort_by(&:id)
+      end      
 
-        it "should return the correct inheritance chain after breaking the old link when there is are two ancestor root nodes" do
-          pole = MyModel.create(:name => "pole")
-          @totem_pole.add_parent(pole)
-          @totem_pole.remove_child(@big_model_totem_pole)
+      describe "and a link between parent and ancestor is removed" do 
+        before(:each) do
+          # the incest is undone!
+          @dad.remove_parent(@grandpa)
+        end
 
-          pole.descendants.sort_by(&:id).should == [pole, @totem_pole, @big_totem_pole, @big_model_totem_pole, @big_red_model_totem_pole].sort_by(&:id)
-          @totem_pole.children.sort_by(&:id).should == [@big_totem_pole].sort_by(&:id)
-          @totem.descendants.sort_by(&:id).should == [@totem, @totem_pole, @big_totem_pole, @big_model_totem_pole, @big_red_model_totem_pole].sort_by(&:id)
+        it "should still return the correct ancestors" do
+          @child.ancestors.sort_by(&:id).should == [@grandpa, @dad, @mom, @child].sort_by(&:id)
+          @mom.ancestors.sort_by(&:id).should == [@grandpa, @mom].sort_by(&:id)
+          @dad.ancestors.sort_by(&:id).should == [@dad].sort_by(&:id)
         end
+
+        it "should still return the correct descendants" do
+          @child.descendants.sort_by(&:id).should == [@child].sort_by(&:id)
+          @mom.descendants.sort_by(&:id).should == [@mom, @child].sort_by(&:id)
+          @dad.descendants.sort_by(&:id).should == [@dad, @child].sort_by(&:id)
+          @grandpa.descendants.sort_by(&:id).should == [@grandpa, @mom, @child].sort_by(&:id)
+        end      
       end
-    end    
+    end
   end
 
-  describe "and two paths of the same length exist to the same node" do
+  describe "models with separate link tables" do
     before(:each) do
-      @grandpa = MyModel.create(:name => 'grandpa')
-      @dad = MyModel.create(:name => 'dad')
-      @mom = MyModel.create(:name => 'mom')
-      @child = MyModel.create(:name => 'child')
-
-      # nevermind the incest
-      @grandpa.add_child(@dad)
-      @dad.add_child(@child)
-      @child.add_parent(@mom)
-      @mom.add_parent(@grandpa)      
+      @klass = SeparateLinkModel
     end
 
-    it "descendants should not return multiple instances of a child" do
-      @grandpa.descendants.sort_by(&:id).should == [@grandpa, @dad, @mom, @child].sort_by(&:id)
-    end      
+    it_should_behave_like "DAG Model"
+  end
 
-    describe "and a link between parent and ancestor is removed" do 
-      before(:each) do
-        # the incest is undone!
-        @dad.remove_parent(@grandpa)
-      end
+  describe "models with unified link tables" do
+    before(:each) do
+      @klass = UnifiedLinkModel
+      @klass.logger = Logger.new(STDOUT)
+    end
 
-      it "should still return the correct ancestors" do
-        @child.ancestors.sort_by(&:id).should == [@grandpa, @dad, @mom, @child].sort_by(&:id)
-        @mom.ancestors.sort_by(&:id).should == [@grandpa, @mom].sort_by(&:id)
-        @dad.ancestors.sort_by(&:id).should == [@dad].sort_by(&:id)
-      end
+    it_should_behave_like "DAG Model"
 
-      it "should still return the correct descendants" do
-        @child.descendants.sort_by(&:id).should == [@child].sort_by(&:id)
-        @mom.descendants.sort_by(&:id).should == [@mom, @child].sort_by(&:id)
-        @dad.descendants.sort_by(&:id).should == [@dad, @child].sort_by(&:id)
-        @grandpa.descendants.sort_by(&:id).should == [@grandpa, @mom, @child].sort_by(&:id)
-      end      
+    it "should create links that include the category type" do
+      record = @klass.create!
+
+      record.parent_links.first.category_type.should == @klass.name
+      record.descendant_links.first.category_type.should == @klass.name
     end
-  end
+  end  
 end

data/spec/spec_helper.rb

@@ -8,22 +8,49 @@ ActiveRecord::Base.logger.level = Logger::INFO
 ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
 
 ActiveRecord::Schema.define(:version => 0) do
-  create_table :my_models, :force => true do |t|
+
+  # MODEL TABLES
+  
+  create_table :separate_link_models, :force => true do |t|
+    t.string :name
+  end
+
+
+  create_table :unified_link_models, :force => true do |t|
     t.string :name
   end
 
-  create_table :my_model_links, :force => true do |t|
+  # SUPPORTING TABLES
+
+  create_table :separate_link_model_links, :force => true do |t|
     t.integer :parent_id
     t.integer :child_id
   end
 
-  create_table :my_model_descendants, :force => true do |t|
+  create_table :separate_link_model_descendants, :force => true do |t|
     t.integer :ancestor_id
     t.integer :descendant_id
     t.integer :distance
   end
+
+  create_table :acts_as_dag_links, :force => true do |t|
+    t.integer :parent_id
+    t.integer :child_id
+    t.string :category_type
+  end
+
+  create_table :acts_as_dag_descendants, :force => true do |t|
+    t.integer :ancestor_id
+    t.integer :descendant_id
+    t.integer :distance
+    t.string :category_type
+  end
+end
+
+class SeparateLinkModel < ActiveRecord::Base
+  acts_as_dag :link_table => 'separate_link_model_links', :descendant_table => 'separate_link_model_descendants', :link_conditions => nil
 end
 
-class MyModel < ActiveRecord::Base
+class UnifiedLinkModel < ActiveRecord::Base
   acts_as_dag
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: acts_as_dag
 version: !ruby/object:Gem::Version
-  version: 1.0.5
+  version: 1.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -18,6 +18,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/acts_as_dag/acts_as_dag.rb
 - lib/acts_as_dag.rb
 - spec/acts_as_dag_spec.rb
 - spec/spec_helper.rb