awesome_nested_set 2.1.6 → 3.0.0.rc.6

data/lib/awesome_nested_set/model.rb

@@ -0,0 +1,248 @@
+require 'awesome_nested_set/model/prunable'
+require 'awesome_nested_set/model/movable'
+require 'awesome_nested_set/model/transactable'
+require 'awesome_nested_set/model/relatable'
+require 'awesome_nested_set/model/rebuildable'
+require 'awesome_nested_set/model/validatable'
+require 'awesome_nested_set/iterator'
+
+module CollectiveIdea #:nodoc:
+  module Acts #:nodoc:
+    module NestedSet #:nodoc:
+
+      module Model
+        extend ActiveSupport::Concern
+
+        included do
+          delegate :quoted_table_name, :arel_table, :to => self
+          extend Validatable
+          extend Rebuildable
+          include Movable
+          include Prunable
+          include Relatable
+          include Transactable
+        end
+
+        module ClassMethods
+          def associate_parents(objects)
+            return objects unless objects.all? {|o| o.respond_to?(:association)}
+
+            id_indexed = objects.index_by(&primary_column_name.to_sym)
+            objects.each do |object|
+              association = object.association(:parent)
+              parent = id_indexed[object.parent_id]
+
+              if !association.loaded? && parent
+                association.target = parent
+                add_to_inverse_association(association, parent)
+              end
+            end
+          end
+
+          def add_to_inverse_association(association, record)
+            inverse_reflection = association.send(:inverse_reflection_for, record)
+            inverse = record.association(inverse_reflection.name)
+            inverse.target << association.owner
+            inverse.loaded!
+          end
+
+          def children_of(parent_id)
+            where arel_table[parent_column_name].eq(parent_id)
+          end
+
+          # Iterates over tree elements and determines the current level in the tree.
+          # Only accepts default ordering, odering by an other column than lft
+          # does not work. This method is much more efficent than calling level
+          # because it doesn't require any additional database queries.
+          #
+          # Example:
+          #    Category.each_with_level(Category.root.self_and_descendants) do |o, level|
+          #
+          def each_with_level(objects, &block)
+            Iterator.new(objects).each_with_level(&block)
+          end
+
+          def leaves
+            nested_set_scope.where "#{quoted_right_column_full_name} - #{quoted_left_column_full_name} = 1"
+          end
+
+          def left_of(node)
+            where arel_table[left_column_name].lt(node)
+          end
+
+          def left_of_right_side(node)
+            where arel_table[right_column_name].lteq(node)
+          end
+
+          def right_of(node)
+            where arel_table[left_column_name].gteq(node)
+          end
+
+          def nested_set_scope(options = {})
+            options = {:order => quoted_order_column_full_name}.merge(options)
+
+            where(options[:conditions]).order(options.delete(:order))
+          end
+
+          def primary_key_scope(id)
+            where arel_table[primary_column_name].eq(id)
+          end
+
+          def root
+            roots.first
+          end
+
+          def roots
+            nested_set_scope.children_of nil
+          end
+        end # end class methods
+
+        # Any instance method that returns a collection makes use of Rails 2.1's named_scope (which is bundled for Rails 2.0), so it can be treated as a finder.
+        #
+        #   category.self_and_descendants.count
+        #   category.ancestors.find(:all, :conditions => "name like '%foo%'")
+        # Value of the parent column
+        def parent_id(target = self)
+          target[parent_column_name]
+        end
+
+        def primary_id(target = self)
+          target[primary_column_name]
+        end
+
+        # Value of the left column
+        def left(target = self)
+          target[left_column_name]
+        end
+
+        # Value of the right column
+        def right(target = self)
+          target[right_column_name]
+        end
+
+        # Returns true if this is a root node.
+        def root?
+          parent_id.nil?
+        end
+
+        # Returns true is this is a child node
+        def child?
+          !root?
+        end
+
+        # Returns true if this is the end of a branch.
+        def leaf?
+          persisted? && right.to_i - left.to_i == 1
+        end
+
+        # All nested set queries should use this nested_set_scope, which
+        # performs finds on the base ActiveRecord class, using the :scope
+        # declared in the acts_as_nested_set declaration.
+        def nested_set_scope(options = {})
+          if (scopes = Array(acts_as_nested_set_options[:scope])).any?
+            options[:conditions] = scopes.inject({}) do |conditions,attr|
+              conditions.merge attr => self[attr]
+            end
+          end
+
+          self.class.base_class.nested_set_scope options
+        end
+
+        def to_text
+          self_and_descendants.map do |node|
+            "#{'*'*(node.level+1)} #{node.primary_id} #{node.to_s} (#{node.parent_id}, #{node.left}, #{node.right})"
+          end.join("\n")
+        end
+
+        protected
+
+        def without_self(scope)
+          return scope if new_record?
+          scope.where(["#{self.class.quoted_table_name}.#{self.class.quoted_primary_column_name} != ?", self.primary_id])
+        end
+
+        def store_new_parent
+          @move_to_new_parent_id = send("#{parent_column_name}_changed?") ? parent_id : false
+          true # force callback to return true
+        end
+
+        def has_depth_column?
+          nested_set_scope.column_names.map(&:to_s).include?(depth_column_name.to_s)
+        end
+
+        def right_most_node
+          @right_most_node ||= self.class.base_class.unscoped.nested_set_scope(
+            :order => "#{quoted_right_column_full_name} desc"
+          ).first
+        end
+
+        def right_most_bound
+          @right_most_bound ||= begin
+            return 0 if right_most_node.nil?
+
+            right_most_node.lock!
+            right_most_node[right_column_name] || 0
+          end
+        end
+
+        def set_depth!
+          return unless has_depth_column?
+
+          in_tenacious_transaction do
+            reload
+            update_depth(level)
+          end
+        end
+
+        def set_depth_for_self_and_descendants!
+          return unless has_depth_column?
+
+          in_tenacious_transaction do
+            reload
+            self_and_descendants.select(primary_column_name).lock(true)
+            old_depth = self[depth_column_name] || 0
+            new_depth = level
+            update_depth(new_depth)
+            change_descendants_depth!(new_depth - old_depth)
+            new_depth
+          end
+        end
+
+        def update_depth(depth)
+          nested_set_scope.primary_key_scope(primary_id).
+              update_all(["#{quoted_depth_column_name} = ?", depth])
+          self[depth_column_name] = depth
+        end
+
+        def change_descendants_depth!(diff)
+          if !leaf? && diff != 0
+            sign = "++-"[diff <=> 0]
+            descendants.update_all("#{quoted_depth_column_name} = #{quoted_depth_column_name} #{sign} #{diff.abs}")
+          end
+        end
+
+        def set_default_left_and_right
+          # adds the new node to the right of all existing nodes
+          self[left_column_name] = right_most_bound + 1
+          self[right_column_name] = right_most_bound + 2
+        end
+
+        # reload left, right, and parent
+        def reload_nested_set
+          reload(
+            :select => "#{quoted_left_column_full_name}, #{quoted_right_column_full_name}, #{quoted_parent_column_full_name}",
+            :lock => true
+          )
+        end
+
+        def reload_target(target, position)
+          if target.is_a? self.class.base_class
+            target.reload
+          elsif position != :root
+            nested_set_scope.where(primary_column_name => target).first!
+          end
+        end
+      end
+    end
+  end
+end

