mongoid_orderable 4.1.0 → 4.1.1

data/lib/mongoid/orderable/errors.rb

@@ -0,0 +1,2 @@
+require 'mongoid/orderable/errors/mongoid_orderable_error'
+require 'mongoid/orderable/errors/invalid_target_position'

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

@@ -0,0 +1,18 @@
+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 MongoidOrderable.mongoid2?
+          translate 'invalid_target_position', { :value => value.inspect }
+        else
+          compose_message 'invalid_target_position', { :value => value.inspect }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module Mongoid::Orderable
+  module Errors
+    class MongoidOrderableError < ::Mongoid::Errors::MongoidError
+
+      if MongoidOrderable.mongoid2?
+        def translate key, options
+          [:message, :summary, :resolution].map do |section|
+            ::I18n.translate "#{BASE_KEY}.#{key}.#{section}", options
+          end.join ' '
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/orderable/generator.rb

@@ -0,0 +1,34 @@
+module Mongoid
+  module Orderable
+    module Generator
+      include Mongoid::Orderable::Generator::Scope
+      include Mongoid::Orderable::Generator::Position
+      include Mongoid::Orderable::Generator::Movable
+      include Mongoid::Orderable::Generator::Listable
+      include Mongoid::Orderable::Generator::Helpers
+
+      def column_name
+        configuration[:field_opts][:as] || configuration[:column]
+      end
+
+      def order_scope
+        configuration[:scope]
+      end
+
+      def generate_all_helpers
+        generate_scope_helpers(column_name, order_scope)
+        generate_position_helpers(column_name)
+        generate_movable_helpers(column_name)
+        generate_listable_helpers(column_name)
+        generate_orderable_helpers
+      end
+
+      protected
+
+      def generate_method(name, &block)
+        klass.send(:define_method, name, &block)
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module Mongoid
+  module Orderable
+    module Generator
+      module Helpers
+
+        def generate_orderable_helpers
+          self_class = klass
+
+          klass.class_eval <<-eos
+            def orderable_base(column = nil)
+              column ||= default_orderable_column
+              #{self_class}.orderable_configurations[column][:base]
+            end
+
+            def orderable_column(column = nil)
+              column ||= default_orderable_column
+              #{self_class}.orderable_configurations[column][:column]
+            end
+          eos
+
+          generate_method(:orderable_inherited_class) do
+            self_class.orderable_configurations.any?{ |col, conf| conf[:inherited] } ? self_class : self.class
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module Mongoid
+  module Orderable
+    module Generator
+      module Listable
+
+        def generate_listable_helpers(column_name)
+          generate_list_helpers(column_name)
+          generate_aliased_helpers(column_name)
+        end
+
+        protected
+
+        def generate_list_helpers(column_name)
+          generate_method("next_#{column_name}_item") do
+            next_item(column_name)
+          end
+
+          generate_method("next_#{column_name}_items") do
+            next_items(column_name)
+          end
+
+          generate_method("previous_#{column_name}_item") do
+            previous_item(column_name)
+          end
+
+          generate_method("previous_#{column_name}_items") do
+            previous_items(column_name)
+          end
+        end
+
+        def generate_aliased_helpers(column_name)
+          klass.class_eval do
+            alias_method "prev_#{column_name}_items", "previous_#{column_name}_items"
+            alias_method "prev_#{column_name}_item",  "previous_#{column_name}_item"
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+module Mongoid
+  module Orderable
+    module Generator
+      module Movable
+
+        def generate_movable_helpers(column_name)
+          generate_move_to_helpers(column_name)
+          generate_insert_at_helpers(column_name)
+          generate_shorthand_helpers(column_name)
+        end
+
+        protected
+
+        def generate_move_to_helpers(column_name)
+          generate_method("move_#{column_name}_to") do |target_position|
+            move_column_to target_position, :column => column_name
+          end
+
+          generate_method("move_#{column_name}_to!") do |target_position|
+            move_column_to target_position, :column => column_name
+            save
+          end
+
+          generate_method("move_#{column_name}_to=") do |target_position|
+            move_column_to target_position, :column => column_name
+          end
+        end
+
+        def generate_insert_at_helpers(column_name)
+          klass.class_eval do
+            alias_method "insert_#{column_name}_at!", "move_#{column_name}_to!"
+            alias_method "insert_#{column_name}_at",  "move_#{column_name}_to"
+            alias_method "insert_#{column_name}_at=", "move_#{column_name}_to="
+          end
+        end
+
+        def generate_shorthand_helpers(column_name)
+          [:top, :bottom].each do |symbol|
+            generate_method "move_#{column_name}_to_#{symbol}" do
+              move_to symbol, :column => column_name
+            end
+
+            generate_method "move_#{column_name}_to_#{symbol}!" do
+              move_to! symbol, :column => column_name
+            end
+          end
+
+          [:higher, :lower].each do |symbol|
+            generate_method "move_#{column_name}_#{symbol}" do
+              move_to symbol, :column => column_name
+            end
+
+            generate_method "move_#{column_name}_#{symbol}!" do
+              move_to! symbol, :column => column_name
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/mongoid/orderable/generator/position.rb

