acts_as_list_mongoid 0.1.0

data/README.markdown

@@ -0,0 +1,61 @@
+# Mongoid Acts as list
+
+This is a port of the classic +acts_as_list+ to Mongoid.
+
+This *acts_as* extension 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 +pos+ will be used automatically.
+
+## Installation
+
+<code>gem install acts_a_list_mongoid</code>
+
+## Usage
+
+See the /specs folder specs that demontrate the API. Usage examples are located in the /examples folder.
+
+## Example
+
+<pre>
+  require 'mongoid'
+  require 'mongoid_embedded_helper'
+
+  Mongoid.configure.master = Mongo::Connection.new.db('acts_as_list-test')
+
+  class Item
+    include Mongoid::Document
+    include Mongoid::Timestamps
+    include ActsAsList::Mongoid 
+
+    field :pos, :type => Integer
+    field :number, :type => Integer
+
+    acts_as_list :column => :pos
+
+    embedded_in :list, :inverse_of => :items
+  end    
+
+  class List
+    include Mongoid::Document
+    field :name, :type => String
+    embeds_many :items
+  end
+
+
+  todo_list = List.new :name => 'My todo list'
+
+  %w{'clean', 'wash', 'repair'}.each do |name| 
+    todo_item = Item.new(:name => name)
+    todo_list.items << todo_item
+  end  
+  todo_list.items.created! # IMPORTANT!!!
+
+  todo_list.items.first.move_to_bottom
+  todo_list.items.last.move_higher
+</pre>  
+  
+
+## Running the specs
+
+<code>rspec spec</code>
+
+

data/Rakefile

@@ -0,0 +1,22 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name        = "acts_as_list_mongoid"
+    gem.summary     = %Q{Gem version of acts_as_list for Mongoid}
+    gem.description = %Q{Make your Mongoid model acts as a list. This acts_as extension provides the capabilities for sorting and reordering a number of objects in a list.
+      The instances that take part in the list should have a +position+ field of type Integer.}
+    gem.email       = "kmandrup@gmail.com"
+    gem.homepage    = "http://github.com/rails/acts_as_list"
+    gem.authors     = ["Kristian Mandrup"]
+    gem.add_dependency "mongoid", ">= 2.0.0.beta7"
+    gem.add_dependency "mongoid_embedded_helper", ">= 0.2.3"
+    # gem.add_development_dependency "yard"
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/example/example.rb

@@ -0,0 +1,35 @@
+require 'mongoid'
+require 'mongoid_embedded_helper'
+                 
+Mongoid.configure.master = Mongo::Connection.new.db('acts_as_list-test')
+
+class Item
+  include Mongoid::Document
+  include Mongoid::Timestamps
+  include ActsAsList::Mongoid 
+  
+  field :pos, :type => Integer
+  field :number, :type => Integer
+  
+  acts_as_list :column => :pos
+
+  embedded_in :list, :inverse_of => :items
+end    
+
+class List
+  include Mongoid::Document
+  field :name, :type => String
+  embeds_many :items
+end
+
+
+todo_list = List.new :name => 'My todo list'
+
+%w{'clean', 'wash', 'repair'}.each do |name| 
+  todo_item = Item.new(:name => name)
+  todo_list.items << todo_item
+end  
+todo_list.items.created!
+
+todo_list.items.first.move_to_bottom
+todo_list.items.last.move_higher

data/init.rb

@@ -0,0 +1,2 @@
+$:.unshift "#{File.dirname(__FILE__)}/lib"
+require 'acts_as_list/mongo_mapper/rails3'

data/lib/acts_as_list_mongoid.rb

@@ -0,0 +1,2 @@
+require "mongoid"
+require 'mongoid/acts_as_list'

data/lib/init.rb

@@ -0,0 +1 @@
+require 'acts_as_list_mongoid'

data/lib/mongoid/acts_as_list.rb

@@ -0,0 +1,370 @@
+require "mongoid"  
+require 'mongoid_embedded_helper'
+
+module ActsAsList
+	module Mongoid
+		def self.included(model)
+			model.class_eval do
+				extend InitializerMethods
+			end
+		end
+
+		module InitializerMethods
+  		def acts_as_list(options = {})
+  			configuration = { :column => 'position' }
+  			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$/
+
+        # write_inheritable_attribute :acts_as_list_options, configuration
+        # class_inheritable_reader :acts_as_list_options
+
+        define_method :position_column do
+          configuration[:column].to_s
+        end
+
+        if !configuration[:scope]
+				  define_method :scope_condition do
+				    {position_key.ne => nil}
+				  end
+        elsif configuration[:scope].is_a?(Symbol)
+  				define_method :scope_condition do
+  					{ "#{configuration[:scope].to_s}" => "\#{#{configuration[:scope].to_s}}".to_i }.symbolize_keys!
+  				end
+				else
+				  raise ArgumentError, "acts_as_list must either take a valid scope option or be in an embedded document and use the parent document as scope"
+  			end
+
+  			include ::Mongoid::EmbeddedHelper
+				include InstanceMethods
+				include Fields
+				include Triggers
+				extend Fields
+				extend ClassMethods
+  		end
+  	end   
+  
+    module ClassMethods
+      def in_scope
+        where(scope_condition)
+      end  		
+    end
+  
+    module InstanceMethods           
+      def order_by_position conditions, extras = []
+        sub_collection = in_collection.where(conditions)
+        sub_collection = if embedded?
+          sub_collection.sort { |x,y| x.my_position <=> y.my_position }
+        else
+          sub_collection.order_by([position_key, :desc])
+        end
+
+        if !extras.empty?        
+          sub_collection = if embedded?
+            sub_collection.sort do |x,y| 
+              if x.my_position == y.my_position
+                x.created_at <=> y.created_at 
+              else
+               x.my_position <=> y.my_position
+              end
+            end
+          else
+            sub_collection.order_by(extras)
+          end
+        end
+        
+        sub_collection
+      end
+
+      # conditions, { position_column => 1 }
+      def do_decrement( conditions, options)  
+        in_collection.where(conditions).adjust! position_key => -1
+      end
+
+      def do_increment( conditions, options)  
+        in_collection.where(conditions).adjust! position_key => 1
+      end
+      
+      def less_than_me
+        { position_key.lt => my_position.to_i}        
+      end
+
+      def greater_than_me
+        { position_key.gt => my_position.to_i}
+      end
+
+      def insert_at(position = 1)
+        insert_in_list_at(position)
+      end
+
+  		# Insert the item at the given position (defaults to the top position of 1).
+      def insert_in_list_at(position = 1)
+        insert_at_position(position)
+      end
+
+      # Swap positions with the next lower item, if one exists.
+      def move_lower     
+        low_item = lower_item  
+        return unless low_item
+
+  			low_item.decrement_position
+        increment_position  
+      end
+
+      # Swap positions with the next higher item, if one exists.
+      def move_higher
+        high_item = higher_item
+        return unless high_item
+
+        high_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
+
+      # Removes the item from the list.
+      def remove_from_list
+        if in_list?
+          decrement_positions_on_lower_items
+  				set_my_position nil
+        end
+      end
+
+      # Increase the position of this item without adjusting the rest of the list.
+      def increment_position
+        return unless in_list?
+  			# in_collection.where(:pos => my_position).
+  			adjust!(position_key => 1) 
+  			save!
+      end
+
+      # Decrease the position of this item without adjusting the rest of the list.
+      def decrement_position
+        return unless in_list?
+        
+        # in_collection.where(:pos => my_position).                 
+        adjust!(position_key => -1)
+        save!        
+      end
+
+      # Return +true+ if this object is the first in the list.
+      def first?
+        return false unless in_list?
+        my_position == 1
+      end
+
+      # Return +true+ if this object is the last in the list.
+      def last?
+        return false unless in_list?      
+        bottom_pos = bottom_position_in_list
+        my_position == bottom_pos
+      end
+
+      # Return the next higher item in the list.
+      def higher_item
+        return nil unless in_list?  
+  			conditions = scope_condition.merge!( less_than_me )
+  			
+        order_by_position(conditions).last
+      end
+
+      # Return the next lower item in the list.
+      def lower_item
+        return nil unless in_list?
+        
+  			conditions = scope_condition.merge!( greater_than_me )
+  			
+        order_by_position(conditions).first
+      end
+
+      # Test if this record is in a list
+      def in_list?
+        !my_position.nil?
+      end
+
+  		# sorts all items in the list
+  		# if two items have same position, the one created more recently goes first
+  		def sort
+  			conditions = scope_condition
+        
+        list_items = order_by_position(conditions, :created_at.desc).to_a
+  			
+  			list_items.each_with_index do |list_item, index|
+  				list_item.set_my_position index + 1
+  			end
+  		end
+
+      private 
+      
+      def add_to_list_top
+        increment_positions_on_all_items
+      end
+
+      def add_to_list_bottom    
+        bottom_pos = bottom_position_in_list.to_i
+        set_my_position(bottom_pos + 1)
+      end
+
+      # Overwrite this method to define the scope of the list changes
+      def scope_condition
+  			{}
+  		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.my_position : 0
+      end
+
+      # Returns the bottom item
+      def bottom_item(except = nil)
+  			conditions = scope_condition
+        if except
+          conditions.merge!( { position_key.ne => except.my_position } )
+        end
+
+  			order_by_position(conditions).last
+      end
+
+      # Forces item to assume the bottom position in the list.
+      def assume_bottom_position
+  			pos = bottom_position_in_list(self).to_i + 1 
+  			set_my_position(pos)
+      end
+
+      # Forces item to assume the top position in the list.
+      def assume_top_position
+  			set_my_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_key.lt => position } )
+  			in_collection.where(conditions).adjust! position_key => 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!( greater_than_me ) 
+
+        decrease_all! in_collection.where(conditions)
+      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!( less_than_me )
+
+        increase_all! in_collection.where(conditions)
+      end
+
+      def adjust_all! collection, number
+        collection.adjust! position_key => number
+      end
+
+      def increase_all! collection        
+        adjust_all! collection, 1
+      end
+
+      def decrease_all! collection        
+        adjust_all! collection, -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_key.gte => position } )
+
+  			increase_all! in_collection.where(conditions)
+      end
+
+      # Increments position (<tt>position_column</tt>) of all items in the list.
+      def increment_positions_on_all_items
+  			conditions = scope_condition                 
+  			
+  			increase_all! in_collection.where(conditions)
+      end
+
+      def insert_at_position(position)
+        remove_from_list
+        increment_positions_on_lower_items(position)
+  			set_my_position(position)
+      end
+    end
+
+    module Triggers
+      def after_parentize     
+        # should register on root element to be called when root is saved first time!?
+      end			
+
+      def created!
+        self['created_at'] = Time.now
+        self['updated_at'] = Time.now        
+        add_to_list_bottom unless in_list?
+      end			
+
+    end
+    
+    module Fields
+      def my_position 
+        self[position_column]
+      end
+
+      def set_my_position new_position
+        if new_position != my_position 
+          self[position_column] = new_position
+          save!
+        end
+      end
+
+			def [](field_name)
+				self.send field_name
+			end
+
+			def []=(key, value)
+        if set_allowed?(key)
+          @attributes[key.to_s] = value 
+        elsif write_allowed?(key)
+          self.send("#{key}=", value) 
+        end 
+				save!
+			end
+
+			def ==(other)
+				return true if other.equal?(self)
+				return true if other.instance_of?(self.class) and other._id == self._id
+				false
+			end
+
+      def position_key
+        position_column.to_sym        
+      end
+    end      
+  end    
+end
+
+class Array            
+  def created!
+    each {|i| i.created! }
+  end
+end  

data/model/embedded_item.rb

@@ -0,0 +1,18 @@
+class Item
+  include Mongoid::Document
+  include Mongoid::Timestamps
+  include ActsAsList::Mongoid 
+  
+  field :pos, :type => Integer
+  field :number, :type => Integer
+  
+  acts_as_list :column => :pos
+
+  embedded_in :list, :inverse_of => :items
+end    
+
+class List
+  include Mongoid::Document
+  field :name, :type => String
+  embeds_many :items
+end

data/spec/.rspec

@@ -0,0 +1 @@
+--format nested --color

data/spec/acts_as_list/embedded/custom_embedded_spec.rb

@@ -0,0 +1,104 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+require 'acts_as_list_mongoid'
+require 'embedded_item'
+
+describe 'ActsAsList for Mongoid' do    
+  
+  before :each do   
+    @list = List.create!
+    @list.items = []
+    (1..4).each do |counter| 
+      @list.items << Item.new(:number => counter)
+    end
+    @list.save!
+    
+    @list.items.created!
+  end    
+  
+  after :each do
+    Mongoid.database.collections.each do |coll|
+      coll.remove
+    end
+  end
+
+  def get_positions list
+    list.items.sort { |x,y| x.my_position <=> y.my_position }.map(&:number)  
+  end
+  
+  context "4 list items (1,2,3,4) that have parent_id pointing to first list container"  do
+    describe '# initial configuration' do
+      it "should list items 1 to 4 in order" do        
+        positions = get_positions @list 
+        positions.should == [1, 2, 3, 4]
+      end 
+    end
+    
+    describe '#reordering' do
+      it "should move item 2 to position 3" do
+        @list.items[1].increment_position
+        @list.items[2].decrement_position      
+        get_positions(@list).should == [1, 3, 2, 4]
+      end
+      
+      
+      it "should move item 2 to position 3" do          
+        @list.items.where(:number => 2).first.move_lower
+        get_positions(@list).should == [1, 3, 2, 4]
+      end
+      
+      it "should move item 2 to position 1" do    
+        @list.items.where(:number => 2).first.move_higher
+        get_positions(@list).should == [2, 1, 3, 4]  
+      end 
+        
+      it "should move item 1 to bottom" do    
+        @list.items.where(:number => 1).first.move_to_bottom
+        get_positions(@list).should == [2, 3, 4, 1]  
+      end
+      
+      it "should move item 1 to top" do    
+        @list.items.where(:number => 1).first.move_to_top
+        get_positions(@list).should == [1, 2, 3, 4]  
+      end
+      
+      it "should move item 2 to bottom" do    
+        @list.items.where(:number => 2).first.move_to_bottom
+        get_positions(@list).should == [1, 3, 4, 2]  
+      end
+      
+      it "should move item 4 to top" do    
+        @list.items.where(:number => 4).first.move_to_top
+        get_positions(@list).should == [4, 1, 2, 3]  
+      end  
+    
+      it "should move item 3 to bottom" do
+        get_positions(@list).should == [1, 2, 3, 4]      
+           
+        @list.items.where(:number => 3).first.move_to_bottom
+        get_positions(@list).should == [1, 2, 4, 3]  
+        
+      end      
+    end
+    
+    describe 'relative position queries' do
+      it "should find item 2 to be lower item of item 1" do
+        expected = @list.items.where(:pos => 2).first
+        @list.items.where(:pos => 1).first.lower_item.should == expected
+      end
+    
+      it "should not find any item higher than nr 1" do
+        @list.items.where(:pos => 1).first.higher_item.should == nil
+      end
+    
+      it "should find item 3 to be higher item of item 4" do     
+        expected = @list.items.where(:pos => 3).first
+        @list.items.where(:pos => 4).first.higher_item.should == expected
+      end
+    
+      it "should not find item lower than item 4" do            
+        @list.items.where(:pos => 4).first.lower_item.should == nil
+      end
+    end        
+  end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--color --format nested

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+require 'rspec'
+require 'rspec/autorun'
+require 'mongoid'
+require 'mongoid_embedded_helper'
+
+$:.unshift "#{File.dirname(__FILE__)}/../model/"
+                 
+Mongoid.configure.master = Mongo::Connection.new.db('acts_as_list-test')
+
+

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification 
+name: acts_as_list_mongoid
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Kristian Mandrup
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-07-06 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mongoid
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 0
+        - 0
+        - beta7
+        version: 2.0.0.beta7
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: mongoid_embedded_helper
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 2
+        - 3
+        version: 0.2.3
+  type: :runtime
+  version_requirements: *id002
+description: |-
+  Make your Mongoid model acts as a list. This acts_as extension provides the capabilities for sorting and reordering a number of objects in a list.
+        The instances that take part in the list should have a +position+ field of type Integer.
+email: kmandrup@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+files: 
+- .DS_Store
+- README.markdown
+- Rakefile
+- VERSION
+- example/example.rb
+- init.rb
+- lib/.DS_Store
+- lib/acts_as_list_mongoid.rb
+- lib/init.rb
+- lib/mongoid/acts_as_list.rb
+- model/embedded_item.rb
+- spec/.rspec
+- spec/acts_as_list/embedded/custom_embedded_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/rails/acts_as_list
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Gem version of acts_as_list for Mongoid
+test_files: 
+- spec/acts_as_list/embedded/custom_embedded_spec.rb
+- spec/spec_helper.rb