mongoid_orderable 4.1.0 → 4.1.1

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    YThjMDBhYzQ5YmQ4NzJlZWRjMjdhZTIyNTdmMTkwMmE0YmZlZWI5NQ==
-  data.tar.gz: !binary |-
-    ZjBmZDk1OTM1MmE1ZGNiMmFiMDU1Y2IxYTAwMzZlZTkzZWFiMjhlYQ==
+SHA1:
+  metadata.gz: cea70aa8c9e3b86f49203e6f1bb17b45a994e45a
+  data.tar.gz: 99ad3433535e36e7e4f9f579f1ab4c7640f5552c
 SHA512:
-  metadata.gz: !binary |-
-    NDc5NWY5NTlkMDYzNWMzZGI3OGRiNjc0MDEzNjdhYWJiMDA5MTkzOTE5OGMx
-    YzA4NWZmNmZmZTJmNTZmNTdlNDFjZDk2NmJkOGQyNDMyMTM2Mjg2ZjU5NGE1
-    MmI0YzU2MmVhODdmMWY1MGI5ZDhhZTVkNGQ0NjRlNzNlMzI4ZDU=
-  data.tar.gz: !binary |-
-    NTYyN2E1ZTVlNDQ5YzZhNDY5Y2UyNDMzZWVhZWQ4YWZmMTJkNTI0ZDNhNzIy
-    ZDg0MTkyZjY3YWVkNzdmNWM5ZDY3ZWJiNDMxYzk2NDM0ZWUxOTFiMmMxMWEy
-    ZjE2MmRiZDcyY2U5NTg1MjU3ODkwOGIwMDIxMDY0NDMyMmExMzQ=
+  metadata.gz: 52b38d32f9272161134dd2c4b04d70549e6b8fe7034b0838c12d243e420702889ae36f2b43463c22b0afafc5447817414f0d402d9441b9a6847434c328f505c4
+  data.tar.gz: 1608265030534f0bb65c9911014cb1e3d6a54691a037644cdc31295aec872c58b4edfc84414cf847e2c35497b2629d87606f6fe48b993c3b2ca34a237d97890b

data/.rvmrc

@@ -1 +1 @@
-rvm use 1.9.3@mongoid_orderable --create
+rvm use 2.0.0@mongoid_orderable --create

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # master
 
+# 4.1.1
+
+  * Fix: index should respect scope (@joeyAghion)
+
 # 4.1.0
 
   * Resolving scope foreign key form passed relation name (@dsci)

data/README.md

@@ -10,6 +10,7 @@ Mongoid::Orderable is a ordered list implementation for your mongoid models.
 * It supports mutators api
 * It correctly assigns the position while moving document between scopes
 * It supports mongoid 2, 3 and 4
+* It supports specifying multiple orderable columns
 
 # How?
 
@@ -18,6 +19,7 @@ gem 'mongoid_orderable'
 ```
 
 Gem has the same api as others. Just include Mongoid::Orderable into your model and call `orderable` method.
+Embedded objects are automatically scoped by their parent.
 
 ```
 class Item
