loyal_awesome_nested_set 0.0.1

data/lib/awesome_nested_set/model/rebuildable.rb

@@ -0,0 +1,40 @@
+require 'awesome_nested_set/tree'
+
+module CollectiveIdea
+  module Acts
+    module NestedSet
+      module Model
+        module Rebuildable
+
+
+          # Rebuilds the left & rights if unset or invalid.
+          # Also very useful for converting from acts_as_tree.
+          def rebuild!(validate_nodes = true)
+            # default_scope with order may break database queries so we do all operation without scope
+            unscoped do
+              Tree.new(self, validate_nodes).rebuild!
+            end
+          end
+
+          def scope_for_rebuild
+            scope = proc {}
+
+            if acts_as_nested_set_options[:scope]
+              scope = proc {|node|
+                scope_column_names.inject("") {|str, column_name|
+                  str << "AND #{connection.quote_column_name(column_name)} = #{connection.quote(node.send(column_name))} "
+                }
+              }
+            end
+            scope
+          end
+
+          def order_for_rebuild
+            "#{quoted_left_column_full_name}, #{quoted_right_column_full_name}, #{primary_key}"
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/awesome_nested_set/model/relatable.rb

@@ -0,0 +1,121 @@
+module CollectiveIdea
+  module Acts
+    module NestedSet
+      module Model
+        module Relatable
+
+          # Returns an collection of all parents
+          def ancestors
+            without_self self_and_ancestors
+          end
+
+          # Returns the collection of all parents and self
+          def self_and_ancestors
+            nested_set_scope.
+              where(arel_table[left_column_name].lteq(left)).
+              where(arel_table[right_column_name].gteq(right))
+          end
+
+          # Returns the collection of all children of the parent, except self
+          def siblings
+            without_self self_and_siblings
+          end
+
+          # Returns the collection of all children of the parent, including self
+          def self_and_siblings
+            nested_set_scope.children_of parent_id
+          end
+
+          # Returns a set of all of its nested children which do not have children
+          def leaves
+            descendants.where(
+              "#{quoted_right_column_full_name} - #{quoted_left_column_full_name} = 1"
+            )
+          end
+
+          # Returns the level of this object in the tree
+          # root level is 0
+          def level
+            parent_id.nil? ? 0 : compute_level
+          end
+
+          # Returns a collection including all of its children and nested children
+          def descendants
+            without_self self_and_descendants
+          end
+
+          # Returns a collection including itself and all of its nested children
+          def self_and_descendants
+            # using _left_ for both sides here lets us benefit from an index on that column if one exists
+            nested_set_scope.right_of(left).left_of(right)
+          end
+
+          def is_descendant_of?(other)
+            within_node?(other, self) && same_scope?(other)
+          end
+
+          def is_or_is_descendant_of?(other)
+            (other == self || within_node?(other, self)) && same_scope?(other)
+          end
+
+          def is_ancestor_of?(other)
+            within_node?(self, other) && same_scope?(other)
+          end
+
+          def is_or_is_ancestor_of?(other)
+            (self == other || within_node?(self, other)) && same_scope?(other)
+          end
+
+          # Check if other model is in the same scope
+          def same_scope?(other)
+            Array(acts_as_nested_set_options[:scope]).all? do |attr|
+              self.send(attr) == other.send(attr)
+            end
+          end
+
+          # Find the first sibling to the left
+          def left_sibling
+            siblings.left_of(left).last
+          end
+
+          # Find the first sibling to the right
+          def right_sibling
+            siblings.right_of(left).first
+          end
+
+          def root
+            return self_and_ancestors.children_of(nil).first if persisted?
+
+            if parent_id && current_parent = nested_set_scope.find(parent_id)
+              current_parent.root
+            else
+              self
+            end
+          end
+
+          protected
+
+          def compute_level
+            node, nesting = determine_depth
+
+            node == self ? ancestors.count : node.level + nesting
+          end
+
+          def determine_depth(node = self, nesting = 0)
+            while (association = node.association(:parent)).loaded? && association.target
+              nesting += 1
+              node = node.parent
+            end if node.respond_to?(:association)
+
+            [node, nesting]
+          end
+
+          def within_node?(node, within)
+            node.left < within.left && within.left < node.right
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/awesome_nested_set/model/transactable.rb

@@ -0,0 +1,27 @@
+module CollectiveIdea #:nodoc:
+  module Acts #:nodoc:
+    module NestedSet #:nodoc:
+      module Model
+        module Transactable
+
+          protected
+          def in_tenacious_transaction(&block)
+            retry_count = 0
+            begin
+              transaction(&block)
+            rescue ActiveRecord::StatementInvalid => error
+              raise unless connection.open_transactions.zero?
+              raise unless error.message =~ /Deadlock found when trying to get lock|Lock wait timeout exceeded/
+              raise unless retry_count < 10
+              retry_count += 1
+              logger.info "Deadlock detected on retry #{retry_count}, restarting transaction"
+              sleep(rand(retry_count)*0.1) # Aloha protocol
+              retry
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/awesome_nested_set/model/validatable.rb

