mongoid_orderable 4.1.1 → 6.0.1

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

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/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,29 @@
+# frozen_string_literal: true
+
+module Mongoid
+module Orderable
+module Mixins
+  module Callbacks
+    extend ActiveSupport::Concern
+
+    ORDERABLE_TRANSACTION_KEY = :__mongoid_orderable_in_txn
+
+    included do
+      around_save :orderable_update_positions
+      after_destroy :orderable_remove_positions, unless: -> { embedded? && _root.destroyed? }
+
+      delegate :update_positions,
+               :remove_positions,
+               to: :orderable_engine,
+               prefix: :orderable
+
+      protected
+
+      def orderable_engine
+        @orderable_engine ||= Mongoid::Orderable::Engine.new(self)
+      end
+    end
+  end
+end
+end
+end

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

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

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Mongoid
+module Orderable
+module Mixins
+  module Listable
+    def in_list?(field = nil)
+      persisted? && !orderable_position(field).nil?
+    end
+
+    # Returns items above the current document.
+    # Items with a position lower than this document's position.
+    def previous_items(field = nil)
+      field ||= default_orderable_field
+      orderable_scope(field).lt(orderable_field(field) => send(field))
+    end
+    alias prev_items previous_items
+
+    # Returns items below the current document.
+    # Items with a position greater than this document's position.
+    def next_items(field = nil)
+      field ||= default_orderable_field
+      orderable_scope(field).gt(orderable_field(field) => send(field))
+    end
+
+    # Returns the previous item in the list
+    def previous_item(field = nil)
+      field ||= default_orderable_field
+      orderable_scope(field).where(orderable_field(field) => send(field) - 1).first
+    end
+    alias prev_item previous_item
+
+    # Returns the next item in the list
+    def next_item(field = nil)
+      field ||= default_orderable_field
+      orderable_scope(field).where(orderable_field(field) => send(field) + 1).first
+    end
+
+    def first?(field = nil)
+      in_list?(field) && orderable_position(field) == orderable_top(field)
+    end
+
+    def last?(field = nil)
+      in_list?(field) && orderable_position(field) == orderable_bottom(field)
+    end
+  end
+end
+end
+end