acts_as_ordered_tree 0.0.7

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in acts_as_ordered_tree.gemspec
+gemspec

data/README.md

@@ -0,0 +1,73 @@
+# Acts As Ordered Tree
+WARNING! THIS GEM IS NOT COMPATIBLE WITH <a href="http://ordered-tree.rubyforge.org">ordered_tree gem</a>.
+
+Specify this `acts_as` extension if you want to model an ordered tree structure by providing a parent association, a children
+association and a sort column. For proper use you should have a foreign key column, which by default is called `parent_id`, and
+a sort column, which by default is called `position`.
+
+## Requirements
+Gem depends on `active_record >= 3`.
+
+## Installation
+Install it via rubygems:
+
+```bash
+gem install acts_as_ordered_tree
+```
+
+Gem depends on `acts_as_tree` and `acts_as_list` gems.
+
+Setup your model:
+
+```ruby
+class Node < ActiveRecord::Base
+  acts_as_ordered_tree
+
+  # gem introduces new ActiveRecord callbacks:
+  # *_reorder - fires when position (but not parent node) is changed
+  # *_move - fires when parent node is changed
+  before_reorder :do_smth
+  before_move :do_smth_else
+end
+```
+
+## Example
+```ruby
+# root
+#  \_ child1
+#       \_ subchild1
+#       \_ subchild2
+
+
+root = Node.create(:name => "root")
+child1 = root.children.create(:name => "child1")
+subchild1 = child1.children.create("name" => "subchild1")
+subchild2 = child1.children.create("name" => "subchild2")
+
+Node.roots # => [root]
+
+root.root? # => true
+root.parent # => nil
+root.ancestors # => []
+root.descendants # => [child1, subchild1, subchild2]
+
+child1.parent # => root
+child1.ancestors # => [root]
+child1.children # => [subchild1, subchild2]
+child1.descendants # => [subchild1, subchild2]
+child1.root? # => false
+child1.leaf? # => false
+
+subchild1.ancestors # => [child1, root]
+subchild1.root # => [root]
+subchild1.leaf? # => true
+subchild1.first? # => true
+subchild1.last? # => false
+subchild2.last? # => true
+
+subchild1.move_to_above_of(child1)
+subchild1.move_to_bottom_of(child1)
+subchild1.move_to_child_of(root)
+subchild1.move_lower
+subchild1.move_higher
+```

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/acts_as_ordered_tree.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "acts_as_ordered_tree/version"
+
+Gem::Specification.new do |s|
+  s.name        = "acts_as_ordered_tree"
+  s.version     = ActsAsOrderedTree::VERSION
+  s.authors     = ["Alexei Mikhailov"]
+  s.email       = ["amikhailov83@gmail.com"]
+  s.homepage    = "https://github.com/take-five/acts_as_ordered_tree"
+  s.summary     = %q{ActiveRecord extension for sorted adjacency lists support}
+
+  s.rubyforge_project = "acts_as_ordered_tree"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency "activesupport", "~> 3"
+  s.add_dependency "activerecord", "~> 3"
+  s.add_dependency "acts_as_tree", "~> 0.1"
+  s.add_dependency "acts_as_list", "~> 0.1"
+
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "simplecov"
+  s.add_development_dependency "sqlite3"
+  s.add_development_dependency "bundler"
+end

data/init.rb

@@ -0,0 +1,2 @@
+require "rubygems"
+require "bundler/setup"

data/lib/acts_as_ordered_tree/iterator.rb

@@ -0,0 +1,36 @@
+require "enumerator"
+
+module ActsAsOrderedTree
+  # Enhanced enumerator
+  #
+  # Allows to use array specific methods like +empty?+, +reverse?+ and so on
+  class Iterator < Enumerator
+    class NullArgument < ArgumentError; end
+    NA = NullArgument.new
+
+    def initialize(*args, &block)
+      @enumerator = Enumerator.new(*args, &block)
+
+      super() do |yielder|
+        @enumerator.each do |e|
+          yielder << e
+        end
+      end
+    end
+
+    # Delegate everything to underlying array
+    def method_missing(method_id, *args, &block)
+      if method_id !~ /^(__|instance_eval|class|object_id)/
+        to_ary!.__send__(method_id, *args, &block)
+      else
+        super
+      end
+    end
+
+    private
+    def to_ary!
+      @enumerator = @enumerator.to_a unless @enumerator.is_a?(Array)
+      @enumerator
+    end
+  end
+end

