ransack 1.7.0 → 2.4.1

data/lib/ransack/adapters/active_record/compat.rb

@@ -1,14 +0,0 @@
-module Arel
-
-  module Visitors
-
-    class DepthFirst < Visitor
-
-      unless method_defined?(:visit_Arel_Nodes_InfixOperation)
-        alias :visit_Arel_Nodes_InfixOperation :binary
-      end
-
-    end
-
-  end
-end

data/lib/ransack/adapters/mongoid/attributes/attribute.rb

@@ -1,37 +0,0 @@
-require 'ransack/adapters/mongoid/attributes/predications'
-require 'ransack/adapters/mongoid/attributes/order_predications'
-
-module Ransack
-  module Adapters
-    module Mongoid
-      module Attributes
-        class Attribute < Struct.new :relation, :name
-          # include Arel::Expressions
-          # include Arel::Predications
-          # include Arel::AliasPredication
-          # include Arel::OrderPredications
-          # include Arel::Math
-
-          include ::Ransack::Adapters::Mongoid::Attributes::Predications
-          include ::Ransack::Adapters::Mongoid::Attributes::OrderPredications
-
-          ###
-          # Create a node for lowering this attribute
-          def lower
-            relation.lower self
-          end
-        end
-
-        class String    < Attribute; end
-        class Time      < Attribute; end
-        class Boolean   < Attribute; end
-        class Decimal   < Attribute; end
-        class Float     < Attribute; end
-        class Integer   < Attribute; end
-        class Undefined < Attribute; end
-      end
-
-      Attribute = Attributes::Attribute
-    end # Attributes
-  end
-end

data/lib/ransack/adapters/mongoid/attributes/order_predications.rb

@@ -1,17 +0,0 @@
-module Ransack
-  module Adapters
-    module Mongoid
-      module Attributes
-        module OrderPredications
-          def asc
-            { name => :asc }
-          end
-
-          def desc
-            { name => :desc }
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ransack/adapters/mongoid/attributes/predications.rb

@@ -1,141 +0,0 @@
-module Ransack
-  module Adapters
-    module Mongoid
-      module Attributes
-        module Predications
-          def not_eq(other)
-            { name => { '$ne' => other } }.to_inquiry
-          end
-
-          def not_eq_any(others)
-            grouping_any :not_eq, others
-          end
-
-          def not_eq_all(others)
-            grouping_all :not_eq, others
-          end
-
-          def eq(other)
-            { name => other }.to_inquiry
-          end
-
-          def eq_any(others)
-            grouping_any :eq, others
-          end
-
-          def eq_all(others)
-            grouping_all :eq, others
-          end
-
-          def in(other)
-            { name => { "$in" => other } }.to_inquiry
-          end
-
-          def in_any(others)
-            grouping_any :in, others
-          end
-
-          def in_all(others)
-            grouping_all :in, others
-          end
-
-          def not_in(other)
-            { "$not" => { name => { "$in" => other } } }.to_inquiry
-          end
-
-          def not_in_any(others)
-            grouping_any :not_in, others
-          end
-
-          def not_in_all(others)
-            grouping_all :not_in, others
-          end
-
-          def matches(other)
-            { name => /#{other}/i }.to_inquiry
-          end
-
-          def matches_any(others)
-            grouping_any :matches, others
-          end
-
-          def matches_all(others)
-            grouping_all :matches, others
-          end
-
-          def does_not_match(other)
-            { "$not" => { name => /#{other}/i } }.to_inquiry
-          end
-
-          def does_not_match_any(others)
-            grouping_any :does_not_match, others
-          end
-
-          def does_not_match_all(others)
-            grouping_all :does_not_match, others
-          end
-
-          def gteq(right)
-            { name => { '$gte' => right } }.to_inquiry
-          end
-
-          def gteq_any(others)
-            grouping_any :gteq, others
-          end
-
-          def gteq_all(others)
-            grouping_all :gteq, others
-          end
-
-          def gt(right)
-            { name => { '$gt' => right } }.to_inquiry
-          end
-
-          def gt_any(others)
-            grouping_any :gt, others
-          end
-
-          def gt_all(others)
-            grouping_all :gt, others
-          end
-
-          def lt(right)
-            { name => { '$lt' => right } }.to_inquiry
-          end
-
-          def lt_any(others)
-            grouping_any :lt, others
-          end
-
-          def lt_all(others)
-            grouping_all :lt, others
-          end
-
-          def lteq(right)
-            { name => { '$lte' => right } }.to_inquiry
-          end
-
-          def lteq_any(others)
-            grouping_any :lteq, others
-          end
-
-          def lteq_all(others)
-            grouping_all :lteq, others
-          end
-
-          private
-
-          def grouping_any(method_id, others)
-            nodes = others.map { |e| send(method_id, e) }
-            { "$or" => nodes }.to_inquiry
-          end
-
-          def grouping_all(method_id, others)
-            nodes = others.map { |e| send(method_id, e) }
-            { "$and" => nodes }.to_inquiry
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ransack/adapters/mongoid/base.rb

@@ -1,130 +0,0 @@
-require 'delegate'
-
-module Ransack
-  module Adapters
-    module Mongoid
-      module Base
-
-        extend ActiveSupport::Concern
-
-        included do
-        end
-
-        class ColumnWrapper < SimpleDelegator
-          def type
-            _super = super
-            case _super
-            when BSON::ObjectId, Object
-              :string
-            else
-              _super.name.underscore.to_sym
-            end
-          end
-        end
-
-        class Connection
-          def initialize model
-            @model = model
-          end
-
-          def quote_column_name name
-            name
-          end
-        end
-
-        module ClassMethods
-          def _ransackers
-            @_ransackers ||= {}
-          end
-
-          def _ransackers=(value)
-            @_ransackers = value
-          end
-
-          def ransack(params = {}, options = {})
-            params = params.presence || {}
-            Search.new(self, params ? params.delete_if {
-              |k, v| v.blank? && v != false } : params, options)
-          end
-
-          alias_method :search, :ransack
-
-          def ransacker(name, opts = {}, &block)
-            self._ransackers = _ransackers.merge name.to_s => Ransacker
-              .new(self, name, opts, &block)
-          end
-
-          def all_ransackable_attributes
-            ['id'] + column_names.select { |c| c != '_id' } + _ransackers.keys
-          end
-
-          def ransackable_attributes(auth_object = nil)
-            all_ransackable_attributes
-          end
-
-          def ransortable_attributes(auth_object = nil)
-            # Here so users can overwrite the attributes
-            # that show up in the sort_select
-            ransackable_attributes(auth_object)
-          end
-
-          def ransackable_associations(auth_object = nil)
-            reflect_on_all_associations_all.map { |a| a.name.to_s }
-          end
-
-          def reflect_on_all_associations_all
-            reflect_on_all_associations(:belongs_to, :has_one, :has_many, :embeds_many, :embedded_in)
-          end
-
-          # For overriding with a whitelist of symbols
-          def ransackable_scopes(auth_object = nil)
-            []
-          end
-
-          # imitating active record
-
-          def joins_values *args
-            []
-          end
-
-          def custom_join_ast *args
-            []
-          end
-
-          def first(*args)
-            if args.size == 0
-              super
-            else
-              self.criteria.limit(args.first)
-            end
-          end
-
-          # def group_by *args, &block
-          #   criteria
-          # end
-
-          def columns
-            @columns ||= fields.map(&:second).map{ |c| ColumnWrapper.new(c) }
-          end
-
-          def column_names
-            @column_names ||= fields.map(&:first)
-          end
-
-          def columns_hash
-            columns.index_by(&:name)
-          end
-
-          def table
-            name = ::Ransack::Adapters::Mongoid::Attributes::Attribute.new(self.criteria, :name)
-            {
-              :name => name
-            }
-          end
-
-        end
-
-      end # Base
-    end
-  end
-end

data/lib/ransack/adapters/mongoid/context.rb

@@ -1,208 +0,0 @@
-require 'ransack/context'
-require 'polyamorous'
-
-module Ransack
-  module Adapters
-    module Mongoid
-      class Context < ::Ransack::Context
-
-        # Because the AR::Associations namespace is insane
-        # JoinDependency = ::Mongoid::Associations::JoinDependency
-        # JoinPart = JoinDependency::JoinPart
-
-        def initialize(object, options = {})
-          super
-          # @arel_visitor = @engine.connection.visitor
-        end
-
-        def relation_for(object)
-          object.all
-        end
-
-        def type_for(attr)
-          return nil unless attr && attr.valid?
-          name    = attr.arel_attribute.name.to_s.split('.').last
-          # table   = attr.arel_attribute.relation.table_name
-
-          # schema_cache = @engine.connection.schema_cache
-          # raise "No table named #{table} exists" unless schema_cache.table_exists?(table)
-          # schema_cache.columns_hash(table)[name].type
-
-          # when :date
-          # when :datetime, :timestamp, :time
-          # when :boolean
-          # when :integer
-          # when :float
-          # when :decimal
-          # else # :string
-
-          name = '_id' if name == 'id'
-
-          t = object.klass.fields[name].try(:type) || @bind_pairs[attr.name].first.fields[name].type
-
-          t.to_s.demodulize.underscore.to_sym
-        end
-
-        def evaluate(search, opts = {})
-          viz = Visitor.new
-          relation = @object.where(viz.accept(search.base))
-          if search.sorts.any?
-            ary_sorting = viz.accept(search.sorts)
-            sorting = {}
-            ary_sorting.each do |s|
-              sorting.merge! Hash[s.map { |k, d| [k.to_s == 'id' ? '_id' : k, d] }]
-            end
-            relation = relation.order_by(sorting)
-            # relation = relation.except(:order)
-            # .reorder(viz.accept(search.sorts))
-          end
-          # -- mongoid has different distinct method
-          # opts[:distinct] ? relation.distinct : relation
-          relation
-        end
-
-        def attribute_method?(str, klass = @klass)
-          exists = false
-          if ransackable_attribute?(str, klass)
-            exists = true
-          elsif (segments = str.split(/_/)).size > 1
-            remainder = []
-            found_assoc = nil
-            while !found_assoc && remainder.unshift(
-              segments.pop) && segments.size > 0 do
-              assoc, poly_class = unpolymorphize_association(
-                segments.join('_')
-                )
-              if found_assoc = get_association(assoc, klass)
-                exists = attribute_method?(remainder.join('_'),
-                  poly_class || found_assoc.klass
-                )
-              end
-            end
-          end
-          exists
-        end
-
-        def table_for(parent)
-          # parent.table
-          Ransack::Adapters::Mongoid::Table.new(parent)
-        end
-
-        def klassify(obj)
-          if Class === obj && obj.ancestors.include?(::Mongoid::Document)
-            obj
-          elsif obj.respond_to? :klass
-            obj.klass
-          elsif obj.respond_to? :base_klass
-            obj.base_klass
-          else
-            raise ArgumentError, "Don't know how to klassify #{obj}"
-          end
-        end
-
-      private
-
-        def get_parent_and_attribute_name(str, parent = @base)
-          attr_name = nil
-
-          if ransackable_attribute?(str, klassify(parent))
-            attr_name = str
-          elsif (segments = str.split(/_/)).size > 1
-            remainder = []
-            found_assoc = nil
-            while remainder.unshift(
-              segments.pop) && segments.size > 0 && !found_assoc do
-              assoc, klass = unpolymorphize_association(segments.join('_'))
-              if found_assoc = get_association(assoc, parent)
-                parent, attr_name = get_parent_and_attribute_name(
-                  remainder.join('_'), found_assoc.klass
-                  )
-                attr_name = "#{segments.join('_')}.#{attr_name}"
-              end
-            end
-          end
-
-          [parent, attr_name]
-        end
-
-        def get_association(str, parent = @base)
-          klass = klassify parent
-          ransackable_association?(str, klass) &&
-            klass.reflect_on_all_associations_all.detect { |a| a.name.to_s == str }
-        end
-
-        def join_dependency(relation)
-          if relation.respond_to?(:join_dependency) # Squeel will enable this
-            relation.join_dependency
-          else
-            build_join_dependency(relation)
-          end
-        end
-
-        # Checkout active_record/relation/query_methods.rb +build_joins+ for
-        # reference. Lots of duplicated code maybe we can avoid it
-        def build_join_dependency(relation)
-          buckets = relation.joins_values.group_by do |join|
-            case join
-            when String
-              Constants::STRING_JOIN
-            when Hash, Symbol, Array
-              Constants::ASSOCIATION_JOIN
-            when JoinDependency, JoinDependency::JoinAssociation
-              Constants::STASHED_JOIN
-            when Arel::Nodes::Join
-              Constants::JOIN_NODE
-            else
-              raise 'unknown class: %s' % join.class.name
-            end
-          end
-
-          association_joins = buckets[Constants::ASSOCIATION_JOIN] || []
-
-          stashed_association_joins = buckets[Constants::STASHED_JOIN] || []
-
-          join_nodes = buckets[Constants::JOIN_NODE] || []
-
-          string_joins = (buckets[Constants::STRING_JOIN] || [])
-            .map { |x| x.strip }
-            .uniq
-
-          join_list = relation.send :custom_join_ast,
-            relation.table.from(relation.table), string_joins
-
-          join_dependency = JoinDependency.new(
-            relation.klass, association_joins, join_list
-          )
-
-          join_nodes.each do |join|
-            join_dependency.alias_tracker.aliases[join.left.name.downcase] = 1
-          end
-
-          join_dependency # ActiveRecord::Associations::JoinDependency
-        end
-
-        # ActiveRecord method
-        def build_or_find_association(name, parent = @base, klass = nil)
-          found_association = @join_dependency.join_associations
-          .detect do |assoc|
-            assoc.reflection.name == name &&
-            assoc.parent == parent &&
-            (!klass || assoc.reflection.klass == klass)
-          end
-          unless found_association
-            @join_dependency.send(
-              :build,
-              Polyamorous::Join.new(name, @join_type, klass),
-              parent
-             )
-            found_association = @join_dependency.join_associations.last
-            # Leverage the stashed association functionality in AR
-            @object = @object.joins(found_association)
-          end
-          found_association
-        end
-
-      end
-    end
-  end
-end

data/lib/ransack/adapters/mongoid/inquiry_hash.rb

@@ -1,23 +0,0 @@
-module Ransack
-  module Adapters
-    module Mongoid
-      class InquiryHash < Hash
-
-        def or(other)
-          { '$or' => [ self, other] }.to_inquiry
-        end
-
-        def and(other)
-          { '$and' => [ self, other] }.to_inquiry
-        end
-
-      end
-    end
-  end
-end
-
-class Hash
-  def to_inquiry
-    ::Ransack::Adapters::Mongoid::InquiryHash[self]
-  end
-end

data/lib/ransack/adapters/mongoid/ransack/constants.rb

@@ -1,88 +0,0 @@
-module Ransack
-  module Constants
-    DERIVED_PREDICATES = [
-      [CONT, {
-        :arel_predicate => 'matches',
-        :formatter => proc { |v| "#{escape_regex(v)}" }
-        }
-      ],
-      ['not_cont', {
-        :arel_predicate => 'does_not_match',
-        :formatter => proc { |v| "#{escape_regex(v)}" }
-        }
-      ],
-      ['start', {
-        :arel_predicate => 'matches',
-        :formatter => proc { |v| "\\A#{escape_regex(v)}" }
-        }
-      ],
-      ['not_start', {
-        :arel_predicate => 'does_not_match',
-        :formatter => proc { |v| "\\A#{escape_regex(v)}" }
-        }
-      ],
-      ['end', {
-        :arel_predicate => 'matches',
-        :formatter => proc { |v| "#{escape_regex(v)}\\Z" }
-        }
-      ],
-      ['not_end', {
-        :arel_predicate => 'does_not_match',
-        :formatter => proc { |v| "#{escape_regex(v)}\\Z" }
-        }
-      ],
-      ['true', {
-        :arel_predicate => 'eq',
-        :compounds => false,
-        :type => :boolean,
-        :validator => proc { |v| TRUE_VALUES.include?(v) }
-        }
-      ],
-      ['false', {
-        :arel_predicate => 'eq',
-        :compounds => false,
-        :type => :boolean,
-        :validator => proc { |v| TRUE_VALUES.include?(v) },
-        :formatter => proc { |v| !v }
-        }
-      ],
-      ['present', {
-        :arel_predicate => proc { |v| v ? 'not_eq_all' : 'eq_any' },
-        :compounds => false,
-        :type => :boolean,
-        :validator => proc { |v| BOOLEAN_VALUES.include?(v) },
-        :formatter => proc { |v| [nil, ''] }
-        }
-      ],
-      ['blank', {
-        :arel_predicate => proc { |v| v ? 'eq_any' : 'not_eq_all' },
-        :compounds => false,
-        :type => :boolean,
-        :validator => proc { |v| BOOLEAN_VALUES.include?(v) },
-        :formatter => proc { |v| [nil, ''] }
-        }
-      ],
-      ['null', {
-        :arel_predicate => proc { |v| v ? 'eq' : 'not_eq' },
-        :compounds => false,
-        :type => :boolean,
-        :validator => proc { |v| BOOLEAN_VALUES.include?(v)},
-        :formatter => proc { |v| nil }
-        }
-      ],
-      ['not_null', {
-        :arel_predicate => proc { |v| v ? 'not_eq' : 'eq' },
-        :compounds => false,
-        :type => :boolean,
-        :validator => proc { |v| BOOLEAN_VALUES.include?(v) },
-        :formatter => proc { |v| nil } }
-      ]
-    ]
-
-  module_function
-    # does nothing
-    def escape_regex(unescaped)
-      Regexp.escape(unescaped)
-    end
-  end
-end