mongoid_orderable 0.0.1

data/.gitignore

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

data/.rspec

@@ -0,0 +1 @@
+--colour

data/.rvmrc

@@ -0,0 +1 @@
+rvm use 1.9.2@mongoid_orderable --create

data/Gemfile

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

data/Rakefile

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

data/lib/mongoid/orderable.rb

@@ -0,0 +1,163 @@
+module Mongoid::Orderable
+  extend ActiveSupport::Concern
+
+  included do
+    orderable
+  end
+
+  module ClassMethods
+    def orderable options = {}
+      configuration = {
+        :column => :position,
+        :scope => nil
+      }
+
+      configuration.update options if options.is_a?(Hash)
+      field configuration[:column], type: Integer
+      index configuration[:column]
+
+      configuration[:scope] = "#{configuration[:scope]}_id".to_sym if configuration[:scope].is_a?(Symbol) && configuration[:scope].to_s !~ /_id$/
+
+      case configuration[:scope]
+      when Symbol then
+        scope :orderable_scope, lambda { |document| where(configuration[:scope] => document.send(configuration[:scope])) }
+      when Proc then
+        scope :orderable_scope, configuration[:scope]
+      else
+        scope :orderable_scope, lambda { |document| where }
+      end
+
+      define_method :orderable_column do
+        configuration[:column]
+      end
+
+      before_save :add_to_list
+      after_destroy :remove_from_list
+    end
+  end
+
+  module InstanceMethods
+
+    def move_to! target_position
+      @move_to = target_position
+      save
+    end
+    alias_method :insert_at!, :move_to!
+
+    def move_to target_position
+      @move_to = target_position
+    end
+    alias_method :insert_at, :move_to
+
+    def move_to= target_position
+      @move_to = target_position
+    end
+    alias_method :insert_at=, :move_to=
+
+    [:top, :bottom].each do |symbol|
+      define_method "move_to_#{symbol}" do
+        move_to symbol
+      end
+
+      define_method "move_to_#{symbol}!" do
+        move_to! symbol
+      end
+    end
+
+    [:higher, :lower].each do |symbol|
+      define_method "move_#{symbol}" do
+        move_to symbol
+      end
+
+      define_method "move_#{symbol}!" do
+        move_to! symbol
+      end
+    end
+
+    def first?
+      in_list? && orderable_position == 1
+    end
+
+    def last?
+      in_list? && orderable_position == bottom_orderable_position
+    end
+
+    def in_list?
+      !orderable_position.nil?
+    end
+
+    def add_to_list
+      apply_position @move_to
+    end
+
+    def remove_from_list
+      orderable_scoped.where(orderable_column.gt => orderable_position).inc(orderable_column => -1)
+    end
+
+  private
+
+    def orderable_position
+      send orderable_column
+    end
+
+    def orderable_position= value
+      send "#{orderable_column}=", value
+    end
+
+    def orderable_scoped
+      if embedded?
+        send(metadata.inverse).send(metadata.name).orderable_scope(self)
+      else
+        self.class.orderable_scope(self)
+      end
+    end
+
+    def orderable_scope_changed?
+      !orderable_scoped.where(:_id => _id).exists?
+    end
+
+    def apply_position target_position
+      if persisted? && !embedded? && orderable_scope_changed?
+        self.class.find(_id).remove_from_list
+        self.orderable_position = nil
+      end
+        
+      return if !target_position && in_list?
+
+      target_position = target_position_to_position target_position
+
+      unless in_list?
+        orderable_scoped.where(orderable_column.gte => target_position).inc(orderable_column => 1)
+      else
+        orderable_scoped.where(orderable_column.gte => target_position, orderable_column.lt => orderable_position).inc(orderable_column => 1) if target_position < orderable_position
+        orderable_scoped.where(orderable_column.gt => orderable_position, orderable_column.lte => target_position).inc(orderable_column => -1) if target_position > orderable_position
+      end
+
+      self.orderable_position = target_position
+    end
+
+    def target_position_to_position target_position
+      target_position = :bottom unless target_position
+
+      target_position = case target_position.to_sym
+        when :top then 1
+        when :bottom then bottom_orderable_position
+        when :higher then orderable_position.pred
+        when :lower then orderable_position.next
+      end unless target_position.is_a? Numeric
+
+      target_position = 1 if target_position < 1
+      target_position = bottom_orderable_position if target_position > bottom_orderable_position
+      target_position
+    end
+
+    def bottom_orderable_position
+      @bottom_orderable_position = begin
+        max = orderable_scoped.max(orderable_column).to_i
+        in_list? ? max : max.next
+      end
+    end
+
+  end
+
+end

data/lib/mongoid_orderable/mongoid/contexts/enumerable.rb

@@ -0,0 +1,17 @@
+module MongoidOrderable #:nodoc:
+  module Mongoid #:nodoc:
+    module Contexts #:nodoc:
+      module Enumerable #:nodoc:
+        def inc attributes = {}
+          iterate do |doc|
+            attributes.each do |attribute, value|
+              doc.inc(attribute, value)
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+Mongoid::Contexts::Enumerable.send :include, MongoidOrderable::Mongoid::Contexts::Enumerable

data/lib/mongoid_orderable/mongoid/contexts/mongo.rb

@@ -0,0 +1,18 @@
+module MongoidOrderable #:nodoc:
+  module Mongoid #:nodoc:
+    module Contexts #:nodoc:
+      module Mongo #:nodoc:
+        def inc attributes = {}
+          klass.collection.update(
+            selector,
+            { "$inc" => attributes },
+            :multi => true,
+            :safe => ::Mongoid.persist_in_safe_mode
+          )
+        end
+      end
+    end
+  end
+end
+
+Mongoid::Contexts::Mongo.send :include, MongoidOrderable::Mongoid::Contexts::Mongo

data/lib/mongoid_orderable/mongoid/criteria.rb

@@ -0,0 +1,4 @@
+Mongoid::Criteria.delegate :inc, :to => :context
+Mongoid::Finders.send :define_method, :inc do |*args|
+  criteria.send :inc, *args
+end

data/lib/mongoid_orderable/version.rb

@@ -0,0 +1,3 @@
+module MongoidOrderable
+  VERSION = "0.0.1"
+end

data/lib/mongoid_orderable.rb

@@ -0,0 +1,11 @@
+require 'mongoid'
+require 'mongoid_orderable/version'
+require 'mongoid_orderable/mongoid/contexts/mongo'
+require 'mongoid_orderable/mongoid/contexts/enumerable'
+require 'mongoid_orderable/mongoid/criteria'
+
+require 'mongoid/orderable'
+
+module MongoidOrderable
+  
+end

data/mongoid_orderable.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "mongoid_orderable/version"
+
+Gem::Specification.new do |s|
+  s.name        = "mongoid_orderable"
+  s.version     = MongoidOrderable::VERSION
+  s.authors     = ["pyromaniac"]
+  s.email       = ["kinwizard@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Acts as list mongoid implementation}
+  s.description = %q{Gem allows mongoid model behave as orderable list}
+
+  s.rubyforge_project = "mongoid_orderable"
+
+  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_runtime_dependency "mongoid"
+end

data/spec/mongoid/orderable_spec.rb

@@ -0,0 +1,254 @@
+require 'spec_helper'
+
+describe Mongoid::Orderable do
+  class SimpleOrderable
+    include Mongoid::Document
+    include Mongoid::Orderable
+  end
+
+  class ScopedGroup
+    include Mongoid::Document
+
+    has_many :scoped_orderables
+  end
+
+  class ScopedOrderable
+    include Mongoid::Document
+    include Mongoid::Orderable
+
+    belongs_to :scoped_group
+
+    orderable :scope => :group
+  end
+
+
+
+  class EmbedsOrderable
+    include Mongoid::Document
+
+    embeds_many :embedded_orderables
+  end
+
+  class EmbeddedOrderable
+    include Mongoid::Document
+    include Mongoid::Orderable
+
+    embedded_in :embeds_orderable
+  end
+
+
+  describe SimpleOrderable do
+    before :each do
+      SimpleOrderable.delete_all
+      5.times do
+        SimpleOrderable.create!
+      end
+    end
+
+    def positions
+      SimpleOrderable.order_by(:position, :asc).map(&:position)
+    end
+
+    it 'should have proper position column' do
+      SimpleOrderable.fields.key?('position').should be_true
+      SimpleOrderable.fields['position'].options[:type].should == Integer
+    end
+
+    it 'should set proper position while creation' do
+      positions.should == [1, 2, 3, 4, 5]
+    end
+
+    describe 'removement' do
+
+      it 'top' do
+        SimpleOrderable.where(:position => 1).destroy
+        positions.should == [1, 2, 3, 4]
+      end
+
+      it 'bottom' do
+        SimpleOrderable.where(:position => 5).destroy
+        positions.should == [1, 2, 3, 4]
+      end
+
+      it 'middle' do
+        SimpleOrderable.where(:position => 3).destroy
+        positions.should == [1, 2, 3, 4]
+      end
+
+    end
+
+    describe 'inserting' do
+
+      it 'top' do
+        newbie = SimpleOrderable.create! :move_to => :top
+        positions.should == [1, 2, 3, 4, 5, 6]
+      end
+
+      it 'bottom' do
+        newbie = SimpleOrderable.create! :move_to => :bottom
+        positions.should == [1, 2, 3, 4, 5, 6]
+      end
+
+      it 'middle' do
+        newbie = SimpleOrderable.create! :move_to => 4
+        positions.should == [1, 2, 3, 4, 5, 6]
+      end
+
+    end
+
+    describe 'movement' do
+
+      it 'higher from top' do
+        record = SimpleOrderable.where(:position => 1).first
+        record.update_attributes :move_to => :higher
+        positions.should == [1, 2, 3, 4, 5]
+        record.reload.position.should == 1
+      end
+
+      it 'higher from bottom' do
+        record = SimpleOrderable.where(:position => 5).first
+        record.update_attributes :move_to => :higher
+        positions.should == [1, 2, 3, 4, 5]
+        record.reload.position.should == 4
+      end
+
+      it 'higher from middle' do
+        record = SimpleOrderable.where(:position => 3).first
+        record.update_attributes :move_to => :higher
+        positions.should == [1, 2, 3, 4, 5]
+        record.reload.position.should == 2
+      end
+
+      it 'lower from top' do
+        record = SimpleOrderable.where(:position => 1).first
+        record.update_attributes :move_to => :lower
+        positions.should == [1, 2, 3, 4, 5]
+        record.reload.position.should == 2
+      end
+
+      it 'lower from bottom' do
+        record = SimpleOrderable.where(:position => 5).first
+        record.update_attributes :move_to => :lower
+        positions.should == [1, 2, 3, 4, 5]
+        record.reload.position.should == 5
+      end
+
+      it 'lower from middle' do
+        record = SimpleOrderable.where(:position => 3).first
+        record.update_attributes :move_to => :lower
+        positions.should == [1, 2, 3, 4, 5]
+        record.reload.position.should == 4
+      end
+
+      it "does nothing if position not change" do
+        record = SimpleOrderable.where(:position => 3).first
+        record.save
+        positions.should == [1, 2, 3, 4, 5]
+        record.reload.position.should == 3
+      end
+
+    end
+
+  end
+
+  describe ScopedOrderable do
+    before :each do
+      ScopedOrderable.delete_all
+      2.times do
+        ScopedOrderable.create! :group_id => 1
+      end
+      3.times do
+        ScopedOrderable.create! :group_id => 2
+      end
+    end
+
+    def positions
+      ScopedOrderable.order_by([:group_id, :asc], [:position, :asc]).map(&:position)
+    end
+
+    it 'should set proper position while creation' do
+      positions.should == [1, 2, 1, 2, 3]
+    end
+
+    describe 'removement' do
+
+      it 'top' do
+        ScopedOrderable.where(:position => 1, :group_id => 1).destroy
+        positions.should == [1, 1, 2, 3]
+      end
+
+      it 'bottom' do
+        ScopedOrderable.where(:position => 3, :group_id => 2).destroy
+        positions.should == [1, 2, 1, 2]
+      end
+
+      it 'middle' do
+        ScopedOrderable.where(:position => 2, :group_id => 2).destroy
+        positions.should == [1, 2, 1, 2]
+      end
+
+    end
+
+    describe 'inserting' do
+
+      it 'top' do
+        newbie = ScopedOrderable.create! :move_to => :top, :group_id => 1
+        positions.should == [1, 2, 3, 1, 2, 3]
+      end
+
+      it 'bottom' do
+        newbie = ScopedOrderable.create! :move_to => :bottom, :group_id => 2
+        positions.should == [1, 2, 1, 2, 3, 4]
+      end
+
+      it 'middle' do
+        newbie = ScopedOrderable.create! :move_to => 2, :group_id => 2
+        positions.should == [1, 2, 1, 2, 3, 4]
+      end
+
+    end
+
+    describe "scope movement" do
+
+      it "without point on position" do
+        record = ScopedOrderable.where(:group_id => 2, :position => 2).first
+        record.update_attributes :group_id => 1
+        positions.should == [1, 2, 3, 1, 2]
+        record.reload.position.should == 3
+      end
+
+      it "with point on position" do
+        record = ScopedOrderable.where(:group_id => 2, :position => 2).first
+        record.update_attributes :group_id => 1, :move_to => :top
+        positions.should == [1, 2, 3, 1, 2]
+        record.reload.position.should == 1
+      end
+
+    end
+
+  end
+
+  describe EmbeddedOrderable do
+    before :each do
+      EmbedsOrderable.delete_all
+      eo = EmbedsOrderable.create!
+      2.times do
+        eo.embedded_orderables.create!
+      end
+      eo = EmbedsOrderable.create!
+      3.times do
+        eo.embedded_orderables.create!
+      end
+    end
+
+    def positions
+      EmbedsOrderable.order_by(:position).all.map { |eo| eo.embedded_orderables.order_by(:position).map(&:position) }
+    end
+
+    it 'should set proper position while creation' do
+      positions.should == [[1, 2], [1, 2, 3]]
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,27 @@
+require 'bundler'
+Bundler.require
+
+DATABASE_ID = Process.pid
+
+Mongoid.configure do |config|
+  database = Mongo::Connection.new.db("mongoid_#{DATABASE_ID}")
+  database.add_user("mongoid", "test")
+  config.master = database
+  config.logger = nil
+end
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+
+  config.before :suite do
+    #DatabaseCleaner[:mongoid].strategy = :truncation
+  end
+
+  config.after :each do
+    #DatabaseCleaner[:mongoid].clean
+  end
+
+  config.after(:suite) do
+    Mongoid.master.connection.drop_database("mongoid_#{DATABASE_ID}")
+  end
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: mongoid_orderable
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- pyromaniac
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-11-11 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &23255180 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *23255180
+- !ruby/object:Gem::Dependency
+  name: mongoid
+  requirement: &23303440 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *23303440
+description: Gem allows mongoid model behave as orderable list
+email:
+- kinwizard@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .rvmrc
+- Gemfile
+- README
+- Rakefile
+- lib/mongoid/orderable.rb
+- lib/mongoid_orderable.rb
+- lib/mongoid_orderable/mongoid/contexts/enumerable.rb
+- lib/mongoid_orderable/mongoid/contexts/mongo.rb
+- lib/mongoid_orderable/mongoid/criteria.rb
+- lib/mongoid_orderable/version.rb
+- mongoid_orderable.gemspec
+- spec/mongoid/orderable_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+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: mongoid_orderable
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: Acts as list mongoid implementation
+test_files: []