@@ -0,0 +1,26 @@
+module Mongoid
+  module Orderable
+    module Generator
+      module Position
+
+        def generate_position_helpers(column_name)
+          klass.class_eval <<-eos
+            def orderable_position(column = nil)
+              column ||= default_orderable_column
+              send "orderable_\#{column}_position"
+            end
+          eos
+
+          generate_method("orderable_#{column_name}_position") do
+            send column_name
+          end
+
+          generate_method("orderable_#{column_name}_position=") do |value|
+            send "#{column_name}=", value
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/mongoid/orderable/generator/scope.rb

@@ -0,0 +1,17 @@
+module Mongoid
+  module Orderable
+    module Generator
+      module Scope
+        def generate_scope_helpers(column_name, order_scope)
+          klass.class_eval do
+            scope "orderable_#{column_name}_scope", case order_scope
+                                                    when Symbol then lambda { |document| where(order_scope => document.send(order_scope)) }
+                                                    when Proc   then order_scope
+                                                    else lambda { |document| where({}) }
+                                                    end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/orderable/helpers.rb

@@ -0,0 +1,50 @@
+module Mongoid
+  module Orderable
+    module Helpers
+
+      def orderable_keys
+        Array orderable_inherited_class.orderable_configurations.try(:keys)
+      end
+
+      def default_orderable_column
+        self.class.orderable_configurations.detect{ |c, conf| conf[:default] }.try(:first) || self.orderable_keys.first
+      end
+
+      private
+
+        def orderable_scoped(column = nil)
+          column ||= default_orderable_column
+
+          if embedded?
+            send(MongoidOrderable.metadata(self).inverse).send(MongoidOrderable.metadata(self).name).send("orderable_#{column}_scope", self)
+          else
+            self.orderable_inherited_class.send("orderable_#{column}_scope", self)
+          end
+        end
+
+        def orderable_scope_changed?(column)
+          if Mongoid.respond_to?(:unit_of_work)
+            Mongoid.unit_of_work do
+              orderable_scope_changed_query(column)
+            end
+          else
+            orderable_scope_changed_query(column)
+          end
+        end
+
+        def orderable_scope_changed_query(column)
+          !orderable_scoped(column).where(:_id => _id).exists?
+        end
+
+        def bottom_orderable_position(column = nil)
+          column ||= default_orderable_column
+          @bottom_orderable_position = begin
+            positions_list = orderable_scoped(column).distinct(orderable_column(column)).compact
+            return orderable_base(column) if positions_list.empty?
+            max = positions_list.map(&:to_i).max.to_i
+            in_list?(column) ? max : max.next
+          end
+        end
+    end
+  end
+end

data/lib/mongoid/orderable/listable.rb

