mongoid_orderable 6.0.5 → 6.0.7

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

@@ -1,81 +1,81 @@
-# frozen_string_literal: true
-
-module Mongoid
-module Orderable
-module Configs
-  class FieldConfig
-    CONFIG_OPTIONS = %i[field
-                        scope
-                        foreign_key
-                        inherited
-                        base
-                        index
-                        default
-                        if
-                        unless
-                        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
-
-    private
-
-    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
+# frozen_string_literal: true
+
+module Mongoid
+module Orderable
+module Configs
+  class FieldConfig
+    CONFIG_OPTIONS = %i[field
+                        scope
+                        foreign_key
+                        inherited
+                        base
+                        index
+                        default
+                        if
+                        unless
+                        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
+
+    private
+
+    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

@@ -1,26 +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
+# 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/errors/invalid_target_position.rb

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

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

@@ -1,20 +1,20 @@
-# frozen_string_literal: true
-
-module Mongoid
-module Orderable
-module Errors
-  class TransactionFailed < ::Mongoid::Errors::MongoidError
-    def initialize(error)
-      super _compose_message(error)
-    end
-
-    private
-
-    def _compose_message(error)
-      compose_message 'transaction_failed'
-      @summary = error.message
-    end
-  end
-end
-end
-end
+# frozen_string_literal: true
+
+module Mongoid
+module Orderable
+module Errors
+  class TransactionFailed < ::Mongoid::Errors::MongoidError
+    def initialize(error)
+      super _compose_message(error)
+    end
+
+    private
+
+    def _compose_message(error)
+      compose_message 'transaction_failed'
+      @summary = error.message
+    end
+  end
+end
+end
+end

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

@@ -1,21 +1,21 @@
-# frozen_string_literal: true
-
-module Mongoid
-module Orderable
-module Generators
-  class Base
-    attr_reader :klass
-
-    def initialize(klass)
-      @klass = klass
-    end
-
-    private
-
-    def generate_method(name, &block)
-      klass.send(:define_method, name, &block)
-    end
-  end
-end
-end
-end
+# frozen_string_literal: true
+
+module Mongoid
+module Orderable
+module Generators
+  class Base
+    attr_reader :klass
+
+    def initialize(klass)
+      @klass = klass
+    end
+
+    private
+
+    def generate_method(name, &block)
+      klass.send(:define_method, name, &block)
+    end
+  end
+end
+end
+end

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

@@ -1,37 +1,37 @@
-# frozen_string_literal: true
-
-module Mongoid
-module Orderable
-module Generators
-  class Helpers < Base
-    def generate
-      self_class = klass
-
-      klass.class_eval <<~KLASS, __FILE__, __LINE__ + 1
-        def orderable_top(field = nil)
-          field ||= default_orderable_field
-          #{self_class}.orderable_configs[field][:base]
-        end
-
-        def orderable_field(field = nil)
-          field ||= default_orderable_field
-          #{self_class}.orderable_configs[field][:field]
-        end
-
-        def orderable_if(field)
-          #{self_class}.orderable_configs[field][:if]
-        end
-
-        def orderable_unless(field)
-          #{self_class}.orderable_configs[field][:unless]
-        end
-      KLASS
-
-      generate_method(:orderable_inherited_class) do
-        self_class.orderable_configs.any? {|_field, conf| conf[:inherited] } ? self_class : self.class
-      end
-    end
-  end
-end
-end
-end
+# frozen_string_literal: true
+
+module Mongoid
+module Orderable
+module Generators
+  class Helpers < Base
+    def generate
+      self_class = klass
+
+      klass.class_eval <<~KLASS, __FILE__, __LINE__ + 1
+        def orderable_top(field = nil)
+          field ||= default_orderable_field
+          #{self_class}.orderable_configs[field][:base]
+        end
+
+        def orderable_field(field = nil)
+          field ||= default_orderable_field
+          #{self_class}.orderable_configs[field][:field]
+        end
+
+        def orderable_if(field)
+          #{self_class}.orderable_configs[field][:if]
+        end
+
+        def orderable_unless(field)
+          #{self_class}.orderable_configs[field][:unless]
+        end
+      KLASS
+
+      generate_method(:orderable_inherited_class) do
+        self_class.orderable_configs.any? {|_field, conf| conf[:inherited] } ? self_class : self.class
+      end
+    end
+  end
+end
+end
+end

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

@@ -1,41 +1,41 @@
-# frozen_string_literal: true
-
-module Mongoid
-module Orderable
-module Generators
-  class Listable < Base
-    def generate(field_name)
-      generate_list_helpers(field_name)
-      generate_aliased_helpers(field_name)
-    end
-
-    private
-
-    def generate_list_helpers(field_name)
-      generate_method("next_#{field_name}_item") do
-        next_item(field_name)
-      end
-
-      generate_method("next_#{field_name}_items") do
-        next_items(field_name)
-      end
-
-      generate_method("previous_#{field_name}_item") do
-        previous_item(field_name)
-      end
-
-      generate_method("previous_#{field_name}_items") do
-        previous_items(field_name)
-      end
-    end
-
-    def generate_aliased_helpers(field_name)
-      klass.class_eval do
-        alias_method "prev_#{field_name}_items", "previous_#{field_name}_items"
-        alias_method "prev_#{field_name}_item",  "previous_#{field_name}_item"
-      end
-    end
-  end
-end
-end
-end
+# frozen_string_literal: true
+
+module Mongoid
+module Orderable
+module Generators
+  class Listable < Base
+    def generate(field_name)
+      generate_list_helpers(field_name)
+      generate_aliased_helpers(field_name)
+    end
+
+    private
+
+    def generate_list_helpers(field_name)
+      generate_method("next_#{field_name}_item") do
+        next_item(field_name)
+      end
+
+      generate_method("next_#{field_name}_items") do
+        next_items(field_name)
+      end
+
+      generate_method("previous_#{field_name}_item") do
+        previous_item(field_name)
+      end
+
+      generate_method("previous_#{field_name}_items") do
+        previous_items(field_name)
+      end
+    end
+
+    def generate_aliased_helpers(field_name)
+      klass.class_eval do
+        alias_method "prev_#{field_name}_items", "previous_#{field_name}_items"
+        alias_method "prev_#{field_name}_item",  "previous_#{field_name}_item"
+      end
+    end
+  end
+end
+end
+end

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

@@ -1,39 +1,39 @@
-# frozen_string_literal: true
-
-module Mongoid
-module Orderable
-module Generators
-  class LockCollection
-    def generate(collection_name)
-      return unless collection_name
-      model_name = collection_name.to_s.singularize.classify
-      return if model_exists?(model_name)
-      ::Mongoid::Orderable.class_eval <<~KLASS, __FILE__, __LINE__ + 1
-        module Models
-          class #{model_name}
-            include Mongoid::Document
-            include Mongoid::Timestamps::Updated::Short
-
-            store_in collection: :#{collection_name}
-
-            field :scope, type: String
-
-            index({ scope: 1 }, { unique: 1 })
-            index({ updated_at: 1 }, { expire_after_seconds: 86400 })
-          end
-        end
-      KLASS
-    end
-
-    private
-
-    def model_exists?(model_name)
-      base = ::Mongoid::Orderable::Models
-      !!(defined?(base) && base.const_get(model_name))
-    rescue NameError
-      false
-    end
-  end
-end
-end
-end
+# frozen_string_literal: true
+
+module Mongoid
+module Orderable
+module Generators
+  class LockCollection
+    def generate(collection_name)
+      return unless collection_name
+      model_name = collection_name.to_s.singularize.classify
+      return if model_exists?(model_name)
+      ::Mongoid::Orderable.class_eval <<~KLASS, __FILE__, __LINE__ + 1
+        module Models
+          class #{model_name}
+            include Mongoid::Document
+            include Mongoid::Timestamps::Updated::Short
+
+            store_in collection: :#{collection_name}
+
+            field :scope, type: String
+
+            index({ scope: 1 }, { unique: 1 })
+            index({ updated_at: 1 }, { expire_after_seconds: 86400 })
+          end
+        end
+      KLASS
+    end
+
+    private
+
+    def model_exists?(model_name)
+      base = ::Mongoid::Orderable::Models
+      !!(defined?(base) && base.const_get(model_name))
+    rescue NameError
+      false
+    end
+  end
+end
+end
+end