acts_as_ordered_tree 1.3.1 → 2.0.0.beta3

data/spec/adapters/postgresql_spec.rb

@@ -0,0 +1,14 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+require 'acts_as_ordered_tree/adapters/postgresql'
+require 'adapters/shared'
+
+describe ActsAsOrderedTree::Adapters::PostgreSQL, :transactional, :if => ENV['DB'] == 'pg' do
+  it { expect(Default.ordered_tree.adapter).to be_a described_class }
+  
+  it_behaves_like 'ActsAsOrderedTree adapter', ActsAsOrderedTree::Adapters::PostgreSQL, :default
+  it_behaves_like 'ActsAsOrderedTree adapter', ActsAsOrderedTree::Adapters::PostgreSQL, :default_with_counter_cache
+  it_behaves_like 'ActsAsOrderedTree adapter', ActsAsOrderedTree::Adapters::PostgreSQL, :scoped
+end

data/spec/adapters/recursive_spec.rb

@@ -0,0 +1,12 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+require 'acts_as_ordered_tree/adapters/recursive'
+require 'adapters/shared'
+
+describe ActsAsOrderedTree::Adapters::Recursive, :transactional do
+  it_behaves_like 'ActsAsOrderedTree adapter', ActsAsOrderedTree::Adapters::Recursive, :default
+  it_behaves_like 'ActsAsOrderedTree adapter', ActsAsOrderedTree::Adapters::Recursive, :default_with_counter_cache
+  it_behaves_like 'ActsAsOrderedTree adapter', ActsAsOrderedTree::Adapters::Recursive, :scoped
+end

data/spec/adapters/shared.rb

