acts_as_ordered_tree 0.0.7 → 1.0.3

data/init.rb

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

data/lib/acts_as_ordered_tree/iterator.rb

@@ -1,36 +0,0 @@
-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

@@ -1,100 +0,0 @@
-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

@@ -1,156 +0,0 @@
-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/spec/database.yml

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

data/spec/iterator_spec.rb

@@ -1,73 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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