data/lib/awesome_nested_set/move.rb

@@ -0,0 +1,131 @@
+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,
+                 :primary_column_name, :quoted_primary_column_name, :primary_id,
+                 :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)
+          _conditions = case_condition_for_direction(:quoted_left_column_name) +
+                        case_condition_for_direction(:quoted_right_column_name) +
+                        case_condition_for_parent
+
+          # We want the record to be 'touched' if it timestamps.
+          if @instance.respond_to?(:updated_at)
+            _conditions << ", updated_at = :timestamp"
+          end
+
+          [
+            _conditions,
+            {
+              :a => a, :b => b, :c => c, :d => d,
+              :primary_id => instance.primary_id,
+              :new_parent_id => new_parent_id,
+              :timestamp => Time.now.utc
+            }
+          ]
+        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 #{quoted_primary_column_name} = :primary_id THEN :new_parent_id " +
+            "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(primary_column_name).lock(true)
+        end
+
+        def root
+          position == :root
+        end
+
+        def new_parent_id
+          case position
+          when :child then target.primary_id
+          when :root  then nil
+          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 then right(target)
+          when :left  then left(target)
+          when :right then right(target) + 1
+          when :root  then nested_set_scope.pluck(right_column_name).max + 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_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, :quoted_primary_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_column_name].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.primary_id]).
+                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

