mongoid_orderable 6.0.5 → 6.0.7

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

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

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

@@ -1,14 +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
+# 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

@@ -1,32 +1,32 @@
-# frozen_string_literal: true
-
-module Mongoid
-module Orderable
-module Handlers
-  class DocumentTransactional < Document
-    def before_create
-      set_new_record_positions
-    end
-
-    def after_create
-      apply_all_positions
-      super
-    end
-
-    private
-
-    def apply_all_positions
-      with_transaction { super }
-    end
-
-    def use_transactions
-      true
-    end
-
-    def with_transaction(&block)
-      Mongoid::Orderable::Handlers::Transaction.new(doc).with_transaction(&block)
-    end
-  end
-end
-end
-end
+# frozen_string_literal: true
+
+module Mongoid
+module Orderable
+module Handlers
+  class DocumentTransactional < Document
+    def before_create
+      set_new_record_positions
+    end
+
+    def after_create
+      apply_all_positions
+      super
+    end
+
+    private
+
+    def apply_all_positions
+      with_transaction { super }
+    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

@@ -1,75 +1,75 @@
-# 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)
-      query_cache.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
-
-    private
-
-    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
-
-    def query_cache
-      defined?(Mongo::QueryCache) ? Mongo::QueryCache : Mongoid::QueryCache
-    end
-  end
-end
-end
-end
+# 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)
+      query_cache.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
+
+    private
+
+    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
+
+    def query_cache
+      defined?(Mongo::QueryCache) ? Mongo::QueryCache : Mongoid::QueryCache
+    end
+  end
+end
+end
+end

data/lib/mongoid/orderable/installer.rb

@@ -1,64 +1,64 @@
-# 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
-
-    private
-
-    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(spec.to_h)
-    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
-      klass.send :prepend, Mixins::Cascadeable if klass.embedded?
-    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
+# 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
+
+    private
+
+    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(spec.to_h)
+    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
+      klass.send :prepend, Mixins::Cascadeable if klass.embedded?
+    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

@@ -1,45 +1,45 @@
-# 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_update :orderable_after_update, prepend: true
-      after_destroy :orderable_after_destroy, prepend: true
-
-      delegate :before_create,
-               :after_create,
-               :before_update,
-               :after_update,
-               :after_destroy,
-               to: :orderable_handler,
-               prefix: :orderable
-
-      private
-
-      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
+# 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_update :orderable_after_update, prepend: true
+      after_destroy :orderable_after_destroy, prepend: true
+
+      delegate :before_create,
+               :after_create,
+               :before_update,
+               :after_update,
+               :after_destroy,
+               to: :orderable_handler,
+               prefix: :orderable
+
+      private
+
+      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

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

@@ -1,15 +1,15 @@
-# frozen_string_literal: true
-
-module Mongoid
-module Orderable
-module Mixins
-  # This is required to trigger callbacks on embedded objects.
-  # Otherwise, the #move_to parameter won't work when saving the parent.
-  module Cascadeable
-    def in_callback_state?(kind)
-      super || move_all.present?
-    end
-  end
-end
-end
-end
+# frozen_string_literal: true
+
+module Mongoid
+module Orderable
+module Mixins
+  # This is required to trigger callbacks on embedded objects.
+  # Otherwise, the #move_to parameter won't work when saving the parent.
+  module Cascadeable
+    def in_callback_state?(kind)
+      super || move_all.present?
+    end
+  end
+end
+end
+end

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

@@ -1,39 +1,45 @@
-# 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
+# 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)
+      scope = orderable_scope(field)
+      scope = scope.ne(_id: _id) if embedded?
+      max = scope.ne(f => nil).max(f)
+      if embedded? && in_list && persisted?
+        previous_position = send("#{f}_was")
+        max = [max, previous_position].compact.max
+      end
+      return orderable_top(field) unless max
+      in_list ? max : max.next
+    end
+  end
+end
+end
+end