jro_apps/redmine Commit - r15729:b58cf253838b

Adds .rebuild_single_tree! to rebuild a single tree (#24167)....

Jean-Philippe Lang -

r15729:b58cf253838b

parent child

Context file:

r15729:b58cf253838b

Collapse all files

lib/redmine/nested_set/issue_nested_set.rb +10 0

             # Redmine - project management software
             # Copyright (C) 2006-2016  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             module Redmine
               module NestedSet
                 module IssueNestedSet
                   def self.included(base)
                     base.class_eval do
                       belongs_to :parent, :class_name => self.name
                       before_create :add_to_nested_set, :if => lambda {|issue| issue.parent.present?}
                       after_create :add_as_root, :if => lambda {|issue| issue.parent.blank?}
                       before_update :handle_parent_change, :if => lambda {|issue| issue.parent_id_changed?}
                       before_destroy :destroy_children
                     end
                     base.extend ClassMethods
                     base.send :include, Redmine::NestedSet::Traversing
                   end
                   private
                   def target_lft
                     scope_for_max_rgt = self.class.where(:root_id => root_id).where(:parent_id => parent_id)
                     if id
                       scope_for_max_rgt = scope_for_max_rgt.where("id < ?", id)
                     end
                     max_rgt = scope_for_max_rgt.maximum(:rgt)
                     if max_rgt
                       max_rgt + 1
                     elsif parent
                       parent.lft + 1
                     else
                     end
                   end
                   def add_to_nested_set(lock=true)
                     lock_nested_set if lock
                     parent.send :reload_nested_set_values
                     self.root_id = parent.root_id
                     self.lft = target_lft
                     self.rgt = lft + 1
                     self.class.where(:root_id => root_id).where("lft >= ? OR rgt >= ?", lft, lft).update_all([
                       "lft = CASE WHEN lft >= :lft THEN lft + 2 ELSE lft END, " +
                       "rgt = CASE WHEN rgt >= :lft THEN rgt + 2 ELSE rgt END",
                       {:lft => lft}
                     ])
                   end
                   def add_as_root
                     self.root_id = id
                     self.lft = 1
                     self.rgt = 2
                     self.class.where(:id => id).update_all(:root_id => root_id, :lft => lft, :rgt => rgt)
                   end
                   def handle_parent_change
                     lock_nested_set
                     reload_nested_set_values
                     if parent_id_was
                       remove_from_nested_set
                     end
                     if parent
                       move_to_nested_set
                     end
                     reload_nested_set_values
                   end
                   def move_to_nested_set
                     if parent
                       previous_root_id = root_id
                       self.root_id = parent.root_id
                       lft_after_move = target_lft
                       self.class.where(:root_id => parent.root_id).update_all([
                         "lft = CASE WHEN lft >= :lft THEN lft + :shift ELSE lft END, " +
                         "rgt = CASE WHEN rgt >= :lft THEN rgt + :shift ELSE rgt END",
                         {:lft => lft_after_move, :shift => (rgt - lft + 1)}
                       ])
                       self.class.where(:root_id => previous_root_id).update_all([
                         "root_id = :root_id, lft = lft + :shift, rgt = rgt + :shift",
                         {:root_id => parent.root_id, :shift => lft_after_move - lft}
                       ])
                       self.lft, self.rgt = lft_after_move, (rgt - lft + lft_after_move)
                       parent.send :reload_nested_set_values
                     end
                   end
                   def remove_from_nested_set
                     self.class.where(:root_id => root_id).where("lft >= ? AND rgt <= ?", lft, rgt).
                       update_all(["root_id = :id, lft = lft - :shift, rgt = rgt - :shift", {:id => id, :shift => lft - 1}])
                     self.class.where(:root_id => root_id).update_all([
                       "lft = CASE WHEN lft >= :lft THEN lft - :shift ELSE lft END, " +
                       "rgt = CASE WHEN rgt >= :lft THEN rgt - :shift ELSE rgt END",
                       {:lft => lft, :shift => rgt - lft + 1}
                     ])
                     self.root_id = id
                     self.lft, self.rgt = 1, (rgt - lft + 1)
                   end
                   def destroy_children
                     unless @without_nested_set_update
                       lock_nested_set
                       reload_nested_set_values
                     end
                     children.each {|c| c.send :destroy_without_nested_set_update}
                     reload
                     unless @without_nested_set_update
                       self.class.where(:root_id => root_id).where("lft > ? OR rgt > ?", lft, lft).update_all([
                         "lft = CASE WHEN lft > :lft THEN lft - :shift ELSE lft END, " +
                         "rgt = CASE WHEN rgt > :lft THEN rgt - :shift ELSE rgt END",
                         {:lft => lft, :shift => rgt - lft + 1}
                       ])
                     end
                   end
                   def destroy_without_nested_set_update
                     @without_nested_set_update = true
                     destroy
                   end
                   def reload_nested_set_values
                     self.root_id, self.lft, self.rgt = self.class.where(:id => id).pluck(:root_id, :lft, :rgt).first
                   end
                   def save_nested_set_values
                     self.class.where(:id => id).update_all(:root_id => root_id, :lft => lft, :rgt => rgt)
                   end
                   def move_possible?(issue)
                     new_record? || !is_or_is_ancestor_of?(issue)
                   end
                   def lock_nested_set
                     if self.class.connection.adapter_name =~ /sqlserver/i
                       lock = "WITH (ROWLOCK HOLDLOCK UPDLOCK)"
                       # Custom lock for SQLServer
                       # This can be problematic if root_id or parent root_id changes
                       # before locking
                       sets_to_lock = [root_id, parent.try(:root_id)].compact.uniq
                       self.class.reorder(:id).where(:root_id => sets_to_lock).lock(lock).ids
                     else
                       sets_to_lock = [id, parent_id].compact
                       self.class.reorder(:id).where("root_id IN (SELECT root_id FROM #{self.class.table_name} WHERE id IN (?))", sets_to_lock).lock.ids
                     end
                   end
                   def nested_set_scope
                     self.class.order(:lft).where(:root_id => root_id)
                   end
                   def same_nested_set_scope?(issue)
                     root_id == issue.root_id
                   end
                   module ClassMethods
                     def rebuild_tree!
                       transaction do
                         reorder(:id).lock.ids
                         update_all(:root_id => nil, :lft => nil, :rgt => nil)
                         where(:parent_id => nil).update_all(["root_id = id, lft = ?, rgt = ?", 1, 2])
                         roots_with_children = joins("JOIN #{table_name} parent ON parent.id = #{table_name}.parent_id AND parent.id = parent.root_id").distinct.pluck("parent.id")
                         roots_with_children.each do |root_id|
                           rebuild_nodes(root_id)
                         end
                       end
                     end
+                    def rebuild_single_tree!(root_id)
+                      root = Issue.where(:parent_id => nil).find(root_id)
+                      transaction do
+                        where(root_id: root_id).reorder(:id).lock.ids
+                        where(root_id: root_id).update_all(:lft => nil, :rgt => nil)
+                        where(root_id: root_id, parent_id: nil).update_all(["lft = ?, rgt = ?", 1, 2])
+                        rebuild_nodes(root_id)
+                      end
+                    end
                     private
                     def rebuild_nodes(parent_id = nil)
                       nodes = where(:parent_id => parent_id, :rgt => nil, :lft => nil).order(:id).to_a
                       nodes.each do |node|
                         node.send :add_to_nested_set, false
                         node.send :save_nested_set_values
                         rebuild_nodes node.id
                       end
                     end
                   end
                 end
               end
             end

test/unit/issue_nested_set_test.rb +19 0

             # Redmine - project management software
             # Copyright (C) 2006-2016  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require File.expand_path('../../test_helper', __FILE__)
             class IssueNestedSetTest < ActiveSupport::TestCase
               fixtures :projects, :users, :roles,
                        :trackers, :projects_trackers,
                        :issue_statuses, :issue_categories, :issue_relations,
                        :enumerations,
                        :issues
               def test_new_record_is_leaf
                 i = Issue.new
                 assert i.leaf?
               end
               def test_create_root_issue
                 lft1 = new_issue_lft
                 issue1 = Issue.generate!
                 lft2 = new_issue_lft
                 issue2 = Issue.generate!
                 issue1.reload
                 issue2.reload
                 assert_equal [issue1.id, nil, lft1, lft1 + 1], [issue1.root_id, issue1.parent_id, issue1.lft, issue1.rgt]
                 assert_equal [issue2.id, nil, lft2, lft2 + 1], [issue2.root_id, issue2.parent_id, issue2.lft, issue2.rgt]
               end
               def test_create_child_issue
                 lft = new_issue_lft
                 parent = Issue.generate!
                 child =  parent.generate_child!
                 parent.reload
                 child.reload
                 assert_equal [parent.id, nil,       lft,     lft + 3], [parent.root_id, parent.parent_id, parent.lft, parent.rgt]
                 assert_equal [parent.id, parent.id, lft + 1, lft + 2], [child.root_id, child.parent_id, child.lft, child.rgt]
               end
               def test_creating_a_child_in_a_subproject_should_validate
                 issue = Issue.generate!
                 child = Issue.new(:project_id => 3, :tracker_id => 2, :author_id => 1,
                                   :subject => 'child', :parent_issue_id => issue.id)
                 assert_save child
                 assert_equal issue, child.reload.parent
               end
               def test_creating_a_child_in_an_invalid_project_should_not_validate
                 issue = Issue.generate!
                 child = Issue.new(:project_id => 2, :tracker_id => 1, :author_id => 1,
                                   :subject => 'child', :parent_issue_id => issue.id)
                 assert !child.save
                 assert_not_equal [], child.errors[:parent_issue_id]
               end
               def test_move_a_root_to_child
                 lft = new_issue_lft
                 parent1 = Issue.generate!
                 parent2 = Issue.generate!
                 child = parent1.generate_child!
                 parent2.parent_issue_id = parent1.id
                 parent2.save!
                 child.reload
                 parent1.reload
                 parent2.reload
                 assert_equal [parent1.id, lft,     lft + 5], [parent1.root_id, parent1.lft, parent1.rgt]
                 assert_equal [parent1.id, lft + 1, lft + 2], [parent2.root_id, parent2.lft, parent2.rgt]
                 assert_equal [parent1.id, lft + 3, lft + 4], [child.root_id, child.lft, child.rgt]
               end
               def test_move_a_child_to_root
                 lft1 = new_issue_lft
                 parent1 = Issue.generate!
                 lft2 = new_issue_lft
                 parent2 = Issue.generate!
                 lft3 = new_issue_lft
                 child = parent1.generate_child!
                 child.parent_issue_id = nil
                 child.save!
                 child.reload
                 parent1.reload
                 parent2.reload
                 assert_equal [parent1.id, lft1, lft1 + 1], [parent1.root_id, parent1.lft, parent1.rgt]
                 assert_equal [parent2.id, lft2, lft2 + 1], [parent2.root_id, parent2.lft, parent2.rgt]
                 assert_equal [child.id,   lft3, lft3 + 1], [child.root_id, child.lft, child.rgt]
               end
               def test_move_a_child_to_another_issue
                 lft1 = new_issue_lft
                 parent1 = Issue.generate!
                 lft2 = new_issue_lft
                 parent2 = Issue.generate!
                 child = parent1.generate_child!
                 child.parent_issue_id = parent2.id
                 child.save!
                 child.reload
                 parent1.reload
                 parent2.reload
                 assert_equal [parent1.id, lft1,     lft1 + 1], [parent1.root_id, parent1.lft, parent1.rgt]
                 assert_equal [parent2.id, lft2,     lft2 + 3], [parent2.root_id, parent2.lft, parent2.rgt]
                 assert_equal [parent2.id, lft2 + 1, lft2 + 2], [child.root_id,   child.lft,   child.rgt]
               end
               def test_move_a_child_with_descendants_to_another_issue
                 lft1 = new_issue_lft
                 parent1 = Issue.generate!
                 lft2 = new_issue_lft
                 parent2 = Issue.generate!
                 child = parent1.generate_child!
                 grandchild = child.generate_child!
                 parent1.reload
                 parent2.reload
                 child.reload
                 grandchild.reload
                 assert_equal [parent1.id, lft1,     lft1 + 5], [parent1.root_id, parent1.lft, parent1.rgt]
                 assert_equal [parent2.id, lft2,     lft2 + 1], [parent2.root_id, parent2.lft, parent2.rgt]
                 assert_equal [parent1.id, lft1 + 1, lft1 + 4], [child.root_id, child.lft, child.rgt]
                 assert_equal [parent1.id, lft1 + 2, lft1 + 3], [grandchild.root_id, grandchild.lft, grandchild.rgt]
                 child.reload.parent_issue_id = parent2.id
                 child.save!
                 child.reload
                 grandchild.reload
                 parent1.reload
                 parent2.reload
                 assert_equal [parent1.id, lft1,     lft1 + 1], [parent1.root_id, parent1.lft, parent1.rgt]
                 assert_equal [parent2.id, lft2,     lft2 + 5], [parent2.root_id, parent2.lft, parent2.rgt]
                 assert_equal [parent2.id, lft2 + 1, lft2 + 4], [child.root_id, child.lft, child.rgt]
                 assert_equal [parent2.id, lft2 + 2, lft2 + 3], [grandchild.root_id, grandchild.lft, grandchild.rgt]
               end
               def test_move_a_child_with_descendants_to_another_project
                 lft1 = new_issue_lft
                 parent1 = Issue.generate!
                 child = parent1.generate_child!
                 grandchild = child.generate_child!
                 lft4 = new_issue_lft
                 child.reload
                 child.project = Project.find(2)
                 assert child.save
                 child.reload
                 grandchild.reload
                 parent1.reload
                 assert_equal [1, parent1.id, lft1, lft1 + 1], [parent1.project_id, parent1.root_id, parent1.lft, parent1.rgt]
                 assert_equal [2, child.id, lft4, lft4 + 3],
                              [child.project_id, child.root_id, child.lft, child.rgt]
                 assert_equal [2, child.id, lft4 + 1, lft4 + 2],
                              [grandchild.project_id, grandchild.root_id, grandchild.lft, grandchild.rgt]
               end
               def test_moving_an_issue_to_a_descendant_should_not_validate
                 parent1 = Issue.generate!
                 parent2 = Issue.generate!
                 child = parent1.generate_child!
                 grandchild = child.generate_child!
                 child.reload
                 child.parent_issue_id = grandchild.id
                 assert !child.save
                 assert_not_equal [], child.errors[:parent_issue_id]
               end
               def test_updating_a_root_issue_should_not_trigger_update_nested_set_attributes_on_parent_change
                 issue = Issue.find(Issue.generate!.id)
                 issue.parent_issue_id = ""
                 issue.expects(:update_nested_set_attributes_on_parent_change).never
                 issue.save!
               end
               def test_updating_a_child_issue_should_not_trigger_update_nested_set_attributes_on_parent_change
                 issue = Issue.find(Issue.generate!(:parent_issue_id => 1).id)
                 issue.parent_issue_id = "1"
                 issue.expects(:update_nested_set_attributes_on_parent_change).never
                 issue.save!
               end
               def test_moving_a_root_issue_should_trigger_update_nested_set_attributes_on_parent_change
                 issue = Issue.find(Issue.generate!.id)
                 issue.parent_issue_id = "1"
                 issue.expects(:update_nested_set_attributes_on_parent_change).once
                 issue.save!
               end
               def test_moving_a_child_issue_to_another_parent_should_trigger_update_nested_set_attributes_on_parent_change
                 issue = Issue.find(Issue.generate!(:parent_issue_id => 1).id)
                 issue.parent_issue_id = "2"
                 issue.expects(:update_nested_set_attributes_on_parent_change).once
                 issue.save!
               end
               def test_moving_a_child_issue_to_root_should_trigger_update_nested_set_attributes_on_parent_change
                 issue = Issue.find(Issue.generate!(:parent_issue_id => 1).id)
                 issue.parent_issue_id = ""
                 issue.expects(:update_nested_set_attributes_on_parent_change).once
                 issue.save!
               end
               def test_destroy_should_destroy_children
                 lft1 = new_issue_lft
                 issue1 = Issue.generate!
                 issue2 = Issue.generate!
                 issue3 = issue2.generate_child!
                 issue4 = issue1.generate_child!
                 issue3.init_journal(User.find(2))
                 issue3.subject = 'child with journal'
                 issue3.save!
                 assert_difference 'Issue.count', -2 do
                   assert_difference 'Journal.count', -1 do
                     assert_difference 'JournalDetail.count', -1 do
                       Issue.find(issue2.id).destroy
                     end
                   end
                 end
                 issue1.reload
                 issue4.reload
                 assert !Issue.exists?(issue2.id)
                 assert !Issue.exists?(issue3.id)
                 assert_equal [issue1.id, lft1,     lft1 + 3], [issue1.root_id, issue1.lft, issue1.rgt]
                 assert_equal [issue1.id, lft1 + 1, lft1 + 2], [issue4.root_id, issue4.lft, issue4.rgt]
               end
               def test_destroy_child_should_update_parent
                 lft1 = new_issue_lft
                 issue = Issue.generate!
                 child1 = issue.generate_child!
                 child2 = issue.generate_child!
                 issue.reload
                 assert_equal [issue.id, lft1, lft1 + 5], [issue.root_id, issue.lft, issue.rgt]
                 child2.reload.destroy
                 issue.reload
                 assert_equal [issue.id, lft1, lft1 + 3], [issue.root_id, issue.lft, issue.rgt]
               end
               def test_destroy_parent_issue_updated_during_children_destroy
                 parent = Issue.generate!
                 parent.generate_child!(:start_date => Date.today)
                 parent.generate_child!(:start_date => 2.days.from_now)
                 assert_difference 'Issue.count', -3 do
                   Issue.find(parent.id).destroy
                 end
               end
               def test_destroy_child_issue_with_children
                 root = Issue.generate!
                 child = root.generate_child!
                 leaf = child.generate_child!
                 leaf.init_journal(User.find(2))
                 leaf.subject = 'leaf with journal'
                 leaf.save!
                 assert_difference 'Issue.count', -2 do
                   assert_difference 'Journal.count', -1 do
                     assert_difference 'JournalDetail.count', -1 do
                       Issue.find(child.id).destroy
                     end
                   end
                 end
                 root = Issue.find(root.id)
                 assert root.leaf?, "Root issue is not a leaf (lft: #{root.lft}, rgt: #{root.rgt})"
               end
               def test_destroy_issue_with_grand_child
                 lft1 = new_issue_lft
                 parent = Issue.generate!
                 issue = parent.generate_child!
                 child = issue.generate_child!
                 grandchild1 = child.generate_child!
                 grandchild2 = child.generate_child!
                 assert_difference 'Issue.count', -4 do
                   Issue.find(issue.id).destroy
                   parent.reload
                   assert_equal [lft1, lft1 + 1], [parent.lft, parent.rgt]
                 end
               end
               def test_project_copy_should_copy_issue_tree
                 p = Project.create!(:name => 'Tree copy', :identifier => 'tree-copy', :tracker_ids => [1, 2])
                 i1 = Issue.generate!(:project => p, :subject => 'i1')
                 i2 = i1.generate_child!(:project => p, :subject => 'i2')
                 i3 = i1.generate_child!(:project => p, :subject => 'i3')
                 i4 = i2.generate_child!(:project => p, :subject => 'i4')
                 i5 = Issue.generate!(:project => p, :subject => 'i5')
                 c = Project.new(:name => 'Copy', :identifier => 'copy', :tracker_ids => [1, 2])
                 c.copy(p, :only => 'issues')
                 c.reload
                 assert_equal 5, c.issues.count
                 ic1, ic2, ic3, ic4, ic5 = c.issues.order('subject').to_a
                 assert ic1.root?
                 assert_equal ic1, ic2.parent
                 assert_equal ic1, ic3.parent
                 assert_equal ic2, ic4.parent
                 assert ic5.root?
               end
+              def test_rebuild_single_tree
+                i1 = Issue.generate!
+                i2 = i1.generate_child!
+                i3 = i1.generate_child!
+                Issue.update_all(:lft => 7, :rgt => 7)
+                Issue.rebuild_single_tree!(i1.id)
+                i1.reload
+                assert_equal [1, 6], [i1.lft, i1.rgt]
+                i2.reload
+                assert_equal [2, 3], [i2.lft, i2.rgt]
+                i3.reload
+                assert_equal [4, 5], [i3.lft, i3.rgt]
+                other = Issue.find(1)
+                assert_equal [7, 7], [other.lft, other.rgt]
+              end
             end

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages