mongoid_orderable 5.0.0 → 6.0.2

data/.gitignore

@@ -1,4 +0,0 @@
-*.gem
-.bundle
-Gemfile.lock
-pkg/*

data/.rspec

@@ -1,2 +0,0 @@
---colour
---format=documentation

data/.rvmrc

@@ -1 +0,0 @@
-rvm use 2.2@mongoid_orderable --create

data/.travis.yml

@@ -1,14 +0,0 @@
-rvm:
-  - 1.9.3
-  - 2.0.0
-  - 2.1
-  - 2.2
-  # - rbx
-
-env:
-  - MONGOID_VERSION=2
-  - MONGOID_VERSION=3
-  - MONGOID_VERSION=4
-  - MONGOID_VERSION=5
-
-services: mongodb

data/Gemfile

@@ -1,18 +0,0 @@
-source "http://rubygems.org"
-
-# Specify your gem's dependencies in mongoid_orderable.gemspec
-gemspec
-
-case version = ENV['MONGOID_VERSION'] || '5.0'
-when /^5/
-  gem 'mongoid', '~> 5.0'
-when /^4/
-  gem 'mongoid', '~> 4.0'
-when /^3/
-  gem 'mongoid', '~> 3.1'
-when /^2/
-  gem 'mongoid', '~> 2.0'
-  gem 'bson_ext', platforms: :ruby
-else
-  gem 'mongoid', version
-end

data/lib/mongoid/orderable/callbacks.rb

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

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

data/lib/mongoid/orderable/errors.rb

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

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

@@ -1,14 +0,0 @@
-module Mongoid::Orderable
-  module Errors
-    class MongoidOrderableError < ::Mongoid::Errors::MongoidError
-
-      if ::Mongoid::Compatibility::Version.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

@@ -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