awesome_nested_set 2.1.4 → 2.1.5

data/CHANGELOG

@@ -1,3 +1,11 @@
+2.1.5
+* Worked around issues where AR#association wasn't present on Rails 3.0.x. [Philip Arndt]
+* Adds option 'order_column' which defaults to 'left_column_name'. [gudata]
+* Added moving with order functionality. [Sytse Sijbrandij]
+* Use tablename in all select queries. [Mikhail Dieterle]
+* Made sure all descendants' depths are updated when moving parent, not just immediate child. [Phil Thompson]
+* Add documentation of the callbacks. [Tobias Maier]
+
 2.1.4
 * nested_set_options accept both Class & AR Relation. [Semyon Perepelitsa]
 * Reduce the number of queries triggered by the canonical usage of `i.level` in the `nested_set` helpers. [thedarkone]
@@ -41,4 +49,4 @@
 * Expect Rails 3
 * Changed how callbacks work. Returning false in a before_move action does not block save operations. Use a validation or exception in the callback if you need that.
 * Switched to RSpec
-* Remove use of Comparable
+* Remove use of Comparable

data/README.rdoc

@@ -43,6 +43,57 @@ Enable the nested set functionality by declaring acts_as_nested_set on your mode
 
 Run `rake rdoc` to generate the API docs and see CollectiveIdea::Acts::NestedSet for more info.
 
+== Callbacks
+
+There are three callbacks called when moving a node. `before_move`, `after_move` and `around_move`.
+
+  class Category < ActiveRecord::Base
+    acts_as_nested_set
+
+    after_move :rebuild_slug
+    around_move :da_fancy_things_around
+
+    private
+    
+    def rebuild_slug
+      # do whatever
+    end
+
+    def da_fancy_things_around
+      # do something...
+      yield # actually moves
+      # do something else...
+    end
+  end
+
+Beside this there are also hooks to act on the newly added or removed children.
+
+  class Category < ActiveRecord::Base  
+    acts_as_nested_set  :before_add     => :do_before_add_stuff,
+                        :after_add      => :do_after_add_stuff,
+                        :before_remove  => :do_before_remove_stuff,
+                        :after_remove   => :do_after_remove_stuff
+
+    private
+
+    def do_before_add_stuff(child_node)
+      # do whatever with the child
+    end
+
+    def do_after_add_stuff(child_node)
+      # do whatever with the child
+    end
+
+    def do_before_remove_stuff(child_node)
+      # do whatever with the child
+    end
+
+    def do_after_remove_stuff(child_node)
+      # do whatever with the child
+    end
+  end
+
+
 == Protecting attributes from mass assignment
 
 It's generally best to "white list" the attributes that can be used in mass assignment:

data/lib/awesome_nested_set/awesome_nested_set.rb

@@ -35,6 +35,8 @@ module CollectiveIdea #:nodoc:
       # * +:counter_cache+ adds a counter cache for the number of children.
       #   defaults to false.
       #   Example: <tt>acts_as_nested_set :counter_cache => :children_count</tt>
+      # * +:order_column+ on which column to do sorting, by default it is the left_column_name
+      #   Example: <tt>acts_as_nested_set :order_column => :position</tt>
       #
       # See CollectiveIdea::Acts::NestedSet::Model::ClassMethods for a list of class methods and
       # CollectiveIdea::Acts::NestedSet::Model for a list of instance methods added
@@ -70,7 +72,7 @@ module CollectiveIdea #:nodoc:
         has_many_children_options = {
           :class_name => self.base_class.to_s,
           :foreign_key => parent_column_name,
-          :order => left_column_name,
+          :order => order_column,
           :inverse_of => (:parent unless options[:polymorphic]),
         }
 
@@ -103,6 +105,10 @@ module CollectiveIdea #:nodoc:
       module Model
         extend ActiveSupport::Concern
 
+        included do
+          delegate :quoted_table_name, :to => self
+        end
+
         module ClassMethods
           # Returns the first root
           def root
@@ -110,11 +116,11 @@ module CollectiveIdea #:nodoc:
           end
 
           def roots
-            where(parent_column_name => nil).order(quoted_left_column_name)
+            where(parent_column_name => nil).order(quoted_left_column_full_name)
           end
 
           def leaves
-            where("#{quoted_right_column_name} - #{quoted_left_column_name} = 1").order(quoted_left_column_name)
+            where("#{quoted_right_column_full_name} - #{quoted_left_column_full_name} = 1").order(quoted_left_column_full_name)
           end
 
           def valid?