@@ -0,0 +1,49 @@
+module Mongoid
+  module Orderable
+    module Listable
+
+      ##
+      # Returns items above the current document.
+      # Items with a position lower than this document's position.
+      def previous_items(column=nil)
+        column = column || default_orderable_column
+        orderable_scoped(column).where(orderable_column(column).lt => send(column))
+      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(column=nil)
+        column = column || default_orderable_column
+        orderable_scoped(column).where(orderable_column(column).gt => send(column))
+      end
+
+      # returns the previous item in the list
+      def previous_item(column=nil)
+        column = column || default_orderable_column
+        orderable_scoped(column).where(orderable_column(column) => send(column) - 1).first
+      end
+      alias_method :prev_item, :previous_item
+
+      # returns the next item in the list
+      def next_item(column=nil)
+        column = column || default_orderable_column
+        orderable_scoped(column).where(orderable_column(column) => send(column) + 1).first
+      end
+
+      def first?(column=nil)
+        in_list?(column) && orderable_position(column) == orderable_base(column)
+      end
+
+      def last?(column=nil)
+        in_list?(column) && orderable_position(column) == bottom_orderable_position(column)
+      end
+
+      def in_list?(column=nil)
+        !orderable_position(column).nil?
+      end
+
+    end
+  end
+end

data/lib/mongoid/orderable/movable.rb

@@ -0,0 +1,58 @@
+module Mongoid
+  module Orderable
+    module Movable
+
+      def move_to!(target_position, options={})
+        move_column_to target_position, options
+        save
+      end
+      alias_method :insert_at!, :move_to!
+
+      def move_to(target_position, options={})
+        move_column_to target_position, options
+      end
+      alias_method :insert_at, :move_to
+
+      def move_to=(target_position, options={})
+        move_column_to target_position, options
+      end
+      alias_method :insert_at=, :move_to=
+
+      [:top, :bottom].each do |symbol|
+        class_eval <<-eos
+          def move_to_#{symbol}(options = {})
+            move_to :#{symbol}, options
+          end
+
+          def move_to_#{symbol}!(options = {})
+            move_to! :#{symbol}, options
+          end
+        eos
+      end
+
+      [:higher, :lower].each do |symbol|
+        class_eval <<-eos
+          def move_#{symbol}(options = {})
+            move_to :#{symbol}, options
+          end
+
+          def move_#{symbol}!(options = {})
+            move_to! :#{symbol}, options
+          end
+        eos
+      end
+
+      protected
+
+      def move_all
+        @move_all || {}
+      end
+
+      def move_column_to(position, options)
+        column = options[:column] || default_orderable_column
+        @move_all = move_all.merge(column => position)
+      end
+
+    end
+  end
+end

data/lib/mongoid/orderable/orderable_class.rb

@@ -0,0 +1,51 @@
+module Mongoid
+  module Orderable
+    class OrderableClass
+      include Mongoid::Orderable::Generator
+
+      attr_reader :klass, :configuration
+
+      def initialize klass, configuration
+        @klass = klass
+        @configuration = configuration
+      end
+
+      def setup
+        add_db_field
+        add_db_index if configuration[:index]
+        save_configuration
+        generate_all_helpers
+        add_callbacks
+      end
+
+      def self.setup(klass, configuration={})
+        new(klass, configuration).setup
+      end
+
+      protected
+
+      def add_db_field
+        klass.field configuration[:column], configuration[:field_opts]
+      end
+
+      def add_db_index
+        spec = [[configuration[:column], 1]]
+        spec.unshift([configuration[:scope], 1]) if configuration[:scope].is_a?(Symbol)
+        if MongoidOrderable.mongoid2?
+          klass.index(spec)
+        else
+          klass.index(Hash[spec])
+        end
+      end
+
+      def save_configuration
+        klass.orderable_configurations ||= {}
+        klass.orderable_configurations = klass.orderable_configurations.merge(column_name => configuration)
+      end
+
+      def add_callbacks
+        klass.add_orderable_callbacks
+      end
+    end
+  end
+end