mongoid_orderable 4.1.1 → 6.0.1

data/Rakefile

@@ -1,6 +1,24 @@
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
-
-RSpec::Core::RakeTask.new(:spec)
-
-task :default => [ :spec ]
+# frozen_string_literal: true
+
+require 'bundler'
+
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  warn e.message
+  warn 'Run `bundle install` to install missing gems'
+  exit e.status_code
+end
+
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+require 'rubocop/rake_task'
+RuboCop::RakeTask.new(:rubocop)
+
+task default: %i[rubocop spec]

data/lib/config/locales/en.yml

@@ -1,9 +1,12 @@
-en:
-  mongoid:
-    errors:
-      messages:
-        invalid_target_position:
-          message: "`%{value}` is not an acceptable value for target position."
-          summary: "Mongoid::Orderable accepts: a Numeric, a numeric string,
-                    :top, :bottom, or nil."
-          resolution: "You must give an acceptable value for target position."
+en:
+  mongoid:
+    errors:
+      messages:
+        invalid_target_position:
+          message: "`%{value}` is not an acceptable value for target position."
+          summary: "Mongoid::Orderable accepts: a Numeric, a numeric string, :top, :bottom, or nil."
+          resolution: "You must give an acceptable value for target position."
+        transaction_failed:
+          message: "Transaction failed due to a database-level conflict."
+          summary: ""
+          resolution: "Please retry the transaction."

data/lib/mongoid/orderable.rb

@@ -1,22 +1,29 @@
-module Mongoid::Orderable
-  extend ActiveSupport::Concern
-
-  included do
-    include Mongoid::Orderable::Helpers
-    include Mongoid::Orderable::Callbacks
-    include Mongoid::Orderable::Movable
-    include Mongoid::Orderable::Listable
-
-    class_attribute :orderable_configurations
-  end
-
-  module ClassMethods
-
-    def orderable options = {}
-      configuration = Mongoid::Orderable::Configuration.build(self, options)
-
-      Mongoid::Orderable::OrderableClass.setup(self, configuration)
-    end
-
-  end
-end
+# frozen_string_literal: true
+
+module Mongoid
+  module Orderable
+    MUTEX = Mutex.new
+
+    class << self
+      def configure
+        yield(config) if block_given?
+      end
+
+      def config
+        @config || MUTEX.synchronize { @config = ::Mongoid::Orderable::Configs::GlobalConfig.new }
+      end
+    end
+
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :orderable_configs
+    end
+
+    class_methods do
+      def orderable(options = {})
+        Mongoid::Orderable::Installer.new(self, options).setup
+      end
+    end
+  end
+end

data/lib/mongoid/orderable/configs/field_config.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Mongoid
+module Orderable
+module Configs
+  class FieldConfig
+    CONFIG_OPTIONS = %i[field
+                        scope
+                        foreign_key
+                        inherited
+                        base
+                        index
+                        default
+                        use_transactions
+                        transaction_max_retries
+                        lock_collection].freeze
+    ALIASES = { column: :field }.freeze
+    FIELD_OPTIONS = %i[as].freeze
+    VALID_OPTIONS = (CONFIG_OPTIONS | FIELD_OPTIONS).freeze
+
+    attr_reader :orderable_class,
+                :options
+
+    def initialize(parent, options = {})
+      @orderable_class = parent
+      assign_options(options)
+      set_field_options
+      set_orderable_scope
+    end
+
+    def global_config
+      cfg = Mongoid::Orderable.config
+      { field: cfg.field,
+        as: cfg.as,
+        index: cfg.index,
+        base: cfg.base,
+        use_transactions: cfg.use_transactions,
+        transaction_max_retries: cfg.transaction_max_retries,
+        lock_collection: cfg.lock_collection }
+    end
+
+    protected
+
+    def assign_options(options)
+      @options = global_config
+      return unless options.is_a?(Hash)
+      @options = @options.merge(options.symbolize_keys.transform_keys {|k| ALIASES[k] || k }).slice(*VALID_OPTIONS)
+    end
+
+    def set_field_options
+      @options[:field_options] = {}
+      FIELD_OPTIONS.each do |key|
+        next unless @options.key?(key)
+        @options[:field_options][key] = @options.delete(key)
+      end
+    end
+
+    def set_orderable_scope
+      return unless @options[:scope].class.in?([Array, Symbol, String])
+
+      scope = Array(@options[:scope])
+      scope.map! do |value|
+        case value
+        when Symbol
+          relation = @orderable_class.relations[@options[:scope].to_s]&.key&.to_sym
+          relation || value
+        when String
+          value.to_sym
+        else
+          raise ArgumentError.new("Orderable :scope invalid: #{@options[:scope]}")
+        end
+      end
+
+      @options[:scope] = scope
+    end
+  end
+end
+end
+end

data/lib/mongoid/orderable/configs/global_config.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Mongoid
+module Orderable
+module Configs
+  class GlobalConfig
+    attr_accessor :field,
+                  :as,
+                  :base,
+                  :index,
+                  :use_transactions,
+                  :transaction_max_retries,
+                  :lock_collection
+
+    def initialize
+      self.field = :position
+      self.index = true
+      self.base = 1
+      self.use_transactions = false
+      self.transaction_max_retries = 10
+      self.lock_collection = :mongoid_orderable_locks
+    end
+  end
+end
+end
+end

data/lib/mongoid/orderable/engine.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+module Mongoid
+module Orderable
+  class Engine
+    ORDERABLE_TRANSACTION_KEY = :__mongoid_orderable_in_txn
+
+    attr_accessor :doc
+
+    def initialize(doc)
+      @doc = doc
+    end
+
+    # For new records, or if the orderable scope changes,
+    # we must yield the save action inside the transaction.
+    def update_positions(&_block)
+      yield and return unless orderable_keys.any? {|field| changed?(field) }
+
+      new_record = new_record?
+      with_transaction do
+        orderable_keys.map {|field| apply_one_position(field, move_all[field]) }
+        yield if new_record
+      end
+
+      yield unless new_record
+    end
+
+    def remove_positions
+      orderable_keys.each do |field|
+        remove_one_position(field)
+      end
+    end
+
+    def apply_one_position(field, target_position)
+      return unless changed?(field)
+
+      set_lock(field) if use_transactions && !embedded?
+
+      f = orderable_field(field)
+      scope = orderable_scope(field)
+      scope_changed = orderable_scope_changed?(field)
+
+      # Set scope-level lock if scope changed
+      if use_transactions && persisted? && !embedded? && scope_changed
+        set_lock(field, true)
+        scope_changed = orderable_scope_changed?(field)
+      end
+
+      # Get the current position as exists in the database
+      current = if !persisted? || scope_changed
+                  nil
+                elsif persisted? && !embedded?
+                  scope.where(_id: _id).pluck(f).first
+                else
+                  orderable_position(field)
+                end
+
+      # If scope changed, remove the position from the old scope
+      if persisted? && !embedded? && scope_changed
+        existing_doc = doc.class.unscoped.find(_id)
+        self.class.new(existing_doc).remove_one_position(field)
+      end
+
+      # Return if there is no instruction to change the position
+      in_list = persisted? && current
+      return if in_list && !target_position
+
+      # Use $inc operator to shift the position of the other documents
+      target = resolve_target_position(field, target_position, in_list)
+      if !in_list
+        scope.gte(f => target).inc(f => 1)
+      elsif target < current
+        scope.where(f => { '$gte' => target, '$lt' => current }).inc(f => 1)
+      elsif target > current
+        scope.where(f => { '$gt' => current, '$lte' => target }).inc(f => -1)
+      end
+
+      # If persisted, update the field in the database atomically
+      doc.set({ f => target }.merge(changed_scope_hash(field))) if use_transactions && persisted? && !embedded?
+      doc.send("orderable_#{field}_position=", target)
+    end
+
+    def remove_one_position(field)
+      f = orderable_field(field)
+      current = orderable_position(field)
+      set_lock(field) if use_transactions && !embedded?
+      orderable_scope(field).gt(f => current).inc(f => -1)
+    end
+
+    protected
+
+    delegate :orderable_keys,
+             :orderable_field,
+             :orderable_position,
+             :orderable_scope,
+             :orderable_scope_changed?,
+             :orderable_top,
+             :orderable_bottom,
+             :_id,
+             :new_record?,
+             :persisted?,
+             :embedded?,
+             :collection_name,
+             to: :doc
+
+    def move_all
+      doc.send(:move_all)
+    end
+
+    def resolve_target_position(field, target_position, in_list)
+      target_position ||= 'bottom'
+
+      unless target_position.is_a? Numeric
+        target_position = case target_position.to_s
+                          when 'top' then (min ||= orderable_top(field))
+                          when 'bottom' then (max ||= orderable_bottom(field, in_list))
+                          when 'higher' then orderable_position(field).pred
+                          when 'lower' then orderable_position(field).next
+                          when /\A\d+\Z/ then target_position.to_i
+                          else raise Mongoid::Orderable::Errors::InvalidTargetPosition.new(target_position)
+                          end
+      end
+
+      if target_position <= (min ||= orderable_top(field))
+        target_position = min
+      elsif target_position > (max ||= orderable_bottom(field, in_list))
+        target_position = max
+      end
+
+      target_position
+    end
+
+    def changed?(field)
+      return true if new_record? || !doc.send(orderable_field(field)) || move_all[field]
+      changeable_keys(field).any? {|f| doc.send("#{f}_changed?") }
+    end
+
+    def changeable_keys(field)
+      [orderable_field(field)] | scope_keys(field)
+    end
+
+    def scope_keys(field)
+      orderable_scope(field).selector.keys.map do |f|
+        doc.fields[f]&.options&.[](:as) || f
+      end
+    end
+
+    def changed_scope_hash(field)
+      scope_keys(field).each_with_object({}) do |f, hash|
+        hash[f] = doc.send(f) if doc.send("#{f}_changed?")
+      end
+    end
+
+    def set_lock(field, scope_changed = false)
+      return unless use_transactions && !embedded?
+      model_name = doc.class.orderable_configs[field][:lock_collection].to_s.singularize.classify
+      model = Mongoid::Orderable::Models.const_get(model_name)
+      attrs = lock_scope(field, scope_changed)
+      model.where(attrs).find_one_and_update(attrs, { upsert: true })
+    end
+
+    def lock_scope(field, scope_changed = false)
+      sel = orderable_scope(field).selector
+      scope = ([collection_name] + (scope_changed ? sel.keys : sel.to_a.flatten)).map(&:to_s).join('|')
+      { scope: scope }
+    end
+
+    def use_transactions
+      orderable_keys.any? {|k| doc.class.orderable_configs[k][:use_transactions] }
+    end
+
+    def transaction_max_retries
+      orderable_keys.map {|k| doc.class.orderable_configs[k][:transaction_max_retries] }.compact.max
+    end
+
+    def with_transaction(&_block)
+      Mongoid::QueryCache.uncached do
+        if use_transactions && !embedded? && !Thread.current[ORDERABLE_TRANSACTION_KEY]
+          Thread.current[ORDERABLE_TRANSACTION_KEY] = true
+          retries = transaction_max_retries
+          begin
+            doc.class.with_session(causal_consistency: true) do |session|
+              doc.class.with(read: { mode: :primary }) do
+                session.start_transaction(read: { mode: :primary },
+                                          read_concern: { level: 'majority' },
+                                          write_concern: { w: 'majority' })
+                yield
+                session.commit_transaction
+              end
+            end
+          rescue Mongo::Error::OperationFailure => e
+            sleep(0.001)
+            retries -= 1
+            retry if retries >= 0
+            raise Mongoid::Orderable::Errors::TransactionFailed.new(e)
+          ensure
+            Thread.current[ORDERABLE_TRANSACTION_KEY] = nil
+          end
+        else
+          yield
+        end
+      end
+    end
+  end
+end
+end

data/lib/mongoid/orderable/errors/invalid_target_position.rb

@@ -1,18 +1,19 @@
-module Mongoid::Orderable
-  module Errors
-    class InvalidTargetPosition < Mongoid::Orderable::Errors::MongoidOrderableError
-      def initialize value
-        super _compose_message(value)
-      end
-
-      private
-      def _compose_message value
-        if MongoidOrderable.mongoid2?
-          translate 'invalid_target_position', { :value => value.inspect }
-        else
-          compose_message 'invalid_target_position', { :value => value.inspect }
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Mongoid
+module Orderable
+module Errors
+  class InvalidTargetPosition < ::Mongoid::Errors::MongoidError
+    def initialize(value)
+      super _compose_message(value)
+    end
+
+    private
+
+    def _compose_message(value)
+      compose_message 'invalid_target_position', value: value.inspect
+    end
+  end
+end
+end
+end