mongoid_orderable 5.2.0 → 6.0.0

data/Dangerfile

@@ -1 +0,0 @@
-danger.import_dangerfile(gem: 'mongoid-danger')

data/Gemfile

@@ -1,26 +0,0 @@
-source 'http://rubygems.org'
-
-# Specify your gem's dependencies in mongoid_orderable.gemspec
-gemspec
-
-case version = ENV['MONGOID_VERSION'] || '7'
-when 'HEAD'
-  gem 'mongoid', github: 'mongodb/mongoid'
-when /^7/
-  gem 'mongoid', '~> 7.0'
-when /^6/
-  gem 'mongoid', '~> 6.0'
-when /^5/
-  gem 'mongoid', '~> 5.0'
-when /^4/
-  gem 'mongoid', '~> 4.0'
-when /^3/
-  gem 'mongoid', '~> 3.1'
-else
-  gem 'mongoid', version
-end
-
-group :test do
-  gem 'rubocop', '0.45.0'
-  gem 'mongoid-danger', '~> 0.1.0', require: false
-end

data/RELEASING.md

@@ -1,68 +0,0 @@
-Releasing Mongoid::Orderable
-============================
-
-There're no particular rules about when to release mongoid_orderable. Release bug fixes frequently, features not so frequently and breaking API changes rarely.
-
-### Release
-
-Run tests, check that all tests succeed locally.
-
-```
-bundle install
-rake
-```
-
-Check that the last build succeeded in [Travis CI](https://travis-ci.org/mongoid/mongoid_orderable) for all supported platforms.
-
-Increment the version, modify [lib/mongoid_orderable/version.rb](lib/mongoid_orderable/version.rb).
-
-*  Increment the third number if the release has bug fixes and/or very minor features, only (eg. change `0.5.1` to `0.5.2`).
-*  Increment the second number if the release contains major features or breaking API changes (eg. change `0.5.1` to `0.4.0`).
-
-Change "Next Release" in [CHANGELOG.md](CHANGELOG.md) to the new version.
-
-```
-### 0.4.0 (2014-01-27)
-```
-
-Remove the line with "Your contribution here.", since there will be no more contributions to this release.
-
-Commit your changes.
-
-```
-git add CHANGELOG.md lib/mongoid_orderable/version.rb
-git commit -m "Preparing for release, 0.4.0."
-git push origin master
-```
-
-Release.
-
-```
-$ rake release
-
-mongoid_orderable 0.4.0 built to pkg/mongoid_orderable-0.4.0.gem.
-Tagged v0.4.0.
-Pushed git commits and tags.
-Pushed mongoid_orderable 0.4.0 to rubygems.org.
-```
-
-### Prepare for the Next Version
-
-Add the next release to [CHANGELOG.md](CHANGELOG.md).
-
-```
-Next Release
-============
-
-* Your contribution here.
-```
-
-Increment the minor version, modify [lib/mongoid_orderable/version.rb](lib/mongoid_orderable/version.rb).
-
-Commit your changes.
-
-```
-git add CHANGELOG.md lib/mongoid_orderable/version.rb
-git commit -m "Preparing for next release, 0.4.1."
-git push origin master
-```

data/lib/mongoid/orderable/callbacks.rb

@@ -1,79 +0,0 @@
-module Mongoid
-  module Orderable
-    module Callbacks
-      extend ActiveSupport::Concern
-
-      included do
-        protected
-
-        def add_to_list
-          orderable_keys.each do |column|
-            apply_position column, move_all[column]
-          end
-        end
-
-        def remove_from_list
-          orderable_keys.each do |column|
-            remove_position_from_list column
-          end
-        end
-
-        def remove_position_from_list(column)
-          col = orderable_column(column)
-          pos = 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)
-            send("orderable_#{column}_position=", nil)
-          end
-
-          return if !target_position && in_list?(column)
-
-          target_position = target_position_to_position column, target_position
-          scope = orderable_scoped(column)
-          col = orderable_column(column)
-          pos = orderable_position(column)
-
-          if !in_list?(column)
-            MongoidOrderable.inc scope.where(col.gte => target_position), col, 1
-          elsif target_position < pos
-            MongoidOrderable.inc(scope.where(col.gte => target_position, col.lt => pos), col, 1)
-          elsif target_position > pos
-            MongoidOrderable.inc(scope.where(col.gt => pos, col.lte => target_position), col, -1)
-          end
-
-          send("orderable_#{column}_position=", target_position)
-        end
-
-        def target_position_to_position(column, target_position)
-          target_position = :bottom unless target_position
-
-          unless target_position.is_a? Numeric
-            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, target_position
-                              end
-          end
-
-          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,58 +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.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]
-          @options[:scope] = if scope_relation
-                               scope_relation.key.to_sym
-                             else
-                               "#{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,6 +0,0 @@
-module Mongoid::Orderable
-  module Errors
-    class MongoidOrderableError < ::Mongoid::Errors::MongoidError
-    end
-  end
-end

data/lib/mongoid/orderable/generator.rb

@@ -1,33 +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,27 +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,39 +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,60 +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,24 +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 ->(document) { where(order_scope => document.send(order_scope)) }
-                                                    when Proc   then order_scope
-                                                    else ->(_document) { where({}) }
-                                                    end
-          end
-        end
-      end
-    end
-  end
-end