data/lib/acts_as_ordered_tree/list.rb

@@ -0,0 +1,100 @@
+require "active_support/concern"
+require "active_support/core_ext/object/with_options"
+
+module ActsAsOrderedTree
+  module List
+    extend ActiveSupport::Concern
+
+    included do
+      include PatchedMethods
+      scope :ordered, order(position_column)
+
+      with_options :if => :parent_changed? do |opts|
+        opts.before_update :remove_from_old_list
+        opts.before_update :add_to_list_bottom
+      end
+
+      define_model_callbacks :reorder
+      around_update :__around_reorder, :if => :position_changed?,
+                                       :unless => :parent_changed?
+    end
+
+    # Returns true if record has changes in +parent_id+
+    def position_changed?
+      changes.has_key?(position_column.to_s)
+    end
+
+    private
+    # Turn off reorder callbacks temporary
+    def skip_reorder_callbacks(skip = true) #:nodoc:
+      @skip_reorder_callbacks = skip
+      result = yield
+      @skip_reorder_callbacks = false
+
+      result
+    end
+
+    def __around_reorder #:nodoc:
+      if @skip_reorder_callbacks
+        yield
+      else
+        run_callbacks(:reorder) { yield }
+      end
+    end
+
+    # It should invoke callbacks, so we patch +acts_as_list+ methods
+    module PatchedMethods #:nodoc:all
+      private
+      def remove_from_old_list
+        unchanged = self.class.find(id)
+        unchanged.send(:decrement_positions_on_lower_items)
+
+        nil
+      end
+
+      # This has the effect of moving all the higher items up one.
+      def decrement_positions_on_higher_items(position)
+        higher_than(position).each do |node|
+          node.decrement!(position_column)
+        end
+      end
+
+      # This has the effect of moving all the lower items up one.
+      def decrement_positions_on_lower_items
+        return unless in_list?
+        lower_than(position).each do |node|
+          node.decrement!(position_column)
+        end
+      end
+
+      # This has the effect of moving all the higher items down one.
+      def increment_positions_on_higher_items
+        return unless in_list?
+
+        higher_than(self[position_column]).each do |node|
+          node.increment!(position_column)
+        end
+      end
+
+      def increment_positions_on_all_items
+        self_and_siblings.each do |sib|
+          sib.increment!(position_column)
+        end
+      end
+
+      def increment_positions_on_lower_items(position)
+        lower_than(position).each do |node|
+          node.increment!(position_column)
+        end
+      end
+
+      def lower_than(position)
+        acts_as_list_class.where(scope_condition).where("#{position_column} >= ?", position.to_i)
+      end
+
+      def higher_than(position)
+        acts_as_list_class.where(scope_condition).where("#{position_column} < ?", position.to_i)
+      end
+    end
+  end # module List
+end # module ActsAsOrderedTree

data/lib/acts_as_ordered_tree/tree.rb

