closure_tree 4.5.0 → 4.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ceda99255848a84a4d3370654ecfad42dc2b7711
-  data.tar.gz: 71096e3755bb3dda8039eb49e3f301930ef7cc0d
+  metadata.gz: 74e74ddf4f763041d38464015bd608db38833721
+  data.tar.gz: 91aeb3af057e67f9b97576ef7cdd2bce155572dd
 SHA512:
-  metadata.gz: f40621b5ddc3cbc1c0de1959f2720b7f1e21e209ed7952878720cbcff981993037330a9c6f1e6f4f287e862b2af82e14b99109dde5a2330c6cb5e3256a0f7acb
-  data.tar.gz: ecd521d391c33e3afb162c25f8760c734dd58acec6c3a875d523ec7ec5dcfb50ccbbd7601f79d2fd68e2a1e592095174381508a8e45708dd91bcf1bd658cf0a7
+  metadata.gz: 298110a1706950f53e77ef1e024fdce605ba0fdd4b0753980b4287c757bcf93cc7086cd548b5ee395a47a905be07ad79b8ccc7c41d66a860cd3e45d4f39f9990
+  data.tar.gz: cd8c0c61c24388929dcefd9611090b6ba0bbc4343f284298b8ae22593d4a1830482ebe8e635362da6f790b246584029e1b3501a7d50d86e13a7e4f61b22243b4

data/.rspec

@@ -0,0 +1 @@
+--format documentation --color --order random

data/.travis.yml

@@ -2,14 +2,17 @@ language: ruby
 rvm:
   - 1.9.3
   - 2.1.2
-  - ruby-head
-#  - rbx-2
+  - rbx-2
+  - jruby-19mode
+#  - ruby-head
+#  - rbx-head
+#  - jruby-head
 
 gemfile:
   - gemfiles/activerecord_3.2.gemfile
   - gemfiles/activerecord_4.0.gemfile
   - gemfiles/activerecord_4.1.gemfile
-  - gemfiles/activerecord_edge.gemfile
+#  - gemfiles/activerecord_edge.gemfile
 
 env:
   - DB=sqlite
@@ -22,7 +25,12 @@ matrix:
   fast_finish: true
   allow_failures:
     - gemfile: gemfiles/activerecord_edge.gemfile
+    - rvm: rbx-2
+    - rvm: jruby-19mode
     - rvm: ruby-head