@@ -0,0 +1,69 @@
+require 'awesome_nested_set/set_validator'
+
+module CollectiveIdea
+  module Acts
+    module NestedSet
+      module Model
+        module Validatable
+
+          def valid?
+            left_and_rights_valid? && no_duplicates_for_columns? && all_roots_valid?
+          end
+
+          def left_and_rights_valid?
+            SetValidator.new(self).valid?
+          end
+
+          def no_duplicates_for_columns?
+            [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}", quoted_primary_key_column_full_name).
+                having("COUNT(#{column}) > 1").
+                first.nil?
+            end
+          end
+
+          # Wrapper for each_root_valid? that can deal with scope.
+          def all_roots_valid?
+            if acts_as_nested_set_options[:scope]
+              all_roots_valid_by_scope?(roots)
+            else
+              each_root_valid?(roots)
+            end
+          end
+
+          def all_roots_valid_by_scope?(roots_to_validate)
+            roots_grouped_by_scope(roots_to_validate).all? do |scope, grouped_roots|
+              each_root_valid?(grouped_roots)
+            end
+          end
+
+          def each_root_valid?(roots_to_validate)
+            left = right = 0
+            roots_to_validate.all? do |root|
+              (root.left > left && root.right > right).tap do
+                left = root.left
+                right = root.right
+              end
+            end
+          end
+
+          private
+          def roots_grouped_by_scope(roots_to_group)
+            roots_to_group.group_by {|record|
+              scope_column_names.collect {|col| record.send(col) }
+            }
+          end
+
+          def scope_string
+            Array(acts_as_nested_set_options[:scope]).map do |c|
+              connection.quote_column_name(c)
+            end.push(nil).join(", ")
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/awesome_nested_set/move.rb

@@ -0,0 +1,117 @@
+module CollectiveIdea #:nodoc:
+  module Acts #:nodoc:
+    module NestedSet #:nodoc:
+      class Move
+        attr_reader :target, :position, :instance
+
+        def initialize(target, position, instance)
+          @target = target
+          @position = position
+          @instance = instance
+        end
+
+        def move
+          prevent_impossible_move
+
+          bound, other_bound = get_boundaries
+
+          # there would be no change
+          return if bound == right || bound == left
+
+          # we have defined the boundaries of two non-overlapping intervals,
+          # so sorting puts both the intervals and their boundaries in order
+          a, b, c, d = [left, right, bound, other_bound].sort
+
+          lock_nodes_between! a, d
+
+          nested_set_scope.where(where_statement(a, d)).
+                           update_all(conditions(a, b, c, d))
+        end
+
+        private
+
+        delegate :left, :right, :left_column_name, :right_column_name,
+                 :quoted_left_column_name, :quoted_right_column_name,
+                 :quoted_parent_column_name, :parent_column_name, :nested_set_scope,
+                 :to => :instance
+
+        delegate :arel_table, :class, :to => :instance, :prefix => true
+        delegate :base_class, :to => :instance_class, :prefix => :instance
+
+        def where_statement(left_bound, right_bound)
+          instance_arel_table[left_column_name].in(left_bound..right_bound).
+            or(instance_arel_table[right_column_name].in(left_bound..right_bound))
+        end
+
+        def conditions(a, b, c, d)
+          [
+           case_condition_for_direction(:quoted_left_column_name) +
+           case_condition_for_direction(:quoted_right_column_name) +
+           case_condition_for_parent,
+           {:a => a, :b => b, :c => c, :d => d, :id => instance.id, :new_parent => new_parent}
+          ]
+        end
+
+        def case_condition_for_direction(column_name)
+          column = send(column_name)
+          "#{column} = CASE " +
+            "WHEN #{column} BETWEEN :a AND :b " +
+            "THEN #{column} + :d - :b " +
+            "WHEN #{column} BETWEEN :c AND :d " +
+            "THEN #{column} + :a - :c " +
+            "ELSE #{column} END, "
+        end
+
+        def case_condition_for_parent
+          "#{quoted_parent_column_name} = CASE " +
+            "WHEN #{instance_base_class.primary_key} = :id THEN :new_parent " +
+            "ELSE #{quoted_parent_column_name} END"
+        end
+
+        def lock_nodes_between!(left_bound, right_bound)
+          # select the rows in the model between a and d, and apply a lock
+          instance_base_class.right_of(left_bound).left_of_right_side(right_bound).
+                              select(:id).lock(true)
+        end
+
+        def root
+          position == :root
+        end
+
+        def new_parent
+          case position
+          when :child
+            target.id
+          else
+            target[parent_column_name]
+          end
+        end
+
+        def get_boundaries
+          if (bound = target_bound) > right
+            bound -= 1
+            other_bound = right + 1
+          else
+            other_bound = left - 1
+          end
+          [bound, other_bound]
+        end
+
+        def prevent_impossible_move
+          if !root && !instance.move_possible?(target)
+            raise ActiveRecord::ActiveRecordError, "Impossible move, target node cannot be inside moved tree."
+          end
+        end
+
+        def target_bound
+          case position
+          when :child;  right(target)
+          when :left;   left(target)
+          when :right;  right(target) + 1
+          else raise ActiveRecord::ActiveRecordError, "Position should be :child, :left, :right or :root ('#{position}' received)."
+          end
+        end
+      end
+    end
+  end
+end

data/lib/awesome_nested_set/set_validator.rb

@@ -0,0 +1,63 @@
+module CollectiveIdea #:nodoc:
+  module Acts #:nodoc:
+    module NestedSet #:nodoc:
+      class SetValidator
+
+        def initialize(model)
+          @model = model
+          @scope = model.all
+          @parent = arel_table.alias('parent')
+        end
+
+        def valid?
+          query.count == 0
+        end
+
+        private
+
+        attr_reader :model, :parent
+        attr_accessor :scope
+
+        delegate :parent_column_name, :primary_key, :left_column_name, :right_column_name, :arel_table,
+          :quoted_table_name, :quoted_parent_column_full_name, :quoted_left_column_full_name, :quoted_right_column_full_name, :quoted_left_column_name, :quoted_right_column_name,
+        :to => :model
+
+        def query
+          join_scope
+          filter_scope
+        end
+
+        def join_scope
+          join_arel = arel_table.join(parent, Arel::Nodes::OuterJoin).on(parent[primary_key].eq(arel_table[parent_column_name]))
+          self.scope = scope.joins(join_arel.join_sql)
+        end
+
+        def filter_scope
+          self.scope = scope.where(
+                                   bound_is_null(left_column_name).
+                                   or(bound_is_null(right_column_name)).
+                                   or(left_bound_greater_than_right).
+                                   or(parent_not_null.and(bounds_outside_parent))
+                                   )
+        end
+
+        def bound_is_null(column_name)
+          arel_table[column_name].eq(nil)
+        end
+
+        def left_bound_greater_than_right
+          arel_table[left_column_name].gteq(arel_table[right_column_name])
+        end
+
+        def parent_not_null
+          arel_table[parent_column_name].not_eq(nil)
+        end
+
+        def bounds_outside_parent
+          arel_table[left_column_name].lteq(parent[left_column_name]).or(arel_table[right_column_name].gteq(parent[right_column_name]))
+        end
+
+      end
+    end
+  end
+end

data/lib/awesome_nested_set/tree.rb

@@ -0,0 +1,63 @@
+module CollectiveIdea #:nodoc:
+  module Acts #:nodoc:
+    module NestedSet #:nodoc:
+      class Tree
+        attr_reader :model, :validate_nodes
+        attr_accessor :indices
+
+        delegate :left_column_name, :right_column_name, :quoted_parent_column_full_name,
+                 :order_for_rebuild, :scope_for_rebuild,
+                 :to => :model
+
+        def initialize(model, validate_nodes)
+          @model = model
+          @validate_nodes = validate_nodes
+          @indices = {}
+        end
+
+        def rebuild!
+          # Don't rebuild a valid tree.
+          return true if model.valid?
+
+          root_nodes.each do |root_node|
+            # setup index for this scope
+            indices[scope_for_rebuild.call(root_node)] ||= 0
+            set_left_and_rights(root_node)
+          end
+        end
+
+        private
+
+        def increment_indice!(node)
+          indices[scope_for_rebuild.call(node)] += 1
+        end
+
+        def set_left_and_rights(node)
+          set_left!(node)
+          # find
+          node_children(node).each { |n| set_left_and_rights(n) }
+          set_right!(node)
+
+          node.save!(:validate => validate_nodes)
+        end
+
+        def node_children(node)
+          model.where(["#{quoted_parent_column_full_name} = ? #{scope_for_rebuild.call(node)}", node]).
+                order(order_for_rebuild)
+        end
+
+        def root_nodes
+          model.where("#{quoted_parent_column_full_name} IS NULL").order(order_for_rebuild)
+        end
+
+        def set_left!(node)
+          node[left_column_name] = increment_indice!(node)
+        end
+
+        def set_right!(node)
+          node[right_column_name] = increment_indice!(node)
+        end
+      end
+    end
+  end
+end