@@ -64,6 +66,58 @@ item.next_item # returns the next item in the list
 item.previous_item # returns the previous item in the list
 ```
 
+# Multiple Columns
+
+You can also define multiple orderable columns for any class including the Mongoid::Orderable module.
+
+```
+class Book
+  include Mongoid::Document
+  include Mongoid::Orderable
+
+  orderable base: 0
+  orderable column: sno, as: :serial_no
+end
+```
+
+The above defines two different orderable_columns on Book - *position* and *serial_no*.
+The following helpers are generated in this case:
+
+```
+item.move_#{column_name}_to 
+item.move_#{column_name}_to=
+item.move_#{column_name}_to!
+
+item.move_#{column_name}_to_top
+item.move_#{column_name}_to_bottom
+item.move_#{column_name}_higher
+item.move_#{column_name}_lower
+
+item.next_#{column_name}_items
+item.previous_#{column_name}_items
+
+item.next_#{column_name}_item
+item.previous_#{column_name}_item
+```
+
+*where column_name is either **position** or  **serial_no**.*
+
+When a model defines multiple orderable columns, the original helpers are also available and work on the first orderable column.
+
+```
+  @book1 = Book.create!
+  @book2 = Book.create!
+  @book2                 => #<Book _id: 53a16a2ba1bde4f746000001, serial_no: 1, position: 1>
+  @book2.move_to! :top   # this will change the :position of the book to 0 (not serial_no)
+  @book2                 => #<Book _id: 53a16a2ba1bde4f746000001, serial_no: 1, position: 0>
+```
+
+To specify any other orderable column as default pass the **default: true** option with orderable.
+
+```
+  orderable column: sno, as: :serial_no, default: true
+```
+
 # Contributing
 
 Fork && Patch && Spec && Push && Pull request.

data/lib/config/locales/en.yml

@@ -0,0 +1,9 @@
+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."

data/lib/mongoid/orderable.rb

@@ -1,239 +1,22 @@
 module Mongoid::Orderable
   extend ActiveSupport::Concern
 
-  module ClassMethods
-    def orderable options = {}
-      configuration = {
-        :column => :position,
-        :index => true,
-        :scope => nil,
-        :base => 1
-      }
-
-      configuration.merge! options if options.is_a?(Hash)
-
-      if configuration[:scope].is_a?(Symbol) && configuration[:scope].to_s !~ /_id$/
-        scope_relation = self.relations[configuration[:scope].to_s]
-        if scope_relation
-          configuration[:scope] = scope_relation.key.to_sym
-        else
-          configuration[:scope] = "#{configuration[:scope]}_id".to_sym
-        end
-      elsif configuration[:scope].is_a?(String)
-        configuration[:scope] = configuration[:scope].to_sym
-      end
-
-      field configuration[:column], orderable_field_opts(configuration)
-      if configuration[:index]
-        if MongoidOrderable.mongoid2?
-          index configuration[:column]
-        else
-          index(configuration[:column] => 1)
-        end
-      end
-
-      case configuration[:scope]
-      when Symbol then
-        scope :orderable_scope, lambda { |document|
-          where(configuration[:scope] => document.send(configuration[:scope])) }
-      when Proc then
-        scope :orderable_scope, configuration[:scope]
-      else
-        scope :orderable_scope, lambda { |document| where({}) }
-      end
-
-      define_method :orderable_column do
-        configuration[:column]
-      end
-
-      define_method :orderable_base do
-        configuration[:base]
-      end
-
-      self_class = self
-      define_method :orderable_inherited_class do
-        self_class if configuration[:inherited]
-      end
-
-      before_save :add_to_list
-      after_destroy :remove_from_list
-    end
-
-    private
-
-    def orderable_field_opts(configuration)
-      field_opts = { :type => Integer }
-      field_opts.merge!(configuration.slice(:as))
-      field_opts
-    end
-  end
-
-  ##
-  # Returns items above the current document.
-  # Items with a position lower than this document's position.
-  def previous_items
-    orderable_scoped.where(orderable_column.lt => self.position)
-  end
-  alias_method :prev_items, :previous_items
-
-  ##
-  # Returns items below the current document.
-  # Items with a position greater than this document's position.
-  def next_items
-    orderable_scoped.where(orderable_column.gt => self.position)
-  end
-
-  # returns the previous item in the list
-  def previous_item
-    if previous_items.present?
-      previous_position = self.position - 1
-      orderable_scoped.where(:position => previous_position).first
-    else
-      nil
-    end
-  end
-  alias_method :prev_item, :previous_item
-
-  # returns the next item in the list
-  def next_item
-    if next_items.present?
-      next_position = self.position + 1
-      orderable_scoped.where(:position => next_position).first
-    else
-      nil
-    end
-  end
-
-  def move_to! target_position
-    @move_to = target_position
-    save
-  end
-  alias_method :insert_at!, :move_to!
-
-  def move_to target_position
-    @move_to = target_position
-  end
-  alias_method :insert_at, :move_to
-
-  def move_to= target_position
-    @move_to = target_position
-  end
-  alias_method :insert_at=, :move_to=
-
-  [:top, :bottom].each do |symbol|
-    define_method "move_to_#{symbol}" do
-      move_to symbol
-    end
-
-    define_method "move_to_#{symbol}!" do
-      move_to! symbol
-    end
-  end
-
-  [:higher, :lower].each do |symbol|
-    define_method "move_#{symbol}" do
-      move_to symbol
-    end
-
-    define_method "move_#{symbol}!" do
-      move_to! symbol
-    end
-  end
-
-  def first?
-    in_list? && orderable_position == orderable_base
-  end
-
-  def last?
-    in_list? && orderable_position == bottom_orderable_position
-  end
-
-  def in_list?
-    !orderable_position.nil?
-  end
+  included do
+    include Mongoid::Orderable::Helpers
+    include Mongoid::Orderable::Callbacks
+    include Mongoid::Orderable::Movable
+    include Mongoid::Orderable::Listable
 
-  def add_to_list
-    apply_position @move_to
+    class_attribute :orderable_configurations
   end
 
-  def remove_from_list
-    MongoidOrderable.inc orderable_scoped.where(orderable_column.gt => orderable_position), orderable_column, -1
-  end
-
-private
-
-  def orderable_position
-    send orderable_column
-  end
-
-  def orderable_position= value
-    send "#{orderable_column}=", value
-  end
-
-  def orderable_scoped
-    if embedded?
-      send(MongoidOrderable.metadata(self).inverse).send(MongoidOrderable.metadata(self).name).orderable_scope(self)
-    else
-      (orderable_inherited_class || self.class).orderable_scope(self)
-    end
-  end
-
-  def orderable_scope_changed?
-    if Mongoid.respond_to?(:unit_of_work)
-      Mongoid.unit_of_work do
-        orderable_scope_changed_query
-      end
-    else
-      orderable_scope_changed_query
-    end
-  end
-
-  def orderable_scope_changed_query
-    !orderable_scoped.where(:_id => _id).exists?
-  end
-
-  def apply_position target_position
-    if persisted? && !embedded? && orderable_scope_changed?
-      self.class.unscoped.find(_id).remove_from_list
-      self.orderable_position = nil
-    end
-
-    return if !target_position && in_list?
+  module ClassMethods
 
-    target_position = target_position_to_position target_position
+    def orderable options = {}
+      configuration = Mongoid::Orderable::Configuration.build(self, options)
 
-    unless in_list?
-      MongoidOrderable.inc orderable_scoped.where(orderable_column.gte => target_position), orderable_column, 1
-    else
-      MongoidOrderable.inc(orderable_scoped.where(orderable_column.gte => target_position, orderable_column.lt => orderable_position), orderable_column, 1) if target_position < orderable_position
-      MongoidOrderable.inc(orderable_scoped.where(orderable_column.gt => orderable_position, orderable_column.lte => target_position), orderable_column, -1) if target_position > orderable_position
+      Mongoid::Orderable::OrderableClass.setup(self, configuration)
     end
 
-    self.orderable_position = target_position
-  end
-
-  def target_position_to_position target_position
-    target_position = :bottom unless target_position
-
-    target_position = case target_position.to_sym
-      when :top then orderable_base
-      when :bottom then bottom_orderable_position
-      when :higher then orderable_position.pred
-      when :lower then orderable_position.next
-    end unless target_position.is_a? Numeric
-
-    target_position = orderable_base if target_position < orderable_base
-    target_position = bottom_orderable_position if target_position > bottom_orderable_position
-    target_position
   end
-
-  def bottom_orderable_position
-    @bottom_orderable_position = begin
-      positions_list = orderable_scoped.distinct(orderable_column)
-      return orderable_base if positions_list.empty?
-      max = positions_list.map(&:to_i).max.to_i
-      in_list? ? max : max.next
-    end
-  end
-
 end

data/lib/mongoid/orderable/callbacks.rb

@@ -0,0 +1,75 @@
+module Mongoid
+  module Orderable
+    module Callbacks
+      extend ActiveSupport::Concern
+
+      included do
+
+        protected
+
+        def add_to_list
+          self.orderable_keys.each do |column|
+            apply_position column, move_all[column]
+          end
+        end
+
+        def remove_from_list
+          self.orderable_keys.each do |column|
+            remove_position_from_list column
+          end
+        end
+
+        def remove_position_from_list(column)
+          col, pos = orderable_column(column), orderable_position(column)
+          MongoidOrderable.inc orderable_scoped(column).where(col.gt => pos), col, -1
+        end
+
+        def apply_position column, target_position
+          if persisted? && !embedded? && orderable_scope_changed?(column)
+            self.class.unscoped.find(_id).remove_position_from_list(column)
+            self.send("orderable_#{column}_position=", nil)
+          end
+
+          return if !target_position && in_list?(column)
+
+          target_position = target_position_to_position column, target_position
+          scope, col, pos = orderable_scoped(column), orderable_column(column), orderable_position(column)
+
+          unless in_list?(column)
+            MongoidOrderable.inc scope.where(col.gte => target_position), col, 1
+          else
+            MongoidOrderable.inc(scope.where(col.gte => target_position, col.lt => pos), col, 1) if target_position < pos
+            MongoidOrderable.inc(scope.where(col.gt => pos, col.lte => target_position), col, -1) if target_position > pos
+          end
+
+          self.send("orderable_#{column}_position=", target_position)
+        end
+
+        def target_position_to_position column, target_position
+          target_position = :bottom unless target_position
+
+          target_position = case target_position.to_s
+                            when 'top' then orderable_base(column)
+                            when 'bottom' then bottom_orderable_position(column)
+                            when 'higher' then orderable_position(column).pred
+                            when 'lower' then orderable_position(column).next
+                            when /\A\d+\Z/ then target_position.to_i
+                            else raise Mongoid::Orderable::Errors::InvalidTargetPosition.new target_position
+                            end unless target_position.is_a? Numeric
+
+          target_position = orderable_base(column) if target_position < orderable_base(column)
+          target_position = bottom_orderable_position(column) if target_position > bottom_orderable_position(column)
+          target_position
+        end
+
+      end
+
+      module ClassMethods
+        def add_orderable_callbacks
+          before_save :add_to_list
+          after_destroy :remove_from_list
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/orderable/configuration.rb

@@ -0,0 +1,60 @@
+module Mongoid
+  module Orderable
+    class Configuration
+
+      CONFIG_OPTIONS = %w(column scope foreign_key inherited base index default).map(&:to_sym)
+      FIELD_OPTIONS  = %w(as).map(&:to_sym)
+      VALID_OPTIONS  = CONFIG_OPTIONS + FIELD_OPTIONS
+
+      attr_reader :orderable_class, :options
+
+      def initialize(parent, options = {})
+        @orderable_class = parent
+        set_options(options)
+        set_field_options
+        set_orderable_scope
+      end
+
+      def default_configuration
+        { :column => :position,
+          :index  => true,
+          :scope  => nil,
+          :base   => 1,
+          :field_opts => { :type => Integer }}
+      end
+
+      def self.build(parent, options = {})
+        new(parent, options).options
+      end
+
+      protected
+
+      def set_options(options)
+        @options = default_configuration
+        return unless options.is_a? Hash
+        @options.merge! options.symbolize_keys.slice(*VALID_OPTIONS)
+      end
+
+      def set_field_options
+        FIELD_OPTIONS.each do |key|
+          next unless options.has_key? key
+          @options[:field_opts][key] = options.delete(key)
+        end
+      end
+
+      def set_orderable_scope
+        if options[:scope].is_a?(Symbol) && options[:scope].to_s !~ /_id$/
+          scope_relation = @orderable_class.relations[options[:scope].to_s]
+          if scope_relation
+            @options[:scope] = scope_relation.key.to_sym
+          else
+            @options[:scope] = "#{options[:scope]}_id".to_sym
+          end
+        elsif options[:scope].is_a?(String)
+          @options[:scope] = options[:scope].to_sym
+        end
+      end
+
+    end
+  end
+end