@@ -0,0 +1,272 @@
+# coding: utf-8
+
+shared_examples 'ActsAsOrderedTree adapter' do |adapter_class, model, attrs = {}|
+  context model.to_s do
+    tree :factory => model, :attributes => attrs do
+      root {
+        child_1 {
+          grandchild_11
+          grandchild_12
+        }
+        child_2 {
+          grandchild_21
+          grandchild_22
+        }
+      }
+    end
+
+    let(:adapter) { adapter_class.new(current_tree.ordered_tree) }
+
+    shared_examples 'ActsAsOrderedTree traverse down for not persisted record' do |method|
+      context 'when new record given' do
+        let(:record) { build model, attrs.merge(:parent => root) }
+
+        subject(:relation) { adapter.send(method, record) }
+
+        it { expect(relation).to be_a ActiveRecord::Relation }
+
+        it 'returns empty relation' do
+          expect(relation.to_a).to eq []
+        end
+
+        it 'does not execute SQL queries' do
+          expect{relation.to_a}.not_to query_database
+        end
+      end
+
+      context 'when destroyed record given' do
+        before { child_1.destroy }
+
+        subject(:relation) { adapter.send(method, child_1) }
+
+        it { expect(relation).to be_a ActiveRecord::Relation }
+
+        it 'returns empty relation' do
+          expect(relation.to_a).to eq []
+        end
+
+        it 'does not execute SQL queries' do
+          expect{relation.to_a}.not_to query_database
+        end
+      end
+    end
+
+    describe '#self_and_descendants' do
+      context 'when persisted record given' do
+        subject(:relation) { adapter.self_and_descendants(root) }
+
+        it { expect(relation).to be_a ActiveRecord::Relation }
+
+        it 'returns node and its descendants ordered by position' do
+          expect(relation.to_a).to eq Array[
+                                          root,
+                                          child_1,
+                                          grandchild_11,
+                                          grandchild_12,
+                                          child_2,
+                                          grandchild_21,
+                                          grandchild_22
+                                      ]
+        end
+      end
+
+      include_examples 'ActsAsOrderedTree traverse down for not persisted record', :self_and_descendants
+    end
+
+    describe '#self_and_descendants with traversal filters' do
+      it 'applies given block to recursive term' do
+        relation = adapter.self_and_descendants(root) { |d| d.where(d.table[:id].not_eq(child_1.id)) }
+
+        expect(relation).to eq [root, child_2, grandchild_21, grandchild_22]
+      end
+
+      example 'start conditions can be changed via #start_with method' do
+        relation = adapter.self_and_descendants(root) { |x| x.start_with { |s| s.where('id != ?', root.id) } }
+
+        expect(relation).to be_empty
+      end
+    end
+
+    describe '#descendants' do
+      context 'when persisted record given' do
+        subject(:relation) { adapter.descendants(root) }
+
+        it { expect(relation).to be_a ActiveRecord::Relation }
+
+        it 'returns node and its descendants ordered by position' do
+          expect(relation.to_a).to eq Array[
+                                          child_1,
+                                          grandchild_11,
+                                          grandchild_12,
+                                          child_2,
+                                          grandchild_21,
+                                          grandchild_22
+                                      ]
+
+          expect(adapter.descendants(child_1)).to eq [grandchild_11, grandchild_12]
+        end
+
+        it 'updates descendants' do
+          relation.update_all(:name => 'x')
+          expect(relation.all? { |r| r.reload.name == 'x' }).to be true
+
+          adapter.descendants(child_1).update_all(:name => 'y')
+          adapter.descendants(child_2).update_all(:name => 'z')
+
+          expect(relation.map { |r| r.reload.name }).to eq ['x', 'y', 'y', 'x', 'z', 'z']
+        end
+      end
+
+      include_examples 'ActsAsOrderedTree traverse down for not persisted record', :descendants
+    end
+
+    describe '#descendants with traversal filters' do
+      it 'applies given block to recursive term' do
+        relation = adapter.descendants(root) { |d| d.where(d.table[:id].not_eq(child_1.id)) }
+
+        expect(relation).to eq [child_2, grandchild_21, grandchild_22]
+      end
+
+      example 'start conditions can be changed via #start_with method' do
+        relation = adapter.descendants(root) { |x| x.start_with { |s| s.where('id != ?', root.id) } }
+
+        expect(relation).to be_empty
+      end
+
+      example 'siblings order can be changed via #order_siblings method' do
+        relation = adapter.descendants(root) { |x| x.order_siblings('position desc') }
+
+        expect(relation).to eq Array[
+          child_2,
+          grandchild_22,
+          grandchild_21,
+          child_1,
+          grandchild_12,
+          grandchild_11
+                               ]
+      end
+    end
+
+    describe '#self_and_ancestors' do
+      context 'when persisted record given' do
+        context 'when level > 0' do
+          subject(:relation) { adapter.self_and_ancestors(grandchild_11) }
+
+          it { expect(relation).to be_a ActiveRecord::Relation }
+
+          it 'returns all node ancestors and itself starting from root' do
+            expect(relation.to_a).to eq Array[root, child_1, grandchild_11]
+          end
+        end
+
+        context 'when level = 0' do
+          subject(:relation) { adapter.self_and_ancestors(root) }
+
+          it { expect(relation).to be_a ActiveRecord::Relation }
+
+          it { expect(relation.to_a).to eq [root] }
+
+          it 'does not query database' do
+            expect{relation.to_a}.not_to query_database
+          end
+        end
+      end
+
+      context 'when new record given' do
+        let(:record_grandparent) { build model, attrs.merge(:parent => grandchild_11) }
+        let(:record_parent) { build model, attrs.merge(:parent => record_grandparent) }
+        let(:record) { build model, attrs.merge(:parent => record_parent) }
+
+        subject(:relation) { adapter.self_and_ancestors(record) }
+
+        it { expect(relation).to be_a ActiveRecord::Relation }
+
+        it 'returns all node ancestors and itself starting from root' do
+          expect(relation.to_a).to eq Array[root, child_1, grandchild_11, record_grandparent, record_parent, record]
+        end
+      end
+
+      context 'when destroyed record given' do
+        before { grandchild_11.destroy }
+
+        subject(:relation) { adapter.self_and_ancestors(grandchild_11) }
+
+        it { expect(relation).to be_a ActiveRecord::Relation }
+
+        it 'returns all node ancestors and itself starting from root' do
+          expect(relation.to_a).to eq Array[root, child_1, grandchild_11]
+        end
+      end
+    end
+
+    describe '#self_and_ancestors with traversal filters' do
+      it 'applies given block to recursive term' do
+        relation = adapter.self_and_ancestors(grandchild_11) { |a| a.where(a.table[:id].not_eq(root.id)) }
+
+        expect(relation).to eq [child_1, grandchild_11]
+      end
+
+      example 'start conditions can be changed via #start_with method' do
+        relation = adapter.self_and_ancestors(grandchild_11) { |x| x.start_with { |s| s.where('id != ?', grandchild_11.id) } }
+
+        expect(relation).to be_empty
+      end
+    end
+
+    describe '#ancestors' do
+      context 'when persisted record given' do
+        context 'when level > 0' do
+          subject(:relation) { adapter.ancestors(grandchild_11) }
+
+          it { expect(relation).to be_a ActiveRecord::Relation }
+
+          it 'returns all node ancestors and itself starting from root' do
+            expect(relation.to_a).to eq Array[root, child_1]
+          end
+        end
+
+        context 'when level = 0' do
+          subject(:relation) { adapter.ancestors(root) }
+
+          it { expect(relation).to be_a ActiveRecord::Relation }
+
+          it { expect(relation.to_a).to eq [] }
+
+          it 'does not query database' do
+            expect{relation.to_a}.not_to query_database
+          end
+        end
+      end
+
+      context 'when new record given' do
+        let(:record_grandparent) { build model, attrs.merge(:parent => grandchild_11) }
+        let(:record_parent) { build model, attrs.merge(:parent => record_grandparent) }
+        let(:record) { build model, attrs.merge(:parent => record_parent) }
+
+        subject(:relation) { adapter.ancestors(record) }
+
+        it { expect(relation).to be_a ActiveRecord::Relation }
+
+        it 'returns all node ancestors and itself starting from root' do
+          expect(relation.to_a).to eq Array[root, child_1, grandchild_11, record_grandparent, record_parent]
+        end
+      end
+    end
+
+    describe '#ancestors with traversal filters' do
+      it 'applies given block to recursive term' do
+        relation = adapter.ancestors(grandchild_11) { |a| a.where(a.table[:id].not_eq(root.id)) }
+        expect(relation).to eq [child_1]
+
+        relation = adapter.ancestors(grandchild_11) { |a| a.where(a.table[:id].not_eq(child_1.id)) }
+        expect(relation).to be_empty
+      end
+
+      example 'start conditions can be changed via #start_with method' do
+        relation = adapter.ancestors(grandchild_11) { |x| x.start_with { |s| s.where('id != ?', grandchild_11.id) } }
+
+        expect(relation).to be_empty
+      end
+    end
+  end
+end