+    - rvm: rbx-head
+    - rvm: jruby-head
+
   exclude:
     - rvm: ruby-head
       gemfile: gemfiles/activerecord_3.2.gemfile

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+### 4.6.0
+
+ * Deterministically ordered trees are guaranteed to have a sort_order now.
+
+   **This may be a breaking change if you're expecting sort_order to be nullable.**
+
+   Many thanks to [David Schmidt](https://github.com/inetdavid) for raising and
+   working on the issue!
+
+ * Added ```append_child``` and ```prepend_child```
+ 
+ * All raw SQL is now ```strip_heredoc```'ed
+
 ### 4.5.0
 
 * Merged a bunch of great changes from [Abdelkader Boudih](https://github.com/seuros), 

data/Gemfile

@@ -1,3 +1,16 @@
 source 'https://rubygems.org'
 gem 'foreigner', :git => 'https://github.com/mceachen/foreigner.git'
+
+platforms :ruby, :rbx do
+  gem 'mysql2'
+  gem 'pg'
+  gem 'sqlite3'
+end
+
+platforms :jruby do
+  gem 'activerecord-jdbcmysql-adapter'
+  gem 'activerecord-jdbcpostgresql-adapter'
+  gem 'activerecord-jdbcsqlite3-adapter'
+end
+
 gemspec

data/README.md

@@ -26,6 +26,7 @@ closure_tree has some great features:
   * 2 SQL INSERTs on node creation
   * 3 SQL INSERT/UPDATEs on node reparenting
 * __Support for Rails 3.2, 4.0, and 4.1__
+* __Support for Ruby 1.9 and 2.1 (jRuby and Rubinius are still in development)__
 * Support for reparenting children (and all their descendants)
 * Support for [concurrency](#concurrency) (using [with_advisory_lock](https://github.com/mceachen/with_advisory_lock))
 * Support for polymorphism [STI](#sti) within the hierarchy
@@ -376,6 +377,15 @@ If your ```order``` column is an integer attribute, you'll also have these:
 * ```node1.self_and_descendants_preordered``` which will return descendants,
   [pre-ordered](http://en.wikipedia.org/wiki/Tree_traversal#Pre-order).
 
+* ```node1.append_child(node2)``` (which is an alias to ```add_child```), which will
+  1. set ```node2```'s parent to ```node1```
+  2. set ```node2```'s sort order to place node2 last in the ```children``` array
+
+* ```node1.prepend_child(node2)``` which will
+  1. set ```node2```'s parent to ```node1```
+  2. set ```node2```'s sort order to place node2 first in the ```children``` array
+     Note that all of ```node1```'s children's sort_orders will be incremented
+
 * ```node1.prepend_sibling(node2)``` which will
   1. set ```node2``` to the same parent as ```node1```,
   2. set ```node2```'s order column to 1 less than ```node1```'s value, and
@@ -388,27 +398,27 @@ If your ```order``` column is an integer attribute, you'll also have these:
 
 ```ruby
 
-root = OrderedTag.create(:name => "root")
-a = OrderedTag.create(:name => "a", :parent => root)
-b = OrderedTag.create(:name => "b")
-c = OrderedTag.create(:name => "c")
+root = OrderedTag.create(name: 'root')
+a = root.append_child(Label.new(name: 'a'))
+b = OrderedTag.create(name: 'b')
+c = OrderedTag.create(name: 'c')
 
 # We have to call 'root.reload.children' because root won't be in sync with the database otherwise:
 
 a.append_sibling(b)
-root.reload.children.collect(&:name)
+root.reload.children.pluck(:name)
 => ["a", "b"]
 
 a.prepend_sibling(b)
-root.reload.children.collect(&:name)
+root.reload.children.pluck(:name)
 => ["b", "a"]
 
 a.append_sibling(c)
-root.reload.children.collect(&:name)
+root.reload.children.pluck(:name)
 => ["b", "a", "c"]
 
 b.append_sibling(c)
-root.reload.children.collect(&:name)
+root.reload.children.pluck(:name)
 => ["b", "c", "a"]
 ```
 
@@ -437,6 +447,10 @@ database with multiple threads, and don't provide an alternative mutex.
 
 ## FAQ
 
+### Are there any how-to articles on how to use this gem?
+
+Yup! [Ilya Bodrov](https://github.com/bodrovis) wrote [Nested Comments with Rails](http://www.sitepoint.com/nested-comments-rails/).
+
 ### Does this work well with ```#default_scope```?
 
 No. Please see [issue 86](https://github.com/mceachen/closure_tree/issues/86) for details.
@@ -484,24 +498,59 @@ after do
 end
 ```
 
+## Testing with Closure Tree
+
+Closure tree comes with some RSpec2/3 matchers which you may use for your tests:
+
+```ruby
+require 'spec_helper'
+require 'closure_tree/test/matcher'
+
+describe Category do
+ # Should syntax
+ it { should be_a_closure_tree }
+ # Expect syntax
+ it { is_expected.to be_a_closure_tree }
+end
+
+describe Label do
+ # Should syntax
+ it { should be_a_closure_tree.ordered }
+ # Expect syntax
+ it { is_expected.to be_a_closure_tree.ordered }
+end
+
+describe TodoList::Item do
+ # Should syntax
+ it { should be_a_closure_tree.ordered(:priority_order) }
+ # Expect syntax
+ it { is_expected.to be_a_closure_tree.ordered(:priority_order) }
+end
+
+```
+
+
 ## Testing
 
 Closure tree is [tested under every valid combination](http://travis-ci.org/#!/mceachen/closure_tree) of
 
-* Ruby 1.9.3 , 2.0.0 and 2.1.2
-* Rubinius 2.2.6
+* Ruby 1.9.3, 2.1.2 (and sometimes head)
+* Rubinius 2.2.1+ (and sometimes head)
+* jRuby 1.9mode (and sometimes head)
 * The latest Rails 3.2, 4.0, 4.1 and master branches
-* Concurrency tests for MySQL and PostgreSQL. SQLite works in a single-threaded environment.
+* Concurrency tests for MySQL and PostgreSQL. SQLite is tested in a single-threaded environment.
 
 Assuming you're using [rbenv](https://github.com/sstephenson/rbenv), you can use ```tests.sh``` to
 run the test matrix locally.
 
 ## Change log
 
-See https://github.com/mceachen/closure_tree/blob/master/CHANGELOG.md
+See the [change log](https://github.com/mceachen/closure_tree/blob/master/CHANGELOG.md).
 
 ## Thanks to
 
+* The more than 20 engineers around the world that have contributed their time and code to this gem
+  (see the [changelog](https://github.com/mceachen/closure_tree/blob/master/CHANGELOG.md)!)
 * https://github.com/collectiveidea/awesome_nested_set
 * https://github.com/patshaughnessy/class_factory
 * JetBrains, which provides an [open-source license](http://www.jetbrains.com/ruby/buy/buy.jsp#openSource) to

data/closure_tree.gemspec

@@ -14,22 +14,21 @@ Gem::Specification.new do |gem|
 
   gem.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
   gem.test_files    = gem.files.grep(%r{^spec/})
+  gem.required_ruby_version     = '>= 1.9.3'
 
   gem.add_runtime_dependency 'activerecord', '>= 3.2.0'
   gem.add_runtime_dependency 'with_advisory_lock', '>= 0.0.9' # <- to prevent duplicate roots
 
   gem.add_development_dependency 'rake'
   gem.add_development_dependency 'yard'
-  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'rspec', '~> 2.14.0' # FIXME: migrate to rspec 3 (or, better, ditch rspec and switch to minitest)
   gem.add_development_dependency 'rspec-instafail'
   gem.add_development_dependency 'rspec-rails' # FIXME: for rspec-rails and rspec fixture support
-  gem.add_development_dependency 'mysql2'
-  gem.add_development_dependency 'pg'
-  gem.add_development_dependency 'sqlite3'
   gem.add_development_dependency 'uuidtools'
   gem.add_development_dependency 'database_cleaner'
   gem.add_development_dependency 'appraisal'
+  gem.add_development_dependency 'timecop'
 
   # gem.add_development_dependency 'ruby-prof' # <- don't need this normally.
-  # TODO: gem 'activerecord-jdbcsqlite3-adapter', :platform => :jruby
+
 end

data/gemfiles/activerecord_3.2.gemfile

@@ -6,4 +6,16 @@ gem "foreigner", :git => "https://github.com/mceachen/foreigner.git"
 gem "activerecord", "~> 3.2"
 gem "strong_parameters"
 
+platforms :ruby, :rbx do
+  gem "mysql2"
+  gem "pg"
+  gem "sqlite3"
+end
+
+platforms :jruby do
+  gem "activerecord-jdbcmysql-adapter"
+  gem "activerecord-jdbcpostgresql-adapter"
+  gem "activerecord-jdbcsqlite3-adapter"
+end
+
 gemspec :path => "../"

data/gemfiles/activerecord_4.0.gemfile

@@ -5,4 +5,16 @@ source "https://rubygems.org"
 gem "foreigner", :git => "https://github.com/mceachen/foreigner.git"
 gem "activerecord", "~> 4.0"
 
+platforms :ruby, :rbx do
+  gem "mysql2"
+  gem "pg"
+  gem "sqlite3"
+end
+
+platforms :jruby do
+  gem "activerecord-jdbcmysql-adapter"
+  gem "activerecord-jdbcpostgresql-adapter"
+  gem "activerecord-jdbcsqlite3-adapter"
+end
+
 gemspec :path => "../"

data/gemfiles/activerecord_4.1.gemfile

@@ -5,4 +5,16 @@ source "https://rubygems.org"
 gem "foreigner", :git => "https://github.com/mceachen/foreigner.git"
 gem "activerecord", "~> 4.1"
 
+platforms :ruby, :rbx do
+  gem "mysql2"
+  gem "pg"
+  gem "sqlite3"
+end
+
+platforms :jruby do
+  gem "activerecord-jdbcmysql-adapter"
+  gem "activerecord-jdbcpostgresql-adapter"
+  gem "activerecord-jdbcsqlite3-adapter"
+end
+
 gemspec :path => "../"

data/gemfiles/activerecord_edge.gemfile

@@ -6,4 +6,16 @@ gem "foreigner", :git => "https://github.com/mceachen/foreigner.git"
 gem "activerecord", :github => "rails/rails"
 gem "arel", :github => "rails/arel"
 
+platforms :ruby, :rbx do
+  gem "mysql2"
+  gem "pg"
+  gem "sqlite3"
+end
+
+platforms :jruby do
+  gem "activerecord-jdbcmysql-adapter"
+  gem "activerecord-jdbcpostgresql-adapter"
+  gem "activerecord-jdbcsqlite3-adapter"
+end
+
 gemspec :path => "../"

data/lib/closure_tree/acts_as_tree.rb

@@ -1,12 +1,4 @@
 require 'with_advisory_lock'
-require 'closure_tree/support'
-require 'closure_tree/hierarchy_maintenance'
-require 'closure_tree/model'
-require 'closure_tree/finders'
-require 'closure_tree/hash_tree'
-require 'closure_tree/digraphs'
-require 'closure_tree/deterministic_ordering'
-require 'closure_tree/numeric_deterministic_ordering'
 
 module ClosureTree
   module ActsAsTree
@@ -20,7 +12,8 @@ module ClosureTree
         :name_column,
         :order,
         :parent_column_name,
-        :with_advisory_lock
+        :with_advisory_lock,
+        :touch
       )
 
       class_attribute :_ct

data/lib/closure_tree/deterministic_ordering.rb

@@ -4,6 +4,10 @@ module ClosureTree
       read_attribute(_ct.order_column_sym)
     end
 
+    def update_order_value(order_value)
+      update_column(_ct.order_column_sym, order_value)
+    end
+
     def order_value=(new_order_value)
       write_attribute(_ct.order_column_sym, new_order_value)
     end

data/lib/closure_tree/finders.rb

@@ -34,7 +34,7 @@ module ClosureTree
     end
 
     def find_all_by_generation(generation_level)
-      s = _ct.base_class.joins(<<-SQL)
+      s = _ct.base_class.joins(<<-SQL.strip_heredoc)
         INNER JOIN (
           SELECT descendant_id
           FROM #{_ct.quoted_hierarchy_table_name}
@@ -75,7 +75,7 @@ module ClosureTree
       end
 
       def leaves
-        s = joins(<<-SQL)
+        s = joins(<<-SQL.strip_heredoc)
           INNER JOIN (
             SELECT ancestor_id
             FROM #{_ct.quoted_hierarchy_table_name}
@@ -96,7 +96,7 @@ module ClosureTree
       end
 
       def find_all_by_generation(generation_level)
-        s = joins(<<-SQL)
+        s = joins(<<-SQL.strip_heredoc)
           INNER JOIN (
             SELECT #{primary_key} as root_id
             FROM #{_ct.quoted_table_name}
@@ -130,7 +130,7 @@ module ClosureTree
         # MySQL doesn't support more than 61 joined tables (!!):
         path.first(50).reverse.each_with_index do |ea, idx|
           next_joined_table = "p#{idx}"
-          scope = scope.joins(<<-SQL)
+          scope = scope.joins(<<-SQL.strip_heredoc)
             INNER JOIN #{_ct.quoted_table_name} AS #{next_joined_table}
               ON #{next_joined_table}.#{_ct.quoted_id_column_name} =
                 #{connection.quote_table_name(last_joined_table)}.#{_ct.quoted_parent_column_name}

data/lib/closure_tree/hash_tree.rb

@@ -27,7 +27,7 @@ module ClosureTree
         # Deepest generation, within limit, for each descendant
         # NOTE: Postgres requires HAVING clauses to always contains aggregate functions (!!)
         having_clause = limit_depth ? "HAVING MAX(generations) <= #{limit_depth - 1}" : ''
-        generation_depth = <<-SQL
+        generation_depth = <<-SQL.strip_heredoc
           INNER JOIN (
             SELECT descendant_id, MAX(generations) as depth
             FROM #{_ct.quoted_hierarchy_table_name}

data/lib/closure_tree/hierarchy_maintenance.rb

@@ -15,6 +15,10 @@ module ClosureTree
       @_ct_skip_cycle_detection = true
     end
 
+    def _ct_skip_sort_order_maintenance!
+      @_ct_skip_sort_order_maintenance = true
+    end
+
     def _ct_validate
       if !@_ct_skip_cycle_detection &&
         !new_record? && # don't validate for cycles if we're a new record
@@ -32,7 +36,7 @@ module ClosureTree
 
     def _ct_after_save
       if changes[_ct.parent_column_name] || @was_new_record
-        rebuild!
+        rebuild! unless @_ct_skip_hierarchy_maintenance
       end
       if changes[_ct.parent_column_name] && !@was_new_record
         # Resetting the ancestral collections addresses
@@ -41,6 +45,7 @@ module ClosureTree
         self_and_ancestors.reload
       end
       @was_new_record = false # we aren't new anymore.
+      @_ct_skip_sort_order_maintenance = false # only skip once.
       true # don't cancel anything.
     end
 
@@ -54,12 +59,12 @@ module ClosureTree
       true # don't prevent destruction
     end
 
-    def rebuild!
+    def rebuild!(called_by_rebuild = false)
       _ct.with_advisory_lock do
         delete_hierarchy_references unless @was_new_record
         hierarchy_class.create!(:ancestor => self, :descendant => self, :generations => 0)
         unless root?
-          _ct.connection.execute <<-SQL
+          _ct.connection.execute <<-SQL.strip_heredoc
             INSERT INTO #{_ct.quoted_hierarchy_table_name}
               (ancestor_id, descendant_id, generations)
             SELECT x.ancestor_id, #{_ct.quote(_ct_id)}, x.generations + 1
@@ -67,8 +72,16 @@ module ClosureTree
             WHERE x.descendant_id = #{_ct.quote(_ct_parent_id)}
           SQL
         end
-        children.each { |c| c.rebuild! }
-        _ct_reorder_children if _ct.order_is_numeric?
+
+        if _ct.order_is_numeric? && !@_ct_skip_sort_order_maintenance
+          _ct_reorder_prior_siblings_if_parent_changed
+          # Prevent double-reordering of siblings:
+          _ct_reorder_siblings if !called_by_rebuild
+        end
+
+        children.each { |c| c.rebuild!(true) }
+
+        _ct_reorder_children if _ct.order_is_numeric? && children.present?
       end
     end
 
@@ -78,7 +91,7 @@ module ClosureTree
         # It shouldn't affect performance of postgresql.
         # See http://dev.mysql.com/doc/refman/5.0/en/subquery-errors.html
         # Also: PostgreSQL doesn't support INNER JOIN on DELETE, so we can't use that.
-        _ct.connection.execute <<-SQL
+        _ct.connection.execute <<-SQL.strip_heredoc
           DELETE FROM #{_ct.quoted_hierarchy_table_name}
           WHERE descendant_id IN (
             SELECT DISTINCT descendant_id

data/lib/closure_tree/model.rb

@@ -8,7 +8,8 @@ module ClosureTree
       belongs_to :parent,
                  class_name: _ct.model_class.to_s,
                  foreign_key: _ct.parent_column_name,
-                 inverse_of: :children
+                 inverse_of: :children,
+                 touch: _ct.options[:touch]
 
       # TODO, remove when activerecord 3.2 support is dropped
       attr_accessible :parent if _ct.use_attr_accessible?
@@ -148,14 +149,5 @@ module ClosureTree
     def _ct_quoted_id
       _ct.quoted_value(_ct_id)
     end
-
-    def _ct_update_column(column, value)
-      if respond_to?(:update_column)
-        update_column(column, value)
-      else
-        # This will run callbacks, but it's better than failing outright:
-        update_attribute(column, value)
-      end
-    end
   end
 end

data/lib/closure_tree/numeric_deterministic_ordering.rb

@@ -6,19 +6,23 @@ module ClosureTree
     extend ActiveSupport::Concern
 
     included do
-      after_destroy :_ct_reorder_after_destroy
+      after_destroy :_ct_reorder_siblings
     end
 
-    def _ct_reorder_after_destroy
-      _ct_reorder_siblings
+    def _ct_reorder_prior_siblings_if_parent_changed
+      if attribute_changed?(_ct.parent_column_name) && !@was_new_record
+        was_parent_id = attribute_was(_ct.parent_column_name)
+        _ct.reorder_with_parent_id(was_parent_id)
+      end
     end
 
-    def _ct_reorder_siblings(minimum_sort_order_value = nil, delta = 0)
-      _ct.reorder_with_parent_id(_ct_parent_id, minimum_sort_order_value, delta)
+    def _ct_reorder_siblings(minimum_sort_order_value = nil)
+      _ct.reorder_with_parent_id(_ct_parent_id, minimum_sort_order_value)
+      reload unless destroyed?
     end
 
-    def _ct_reorder_children(minimum_sort_order_value = nil, delta = 0)
-      _ct.reorder_with_parent_id(_ct_id, minimum_sort_order_value, delta)
+    def _ct_reorder_children(minimum_sort_order_value = nil)
+      _ct.reorder_with_parent_id(_ct_id, minimum_sort_order_value)
     end
 
     def self_and_descendants_preordered
@@ -46,13 +50,13 @@ module ClosureTree
 
     module ClassMethods
       def roots_and_descendants_preordered
-        h = _ct.connection.select_one(<<-SQL)
+        h = _ct.connection.select_one(<<-SQL.strip_heredoc)
           SELECT
             count(*) as total_descendants,
             max(generations) as max_depth
           FROM #{_ct.quoted_hierarchy_table_name}
         SQL
-        join_sql = <<-SQL
+        join_sql = <<-SQL.strip_heredoc
           JOIN #{_ct.quoted_hierarchy_table_name} anc_hier
             ON anc_hier.descendant_id = #{_ct.quoted_table_name}.id
           JOIN #{_ct.quoted_table_name} anc
@@ -70,6 +74,19 @@ module ClosureTree
       end
     end
 
+    def append_child(child_node)
+      add_child(child_node)
+    end
+
+    def prepend_child(child_node)
+      child_node.order_value = -1
+      child_node.parent = self
+      child_node._ct_skip_sort_order_maintenance!
+      child_node.save
+      _ct_reorder_children
+      child_node.reload
+    end
+
     def append_sibling(sibling_node)
       add_sibling(sibling_node, true)
     end
@@ -80,39 +97,39 @@ module ClosureTree
 
     def add_sibling(sibling, add_after = true)
       fail "can't add self as sibling" if self == sibling
+
+      # Make sure self isn't dirty, because we're going to call reload:
+      save
+
       _ct.with_advisory_lock do
-        if self.order_value.nil?
-          # ergh, we don't know where we stand within the siblings, so establish that first:
-          _ct_reorder_siblings
-          reload # < because self.order_value changed
-        end
         prior_sibling_parent = sibling.parent
-        if prior_sibling_parent == self.parent
-          # We have to adjust the prior siblings by moving sibling out of the way:
-          sibling._ct_update_column(_ct.parent_column_sym, nil)
-          if sibling.order_value && sibling.order_value < self.order_value
-            _ct_reorder_siblings(sibling.order_value, 0)
-            reload # < because self.order_value changed
-          end
-        end
-        _ct_move_new_sibling(sibling, add_after)
-        if prior_sibling_parent && prior_sibling_parent != self.parent
-          prior_sibling_parent._ct_reorder_children
+        reorder_from_value = if prior_sibling_parent == self.parent
+          [self.order_value, sibling.order_value].compact.min
+        else
+          self.order_value
         end
-        sibling
-      end
-    end
 
-    def _ct_move_new_sibling(sibling, add_after)
-      _ct_reorder_siblings(self.order_value + 1, 1)
-      if add_after
-        sibling.order_value = self.order_value + 1
-      else
         sibling.order_value = self.order_value
-        self.order_value += 1
-        self.save!
+        sibling.parent = self.parent
+        sibling._ct_skip_sort_order_maintenance!
+        sibling.save # may be a no-op
+
+        _ct_reorder_siblings(reorder_from_value)
+
+        # The sort order should be correct now except for self and sibling, which may need to flip:
+        sibling_is_after = self.reload.sort_order < sibling.reload.sort_order
+        if add_after != sibling_is_after
+          # We need to flip the sort orders:
+          self_so, sib_so = self.sort_order, sibling.sort_order
+          update_order_value(sib_so)
+          sibling.update_order_value(self_so)
+        end
+
+        if prior_sibling_parent != self.parent
+          prior_sibling_parent.try(:_ct_reorder_children)
+        end
+        sibling
       end
-      parent.add_child(sibling) # <- this causes sibling to be saved.
     end
   end
 end