mongoid_acts_as_list 0.0.3

data/.gitignore

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

data/.rspec

@@ -0,0 +1 @@
+--color

data/.vimrc.local

@@ -0,0 +1,2 @@
+map <Leader>r :w\|!clear && bundle exec rspec %<cr>
+map <Leader>R :w\|!clear && bundle exec rspec spec<cr>

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/README.markdown

@@ -0,0 +1,134 @@
+ActsAsList for Mongoid
+=====================
+
+## Description
+
+Mongoid::ActsAsList provides the ability of ordering and sorting a number of objects in a list using Mongoid as an ODM.
+
+
+## Install
+
+Place the following in your Gemfile:
+
+``` ruby
+gem 'mongoid_acts_as_list', '~> 0.0.3'
+```
+
+Then run `bundle install`
+
+
+## Configuration
+
+Configure defaults values used by ActsAsList:
+
+
+``` ruby
+Mongoid::ActsAsList.configure do |config|
+
+  # These are the default values. Modify as you see fit:
+
+  config.default_position_field = :position
+  config.start_list_at = 0
+
+end
+```
+
+Make sure it is loaded before calling ` acts_as_list `. You can place this code in an initializer file for example.
+
+## Usage
+
+Activate ActsAsList in your models.
+
+In has_many/belongs_to associations, you will need to provide a `:scope` option:
+
+``` ruby
+class List
+  include Mongoid::Document
+
+  has_many :items
+end
+
+class Item
+  include Mongoid::Document
+  include Mongoid::ActsAsList
+
+  belongs_to :list
+  acts_as_list scope: :list
+end
+```
+
+On embedded document, the scope option is not necessary:
+
+``` ruby
+class List
+  include Mongoid::Document
+
+  embeds_many :items
+end
+
+class Item
+  include Mongoid::Document
+  include Mongoid::ActsAsList
+
+  embedded_in :list
+  acts_as_list
+end
+```
+
+
+``` ruby
+## Class Methods
+
+list.items.order_by_position #=> returns all items in `list` ordered by position
+
+## Instance Methods
+
+item.move to: 2              #=> moves item to the 2nd position
+item.move to: :start         #=> moves item to the first position in the list
+item.move to: :end           #=> moves item to the last position in the list
+item.move before: other_item #=> moves item before other_item
+item.move after:  other_item #=> moves item after other_item
+item.move forward:  3        #=> move item 3 positions closer to the end of the list
+item.move backward: 2        #=> move item 2 positions closer to the start of the list
+item.move :forward           #=> same as item.move(forward:  1)
+item.move :backward          #=> same as item.move(backward: 1)
+
+item.in_list?                #=> true
+item.remove_from_list        #=> sets the position to nil and reorders other items
+item.not_in_list?            #=> true
+
+item.first?
+item.last?
+
+item.next_item               #=> returns the item immediately following `item` in the list
+item.previous_item           #=> returns the item immediately preceding `item` in the list
+```
+
+Other methods are available, as well as all the methods from the original ActiveRecord ActsAsList gem.
+Check the source and documentation to find out more!
+
+
+## Requirements
+
+Tested with Mongoid 2.4.6 on Ruby 1.9.3-p125, Rails 3.2.2, and Mongo 2.x
+
+
+## Roadmap
+
+* Test with several layers of embedding documents
+
+
+## Contributing
+ 
+- Fork the project
+- Start a feature/bugfix branch
+- Start writing tests
+- Commit and push until all tests are green and you are happy with your contribution
+
+- If you're using Vim, source the .vimrc.local file. It provides 2 shortcuts for running the specs:
+   - `<Leader>r` runs the current spec file
+   - `<Leader>R` runs all spec files
+
+## Copyright
+
+Copyright (c) 2012 Olivier Melcher, released under the MIT license

data/Rakefile

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

data/acts_as_list.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "mongoid/acts_as_list/version"
+
+Gem::Specification.new do |s|
+  s.name        = "mongoid_acts_as_list"
+  s.version     = Mongoid::ActsAsList::VERSION
+  s.authors     = ["Olivier Melcher"]
+  s.email       = ["olivier.melcher@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Implementation of the acts as list gem for Mongoid}
+  s.description = %q{}
+
+  s.rubyforge_project = "acts_as_list"
+
+  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"]
+
+  # specify any dependencies here; for example:
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "bson_ext", "~> 1.5"
+  s.add_development_dependency "database_cleaner"
+  s.add_development_dependency "pry"
+  s.add_runtime_dependency "mongoid", [">= 2.0.1"]
+end

data/lib/mongoid/acts_as_list/configuration.rb

@@ -0,0 +1,12 @@
+module Mongoid
+  module ActsAsList
+    class Configuration
+      attr_accessor :default_position_field, :start_list_at
+
+      def initialize
+        @default_position_field = :position
+        @start_list_at = 0
+      end
+    end
+  end
+end

data/lib/mongoid/acts_as_list/list/embedded.rb

@@ -0,0 +1,47 @@
+module Mongoid::ActsAsList
+  module List::Embedded
+    extend ActiveSupport::Concern
+
+    included do
+      raise List::ScopeMissingError, "Mongoid::ActsAsList::Embedded can only be included in embedded documents" unless embedded?
+    end
+
+    module ClassMethods
+      private
+
+      def define_position_scope(scope_name)
+        define_method(:scope_condition) { {position_field.ne => nil} }
+      end
+    end
+
+    ## InstanceMethods
+    private
+
+    def shift_position options = {}
+      criteria    = options.fetch(:for, to_criteria)
+      by_how_much = options.fetch(:by, 1)
+
+      criteria = criteria.to_criteria if criteria.is_a? self.class
+
+      criteria.each do |doc|
+        doc.inc(position_field, by_how_much)
+      end
+    end
+
+    def to_criteria
+      embedded_collection.where(_id: _id)
+    end
+
+    def items_in_list
+      embedded_collection.where(scope_condition)
+    end
+
+    def root_collection
+      _parent.db.collection(_parent.collection.name)
+    end
+
+    def embedded_collection
+      _parent.send(metadata.name)
+    end
+  end
+end

data/lib/mongoid/acts_as_list/list/root.rb

@@ -0,0 +1,38 @@
+module Mongoid::ActsAsList
+  module List
+    module Root
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        private
+
+        def define_position_scope(scope_name)
+          raise List::ScopeMissingError, "#acts_as_list requires a scope option" if scope_name.blank?
+
+          scope_name = "#{scope_name}_id".intern if scope_name.to_s !~ /_id$/
+          define_method(:scope_condition) { {scope_name => self[scope_name]} }
+        end
+      end
+
+      ## InstanceMethods
+      private
+
+      def shift_position options = {}
+        criteria    = options.fetch(:for, to_criteria)
+        by_how_much = options.fetch(:by, 1)
+
+        criteria = criteria.to_criteria if criteria.is_a? self.class
+
+        db.collection(collection.name).update(criteria.selector, {"$inc" => { position_field => by_how_much }}, {multi: true})
+      end
+
+      def to_criteria
+        self.class.where(_id: _id)
+      end
+
+      def items_in_list
+        self.class.where(scope_condition).and(position_field.ne => nil)
+      end
+    end
+  end
+end

data/lib/mongoid/acts_as_list/list.rb

@@ -0,0 +1,295 @@
+module Mongoid::ActsAsList
+  module List
+    extend ActiveSupport::Concern
+
+    autoload :Root     , 'mongoid/acts_as_list/list/root.rb'
+    autoload :Embedded , 'mongoid/acts_as_list/list/embedded.rb'
+
+    class ScopeMissingError < RuntimeError; end
+
+    module ClassMethods
+      def acts_as_list options = {}
+        field = options.fetch(:field, Mongoid::ActsAsList.configuration.default_position_field).try(:to_sym)
+        scope = options.fetch(:scope, nil).try(:to_sym)
+
+        include list_submodule
+        define_position_field field
+        define_position_scope scope
+      end
+
+      def order_by_position(conditions = {}, order = :asc)
+        order, conditions = [conditions || :asc, {}] unless conditions.is_a? Hash
+        where( conditions ).order_by [[position_field, order], [:created_at, order]]
+      end
+
+    private
+
+      def list_submodule
+        embedded? ? Embedded : Root
+      end
+
+      def define_position_field(field_name)
+        field field_name, type: Integer
+
+        set_callback :validation, :before, if: -> { new? && not_in_list? } do |doc|
+          doc[field_name] = doc.send(:next_available_position_in_list)
+        end
+
+        set_callback :destroy, :after, :shift_later_items_towards_start_of_list, if: -> { in_list? }
+
+        [:define_method, :define_singleton_method].each do |define_method|
+          send(define_method, :position_field) { field_name }
+        end
+      end
+    end
+
+    ## InstanceMethods
+
+    # Public: Moves the item to new position in the list
+    #
+    # where - a Hash specifying where to move the item
+    #           :to                - an Integer representing a position number
+    #                                or a Symbol from the list :start, :top, :end, :bottom
+    #           :before, :above    - another object in the list
+    #           :after: , :below   - another object in the list
+    #           :forward, :lower   - an Integer specify by how much to move the item forward.
+    #                                will stop moving the item when it reaches the end of the list
+    #           :backward, :higher - an Integer specify by how much to move the item forward.
+    #                                will stop moving the item when it reaches the end of the list
+    #
+    #         or a Symbol in :forward, :lower, :backward, :higher
+    #
+    # Examples
+    #
+    #   item.move to: 3
+    #   #=> moves item to the 3rd position
+    #
+    #   item.move to: :start
+    #   #=> moves item to the first position in the list
+    #
+    #   other_item.position #=> 3
+    #
+    #   item.move before: other_item
+    #   #=> moves item to position 3 and other_item to position 4
+    #
+    #   item.move after: other_item
+    #   #=> moves item to position 4
+    #
+    #   item.move backward: 3
+    #   #=> move item 3 positions closer to the start of the list
+    #
+    #   item.move :forward
+    #   #=> same as item.move(forward: 1)
+    #
+    # Returns nothing
+    def move(where = {})
+      if where.is_a? Hash
+        options = [:to, :before, :above, :after, :below, :forward, :forwards, :lower, :backward, :backwards, :higher]
+
+        prefix, destination = where.each.select { |k, _| options.include? k }.first
+        raise ArgumentError, "#move requires one of the following options: #{options.join(', ')}" unless prefix
+
+        send("move_#{prefix}", destination)
+      else
+        destination = where
+
+        send("move_#{destination}")
+      end
+    end
+
+    def move_to(destination)
+      if destination.is_a? Symbol
+        send("move_to_#{destination}")
+      else
+        destination = position_within_list_boundaries(destination)
+        insert_at destination
+      end
+    end
+
+    def move_to_end
+      new_position = in_list? ? last_position_in_list : next_available_position_in_list
+      insert_at new_position
+    end
+    alias_method :move_to_bottom, :move_to_end
+
+    def move_to_start
+      insert_at start_position_in_list
+    end
+    alias_method :move_to_top, :move_to_start
+
+    def move_forwards by_how_much = 1
+      move_to(self[position_field] + by_how_much) unless last?
+    end
+    alias_method :move_lower  , :move_forwards
+    alias_method :move_forward, :move_forwards
+
+    def move_backwards by_how_much = 1
+      move_to(self[position_field] - by_how_much) unless first?
+    end
+    alias_method :move_higher , :move_backwards
+    alias_method :move_forward, :move_forwards
+
+    def move_before(other_item)
+      destination = other_item[position_field]
+      origin = self[position_field]
+
+      if origin > destination
+        insert_at destination
+      else
+        insert_at destination - 1
+      end
+    end
+    alias_method :move_above, :move_before
+
+    def move_after(other_item)
+      destination = other_item[position_field]
+      origin = self[position_field]
+
+      if origin > destination
+        insert_at destination + 1
+      else
+        insert_at destination
+      end
+    end
+    alias_method :move_below, :move_after
+
+    # Public: Removes the item from the list
+    #
+    # Returns true if the item was removed, false if not
+    def remove_from_list
+      return true unless in_list?
+      shift_later_items_towards_start_of_list
+      update_attributes(position_field => nil)
+    end
+
+    # Public: Indicates if an item is in the list
+    #
+    # Returns true if the item is in the list or false if not
+    def in_list?
+      self[position_field].present?
+    end
+
+    # Public: Indicates if an item is not in the list
+    #
+    # Returns true if the item is not in the list or false if it is
+    def not_in_list?
+      !in_list?
+    end
+
+    # Public: Indicates if an item is the first of the list
+    #
+    # Returns true if the item is the first in the list or false if not
+    def first?
+      self[position_field] == start_position_in_list
+    end
+
+    # Public: Indicates if an item is the last of the list
+    #
+    # Returns true if the item is the last in the list or false if not
+    def last?
+      self[position_field] == last_item_in_list[position_field]
+    end
+
+    # Public: Gets the following item in the list
+    #
+    # Returns the next item in the list
+    #   or nil if there isn't a next item
+    def next_item
+      return unless in_list?
+      items_in_list.where(position_field => self[position_field]+1).first
+    end
+    alias_method :higher_item, :next_item
+
+    # Public: Gets the preceding item in the list
+    #
+    # Returns the previous item in the list
+    #   or nil if there isn't a previous item
+    def previous_item
+      return unless in_list?
+      items_in_list.where(position_field => self[position_field]-1).first
+    end
+    alias_method :lower_item, :previous_item
+
+    # Public: Insert at a given position in the list
+    #
+    # new_position - an Integer indicating the position to insert the item at
+    #
+    # Returns nothing
+    def insert_at(new_position)
+      insert_space_at(new_position)
+      update_attribute(position_field, new_position)
+    end
+
+  private
+
+    # Internal: Make space in the list at a given position number
+    #   used when moving a item to a new position in the list.
+    #
+    # position - an Integer representing the position number
+    #
+    # Returns nothing
+    def insert_space_at(position)
+      from = self[position_field] || next_available_position_in_list
+      to   = position
+
+      if from < to
+        shift_position for: items_between(from, to + 1), by: -1
+      else
+        shift_position for: items_between(to - 1, from), by: 1
+      end
+    end
+
+    def items_between(from, to, options = {})
+      strict = options.fetch(:strict, true)
+      if strict
+        items_in_list.where(position_field.gt => from, position_field.lt => to)
+      else
+        items_in_list.where(position_field.gte => from, position_field.lte => to)
+      end
+    end
+
+    def last_item_in_list
+      items_in_list.order_by_position.last
+    end
+
+    def last_position_in_list
+      last_item_in_list.try(position_field)
+    end
+
+    def previous_items_in_list
+      items_in_list.where(position_field.lt => self[position_field])
+    end
+
+    def next_items_in_list
+      items_in_list.where(position_field.gt => self[position_field])
+    end
+
+    def shift_later_items_towards_start_of_list
+      return unless in_list?
+      shift_position for: next_items_in_list, by: -1
+    end
+
+    def next_available_position_in_list
+      if item = last_item_in_list
+        item[position_field] + 1
+      else
+        start_position_in_list
+      end
+    end
+
+    def first_position_in_list
+      Mongoid::ActsAsList.configuration.start_list_at
+    end
+    alias_method :start_position_in_list, :first_position_in_list
+
+    def position_within_list_boundaries(position)
+      if position < start_position_in_list
+        position = start_position_in_list
+      elsif position > last_position_in_list
+        position = last_position_in_list
+      end
+
+      position
+    end
+  end
+end

data/lib/mongoid/acts_as_list/version.rb

@@ -0,0 +1,5 @@
+module Mongoid
+  module ActsAsList
+    VERSION = "0.0.3"
+  end
+end

data/lib/mongoid_acts_as_list.rb

@@ -0,0 +1,21 @@
+require_relative 'mongoid/acts_as_list/list'
+require_relative 'mongoid/acts_as_list/configuration'
+require_relative 'mongoid/acts_as_list/version'
+
+module Mongoid
+  module ActsAsList
+    class << self
+      attr_accessor :configuration
+
+      def configure
+        self.configuration ||= Configuration.new
+        yield(configuration) if block_given?
+      end
+
+      def included base
+        self.configure
+        base.send :include, List
+      end
+    end
+  end
+end

data/spec/acts_as_list/embeds_many_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe Mongoid::ActsAsList::List do
+  [:position, :number].each do |default_field_name|
+    let(:position_field) { default_field_name }
+
+    before do
+      Mongoid::ActsAsList.configure do |config|
+        config.default_position_field = position_field
+      end
+
+      require 'fixtures/embeds_many_models'
+    end
+
+    describe Mongoid::ActsAsList::List::Embedded do
+      let(:category_1) { Category.create! }
+      let(:category_2) { Category.create! }
+      let(:category_3) { Category.create! }
+
+      before do
+        [category_1, category_2].each do |cat|
+          3.times do |n|
+            cat.items.create! position_field => n
+          end
+          cat.should have(3).items
+        end
+      end
+
+      it "should be embedded" do
+        EmbeddedItem.should be_embedded
+      end
+
+      it "should not include ActsAsList::Relational" do
+        EmbeddedItem.included_modules.should_not include Mongoid::ActsAsList::List::Root
+      end
+
+      it_behaves_like 'a list'
+
+      describe ".acts_as_list" do
+        it "defines #scope_condition" do
+          item = category_1.items.first
+          item.scope_condition.should == {position_field.ne => nil}
+        end
+      end
+    end
+  end
+end