@@ -0,0 +1,156 @@
+require "active_support/concern"
+
+module ActsAsOrderedTree
+  module Tree
+    extend ActiveSupport::Concern
+
+    included do
+      # remove +acts_as_tree+ version of +roots+ method
+      class << self
+        remove_method :roots
+
+        # Retrieve first root node
+        #
+        # Replacement for native +ActsAsTree.root+ method
+        def root
+          roots.first
+        end
+      end
+
+      scope :roots, where(parent_column => nil).order(quoted_position_column)
+
+      validate :validate_incest
+
+      define_model_callbacks :move
+      around_update :__around_move, :if => :parent_changed?
+    end
+
+    # == Instance methods
+
+    # returns a Enumerator of ancestors, starting from parent until root
+    def ancestors
+      Iterator.new do |yielder|
+        node = self
+        yielder << node while node = node.parent
+      end
+    end
+
+    # returns a Enumerator of ancestors, including self
+    def self_and_ancestors
+      Iterator.new do |y|
+        y << self
+        ancestors.each { |a| y << a }
+      end
+    end
+
+    # returns a Enumerator of node's descendants, traversing depth first
+    #
+    # == Example
+    # The tree:
+    #   # * root
+    #   #   * child_1
+    #   #     * grandchild_1_1
+    #   #     * grandchild_1_2
+    #   #   * child_2
+    #   #     * grandchild_2_1
+    #
+    #   root.descendants # => [root,
+    #                    #     child_1, grandchild_1_1, grandchild_1_2,
+    #                    #     child_2, grandchild_2_1]
+    def descendants
+      Iterator.new do |yielder|
+        children.each do |child|
+          yielder << child
+
+          child.descendants.each do |grandchild|
+            yielder << grandchild
+          end
+        end
+      end
+    end # def descendants
+
+    def self_and_descendants
+      Iterator.new do |y|
+        y << self
+        descendants.each { |x| y << x }
+      end
+    end
+
+    # Returns depth of current node
+    def depth
+      ancestors.count
+    end
+    alias level depth
+
+    # Return +true+ if +self+ is root node
+    def root?
+      self[parent_column].nil?
+    end
+
+    # Return +true+ if +self+ is leaf node
+    def leaf?
+      children.empty?
+    end
+
+    # Returns true if record has changes in +parent_id+
+    def parent_changed?
+      changes.has_key?(parent_column.to_s)
+    end
+
+    # Move node to other parent, make it last child of new parent
+    def move_to_child_of(another_parent)
+      transaction do
+        self.parent = another_parent
+
+        p_changed = parent_changed?
+        save if p_changed
+
+        skip_reorder_callbacks(p_changed) { move_to_bottom }
+
+        parent.children.reload
+      end
+    end
+
+    # Move node to position of +another_node+, shift down lower items
+    def move_to_above_of(another_node)
+      p_changed = parent != another_node.parent
+
+      transaction do
+        move_to_child_of(another_node.parent)
+        
+        skip_reorder_callbacks(p_changed) do
+          insert_at(another_node[position_column])
+        end
+
+        another_node.parent.children.reload if another_node.parent.present?
+        another_node.reload
+      end
+    end
+
+    # Move node to the next of +another_node+, shift down lower items
+    def move_to_bottom_of(another_node)
+      p_changed = parent != another_node.parent
+
+      transaction do
+        move_to_child_of(another_node.parent)
+
+        skip_reorder_callbacks(p_changed) do
+          insert_at(another_node[position_column] + 1)
+        end
+
+        another_node.parent.children.reload if another_node.parent.present?
+        another_node.reload
+      end
+    end
+
+    protected
+    def validate_incest #:nodoc:
+      errors.add(:parent, :linked_to_self) if parent == self
+      errors.add(:parent, :linked_to_descendant) if descendants.include?(parent)
+    end
+
+    def __around_move #:nodoc:
+      run_callbacks(:move) { yield }
+    end
+  end # module Tree
+end # module ActsAsOrderedTree

data/lib/acts_as_ordered_tree/version.rb

@@ -0,0 +1,3 @@
+module ActsAsOrderedTree
+  VERSION = "0.0.7"
+end

data/lib/acts_as_ordered_tree.rb