@@ -126,15 +132,15 @@ module CollectiveIdea #:nodoc:
             joins("LEFT OUTER JOIN #{quoted_table_name}" +
                 (connection.adapter_name.match(/Oracle/).nil? ?  " AS " : " ") +
                 "parent ON " +
-                "#{quoted_table_name}.#{quoted_parent_column_name} = parent.#{primary_key}").
+                "#{quoted_parent_column_full_name} = parent.#{primary_key}").
             where(
-                "#{quoted_table_name}.#{quoted_left_column_name} IS NULL OR " +
-                "#{quoted_table_name}.#{quoted_right_column_name} IS NULL OR " +
-                "#{quoted_table_name}.#{quoted_left_column_name} >= " +
-                  "#{quoted_table_name}.#{quoted_right_column_name} OR " +
-                "(#{quoted_table_name}.#{quoted_parent_column_name} IS NOT NULL AND " +
-                  "(#{quoted_table_name}.#{quoted_left_column_name} <= parent.#{quoted_left_column_name} OR " +
-                  "#{quoted_table_name}.#{quoted_right_column_name} >= parent.#{quoted_right_column_name}))"
+                "#{quoted_left_column_full_name} IS NULL OR " +
+                "#{quoted_right_column_full_name} IS NULL OR " +
+                "#{quoted_left_column_full_name} >= " +
+                  "#{quoted_right_column_full_name} OR " +
+                "(#{quoted_parent_column_full_name} IS NOT NULL AND " +
+                  "(#{quoted_left_column_full_name} <= parent.#{quoted_left_column_name} OR " +
+                  "#{quoted_right_column_full_name} >= parent.#{quoted_right_column_name}))"
             ).count == 0
           end
 
@@ -142,7 +148,7 @@ module CollectiveIdea #:nodoc:
             scope_string = Array(acts_as_nested_set_options[:scope]).map do |c|
               connection.quote_column_name(c)
             end.push(nil).join(", ")
-            [quoted_left_column_name, quoted_right_column_name].all? do |column|
+            [quoted_left_column_full_name, quoted_right_column_full_name].all? do |column|
               # No duplicates
               select("#{scope_string}#{column}, COUNT(#{column})").
                   group("#{scope_string}#{column}").
@@ -192,14 +198,14 @@ module CollectiveIdea #:nodoc:
               # set left
               node[left_column_name] = indices[scope.call(node)] += 1
               # find
-              where(["#{quoted_parent_column_name} = ? #{scope.call(node)}", node]).order("#{quoted_left_column_name}, #{quoted_right_column_name}, id").each{|n| set_left_and_rights.call(n) }
+              where(["#{quoted_parent_column_full_name} = ? #{scope.call(node)}", node]).order("#{quoted_left_column_full_name}, #{quoted_right_column_full_name}, id").each{|n| set_left_and_rights.call(n) }
               # set right
               node[right_column_name] = indices[scope.call(node)] += 1
               node.save!(:validate => validate_nodes)
             end
 
             # Find root node(s)
-            root_nodes = where("#{quoted_parent_column_name} IS NULL").order("#{quoted_left_column_name}, #{quoted_right_column_name}, id").each do |root_node|
+            root_nodes = where("#{quoted_parent_column_full_name} IS NULL").order("#{quoted_left_column_full_name}, #{quoted_right_column_full_name}, id").each do |root_node|
               # setup index for this scope
               indices[scope.call(root_node)] ||= 0
               set_left_and_rights.call(root_node)
@@ -261,12 +267,16 @@ module CollectiveIdea #:nodoc:
           end
 
           def associate_parents(objects)
-            id_indexed = objects.index_by(&:id)
-            objects.each do |object|
-              if !(association = object.association(:parent)).loaded? && (parent = id_indexed[object.parent_id])
-                association.target = parent
-                association.set_inverse_instance(parent)
+            if objects.all?{|o| o.respond_to?(:association)}
+              id_indexed = objects.index_by(&:id)
+              objects.each do |object|
+                if !(association = object.association(:parent)).loaded? && (parent = id_indexed[object.parent_id])
+                  association.target = parent
+                  association.set_inverse_instance(parent)
+                end
               end
+            else
+              objects
             end
           end
         end
