mongo_mapper_acts_as_list 0.1

data/README.rdoc

@@ -0,0 +1,44 @@
+= mongo_mapper_acts_as_list
+
+This is a port of classic Rails' {acts_as_list}[http://github.com/rails/acts_as_list] to Mongo Mapper. This MongoMapper plugin provides the capabilities for sorting and reordering a number of objects in a list. If you do not specify custom position column in the options, a key named position will be used by default.
+
+It has (almost) the same functionality and passes the original test-suite. Scope needs to be defined as symbol or array of symbols. It does not work for Embedded Documents.
+
+== Installation
+
+mongo_mapper_acts_as_list is available as RubyGem:
+
+  gem install mongo_mapper_acts_as_list
+  
+== Example
+
+  class TodoList
+    include MongoMapper::Document
+    
+    many :todo_items, :order => "position"
+  end
+
+  class TodoItem
+    include MongoMapper::Document
+    plugin MongoMapper::Plugins::ActsAsList
+    
+    key :todo_list_id, ObjectId
+    belongs_to :todo_list
+
+    acts_as_list :scope => :todo_list_id
+  end
+
+  todo_list.first.move_to_bottom
+  todo_list.last.move_higher
+
+== Note on Patches/Pull Requests
+
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a future version unintentionally.
+* Commit, do not mess with rakefile, version, or history. (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Original Rails' acts_as_list Copyright (c) 2007 David Heinemeier Hansson, released under the MIT license

data/lib/mongo_mapper/plugins/acts_as_list.rb

@@ -0,0 +1,234 @@
+module MongoMapper
+  module Plugins
+    module ActsAsList
+
+      require 'mongo_mapper'
+  
+      module ClassMethods
+        def acts_as_list(options = {})
+          configuration = { :column => "position", :scope => {} }
+          configuration.update(options) if options.is_a?(Hash)
+          
+          configuration[:scope] = "#{configuration[:scope]}_id".intern if configuration[:scope].is_a?(Symbol) && configuration[:scope].to_s !~ /_id$/
+      
+          if configuration[:scope].is_a?(Symbol)
+            scope_condition_method = %(
+              def scope_condition
+                { "#{configuration[:scope].to_s}" => send(:#{configuration[:scope].to_s}) }.symbolize_keys!
+              end
+            )
+          elsif configuration[:scope].is_a?(Array)
+            scope_condition_method = %(
+              def scope_condition
+                attrs = %w(#{configuration[:scope].join(" ")}).inject({}) do |memo, column| 
+                  memo[column.intern] = send(column.intern)
+                  memo
+                end
+                attrs.symbolize_keys!
+              end
+            )
+          else
+            scope_condition_method = "def scope_condition() \"#{configuration[:scope]}\" end"
+          end
+      
+          class_eval <<-EOV
+            include MongoMapper::Plugins::ActsAsList::InstanceMethods
+
+            def acts_as_list_class
+              ::#{self.name}
+            end
+
+            def position_column
+              '#{configuration[:column]}'
+            end
+
+            #{scope_condition_method}
+
+            before_destroy :decrement_positions_on_lower_items
+            before_create  :add_to_list_bottom
+          EOV
+        end
+    
+      end
+
+
+
+      module InstanceMethods
+        # Insert the item at the given position (defaults to the top position of 1).
+        def insert_at(position = 1)
+          insert_at_position(position)
+        end
+    
+        # Swap positions with the next lower item, if one exists.
+        def move_lower
+          return unless lower_item
+          lower_item.decrement_position
+          increment_position
+        end
+    
+        # Swap positions with the next higher item, if one exists.
+        def move_higher
+          return unless higher_item
+          higher_item.increment_position
+          decrement_position
+        end
+    
+        # Move to the bottom of the list. If the item is already in the list, the items below it have their
+        # position adjusted accordingly.
+        def move_to_bottom
+          return unless in_list?
+          decrement_positions_on_lower_items
+          assume_bottom_position
+        end
+    
+        # Move to the top of the list. If the item is already in the list, the items above it have their
+        # position adjusted accordingly.
+        def move_to_top
+          return unless in_list?
+          increment_positions_on_higher_items
+          assume_top_position
+        end
+    
+        def update_position(value=nil)
+          # update_attribute position_column, value
+          self.set( { position_column.to_sym => value } )
+          self[position_column] = value
+        end
+    
+        # Removes the item from the list.
+        def remove_from_list
+          if in_list?
+            decrement_positions_on_lower_items
+            update_position( nil )
+          end
+        end
+        
+        # Increase the position of this item without adjusting the rest of the list.
+        def increment_position
+          return unless in_list?
+          update_position( self.send(position_column).to_i+1 )
+        end
+    
+        # Decrease the position of this item without adjusting the rest of the list.
+        def decrement_position
+          return unless in_list?
+          update_position( self.send(position_column).to_i-1 )
+        end
+    
+        # Return +true+ if this object is the first in the list.
+        def first?
+          return false unless in_list?
+          self.send(position_column) == 1
+        end
+
+        # Return +true+ if this object is the last in the list.
+        def last?
+          return false unless in_list?
+          self.send(position_column) == bottom_position_in_list
+        end
+
+        # Return the next higher item in the list.
+        def higher_item
+          return nil unless in_list?
+          conditions = scope_condition
+          conditions.merge!( { position_column.to_sym => send(position_column).to_i-1 } )
+          acts_as_list_class.where(conditions).first
+        end
+
+        # Return the next lower item in the list.
+        def lower_item
+          return nil unless in_list?
+          conditions = scope_condition
+          conditions.merge!( { position_column.to_sym => send(position_column).to_i+1 } )
+          acts_as_list_class.where(conditions).first
+        end
+
+        # Test if this record is in a list
+        def in_list?
+          !send(position_column).nil?
+        end
+
+        private
+        
+        def add_to_list_top
+          increment_positions_on_all_items
+        end
+
+        def add_to_list_bottom
+          self[position_column] = bottom_position_in_list.to_i+1
+        end
+
+        def scope_condition() "1" end
+          
+        # Returns the bottom position number in the list.
+        #   bottom_position_in_list    # => 2
+        def bottom_position_in_list(except = nil)
+          item = bottom_item(except)
+          item ? item.send(position_column) : 0
+        end
+
+        # Returns the bottom item
+        def bottom_item(except = nil)
+          conditions = scope_condition
+          conditions.merge!( { :id.ne => except.id } ) if except
+          acts_as_list_class.where(conditions).sort(position_column.to_sym.desc).first
+        end
+        
+        # Forces item to assume the bottom position in the list.
+        def assume_bottom_position
+          update_position( bottom_position_in_list(self).to_i+1 )
+        end
+
+        # Forces item to assume the top position in the list.
+        def assume_top_position
+          update_position 1
+        end
+
+        # This has the effect of moving all the higher items up one.
+        def decrement_positions_on_higher_items(position)
+          conditions = scope_condition
+          conditions.merge!( { position_column.to_sym.lt => position } )
+          acts_as_list_class.decrement( conditions, { position_column.to_sym => 1 } )
+        end
+
+        # This has the effect of moving all the lower items up one.
+        def decrement_positions_on_lower_items
+          return unless in_list?
+          conditions = scope_condition
+          conditions.merge!( { position_column.to_sym.gt => send(position_column).to_i } )
+          acts_as_list_class.decrement( conditions, { position_column => 1 } )
+        end       
+  
+        # This has the effect of moving all the higher items down one.
+        def increment_positions_on_higher_items
+          return unless in_list?
+          conditions = scope_condition
+          conditions.merge!( { position_column.to_sym.lt => send(position_column).to_i } )
+          acts_as_list_class.increment( conditions, { position_column.to_sym => 1 } )
+        end
+
+        # This has the effect of moving all the lower items down one.
+        def increment_positions_on_lower_items(position)
+          conditions = scope_condition
+          conditions.merge!( { position_column.to_sym.gte => position } )
+          acts_as_list_class.increment( conditions, { position_column.to_sym => 1 } )
+        end
+
+        # Increments position (<tt>position_column</tt>) of all items in the list.
+        def increment_positions_on_all_items
+          conditions = scope_condition
+          acts_as_list_class.increment( conditions, { position_column.to_sym => 1 } )
+        end
+
+        def insert_at_position(position)
+          remove_from_list
+          increment_positions_on_lower_items( position )
+          update_position( position )
+        end
+        
+
+      end
+
+    end
+  end
+end

data/lib/mongo_mapper/plugins/version.rb

@@ -0,0 +1,8 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module ActsAsList
+      Version = '0.1'
+    end
+  end
+end

data/test/mongo_mapper_acts_as_list_test.rb

@@ -0,0 +1,335 @@
+require 'test_helper'
+
+
+
+# CLASS SETUP
+
+class ListMixin
+  include MongoMapper::Document
+
+  plugin MongoMapper::Plugins::ActsAsList
+
+  key :pos, Integer
+  key :parent_id, Integer
+  key :original_id, Integer
+
+  acts_as_list :column => :pos, :scope => :parent_id
+end
+
+class ListMixinSub1 < ListMixin
+end
+
+class ListMixinSub2 < ListMixin
+end
+
+class ListMixinWithArrayScope
+  include MongoMapper::Document
+
+  plugin MongoMapper::Plugins::ActsAsList
+
+  key :pos, Integer
+  key :parent_id, Integer
+
+  acts_as_list :column => :pos, :scope => [:parent_id, :original_id]
+end
+
+
+
+# TESTS
+
+class ScopeTest < ActiveSupport::TestCase
+
+  def setup
+    @lm1 = ListMixin.create! :pos => 1, :parent_id => 5, :original_id => 1
+    @lm2 = ListMixinWithArrayScope.create! :pos => 1, :parent_id => 5, :original_id => 1
+  end
+
+  def test_symbol_scope
+    assert_equal @lm1.scope_condition, { :parent_id => 5 }
+    assert_equal @lm2.scope_condition, { :parent_id => 5, :original_id => 1 }
+  end
+
+end
+
+
+
+class ActiveSupport::TestCase
+	
+	private
+	
+	def mixins_with_parent_id(parent_id)
+		ListMixin.where(:parent_id => parent_id).sort(:pos).all.map(&:original_id)
+	end
+	
+	def mixin_with_original_id(original_id)
+		ListMixin.where(:original_id => original_id).first
+	end
+end
+
+
+
+class ListTest < ActiveSupport::TestCase
+
+    def setup
+      (1..4).each{ |counter| ListMixin.create! :pos => counter, :parent_id => 5, :original_id => counter }
+    end
+
+    def test_reordering
+      assert_equal [1, 2, 3, 4], mixins_with_parent_id(5)
+
+      mixin_with_original_id(2).move_lower
+      assert_equal [1, 3, 2, 4], mixins_with_parent_id(5)
+
+      mixin_with_original_id(2).move_higher
+      assert_equal [1, 2, 3, 4], mixins_with_parent_id(5)
+
+      mixin_with_original_id(1).move_to_bottom
+      assert_equal [2, 3, 4, 1], mixins_with_parent_id(5)
+
+      mixin_with_original_id(1).move_to_top
+      assert_equal [1, 2, 3, 4], mixins_with_parent_id(5)
+
+      mixin_with_original_id(2).move_to_bottom
+      assert_equal [1, 3, 4, 2], mixins_with_parent_id(5)
+
+      mixin_with_original_id(4).move_to_top
+      assert_equal [4, 1, 3, 2], mixins_with_parent_id(5)
+    end
+
+    def test_move_to_bottom_with_next_to_last_item
+      assert_equal [1, 2, 3, 4], mixins_with_parent_id(5)
+      mixin_with_original_id(3).move_to_bottom
+      assert_equal [1, 2, 4, 3], mixins_with_parent_id(5)
+    end
+
+    def test_next_prev
+      assert_equal mixin_with_original_id(2), mixin_with_original_id(1).lower_item
+      assert_nil mixin_with_original_id(1).higher_item
+      assert_equal mixin_with_original_id(3), mixin_with_original_id(4).higher_item
+      assert_nil mixin_with_original_id(4).lower_item
+    end
+
+    def test_injection
+      item = ListMixin.new(:parent_id => 1)
+      assert_equal item.scope_condition, {:parent_id => 1}
+      assert_equal "pos", item.position_column
+    end
+
+    def test_insert
+      new = ListMixin.create(:parent_id => 20)
+      assert_equal 1, new.pos
+      assert new.first?
+      assert new.last?
+
+      new = ListMixin.create(:parent_id => 20)
+      assert_equal 2, new.pos
+      assert !new.first?
+      assert new.last?
+
+      new = ListMixin.create(:parent_id => 20)
+      assert_equal 3, new.pos
+      assert !new.first?
+      assert new.last?
+
+      new = ListMixin.create(:parent_id => 0)
+      assert_equal 1, new.pos
+      assert new.first?
+      assert new.last?
+    end
+
+    def test_insert_at
+      new = ListMixin.create(:parent_id => 20)
+      assert_equal 1, new.pos
+
+      new = ListMixin.create(:parent_id => 20)
+      assert_equal 2, new.pos
+
+      new = ListMixin.create(:parent_id => 20)
+      assert_equal 3, new.pos
+
+      new4 = ListMixin.create(:parent_id => 20)
+      assert_equal 4, new4.pos
+
+      new4.insert_at(3)
+      assert_equal 3, new4.pos
+
+      new.reload
+      assert_equal 4, new.pos
+
+      new.insert_at(2)
+      assert_equal 2, new.pos
+
+      new4.reload
+      assert_equal 4, new4.pos
+
+      new5 = ListMixin.create(:parent_id => 20)
+      assert_equal 5, new5.pos
+
+      new5.insert_at(1)
+      assert_equal 1, new5.pos
+
+      new4.reload
+      assert_equal 5, new4.pos
+    end
+
+    def test_delete_middle
+      assert_equal [1, 2, 3, 4], mixins_with_parent_id(5)
+
+      mixin_with_original_id(2).destroy
+
+      assert_equal [1, 3, 4], mixins_with_parent_id(5)
+
+      assert_equal 1, mixin_with_original_id(1).pos
+      assert_equal 2, mixin_with_original_id(3).pos
+      assert_equal 3, mixin_with_original_id(4).pos
+
+      mixin_with_original_id(1).destroy
+
+      assert_equal [3, 4], mixins_with_parent_id(5)
+
+      assert_equal 1, mixin_with_original_id(3).pos
+      assert_equal 2, mixin_with_original_id(4).pos
+    end
+
+    def test_nil_scope
+      new1, new2, new3 = ListMixin.create, ListMixin.create, ListMixin.create
+      new2.move_higher
+      assert_equal [new2, new1, new3], ListMixin.where(:parent_id => nil).sort(:pos).all
+    end
+
+    def test_remove_from_list_should_then_fail_in_list? 
+      assert_equal true, mixin_with_original_id(1).in_list?
+      mixin_with_original_id(1).remove_from_list
+      assert_equal false, mixin_with_original_id(1).in_list?
+    end 
+
+    def test_remove_from_list_should_set_position_to_nil 
+      assert_equal [1, 2, 3, 4], mixins_with_parent_id(5)
+
+      mixin_with_original_id(2).remove_from_list 
+
+      assert_equal [2, 1, 3, 4], mixins_with_parent_id(5)
+
+      assert_equal 1,   mixin_with_original_id(1).pos
+      assert_equal nil, mixin_with_original_id(2).pos
+      assert_equal 2,   mixin_with_original_id(3).pos
+      assert_equal 3,   mixin_with_original_id(4).pos
+    end 
+
+    def test_remove_before_destroy_does_not_shift_lower_items_twice 
+      assert_equal [1, 2, 3, 4], mixins_with_parent_id(5)
+
+      mixin_with_original_id(2).remove_from_list 
+      mixin_with_original_id(2).destroy 
+
+      assert_equal [1, 3, 4], mixins_with_parent_id(5)
+
+      assert_equal 1, mixin_with_original_id(1).pos
+      assert_equal 2, mixin_with_original_id(3).pos
+      assert_equal 3, mixin_with_original_id(4).pos
+    end 
+  
+end
+
+class ListSubTest < ActiveSupport::TestCase
+
+  def setup
+    (1..4).each{ |i| ((i % 2 == 1) ? ListMixinSub1 : ListMixinSub2).create! :pos => i, :parent_id => 5000, :original_id => i }
+  end
+
+  def test_reordering
+    assert_equal [1, 2, 3, 4], mixins_with_parent_id(5000)
+
+    mixin_with_original_id(2).move_lower
+    assert_equal [1, 3, 2, 4], mixins_with_parent_id(5000)
+      
+    mixin_with_original_id(2).move_higher
+    assert_equal [1, 2, 3, 4], mixins_with_parent_id(5000)
+      
+    mixin_with_original_id(1).move_to_bottom
+    assert_equal [2, 3, 4, 1], mixins_with_parent_id(5000)
+
+    mixin_with_original_id(1).move_to_top
+    assert_equal [1, 2, 3, 4], mixins_with_parent_id(5000)
+      
+    mixin_with_original_id(2).move_to_bottom
+    assert_equal [1, 3, 4, 2], mixins_with_parent_id(5000)
+      
+    mixin_with_original_id(4).move_to_top
+    assert_equal [4, 1, 3, 2], mixins_with_parent_id(5000)
+  end
+
+  def test_move_to_bottom_with_next_to_last_item
+    assert_equal [1, 2, 3, 4], mixins_with_parent_id(5000)
+    mixin_with_original_id(3).move_to_bottom
+    assert_equal [1, 2, 4, 3], mixins_with_parent_id(5000)
+  end
+
+  def test_next_prev
+    assert_equal mixin_with_original_id(2), mixin_with_original_id(1).lower_item
+    assert_nil mixin_with_original_id(1).higher_item
+    assert_equal mixin_with_original_id(3), mixin_with_original_id(4).higher_item
+    assert_nil mixin_with_original_id(4).lower_item
+  end
+
+  def test_injection
+    item = ListMixin.new(:parent_id => 1)
+    assert_equal item.scope_condition, { :parent_id => 1 }
+    assert_equal "pos", item.position_column
+  end
+
+  def test_insert_at
+    new = ListMixin.create(:parent_id => 20)
+    assert_equal 1, new.pos
+ 
+    new = ListMixinSub1.create(:parent_id => 20)
+    assert_equal 2, new.pos
+ 
+    new = ListMixinSub2.create(:parent_id => 20)
+    assert_equal 3, new.pos
+ 
+    new4 = ListMixin.create(:parent_id => 20)
+    assert_equal 4, new4.pos
+ 
+    new4.insert_at(3)
+    assert_equal 3, new4.pos
+ 
+    new.reload
+    assert_equal 4, new.pos
+ 
+    new.insert_at(2)
+    assert_equal 2, new.pos
+ 
+    new4.reload
+    assert_equal 4, new4.pos
+ 
+    new5 = ListMixinSub1.create(:parent_id => 20)
+    assert_equal 5, new5.pos
+ 
+    new5.insert_at(1)
+    assert_equal 1, new5.pos
+ 
+    new4.reload
+    assert_equal 5, new4.pos
+  end
+
+  def test_delete_middle
+    assert_equal [1, 2, 3, 4], mixins_with_parent_id(5000)
+ 
+    mixin_with_original_id(2).destroy
+ 
+    assert_equal [1, 3, 4], mixins_with_parent_id(5000)
+ 
+    assert_equal 1, mixin_with_original_id(1).pos
+    assert_equal 2, mixin_with_original_id(3).pos
+    assert_equal 3, mixin_with_original_id(4).pos
+ 
+    mixin_with_original_id(1).destroy
+ 
+    assert_equal [3, 4], mixins_with_parent_id(5000)
+ 
+    assert_equal 1, mixin_with_original_id(3).pos
+    assert_equal 2, mixin_with_original_id(4).pos
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,31 @@
+require 'rubygems'
+$:.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
+
+require 'mongo_mapper'
+require 'mongo_mapper/plugins/acts_as_list'
+require 'test/unit'
+
+
+
+class ActiveSupport::TestCase
+  
+  # Drop all collections after each test case.
+  def teardown
+    MongoMapper.database.collections.each { |coll| coll.remove }
+  end
+
+  # Make sure that each test case has a teardown
+  # method to clear the db after each test.
+  def inherited(base)
+    base.define_method teardown do 
+      super
+    end
+  end
+
+end
+
+
+
+MongoMapper.connection = Mongo::Connection.new('127.0.0.1', 27017)
+MongoMapper.database = "mongo_mapper_acts_as_list_test"
+MongoMapper.database.collections.each { |c| c.drop_indexes }

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification 
+name: mongo_mapper_acts_as_list
+version: !ruby/object:Gem::Version 
+  hash: 9
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  version: "0.1"
+platform: ruby
+authors: 
+- Tomas Celizna
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-31 01:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mongo_mapper
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+description: 
+email: 
+- tomas.celizna@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/mongo_mapper/plugins/acts_as_list.rb
+- lib/mongo_mapper/plugins/version.rb
+- test/mongo_mapper_acts_as_list_test.rb
+- test/test_helper.rb
+- README.rdoc
+has_rdoc: true
+homepage: http://github.com/tomasc/mongo_mapper_acts_as_list
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Port of classic Rails ActsAsList for MongoMapper
+test_files: []
+