mongoid_orderable 5.0.0 → 6.0.2

data/lib/mongoid/orderable/mixins/helpers.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Mongoid
+module Orderable
+module Mixins
+  module Helpers
+    def orderable_keys
+      Array(orderable_inherited_class.orderable_configs.try(:keys))
+    end
+
+    def default_orderable_field
+      self.class.orderable_configs.detect {|_c, conf| conf[:default] }.try(:first) || orderable_keys.first
+    end
+
+    def orderable_scope(field = nil)
+      field ||= default_orderable_field
+
+      if embedded?
+        _parent.send(_association.name).send("orderable_#{field}_scope", self)
+      else
+        orderable_inherited_class.send("orderable_#{field}_scope", self)
+      end
+    end
+
+    def orderable_scope_changed?(field)
+      !orderable_scope(field).where(_id: _id).exists?
+    end
+
+    def orderable_bottom(field = nil, in_list = true)
+      field ||= default_orderable_field
+      f = orderable_field(field)
+      max = orderable_scope(field).ne(f => nil).max(f)
+      return orderable_top(field) unless max
+      in_list ? max : max.next
+    end
+  end
+end
+end
+end

data/lib/mongoid/orderable/mixins/listable.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Mongoid
+module Orderable
+module Mixins
+  module Listable
+    def in_list?(field = nil)
+      persisted? && !orderable_position(field).nil?
+    end
+
+    # Returns items above the current document.
+    # Items with a position lower than this document's position.
+    def previous_items(field = nil)
+      field ||= default_orderable_field
+      orderable_scope(field).lt(orderable_field(field) => send(field))
+    end
+    alias prev_items previous_items
+
+    # Returns items below the current document.
+    # Items with a position greater than this document's position.
+    def next_items(field = nil)
+      field ||= default_orderable_field
+      orderable_scope(field).gt(orderable_field(field) => send(field))
+    end
+
+    # Returns the previous item in the list
+    def previous_item(field = nil)
+      field ||= default_orderable_field
+      orderable_scope(field).where(orderable_field(field) => send(field) - 1).first
+    end
+    alias prev_item previous_item
+
+    # Returns the next item in the list
+    def next_item(field = nil)
+      field ||= default_orderable_field
+      orderable_scope(field).where(orderable_field(field) => send(field) + 1).first
+    end
+
+    def first?(field = nil)
+      in_list?(field) && orderable_position(field) == orderable_top(field)
+    end
+
+    def last?(field = nil)
+      in_list?(field) && orderable_position(field) == orderable_bottom(field)
+    end
+  end
+end
+end
+end

data/lib/mongoid/orderable/mixins/movable.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Mongoid
+module Orderable
+module Mixins
+  module Movable
+    def move_to!(target_position, options = {})
+      move_field_to target_position, options
+      save
+    end
+    alias insert_at! move_to!
+
+    def move_to(target_position, options = {})
+      move_field_to target_position, options
+    end
+    alias insert_at move_to
+
+    def move_to=(target_position, options = {})
+      move_field_to target_position, options
+    end
+    alias insert_at= move_to=
+
+    %i[top bottom].each do |symbol|
+      class_eval <<~KLASS, __FILE__, __LINE__ + 1
+        def move_to_#{symbol}(options = {})
+          move_to :#{symbol}, options
+        end
+
+        def move_to_#{symbol}!(options = {})
+          move_to! :#{symbol}, options
+        end
+      KLASS
+    end
+
+    %i[higher lower].each do |symbol|
+      class_eval <<~KLASS, __FILE__, __LINE__ + 1
+        def move_#{symbol}(options = {})
+          move_to :#{symbol}, options
+        end
+
+        def move_#{symbol}!(options = {})
+          move_to! :#{symbol}, options
+        end
+      KLASS
+    end
+
+    protected
+
+    def move_all
+      @move_all || {}
+    end
+
+    def move_field_to(position, options)
+      field = options[:field] || default_orderable_field
+      @move_all = move_all.merge(field => position)
+    end
+  end
+end
+end
+end

data/lib/mongoid/orderable/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Orderable
+    VERSION = '6.0.2'
+  end
+end

data/lib/mongoid_orderable.rb

@@ -1,54 +1,33 @@
-require 'active_support'
-
-I18n.enforce_available_locales = false if I18n.respond_to?(:enforce_available_locales)
-I18n.load_path << File.join(File.dirname(__FILE__), 'config', 'locales', 'en.yml')
-
-require 'mongoid'
-require 'mongoid/compatibility'
-
-module MongoidOrderable
-  if ::Mongoid::Compatibility::Version.mongoid2? || ::Mongoid::Compatibility::Version.mongoid3?
-    def self.inc instance, attribute, value
-      instance.inc attribute, value
-    end
-
-    def self.metadata instance
-      instance.metadata
-    end
-  else
-    def self.inc instance, attribute, value
-      instance.inc(attribute => value)
-    end
-
-    def self.metadata instance
-      instance.relation_metadata
-    end
-  end
-end
-
-require 'mongoid_orderable/version'
-
-if ::Mongoid::Compatibility::Version.mongoid2?
-  require 'mongoid_orderable/mongoid/contexts/mongo'
-  require 'mongoid_orderable/mongoid/contexts/enumerable'
-  require 'mongoid_orderable/mongoid/criteria'
-else
-  require 'mongoid_orderable/mongoid/contextual/memory'
-end
-
-require 'mongoid/orderable'
-require 'mongoid/orderable/errors'
-require 'mongoid/orderable/configuration'
-require 'mongoid/orderable/helpers'
-require 'mongoid/orderable/callbacks'
-require 'mongoid/orderable/listable'
-require 'mongoid/orderable/movable'
-
-require 'mongoid/orderable/generator/listable'
-require 'mongoid/orderable/generator/movable'
-require 'mongoid/orderable/generator/position'
-require 'mongoid/orderable/generator/scope'
-require 'mongoid/orderable/generator/helpers'
-require 'mongoid/orderable/generator'
-
-require 'mongoid/orderable/orderable_class'
+# frozen_string_literal: true
+
+require 'active_support'
+
+I18n.enforce_available_locales = false if I18n.respond_to?(:enforce_available_locales)
+I18n.load_path << File.join(File.dirname(__FILE__), 'config', 'locales', 'en.yml')
+
+require 'mongoid'
+
+require 'mongoid/orderable/version'
+
+require 'mongoid/orderable'
+require 'mongoid/orderable/configs/global_config'
+require 'mongoid/orderable/configs/field_config'
+require 'mongoid/orderable/errors/invalid_target_position'
+require 'mongoid/orderable/errors/transaction_failed'
+require 'mongoid/orderable/mixins/helpers'
+require 'mongoid/orderable/mixins/callbacks'
+require 'mongoid/orderable/mixins/listable'
+require 'mongoid/orderable/mixins/movable'
+require 'mongoid/orderable/generators/base'
+require 'mongoid/orderable/generators/listable'
+require 'mongoid/orderable/generators/lock_collection'
+require 'mongoid/orderable/generators/movable'
+require 'mongoid/orderable/generators/position'
+require 'mongoid/orderable/generators/scope'
+require 'mongoid/orderable/generators/helpers'
+require 'mongoid/orderable/handlers/base'
+require 'mongoid/orderable/handlers/document'
+require 'mongoid/orderable/handlers/document_embedded'
+require 'mongoid/orderable/handlers/document_transactional'
+require 'mongoid/orderable/handlers/transaction'
+require 'mongoid/orderable/installer'

data/spec/integration/concurrency_spec.rb

@@ -0,0 +1,232 @@
+require 'spec_helper'
+
+describe 'concurrency' do
+  enable_transactions!
+
+  describe 'simple create' do
+
+    it 'should correctly insert at the top' do
+      20.times.map do
+        Thread.new do
+          SimpleOrderable.create!(move_to: :top)
+        end
+      end.each(&:join)
+
+      expect(SimpleOrderable.pluck(:position).sort).to eq((1..20).to_a)
+    end
+
+    it 'should correctly insert at the bottom' do
+      20.times.map do
+        Thread.new do
+          SimpleOrderable.create!
+        end
+      end.each(&:join)
+
+      expect(SimpleOrderable.pluck(:position).sort).to eq((1..20).to_a)
+    end
+
+    it 'should correctly insert at a random position' do
+      20.times.map do
+        Thread.new do
+          SimpleOrderable.create!(move_to: (1..10).to_a.sample)
+        end
+      end.each(&:join)
+
+      expect(SimpleOrderable.pluck(:position).sort).to eq((1..20).to_a)
+    end
+  end
+
+  describe 'simple update' do
+    before :each do
+      5.times { SimpleOrderable.create! }
+    end
+
+    it 'should correctly move items to top' do
+      20.times.map do
+        Thread.new do
+          record = SimpleOrderable.all.sample
+          record.update_attributes move_to: :top
+        end
+      end.each(&:join)
+
+      expect(SimpleOrderable.pluck(:position).sort).to eq([1, 2, 3, 4, 5])
+    end
+
+    it 'should correctly move items to bottom' do
+      20.times.map do
+        Thread.new do
+          record = SimpleOrderable.all.sample
+          record.update_attributes move_to: :bottom
+        end
+      end.each(&:join)
+
+      expect(SimpleOrderable.pluck(:position).sort).to eq([1, 2, 3, 4, 5])
+    end
+
+    it 'should correctly move items higher' do
+      20.times.map do
+        Thread.new do
+          record = SimpleOrderable.all.sample
+          record.update_attributes move_to: :higher
+        end
+      end.each(&:join)
+
+      expect(SimpleOrderable.pluck(:position).sort).to eq([1, 2, 3, 4, 5])
+    end
+
+    it 'should correctly move items lower' do
+      20.times.map do
+        Thread.new do
+          record = SimpleOrderable.all.sample
+          record.update_attributes move_to: :lower
+        end
+      end.each(&:join)
+
+      expect(SimpleOrderable.pluck(:position).sort).to eq([1, 2, 3, 4, 5])
+    end
+
+    it 'should correctly insert at the top' do
+      20.times.map do
+        Thread.new do
+          SimpleOrderable.create!(move_to: :top)
+        end
+      end.each(&:join)
+
+      expect(SimpleOrderable.pluck(:position).sort).to eq((1..25).to_a)
+    end
+
+    it 'should correctly insert at the bottom' do
+      20.times.map do
+        Thread.new do
+          SimpleOrderable.create!
+        end
+      end.each(&:join)
+
+      expect(SimpleOrderable.pluck(:position).sort).to eq((1..25).to_a)
+    end
+
+    it 'should correctly insert at a random position' do
+      20.times.map do
+        Thread.new do
+          SimpleOrderable.create!(move_to: (1..10).to_a.sample)
+        end
+      end.each(&:join)
+
+      expect(SimpleOrderable.pluck(:position).sort).to eq((1..25).to_a)
+    end
+
+    it 'should correctly move items to a random position' do
+      20.times.map do
+        Thread.new do
+          record = SimpleOrderable.all.sample
+          record.update_attributes move_to: (1..5).to_a.sample
+        end
+      end.each(&:join)
+
+      expect(SimpleOrderable.pluck(:position).sort).to eq([1, 2, 3, 4, 5])
+    end
+  end
+
+  describe 'scoped update' do
+
+    before :each do
+      2.times { ScopedOrderable.create! group_id: 1 }
+      3.times { ScopedOrderable.create! group_id: 2 }
+    end
+
+    it 'should correctly move items to top' do
+      20.times.map do
+        Thread.new do
+          record = ScopedOrderable.all.sample
+          record.update_attributes move_to: :top
+        end
+      end.each(&:join)
+
+      expect(ScopedOrderable.pluck(:position).sort).to eq([1, 1, 2, 2, 3])
+    end
+
+    it 'should correctly move items to bottom' do
+      20.times.map do
+        Thread.new do
+          record = ScopedOrderable.all.sample
+          record.update_attributes move_to: :bottom
+        end
+      end.each(&:join)
+
+      expect(ScopedOrderable.pluck(:position).sort).to eq([1, 1, 2, 2, 3])
+    end
+
+    it 'should correctly move items higher' do
+      20.times.map do
+        Thread.new do
+          record = ScopedOrderable.all.sample
+          record.update_attributes move_to: :higher
+        end
+      end.each(&:join)
+
+      expect(ScopedOrderable.pluck(:position).sort).to eq([1, 1, 2, 2, 3])
+    end
+
+    it 'should correctly move items lower' do
+      20.times.map do
+        Thread.new do
+          record = ScopedOrderable.all.sample
+          record.update_attributes move_to: :lower
+        end
+      end.each(&:join)
+
+      expect(ScopedOrderable.pluck(:position).sort).to eq([1, 1, 2, 2, 3])
+    end
+
+    it 'should correctly move items to a random position' do
+      20.times.map do
+        Thread.new do
+          record = ScopedOrderable.all.sample
+          record.update_attributes move_to: (1..5).to_a.sample
+        end
+      end.each(&:join)
+
+      expect(ScopedOrderable.pluck(:position).sort).to eq([1, 1, 2, 2, 3])
+    end
+
+    # This spec fails randomly
+    it 'should correctly move items to a random scope', retry: 5 do
+      20.times.map do
+        Thread.new do
+          record = ScopedOrderable.all.sample
+          group_id = ([1, 2, 3] - [record.group_id]).sample
+          record.update_attributes group_id: group_id
+        end
+      end.each(&:join)
+
+      result = ScopedOrderable.all.to_a.each_with_object({}) do |obj, hash|
+        hash[obj.group_id] ||= []
+        hash[obj.group_id] << obj.position
+      end
+
+      result.values.each do |ary|
+        expect(ary.sort).to eq((1..(ary.size)).to_a)
+      end
+    end
+
+    it 'should correctly move items to a random position and scope' do
+      20.times.map do
+        Thread.new do
+          record = ScopedOrderable.all.sample
+          group_id = ([1, 2, 3] - [record.group_id]).sample
+          position = (1..5).to_a.sample
+          record.update_attributes group_id: group_id, move_to: position
+        end
+      end.each(&:join)
+
+      result = ScopedOrderable.all.to_a.each_with_object({}) do |obj, hash|
+        hash[obj.group_id] ||= []
+        hash[obj.group_id] << obj.position
+      end
+
+      result.values.each do |ary|
+        expect(ary.sort).to eq((1..(ary.size)).to_a)
+      end
+    end
+  end
+end