ransack 1.5.1 → 1.6.0

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

@@ -0,0 +1,64 @@
+require 'ransack/visitor'
+
+module Ransack
+  class Context
+    attr_reader :arel_visitor
+
+    class << self
+
+      def for_class(klass, options = {})
+        if klass < ActiveRecord::Base
+          Adapters::ActiveRecord::Context.new(klass, options)
+        end
+      end
+
+      def for_object(object, options = {})
+        case object
+        when ActiveRecord::Relation
+          Adapters::ActiveRecord::Context.new(object.klass, options)
+        end
+      end
+
+    end # << self
+
+    def initialize(object, options = {})
+      @object = relation_for(object)
+      @klass = @object.klass
+      @join_dependency = join_dependency(@object)
+      @join_type = options[:join_type] || Polyamorous::OuterJoin
+      @search_key = options[:search_key] || Ransack.options[:search_key]
+
+      if ::ActiveRecord::VERSION::STRING >= Constants::RAILS_4_1
+        @base = @join_dependency.join_root
+        @engine = @base.base_klass.arel_engine
+      else
+        @base = @join_dependency.join_base
+        @engine = @base.arel_engine
+      end
+
+      @default_table = Arel::Table.new(
+        @base.table_name, :as => @base.aliased_table_name, :engine => @engine
+        )
+      @bind_pairs = Hash.new do |hash, key|
+        parent, attr_name = get_parent_and_attribute_name(key.to_s)
+        if parent && attr_name
+          hash[key] = [parent, attr_name]
+        end
+      end
+    end
+
+    def klassify(obj)
+      if Class === obj && ::ActiveRecord::Base > obj
+        obj
+      elsif obj.respond_to? :klass
+        obj.klass
+      elsif obj.respond_to? :active_record  # Rails 3
+        obj.active_record
+      elsif obj.respond_to? :base_klass     # Rails 4
+        obj.base_klass
+      else
+        raise ArgumentError, "Don't know how to klassify #{obj.inspect}"
+      end
+    end
+  end
+end

data/lib/ransack/adapters/active_record/ransack/nodes/condition.rb

@@ -0,0 +1,48 @@
+module Ransack
+  module Nodes
+    class Condition
+
+      def arel_predicate
+        predicates = attributes.map do |attr|
+          attr.attr.send(
+            arel_predicate_for_attribute(attr),
+            formatted_values_for_attribute(attr)
+          )
+        end
+
+        if predicates.size > 1
+          case combinator
+          when Constants::AND
+            Arel::Nodes::Grouping.new(Arel::Nodes::And.new(predicates))
+          when Constants::OR
+            predicates.inject(&:or)
+          end
+        else
+          return_predicate(predicates.first)
+        end
+      end
+
+      private
+
+        # FIXME: Improve this edge case patch for Arel >= 6.0 (Rails >= 4.2)
+        #        that adds several conditionals to handle changing Arel API.
+        #        Related to Ransack issue #472 and pull requests #486-488.
+        #
+        def return_predicate(predicate)
+          if casted_array_with_in_predicate?(predicate)
+            predicate.right[0] = predicate.right[0].val
+            .map { |v| v.is_a?(String) ? Arel::Nodes.build_quoted(v) : v }
+          end
+          predicate
+        end
+        #
+        def casted_array_with_in_predicate?(predicate)
+          return unless defined?(Arel::Nodes::Casted)
+          predicate.class == Arel::Nodes::In &&
+          predicate.right.is_a?(Array) &&
+          predicate.right[0].class == Arel::Nodes::Casted
+        end
+
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+module Ransack
+  module Translate
+
+    def self.i18n_key(klass)
+      if ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR == 0
+        klass.model_name.i18n_key.to_s.tr('.'.freeze, '/'.freeze)
+      else
+        klass.model_name.i18n_key.to_s.freeze
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Ransack
+  class Visitor
+    def visit_and(object)
+      nodes = object.values.map { |o| accept(o) }.compact
+      return nil unless nodes.size > 0
+
+      if nodes.size > 1
+        Arel::Nodes::Grouping.new(Arel::Nodes::And.new(nodes))
+      else
+        nodes.first
+      end
+    end
+
+    def quoted?(object)
+      case object
+      when Arel::Nodes::SqlLiteral, Bignum, Fixnum
+        false
+      else
+        true
+      end
+    end
+
+  end
+end

data/lib/ransack/adapters/mongoid.rb

@@ -0,0 +1,13 @@
+require 'ransack/adapters/mongoid/base'
+::Mongoid::Document.send :include, Ransack::Adapters::Mongoid::Base
+
+require 'ransack/adapters/mongoid/attributes/attribute'
+require 'ransack/adapters/mongoid/table'
+require 'ransack/adapters/mongoid/inquiry_hash'
+
+case ::Mongoid::VERSION
+when /^3\.2\./
+  require 'ransack/adapters/mongoid/3.2/context'
+else
+  require 'ransack/adapters/mongoid/context'
+end

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

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

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

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

@@ -0,0 +1,126 @@
+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)
+          end
+
+          # For overriding with a whitelist of symbols
+          def ransackable_scopes(auth_object = nil)
+            []
+          end
+
+          # imitating active record
+
+          def joins_values *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