data/lib/awesome_nested_set/version.rb

@@ -1,3 +1,3 @@
 module AwesomeNestedSet
-  VERSION = '2.1.6' unless defined?(::AwesomeNestedSet::VERSION)
+  VERSION = '3.0.0.rc.6' unless defined?(::AwesomeNestedSet::VERSION)
 end

data/lib/awesome_nested_set.rb

@@ -5,4 +5,4 @@ ActiveRecord::Base.send :extend, CollectiveIdea::Acts::NestedSet
 if defined?(ActionView)
   require 'awesome_nested_set/helper'
   ActionView::Base.send :include, CollectiveIdea::Acts::NestedSet::Helper
-end
+end

metadata

@@ -1,8 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: awesome_nested_set
 version: !ruby/object:Gem::Version
-  version: 2.1.6
-  prerelease: 
+  version: 3.0.0.rc.6
 platform: ruby
 authors:
 - Brandon Keepers
@@ -11,113 +10,137 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-14 00:00:00.000000000 Z
+date: 2014-07-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: 4.0.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: '5'
 - !ruby/object:Gem::Dependency
   name: rspec-rails
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '2.12'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '2.12'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '10'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '10'
 - !ruby/object:Gem::Dependency
   name: combustion
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.3.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.3.3
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: An awesome nested set implementation for Active Record
 email: info@collectiveidea.com
 executables: []
 extensions: []
 extra_rdoc_files:
-- README.rdoc
+- README.md
 files:
+- CHANGELOG
+- MIT-LICENSE
+- README.md
+- lib/awesome_nested_set.rb
 - lib/awesome_nested_set/awesome_nested_set.rb
+- lib/awesome_nested_set/columns.rb
 - lib/awesome_nested_set/helper.rb
+- lib/awesome_nested_set/iterator.rb
+- lib/awesome_nested_set/model.rb
+- lib/awesome_nested_set/model/movable.rb
+- lib/awesome_nested_set/model/prunable.rb
+- lib/awesome_nested_set/model/rebuildable.rb
+- lib/awesome_nested_set/model/relatable.rb
+- lib/awesome_nested_set/model/transactable.rb
+- lib/awesome_nested_set/model/validatable.rb
+- lib/awesome_nested_set/move.rb
+- lib/awesome_nested_set/set_validator.rb
+- lib/awesome_nested_set/tree.rb
 - lib/awesome_nested_set/version.rb
-- lib/awesome_nested_set.rb
-- MIT-LICENSE
-- README.rdoc
-- CHANGELOG
 homepage: http://github.com/collectiveidea/awesome_nested_set
 licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options:
-- --main
-- README.rdoc
-- --inline-source
-- --line-numbers
+- "--main"
+- README.md
+- "--inline-source"
+- "--line-numbers"
 require_paths:
 - lib
 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'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.25
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: An awesome nested set implementation for Active Record
 test_files: []
+has_rdoc: