mongoid_orderable 5.0.0 → 6.0.2

data/lib/mongoid/orderable/generators/position.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Mongoid
+module Orderable
+module Generators
+  class Position < Base
+    def generate(field_name)
+      klass.class_eval <<~KLASS, __FILE__, __LINE__ + 1
+        def orderable_position(field = nil)
+          field ||= default_orderable_field
+          send "orderable_\#{field}_position"
+        end
+      KLASS
+
+      generate_method("orderable_#{field_name}_position") do
+        send field_name
+      end
+
+      generate_method("orderable_#{field_name}_position=") do |value|
+        send "#{field_name}=", value
+      end
+    end
+  end
+end
+end
+end

data/lib/mongoid/orderable/generators/scope.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Mongoid
+module Orderable
+module Generators
+  class Scope < Base
+    def generate(field_name, order_scope)
+      criteria = criteria(order_scope)
+      klass.class_eval do
+        scope "orderable_#{field_name}_scope", criteria
+      end
+    end
+
+    protected
+
+    def criteria(order_scope)
+      case order_scope
+      when Proc then order_scope
+      when Array then ->(doc) { where(order_scope.each_with_object({}) {|f, h| h[f] = doc.send(f) }) }
+      else ->(_doc) { where({}) }
+      end
+    end
+  end
+end
+end
+end

data/lib/mongoid/orderable/handlers/base.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+module Mongoid
+module Orderable
+module Handlers
+  class Base
+    attr_reader :doc
+
+    def initialize(doc)
+      @doc = doc
+    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 use_transactions
+      false
+    end
+
+    def any_field_changed?
+      orderable_keys.any? {|field| changed?(field) }
+    end
+
+    def apply_all_positions
+      orderable_keys.map {|field| apply_one_position(field, move_all[field]) }
+    end
+
+    def apply_one_position(field, target_position)
+      return unless changed?(field)
+
+      set_lock(field) if use_transactions
+
+      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? && 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).send(: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?
+      doc.send("orderable_#{field}_position=", target)
+    end
+
+    def remove_all_positions
+      orderable_keys.each do |field|
+        remove_one_position(field)
+      end
+    end
+
+    def remove_one_position(field)
+      f = orderable_field(field)
+      current = orderable_position(field)
+      set_lock(field) if use_transactions
+      orderable_scope(field).gt(f => current).inc(f => -1)
+    end
+
+    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, generic = false)
+      return unless use_transactions
+      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, generic)
+      model.where(attrs).find_one_and_update(attrs, { upsert: true })
+    end
+
+    def lock_scope(field, generic = false)
+      sel = orderable_scope(field).selector
+      scope = ([collection_name] + (generic ? [field] : sel.to_a.flatten)).map(&:to_s).join('|')
+      { scope: scope }
+    end
+  end
+end
+end
+end

data/lib/mongoid/orderable/handlers/document.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Mongoid
+module Orderable
+module Handlers
+  class Document < Base
+    def before_create
+      apply_all_positions
+    end
+
+    def after_create; end
+
+    def before_update
+      return unless any_field_changed?
+      apply_all_positions
+    end
+
+    def after_destroy
+      remove_all_positions
+    end
+  end
+end
+end
+end

data/lib/mongoid/orderable/handlers/document_embedded.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Mongoid
+module Orderable
+module Handlers
+  class DocumentEmbedded < Document
+    def after_destroy
+      return if doc._root.destroyed?
+      super
+    end
+  end
+end
+end
+end

data/lib/mongoid/orderable/handlers/document_transactional.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Mongoid
+module Orderable
+module Handlers
+  class DocumentTransactional < Document
+    def before_create
+      clear_all_positions
+    end
+
+    def after_create
+      apply_all_positions
+    end
+
+    protected
+
+    def apply_all_positions
+      with_transaction { super }
+    end
+
+    def clear_all_positions
+      orderable_keys.each {|field| doc.send("orderable_#{field}_position=", nil) }
+    end
+
+    def use_transactions
+      true
+    end
+
+    def with_transaction(&block)
+      Mongoid::Orderable::Handlers::Transaction.new(doc).with_transaction(&block)
+    end
+  end
+end
+end
+end

data/lib/mongoid/orderable/handlers/transaction.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Mongoid
+module Orderable
+module Handlers
+  # Executes a block within the context of a MongoDB transaction.
+  class Transaction
+    THREAD_KEY = :__mongoid_orderable_in_txn
+    RETRY_SLEEP = 0.001
+
+    attr_reader :doc
+
+    def initialize(doc)
+      @doc = doc
+    end
+
+    def with_transaction(&block)
+      Mongoid::QueryCache.uncached do
+        if Thread.current[THREAD_KEY]
+          yield
+        else
+          Thread.current[THREAD_KEY] = true
+          retries = transaction_max_retries
+          begin
+            do_transaction(&block)
+          rescue Mongo::Error::OperationFailure => e
+            sleep(RETRY_SLEEP)
+            retries -= 1
+            retry if retries >= 0
+            raise Mongoid::Orderable::Errors::TransactionFailed.new(e)
+          ensure
+            Thread.current[THREAD_KEY] = nil
+          end
+        end
+      end
+    end
+
+    protected
+
+    def do_transaction(&_block)
+      doc.class.with_session(session_opts) do |session|
+        doc.class.with(persistence_opts) do
+          session.start_transaction(transaction_opts)
+          yield
+          session.commit_transaction
+        end
+      end
+    end
+
+    def session_opts
+      { read: { mode: :primary },
+        causal_consistency: true }
+    end
+
+    def persistence_opts
+      { read: { mode: :primary } }
+    end
+
+    def transaction_opts
+      { read: { mode: :primary },
+        read_concern: { level: 'majority' },
+        write_concern: { w: 'majority' } }
+    end
+
+    def transaction_max_retries
+      doc.orderable_keys.map {|k| doc.class.orderable_configs.dig(k, :transaction_max_retries) }.compact.max
+    end
+  end
+end
+end
+end

data/lib/mongoid/orderable/installer.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Mongoid
+module Orderable
+  class Installer
+    attr_reader :klass, :config
+
+    def initialize(klass, options = {})
+      @klass = klass
+      @config = Mongoid::Orderable::Configs::FieldConfig.new(klass, options).options
+    end
+
+    def setup
+      add_db_field
+      add_db_index if config[:index]
+      save_config
+      include_mixins
+      generate_all_helpers
+    end
+
+    protected
+
+    def field_name
+      config[:field_options][:as] || config[:field]
+    end
+
+    def order_scope
+      config[:scope]
+    end
+
+    def add_db_field
+      klass.field(config[:field], { type: Integer }.reverse_merge(config[:field_options]))
+    end
+
+    def add_db_index
+      spec = [[config[:field], 1]]
+      config[:scope].each {|field| spec.unshift([field, 1]) } if config[:scope].is_a?(Array)
+      klass.index(Hash[spec])
+    end
+
+    def save_config
+      klass.orderable_configs ||= {}
+      klass.orderable_configs = klass.orderable_configs.merge(field_name => config)
+    end
+
+    def include_mixins
+      klass.send :include, Mixins::Helpers
+      klass.send :include, Mixins::Callbacks
+      klass.send :include, Mixins::Movable
+      klass.send :include, Mixins::Listable
+    end
+
+    def generate_all_helpers
+      Generators::Scope.new(klass).generate(field_name, order_scope)
+      Generators::Position.new(klass).generate(field_name)
+      Generators::Movable.new(klass).generate(field_name)
+      Generators::Listable.new(klass).generate(field_name)
+      Generators::Helpers.new(klass).generate
+      Generators::LockCollection.new.generate(config[:lock_collection])
+    end
+  end
+end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Mongoid
+module Orderable
+module Mixins
+  module Callbacks
+    extend ActiveSupport::Concern
+
+    ORDERABLE_TRANSACTION_KEY = :__mongoid_orderable_in_txn
+
+    included do
+      before_create :orderable_before_create
+      after_create :orderable_after_create, prepend: true
+      before_update :orderable_before_update
+      after_destroy :orderable_after_destroy, prepend: true
+
+      delegate :before_create,
+               :after_create,
+               :before_update,
+               :after_destroy,
+               to: :orderable_handler,
+               prefix: :orderable
+
+      protected
+
+      def orderable_handler
+        @orderable_handler ||= self.class.orderable_handler_class.new(self)
+      end
+
+      def self.orderable_handler_class
+        if embedded?
+          Mongoid::Orderable::Handlers::DocumentEmbedded
+        elsif orderable_configs.values.any? {|c| c[:use_transactions] }
+          Mongoid::Orderable::Handlers::DocumentTransactional
+        else
+          Mongoid::Orderable::Handlers::Document
+        end
+      end
+    end
+  end
+end
+end
+end