@@ -321,7 +331,7 @@ module CollectiveIdea #:nodoc:
         # Returns the array of all parents and self
         def self_and_ancestors
           nested_set_scope.where([
-            "#{self.class.quoted_table_name}.#{quoted_left_column_name} <= ? AND #{self.class.quoted_table_name}.#{quoted_right_column_name} >= ?", left, right
+            "#{quoted_left_column_full_name} <= ? AND #{quoted_right_column_full_name} >= ?", left, right
           ])
         end
 
@@ -342,7 +352,7 @@ module CollectiveIdea #:nodoc:
 
         # Returns a set of all of its nested children which do not have children
         def leaves
-          descendants.where("#{self.class.quoted_table_name}.#{quoted_right_column_name} - #{self.class.quoted_table_name}.#{quoted_left_column_name} = 1")
+          descendants.where("#{quoted_right_column_full_name} - #{quoted_left_column_full_name} = 1")
         end
 
         # Returns the level of this object in the tree
@@ -354,7 +364,7 @@ module CollectiveIdea #:nodoc:
         # Returns a set of itself and all of its nested children
         def self_and_descendants
           nested_set_scope.where([
-            "#{self.class.quoted_table_name}.#{quoted_left_column_name} >= ? AND #{self.class.quoted_table_name}.#{quoted_left_column_name} < ?", left, right
+            "#{quoted_left_column_full_name} >= ? AND #{quoted_left_column_full_name} < ?", left, right
             # using _left_ for both sides here lets us benefit from an index on that column if one exists
           ])
         end
@@ -389,13 +399,13 @@ module CollectiveIdea #:nodoc:
 
         # Find the first sibling to the left
         def left_sibling
-          siblings.where(["#{self.class.quoted_table_name}.#{quoted_left_column_name} < ?", left]).
-                  order("#{self.class.quoted_table_name}.#{quoted_left_column_name} DESC").last
+          siblings.where(["#{quoted_left_column_full_name} < ?", left]).
+                  order("#{quoted_left_column_full_name} DESC").last
         end
 
         # Find the first sibling to the right
         def right_sibling
-          siblings.where(["#{self.class.quoted_table_name}.#{quoted_left_column_name} > ?", left]).first
+          siblings.where(["#{quoted_left_column_full_name} > ?", left]).first
         end
 
         # Shorthand method for finding the left sibling and moving to the left of it.
@@ -439,6 +449,28 @@ module CollectiveIdea #:nodoc:
           move_to nil, :root
         end
 
+        # Order children in a nested set by an attribute
+        # Can order by any attribute class that uses the Comparable mixin, for example a string or integer
+        # Usage example when sorting categories alphabetically: @new_category.move_to_ordered_child_of(@root, "name")
+        def move_to_ordered_child_of(parent, order_attribute, ascending = true)
+          self.move_to_root and return unless parent
+          left = nil # This is needed, at least for the tests.
+          parent.children.each do |n| # Find the node immediately to the left of this node.
+            if ascending
+              left = n if n.send(order_attribute) < self.send(order_attribute)
+            else
+              left = n if n.send(order_attribute) > self.send(order_attribute)
+            end
+          end
+          self.move_to_child_of(parent)
+          return unless parent.children.count > 1 # Only need to order if there are multiple children.
+          if left # Self has a left neighbor.
+            self.move_to_right_of(left)
+          else # Self is the left most node.
+            self.move_to_left_of(parent.children[0])
+          end
+        end
+
         def move_possible?(target)
           self != target && # Can't target self
           same_scope?(target) && # can't be in different scopes
@@ -459,7 +491,7 @@ module CollectiveIdea #:nodoc:
           while (association = node.association(:parent)).loaded? && association.target
             nesting += 1
             node = node.parent
-          end
+          end if node.respond_to? :association
           node == self ? ancestors.count : node.level + nesting
         end
 
@@ -471,7 +503,7 @@ module CollectiveIdea #:nodoc:
         # the base ActiveRecord class, using the :scope declared in the acts_as_nested_set
         # declaration.
         def nested_set_scope(options = {})
-          options = {:order => quoted_left_column_name}.merge(options)
+          options = {:order => quoted_left_column_full_name}.merge(options)
           scopes = Array(acts_as_nested_set_options[:scope])
           options[:conditions] = scopes.inject({}) do |conditions,attr|
             conditions.merge attr => self[attr]
@@ -505,7 +537,7 @@ module CollectiveIdea #:nodoc:
 
         # on creation, set automatically lft and rgt to the end of the tree
         def set_default_left_and_right