@@ -0,0 +1,52 @@
+require "enumerator"
+
+require "active_record"
+require "acts_as_list"
+require "acts_as_tree"
+
+require "acts_as_ordered_tree/version"
+require "acts_as_ordered_tree/iterator"
+require "acts_as_ordered_tree/tree"
+require "acts_as_ordered_tree/list"
+
+module ActsAsOrderedTree
+  def acts_as_ordered_tree(options = {})
+    configuration = configure_ordered_tree(options)
+
+    acts_as_tree :foreign_key => parent_column,
+                 :order => position_column,
+                 :counter_cache => configuration[:counter_cache]
+
+    acts_as_list :column => position_column,
+                 :scope => parent_column
+
+    # acts_as_tree creates ugly associations
+    # patch them
+    children = reflect_on_association :children
+    children.options[:order] = quoted_position_column
+
+    include ActsAsOrderedTree::Tree
+    include ActsAsOrderedTree::List
+  end # def acts_as_ordered_tree
+
+  private
+  # Add ordered_tree configuration readers
+  def configure_ordered_tree(options = {}) #:nodoc:
+    configuration = { :foreign_key  => :parent_id ,
+                      :order        => :position  }
+    configuration.update(options) if options.is_a?(Hash)
+
+    class_attribute :parent_column, :position_column
+
+    self.parent_column   = configuration[:foreign_key].to_sym
+    self.position_column = configuration[:order].to_sym
+
+    configuration
+  end # def configure_ordered_tree
+
+  def quoted_position_column #:nodoc:
+    [quoted_table_name, connection.quote_column_name(position_column)].join('.')
+  end # def quoted_position_column
+end # module ActsAsOrderedTree
+
+ActiveRecord::Base.extend(ActsAsOrderedTree)

data/spec/acts_as_ordered_tree_spec.rb