data/spec/callbacks_spec.rb

@@ -0,0 +1,177 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+describe ActsAsOrderedTree, 'before/after add/remove callbacks', :transactional do
+  class Class1 < Default
+    cattr_accessor :triggered_callbacks
+
+    def self.triggered?(kind, *args)
+      if args.any?
+        triggered_callbacks.include?([kind, *args])
+      else
+        triggered_callbacks.any? { |c| c.first == kind }
+      end
+    end
+
+    acts_as_ordered_tree :before_add => :before_add,
+                         :after_add => :after_add,
+                         :before_remove => :before_remove,
+                         :after_remove => :after_remove
+
+    def run_callback(kind, *args)
+      self.class.triggered_callbacks ||= []
+      self.class.triggered_callbacks << [kind, self, *args]
+      yield if block_given?
+    end
+
+    CALLBACKS = [:before, :after, :around].product([:add, :remove, :move, :reorder]).map { |a, b| "#{a}_#{b}".to_sym }
+
+    CALLBACKS.each do |callback|
+      define_method(callback) { |*args, &block| run_callback(callback, *args, &block) }
+      send(callback, callback) if respond_to?(callback)
+    end
+  end
+
+  matcher :trigger_callback do |*callbacks, &block|
+    supports_block_expectations
+
+    match_for_should do |proc|
+      @with ||= nil
+      Class1.triggered_callbacks = []
+      proc.call
+      callbacks.all? { |callback| Class1.triggered?(callback, *@with) }
+    end
+
+    match_for_should_not do |proc|
+      @with ||= nil
+      Class1.triggered_callbacks = []
+      proc.call
+      callbacks.none? { |callback| Class1.triggered?(callback, *@with) }
+    end
+
+    chain :with do |*args, &blk|
+      @with = args
+      @block = blk
+    end
+
+    description do
+      description = "trigger callbacks #{callbacks.map(&:inspect).join(', ')}"
+      description << " with arguments #{@with.inspect}" if @with
+      description
+    end
+
+    failure_message_for_should do
+      "expected that block would #{description}"
+    end
+
+    failure_message_for_should_not do
+      desc = "expected that block would not #{description}, but following callbacks were triggered:"
+      Class1.triggered_callbacks.each do |kind, *args|
+        desc << "\n * #{kind.inspect} #{args.inspect}"
+      end
+      desc
+    end
+  end
+  alias_method :trigger_callbacks, :trigger_callback
+
+  # root
+  #   child 1
+  #     child 2
+  #     child 3
+  #   child 4
+  #     child 5
+  let(:root) { Class1.create :name => 'root' }
+  let!(:child1) { Class1.create :name => 'child1', :parent => root }
+  let!(:child2) { Class1.create :name => 'child2', :parent => child1 }
+  let!(:child3) { Class1.create :name => 'child3', :parent => child1 }
+  let!(:child4) { Class1.create :name => 'child4', :parent => root }
+  let!(:child5) { Class1.create :name => 'child5', :parent => child4 }
+
+  it 'does not trigger any callbacks when tree attributes were not changed' do
+    expect {
+      child2.update_attributes :name => 'x'
+    }.not_to trigger_callbacks(*Class1::CALLBACKS)
+  end
+
+  it 'does not trigger any callbacks except :before_remove and :after_remove when node is destroyed' do
+    expect {
+      child2.destroy
+    }.not_to trigger_callbacks(*Class1::CALLBACKS - [:before_remove, :after_remove])
+  end
+
+  describe '*_add callbacks' do
+    let(:new_record) { Class1.new :name => 'child6' }
+
+    it 'fires *_add callbacks when new children added to node' do
+      expect {
+        child1.children << new_record
+      }.to trigger_callbacks(:before_add, :after_add).with(child1, new_record)
+    end
+
+    it 'fires *_add callbacks when node is moved from another parent' do
+      expect {
+        child2.update_attributes!(:parent => child4)
+      }.to trigger_callbacks(:before_add, :after_add).with(child4, child2)
+    end
+  end
+
+  describe '*_remove callbacks' do
+    it 'fires *_remove callbacks when node is moved from another parent' do
+      expect {
+        child2.update_attributes!(:parent => child4)
+      }.to trigger_callbacks(:before_remove, :after_remove).with(child1, child2)
+    end
+
+    it 'fires *_remove callbacks when node is destroyed' do
+      expect {
+        child2.destroy
+      }.to trigger_callbacks(:before_remove, :after_remove).with(child1, child2)
+    end
+  end
+
+  describe '*_move callbacks' do
+    it 'fires *_move callbacks when node is moved to another parent' do
+      expect {
+        child2.update_attributes!(:parent => child4)
+      }.to trigger_callbacks(:before_move, :around_move, :after_move).with(child2)
+    end
+
+    it 'does not trigger *_move callbacks when node is not moved to another parent' do
+      expect {
+        child2.move_lower
+      }.not_to trigger_callbacks(:before_move, :around_move, :after_move)
+
+      expect {
+        root.move_to_root
+      }.not_to trigger_callbacks(:before_move, :around_move, :after_move)
+    end
+  end
+
+  describe '*_reorder callbacks' do
+    it 'fires *_reorder callbacks when node position is changed but parent not' do
+      expect {
+        child2.position += 1
+        child2.save
+      }.to trigger_callbacks(:before_reorder, :around_reorder, :after_reorder).with(child2)
+    end
+
+    it 'does not fire *_reorder callbacks when node is moved to another parent' do
+      expect {
+        child2.move_to_root
+      }.not_to trigger_callbacks(:before_reorder, :around_reorder, :after_reorder)
+    end
+  end
+
+  describe 'Callbacks context' do
+    specify 'new parent_id should be available in before_move' do
+      expect(child2).to receive(:before_move) { expect(child2.parent_id).to eq child4.id }
+      child2.update_attributes! :parent => child4
+    end
+
+    specify 'new position should be available in before_reorder' do
+      expect(child2).to receive(:before_reorder) { expect(child2.position).to eq 2 }
+      child2.move_lower
+    end
+  end
+end