-          highest_right_row = nested_set_scope(:order => "#{quoted_right_column_name} desc").limit(1).lock(true).first
+          highest_right_row = nested_set_scope(:order => "#{quoted_right_column_full_name} desc").limit(1).lock(true).first
           maxright = highest_right_row ? (highest_right_row[right_column_name] || 0) : 0
           # adds the new node to the right of all existing nodes
           self[left_column_name] = maxright + 1
@@ -535,7 +567,7 @@ module CollectiveIdea #:nodoc:
           in_tenacious_transaction do
             reload_nested_set
             # select the rows in the model that extend past the deletion point and apply a lock
-            nested_set_scope.where(["#{quoted_left_column_name} >= ?", left]).
+            nested_set_scope.where(["#{quoted_left_column_full_name} >= ?", left]).
                                   select(id).lock(true)
 
             if acts_as_nested_set_options[:dependent] == :destroy
@@ -550,11 +582,11 @@ module CollectiveIdea #:nodoc:
 
             # update lefts and rights for remaining nodes
             diff = right - left + 1
-            nested_set_scope.where(["#{quoted_left_column_name} > ?", right]).update_all(
+            nested_set_scope.where(["#{quoted_left_column_full_name} > ?", right]).update_all(
               ["#{quoted_left_column_name} = (#{quoted_left_column_name} - ?)", diff]
             )
 
-            nested_set_scope.where(["#{quoted_right_column_name} > ?", right]).update_all(
+            nested_set_scope.where(["#{quoted_right_column_full_name} > ?", right]).update_all(
               ["#{quoted_right_column_name} = (#{quoted_right_column_name} - ?)", diff]
             )
 
@@ -566,7 +598,7 @@ module CollectiveIdea #:nodoc:
         # reload left, right, and parent
         def reload_nested_set
           reload(
-            :select => "#{quoted_left_column_name}, #{quoted_right_column_name}, #{quoted_parent_column_name}",
+            :select => "#{quoted_left_column_full_name}, #{quoted_right_column_full_name}, #{quoted_parent_column_full_name}",
             :lock => true
           )
         end
@@ -611,7 +643,7 @@ module CollectiveIdea #:nodoc:
 
               # select the rows in the model between a and d, and apply a lock
               self.class.base_class.select('id').lock(true).where(
-                ["#{quoted_left_column_name} >= :a and #{quoted_right_column_name} <= :d", {:a => a, :d => d}]
+                ["#{quoted_left_column_full_name} >= :a and #{quoted_right_column_full_name} <= :d", {:a => a, :d => d}]
               )
 
               new_parent = case position
@@ -641,7 +673,7 @@ module CollectiveIdea #:nodoc:
             end
             target.reload_nested_set if target
             self.set_depth!
-            self.children.each(&:save)
+            self.descendants.each(&:save)
             self.reload_nested_set
           end
         end
@@ -666,6 +698,10 @@ module CollectiveIdea #:nodoc:
           acts_as_nested_set_options[:parent_column]
         end
 
+        def order_column
+          acts_as_nested_set_options[:order_column] || left_column_name
+        end
+
         def scope_column_names
           Array(acts_as_nested_set_options[:scope])
         end
@@ -689,9 +725,20 @@ module CollectiveIdea #:nodoc:
         def quoted_scope_column_names
           scope_column_names.collect {|column_name| connection.quote_column_name(column_name) }
         end
+
+        def quoted_left_column_full_name
+          "#{quoted_table_name}.#{quoted_left_column_name}"
+        end
+
+        def quoted_right_column_full_name
+          "#{quoted_table_name}.#{quoted_right_column_name}"
+        end
+
+        def quoted_parent_column_full_name
+          "#{quoted_table_name}.#{quoted_parent_column_name}"
+        end
       end
 
     end
   end
 end
-

data/lib/awesome_nested_set/version.rb

@@ -1,3 +1,3 @@
 module AwesomeNestedSet
-  VERSION = '2.1.4' unless defined?(::AwesomeNestedSet::VERSION)
-end
+  VERSION = '2.1.5' unless defined?(::AwesomeNestedSet::VERSION)
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: awesome_nested_set
 version: !ruby/object:Gem::Version
-  version: 2.1.4
+  version: 2.1.5
   prerelease: 
 platform: ruby
 authors:
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-21 00:00:00.000000000 Z
+date: 2012-09-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -29,6 +29,22 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.8'
 description: An awesome nested set implementation for Active Record
 email: info@collectiveidea.com
 executables: []
@@ -67,7 +83,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.22
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: An awesome nested set implementation for Active Record