@@ -0,0 +1,314 @@
+require File.expand_path('../test_helper', __FILE__)
+
+describe ActsAsOrderedTree do
+  before :all do
+    root   = Node.create(:name => "Root")
+    child1 = Node.create(:parent_id => root.id, :name => "Child 1")
+    child2 = Node.create(:parent_id => root.id, :name => "Child 2")
+
+    Node.create(:parent_id => child1.id, :name => "Subchild 1")
+    Node.create(:parent_id => child1.id, :name => "Subchild 2")
+    Node.create(:parent_id => child2.id, :name => "Subchild 3")
+  end
+
+  let(:root) { Node.where(:parent_id => nil).first }
+  let(:branch) { Node.where(:parent_id => root.id).first }
+  let(:second_branch) { Node.where(:parent_id => root.id).last }
+  let(:leaf) { Node.where(:parent_id => branch.id).first }
+  let(:last) { Node.last }
+  let(:blank) { Node.new(:parent_id => branch.id) }
+
+  describe "class" do
+    it "should be properly configured" do
+      Node.position_column.should eq(:position)
+      Node.parent_column.should eq(:parent_id)
+    end
+
+    it "should have roots" do
+      Node.roots.count.should eq(1)
+      Node.roots.first.should eq(root)
+      Node.root.should eq(root)
+    end
+  end
+
+  describe "tree" do
+    it "should have roots" do
+      root.root.should eq(root)
+      branch.root.should eq(root)
+      leaf.root.should eq(root)
+    end
+
+    it "should have children" do
+      root.children.count.should eq(2)
+      branch.children.count.should eq(2)
+      leaf.children.count.should eq(0)
+    end
+
+    it "should have parents" do
+      root.parent.should be(nil)
+      branch.parent.should eq(root)
+      leaf.parent.should eq(branch)
+    end
+
+    it "should return true if root" do
+      root.root?.should be(true)
+      branch.root?.should be(false)
+      leaf.root?.should be(false)
+    end
+
+    it "should return true if leaf" do
+      root.leaf?.should be(false)
+      branch.leaf?.should be(false)
+      leaf.leaf?.should be(true)
+    end
+
+    it "should tell about node's depth" do
+      root.depth.should eq(0)
+      branch.depth.should eq(1)
+      leaf.depth.should eq(2)
+    end
+
+    it "should iterate over ancestors" do
+      leaf.self_and_ancestors.should have(3).items
+      leaf.ancestors.should have(2).items
+      branch.ancestors.should have(1).items
+      root.ancestors.should have(0).items
+    end
+
+    it "should iterate over descendants" do
+      root.self_and_descendants.should have(6).items
+
+      root.descendants.should have(5).items
+      root.descendants.first.should eq(branch)
+      root.descendants.last.should eq(last)
+
+      branch.descendants.should have(2).items
+      branch.descendants.first.should eq(leaf)
+
+      leaf.descendants.should have(0).items
+    end
+
+    it "should have siblings" do
+      branch.self_and_siblings.should have(2).items
+      branch.self_and_siblings.should include(branch)
+
+      branch.siblings.should have(1).item
+      branch.siblings.should_not include(branch)
+    end
+  end
+
+  describe "list" do
+    it "should be ordered" do
+      root.position.should eq(1)
+      root.children.first.position.should eq(1)
+      root.children.last.position.should eq(2)
+    end
+
+    it "should be sortable through scope" do
+      Node.where(:parent_id => root.id).ordered.first.should eq(branch)
+    end
+  end
+
+  describe "mutations" do
+    around(:each) do |example|
+      Node.transaction do
+        example.run
+
+        raise ActiveRecord::Rollback
+      end
+    end
+
+    it "should be placed to the bottom of the list" do
+      blank.save
+      branch.children.last.should eq(blank)
+    end
+
+    it "should be placed to the middle of the list" do
+      blank.position = 2
+      blank.save
+
+      blank.position.should eq(2)
+      blank.siblings.should have(2).items
+      blank.siblings.last.position.should eq(3)
+    end
+
+    it "should be movable inside parent" do
+      last_child = branch.children.last
+
+      blank.save
+      blank.move_higher
+
+      blank.position.should eq(2)
+      last_child.reload.position.should eq(3)
+
+      blank.move_lower
+      blank.position.should eq(3)
+    end
+
+    it "should be movable to bottom of its parent" do
+      first_child = branch.children.first
+
+      first_child.move_to_bottom
+      first_child.position.should eq(2)
+      first_child.reload.position.should eq(2)
+    end
+
+    it "should be movable to top of its parent" do
+      first_child = branch.children.first
+      last_child = branch.children.last
+
+      last_child.move_to_top
+
+      last_child.position.should eq(1)
+      last_child.reload.position.should eq(1)
+
+      first_child.reload.position.should eq(2)
+    end
+
+    it "should shift up lower items when parent is changed" do
+      first_child = branch.children.first
+      last_child = branch.children.last
+      
+      # move to other parent
+      first_child.parent = second_branch
+      first_child.should be_parent_changed
+
+      first_child.save
+
+      # old sibling should shift up
+      last_child.reload.position.should eq(1)
+    end
+
+    it "should save its previous position when parent is changed" do
+      first_child = branch.children.first
+
+      first_child.parent = second_branch
+      first_child.save
+
+      first_child.position.should eq(1)
+      last.position.should eq(2)
+    end
+
+    it "should be movable to last position of new parent" do
+      first_child = branch.children.first
+
+      first_child.move_to_child_of(second_branch)
+      first_child.parent.should eq(second_branch)
+      first_child.should be_last
+    end
+
+    it "should be movable to above of some node" do
+      first_child = branch.children.first
+      above_of    = second_branch.children.first
+
+      first_child.move_to_above_of(above_of)
+      first_child.parent.should eq(second_branch)
+      
+      first_child.position.should eq(1)
+      above_of.position.should eq(2)
+    end
+
+    it "should be movable to bottom of some node" do
+      second = second_branch
+
+      first_child = branch.children.first
+
+      first_child.move_to_bottom_of(branch)
+      first_child.parent.should eq(branch.parent)
+
+      first_child.position.should eq(2)
+      second.reload.position.should eq(3)
+    end
+
+    it "should shift up lower items on destroy" do
+      branch.children.first.destroy
+
+      branch.children.should have(1).items
+      branch.children.first.position.should eq(1)
+    end
+
+    describe "callbacks" do
+      it "should fire *_reorder callbacks when position (but not parent) changes" do
+        examples_count = 6
+
+        second_branch.should_receive(:on_before_reorder).exactly(examples_count)
+        second_branch.should_receive(:on_around_reorder).exactly(examples_count)
+        second_branch.should_receive(:on_after_reorder).exactly(examples_count)
+
+        second_branch.move_higher
+        second_branch.move_lower
+        second_branch.move_to_top
+        second_branch.move_to_bottom
+        second_branch.decrement_position
+        second_branch.increment_position
+      end
+
+      it "should not fire *_reorder callbacks when parent_changes" do
+        leaf.should_not_receive(:on_before_reorder)
+        leaf.should_not_receive(:on_around_reorder)
+        leaf.should_not_receive(:on_after_reorder)
+
+        p1 = leaf.parent
+        p2 = second_branch
+
+        leaf.move_to_child_of(p2)
+        leaf.move_to_above_of(p1.children.first)
+        leaf.move_to_child_of(p2)
+        leaf.move_to_bottom_of(p1.children.first)
+      end
+
+      it "should not fire *_reorder callbacks when position is not changed" do
+        leaf.should_not_receive(:on_before_reorder)
+        leaf.should_not_receive(:on_around_reorder)
+        leaf.should_not_receive(:on_after_reorder)
+
+        last.should_not_receive(:on_before_reorder)
+        last.should_not_receive(:on_around_reorder)
+        last.should_not_receive(:on_after_reorder)
+
+        leaf.move_higher
+        last.move_lower
+
+        leaf.save
+        last.save
+      end
+
+      it "should fire *_move callbacks when parent is changed" do
+        examples_count = 3
+        leaf.should_receive(:on_before_move).exactly(examples_count)
+        leaf.should_receive(:on_after_move).exactly(examples_count)
+        leaf.should_receive(:on_around_move).exactly(examples_count)
+
+        p1 = leaf.parent
+        p2 = second_branch
+
+        leaf.move_to_child_of(p2)
+        leaf.move_to_above_of(p1)
+        leaf.move_to_bottom_of(p1.children.first)
+      end
+
+      it "should not fire *_move callbacks when parent is not changed" do
+        leaf.should_not_receive(:on_before_move)
+        leaf.should_not_receive(:on_after_move)
+        leaf.should_not_receive(:on_around_move)
+
+        leaf.move_to_child_of(leaf.parent)
+        leaf.move_to_above_of(leaf.siblings.first)
+        leaf.move_to_bottom_of(leaf.siblings.first)
+        leaf.reload.save
+      end
+    end
+  end
+
+  describe "validations" do
+    it "should not allow to link parent to itself" do
+      branch.parent = branch
+      branch.should_not be_valid
+    end
+
+    it "should not allow to link to one of its descendants" do
+      branch.parent = leaf
+      branch.should_not be_valid
+    end
+  end
+end

