acts_as_dag 1.1.2 → 1.2.0

data/lib/acts_as_dag/acts_as_dag.rb

@@ -16,14 +16,14 @@ 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
+          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"
+          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
@@ -45,32 +45,35 @@ module ActsAsDAG
         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
+      # NOTE: Uniq in order to prevent multiple instance being returned if there are multiple paths between ancestor and 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 :ancestors,        lambda { select("#{table_name}.*, #{descendant_class.table_name}.distance").order('distance DESC').uniq }, :through => :ancestor_links, :source => :ancestor
+      has_many :descendants,      lambda { select("#{table_name}.*, #{descendant_class.table_name}.distance").order('distance ASC').uniq }, :through => :descendant_links, :source => :descendant
+
+      has_many :ancestor_links,   lambda { where options[:link_conditions] }, :class_name => descendant_class, :foreign_key => 'descendant_id', :dependent => :delete_all
+      has_many :descendant_links, lambda { where options[:link_conditions] }, :class_name => descendant_class, :foreign_key => 'ancestor_id', :dependent => :delete_all
+
+      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, :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
+      has_many :parents,          :through => :parent_links, :source => :parent
+      has_many :children,         :through => :child_links, :source => :child
+
+      # 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 }
 
       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
@@ -98,19 +101,21 @@ module ActsAsDAG
 
         # Try drop each category into each root
         categories.sort_by(&:name).each do |category|
+          start = Time.now
           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} in #{categories.collect(&:name).join(', ')}"
+            ActiveRecord::Base.logger.info { "Plinko couldn't find a suitable parent for #{category.name}" }
             categories_with_no_parents << category       
           end
+          puts "took #{Time.now - start} to analyze #{category.name}"
         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"
+          ActiveRecord::Base.logger.info { "Adding #{categories_with_no_parents.collect(&:name).join(', ')} to roots" }
           roots_categories.concat categories_with_no_parents
         end
       end
@@ -121,10 +126,10 @@ module ActsAsDAG
     def reset_hierarchy(categories_to_reset = self.all)
       ids = categories_to_reset.collect(&:id)
 
-      ActiveRecord::Base.logger.info "Clearing #{self.name} hierarchy links"
+      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"
+      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|
@@ -200,17 +205,17 @@ module ActsAsDAG
     # 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}'..."
+      # 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)}
+        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}'"
+            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
@@ -270,7 +275,7 @@ module ActsAsDAG
     # 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})"
+      #      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?
@@ -282,7 +287,7 @@ module ActsAsDAG
       # 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"
+        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)
@@ -300,7 +305,7 @@ module ActsAsDAG
       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!
+          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)
         end
       end
     end
@@ -309,7 +314,7 @@ module ActsAsDAG
     # 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})"
+      #      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
@@ -317,7 +322,7 @@ module ActsAsDAG
       klass = child.class
 
       # delete the links
-      klass.link_table_entries.where(:parent_id => (parent ? parent.id : nil), :child_id => child.id).delete_all
+      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
@@ -358,7 +363,7 @@ module ActsAsDAG
       # 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.where(:ancestor_id => ancestor.id, :descendant_id => current.id, :distance => index).first_or_create!
+        klass.descendant_table_entries.find_or_create_by!(:ancestor_id => ancestor.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

data/spec/acts_as_dag_spec.rb

@@ -14,11 +14,6 @@ describe 'acts_as_dag' do
         @child = @klass.create(:name => 'child')
       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
@@ -72,6 +67,20 @@ describe 'acts_as_dag' do
         @dad.descendants.should == [@dad,@child]
         @dad.children.should == [@child]
       end
+
+      it "should return ancestors in order of greatest distance to least" do
+        @dad.add_child(@child)
+        @grandpa.add_child(@dad)
+
+        @child.ancestors.should == [@grandpa, @dad, @child]
+      end
+
+      it "should return descendants in order of of least distance to greatest" do
+        @dad.add_child(@child)
+        @grandpa.add_child(@dad)
+
+        @grandpa.descendants.should == [@grandpa, @dad, @child]
+      end
       
       it "should be able to test descent" do
         @dad.add_child(@child)
@@ -81,7 +90,18 @@ describe 'acts_as_dag' do
         @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 a root node immediately after saving" do
+        @grandpa.parents.should be_empty
+        @grandpa.root?.should be_true
+      end      
+
+      it "should be a child if it has a parent" do
+        @grandpa.add_child(@dad)
+        @grandpa.add_child(@mom)
+        @klass.children.order(:id).should == [@dad, @mom]
+      end      
     end
 
     describe "reorganization" do
@@ -151,7 +171,7 @@ describe 'acts_as_dag' do
         @big_totem_pole_model.reload.children.should == [@big_red_model_totem_pole]
       end  
 
-      describe "when there is a single long inheritance chain" do
+      describe "when there is a single long inheritance chain with multiple paths between an ancestor and descendant" do
         before(:each) do
           @totem.add_child(@totem_pole)
           @totem_pole.add_child(@big_totem_pole)
@@ -159,6 +179,14 @@ describe 'acts_as_dag' do
           @big_model_totem_pole.add_child(@big_red_model_totem_pole)
         end
 
+        it "should not return multiple instances of any descendants" do
+          @totem.descendants.should == [@totem, @totem_pole, @big_totem_pole, @big_model_totem_pole, @big_red_model_totem_pole]
+        end
+
+        it "should not return multiple instances of any ancestors" do
+          @big_red_model_totem_pole.ancestors.should == [@totem, @totem_pole, @big_totem_pole, @big_model_totem_pole, @big_red_model_totem_pole]
+        end
+
         describe "and we are reorganizing the middle of the chain" do
           # Totem
           #   |

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: acts_as_dag
 version: !ruby/object:Gem::Version
-  version: 1.1.2
+  version: 1.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -11,7 +11,23 @@ autorequire:
 bindir: bin
 cert_chain: []
 date: 2013-01-24 00:00:00.000000000 Z
-dependencies: []
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
 description: 
 email: technical@rrnpilot.org
 executables: []
@@ -33,18 +49,18 @@ require_paths:
 required_ruby_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
 summary: Adds directed acyclic graph functionality to ActiveRecord.