mongoid_orderable 4.1.1 → 6.0.1

data/lib/mongoid/orderable/generator.rb

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

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

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

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

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

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

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

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

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

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

data/lib/mongoid_orderable/mongoid/contexts/enumerable.rb

@@ -1,15 +0,0 @@
-module MongoidOrderable #:nodoc:
-  module Mongoid #:nodoc:
-    module Contexts #:nodoc:
-      module Enumerable #:nodoc:
-        def inc attribute, value
-          iterate do |doc|
-            MongoidOrderable.inc doc, attribute, value
-          end
-        end
-      end
-    end
-  end
-end
-
-Mongoid::Contexts::Enumerable.send :include, MongoidOrderable::Mongoid::Contexts::Enumerable