data/spec/database.yml

@@ -0,0 +1,3 @@
+database:
+  adapter: sqlite3
+  database: ":memory:"

data/spec/iterator_spec.rb

@@ -0,0 +1,73 @@
+require File.expand_path('../test_helper', __FILE__)
+
+describe ActsAsOrderedTree::Iterator do
+  let(:iterator) do
+    ActsAsOrderedTree::Iterator.new([1, 2, 3, 4, 2, 3])
+  end
+
+  let(:blanks) { ActsAsOrderedTree::Iterator.new([1, nil, 3]) }
+
+  it "should have random access" do
+    iterator[1].should eq(2)
+    iterator.at(1).should eq(2)
+    iterator.fetch(1).should eq(2)
+    iterator.values_at(1, 2).should eq([2, 3])
+    iterator.last.should eq(3)
+    iterator.slice(1, 2).should have(2).items
+    iterator.sample.should be_a(Fixnum)
+  end
+
+  it "should support operators" do
+    (iterator + [5]).should have(7).items
+    (iterator - [4]).should have(5).items
+    (iterator * 2).should have(12).items
+    (iterator & [4]).should have(1).items
+    (iterator | [4]).should have(4).items
+    iterator.concat([5]).should have(7).items
+  end
+
+  it "should find left index" do
+    iterator.find_index(2).should eq(1)
+    iterator.find_index { |n| n == 2 }.should eq(1)
+  end
+
+  it "should find right index" do
+    iterator.rindex(2).should eq(4)
+    iterator.rindex { |n| n == 2 }.should eq(4)
+  end
+
+  it "should be compacted" do
+    blanks.compact.should have(2).items
+  end
+
+  it "should be mutable" do
+    iter = ActsAsOrderedTree::Iterator.new([1, 2])
+    iter << 3 # [1, 2, 3]
+
+    iter.should have(3).items
+
+    iter.insert(1, 99) # [1, 99, 2, 3]
+    iter.at(1).should eq(99)
+
+    last = iter.pop # [1, 99, 2]
+    iter.last.should eq(2)
+    last.should eq(3)
+
+    first = iter.shift # [99, 2]
+    iter.first.should eq(99)
+    first.should eq(1)
+
+    iter.unshift(100) # [100, 99, 2]
+    iter.first.should eq(100)
+
+    iter.push(4)
+    iter.should have(4).items
+    iter.last.should eq(4)
+  end
+
+  it "should raise NoMethodError" do
+    iter = ActsAsOrderedTree::Iterator.new([1, 2])
+    
+    lambda { iter.__undefined_method__ }.should raise_error(NoMethodError)
+  end
+end

