mongoid_orderable 5.0.0 → 6.0.2

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/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 ::Mongoid::Compatibility::Version.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

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

@@ -0,0 +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

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

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

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

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

@@ -0,0 +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
+
+    protected
+
+    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

@@ -0,0 +1,37 @@
+# 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
+
+            store_in collection: :#{collection_name}
+
+            field :scope, type: String
+
+            index({ scope: 1 }, { unique: 1 })
+          end
+        end
+      KLASS
+    end
+
+    protected
+
+    def model_exists?(model_name)
+      base = ::Mongoid::Orderable::Models
+      !!(defined?(base) && base.const_get(model_name))
+    rescue NameError
+      false
+    end
+  end
+end
+end
+end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Mongoid
+module Orderable
+module Generators
+  class Movable < Base
+    def generate(field_name)
+      generate_move_to_helpers(field_name)
+      generate_insert_at_helpers(field_name)
+      generate_shorthand_helpers(field_name)
+    end
+
+    protected
+
+    def generate_move_to_helpers(field_name)
+      generate_method("move_#{field_name}_to") do |target_position|
+        move_field_to target_position, field: field_name
+      end
+
+      generate_method("move_#{field_name}_to!") do |target_position|
+        move_field_to target_position, field: field_name
+        save
+      end
+
+      generate_method("move_#{field_name}_to=") do |target_position|
+        move_field_to target_position, field: field_name
+      end
+    end
+
+    def generate_insert_at_helpers(field_name)
+      klass.class_eval do
+        alias_method "insert_#{field_name}_at!", "move_#{field_name}_to!"
+        alias_method "insert_#{field_name}_at",  "move_#{field_name}_to"
+        alias_method "insert_#{field_name}_at=", "move_#{field_name}_to="
+      end
+    end
+
+    def generate_shorthand_helpers(field_name)
+      %i[top bottom].each do |symbol|
+        generate_method "move_#{field_name}_to_#{symbol}" do
+          move_to symbol, field: field_name
+        end
+
+        generate_method "move_#{field_name}_to_#{symbol}!" do
+          move_to! symbol, field: field_name
+        end
+      end
+
+      %i[higher lower].each do |symbol|
+        generate_method "move_#{field_name}_#{symbol}" do
+          move_to symbol, field: field_name
+        end
+
+        generate_method "move_#{field_name}_#{symbol}!" do
+          move_to! symbol, field: field_name
+        end
+      end
+    end
+  end
+end
+end
+end