data/spec/test_helper.rb

@@ -0,0 +1,53 @@
+require File.expand_path('../../init', __FILE__)
+
+require "rspec"
+require "rspec-expectations"
+
+require "simplecov"
+SimpleCov.start
+
+require "acts_as_ordered_tree"
+require "logger"
+
+config = YAML::load(IO.read(File.dirname(__FILE__) + '/database.yml'))
+ActiveRecord::Base.establish_connection(config['database'])
+ActiveRecord::Base.logger = Logger.new(ENV['DEBUG'] ? $stderr : '/dev/null')
+
+# Create schema
+ActiveRecord::Base.connection.create_table :nodes do |t|
+  t.integer :parent_id
+  t.integer :position
+  t.string  :name
+end
+
+class Node < ActiveRecord::Base
+  acts_as_ordered_tree
+
+  before_reorder :on_before_reorder
+  after_reorder  :on_after_reorder
+  around_reorder :on_around_reorder
+  before_move    :on_before_move
+  after_move     :on_after_move
+  around_move    :on_around_move
+
+  def self.debug
+    buf = StringIO.new("", "w")
+
+    roots.each do |n|
+      buf.puts "! #{n.name}"
+      n.descendants.each do |d|
+        buf.puts "#{' ' * d.level * 2} (##{d.id}): #{d.name} @ #{d.position}"
+      end
+    end
+
+    print buf.string
+  end
+
+  # stub
+  def on_before_reorder;end
+  def on_after_reorder;end
+  def on_around_reorder;yield end
+  def on_before_move; end
+  def on_after_move; end
+  def on_around_move; yield end
+end

metadata

@@ -0,0 +1,149 @@
+--- !ruby/object:Gem::Specification
+name: acts_as_ordered_tree
+version: !ruby/object:Gem::Version
+  version: 0.0.7
+  prerelease: 
+platform: ruby
+authors:
+- Alexei Mikhailov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-15 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &19980600 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: *19980600
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: &19980040 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: *19980040
+- !ruby/object:Gem::Dependency
+  name: acts_as_tree
+  requirement: &19979360 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: *19979360
+- !ruby/object:Gem::Dependency
+  name: acts_as_list
+  requirement: &19978620 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: *19978620
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &19977860 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *19977860
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: &19977100 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *19977100
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: &19976120 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *19976120
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &19945820 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *19945820
+description: 
+email:
+- amikhailov83@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- acts_as_ordered_tree.gemspec
+- init.rb
+- lib/acts_as_ordered_tree.rb
+- lib/acts_as_ordered_tree/iterator.rb
+- lib/acts_as_ordered_tree/list.rb
+- lib/acts_as_ordered_tree/tree.rb
+- lib/acts_as_ordered_tree/version.rb
+- spec/acts_as_ordered_tree_spec.rb
+- spec/database.yml
+- spec/iterator_spec.rb
+- spec/test_helper.rb
+homepage: https://github.com/take-five/acts_as_ordered_tree
+licenses: []
+post_install_message: 
+rdoc_options: []
+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'
+requirements: []
+rubyforge_project: acts_as_ordered_tree
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: ActiveRecord extension for sorted adjacency lists support
+test_files: []
+has_rdoc: