ransack 1.5.1 → 1.6.0

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

@@ -0,0 +1,35 @@
+module Ransack
+  module Adapters
+    module Mongoid
+      class Table
+        attr_accessor :name
+
+        alias :table_name :name
+
+        def initialize(object, engine = nil)
+          @object  = object
+          @name    = object.collection.name
+          @engine  = engine
+          @columns = nil
+          @aliases = []
+          @table_alias = nil
+          @primary_key = nil
+
+          if Hash === engine
+            # @engine  = engine[:engine] || Table.engine
+
+            # Sometime AR sends an :as parameter to table, to let the table know
+            # that it is an Alias.  We may want to override new, and return a
+            # TableAlias node?
+            # @table_alias = engine[:as] unless engine[:as].to_s == @name
+          end
+        end
+
+        def [](name)
+          Ransack::Adapters::Mongoid::Attribute.new self, name
+        end
+
+      end
+    end
+  end
+end

data/lib/ransack/configuration.rb

@@ -24,7 +24,7 @@ module Ransack
 
       self.predicates[name] = Predicate.new(opts)
 
-      Ransack::Constants::SUFFIXES.each do |suffix|
+      Constants::SUFFIXES.each do |suffix|
         compound_name = name + suffix
         self.predicates[compound_name] = Predicate.new(
           opts.merge(
@@ -38,13 +38,31 @@ module Ransack
       end if compounds
     end
 
-    # default search_key that, it can be overridden on sort_link level
+    # The default `search_key` name is `:q`. The default key may be overridden
+    # in an initializer file like `config/initializers/ransack.rb` as follows:
+    #
+    # Ransack.configure do |config|
+    #   # Name the search_key `:query` instead of the default `:q`
+    #   config.search_key = :query
+    # end
+    #
+    # Sometimes there are situations when the default search parameter name
+    # cannot be used, for instance if there were two searches on one page.
+    # Another name can be set using the `search_key` option with Ransack
+    # `ransack`, `search` and `@search_form_for` methods in controllers & views.
+    #
+    # In the controller:
+    # @search = Log.ransack(params[:log_search], search_key: :log_search)
+    #
+    # In the view:
+    # <%= f.search_form_for @search, as: :log_search %>
+    #
     def search_key=(name)
       self.options[:search_key] = name
     end
 
-    # raise an error if an unknown predicate, condition or attribute is passed
-    # into a search
+    # Raise an error if an unknown predicate, condition or attribute is passed
+    # into a search.
     def ignore_unknown_conditions=(boolean)
       self.options[:ignore_unknown_conditions] = boolean
     end

data/lib/ransack/constants.rb

@@ -2,22 +2,39 @@ module Ransack
   module Constants
     ASC                 = 'asc'.freeze
     DESC                = 'desc'.freeze
+    ASC_DESC            = [ASC, DESC].freeze
+
     ASC_ARROW           = '▲'.freeze
     DESC_ARROW          = '▼'.freeze
+
     OR                  = 'or'.freeze
     AND                 = 'and'.freeze
+    SPACED_AND          = ' AND '.freeze
+
     SORT                = 'sort'.freeze
     SORT_LINK           = 'sort_link'.freeze
+    SORT_DIRECTION      = 'sort_direction'.freeze
+
+    CAP_SEARCH          = 'Search'.freeze
     SEARCH              = 'search'.freeze
-    DEFAULT_SEARCH_KEY  = 'q'.freeze
+    SEARCHES            = 'searches'.freeze
+
     ATTRIBUTE           = 'attribute'.freeze
-    DISTINCT            = 'DISTINCT '.freeze
+    ATTRIBUTES          = 'attributes'.freeze
     COMBINATOR          = 'combinator'.freeze
+
     SPACE               = ' '.freeze
     COMMA_SPACE         = ', '.freeze
+    COLON_SPACE         = ': '.freeze
+    TWO_COLONS          = '::'.freeze
     UNDERSCORE          = '_'.freeze
+    LEFT_PARENTHESIS    = '('.freeze
+    Q                   = 'q'.freeze
+    I                   = 'i'.freeze
     NON_BREAKING_SPACE  = ' '.freeze
+    DOT_ASTERIX         = '.*'.freeze
     EMPTY               = ''.freeze
+
     STRING_JOIN         = 'string_join'.freeze
     ASSOCIATION_JOIN    = 'association_join'.freeze
     STASHED_JOIN        = 'stashed_join'.freeze
@@ -25,138 +42,27 @@ module Ransack
 
     TRUE_VALUES = [true, 1, '1', 't', 'T', 'true', 'TRUE'].to_set
     FALSE_VALUES = [false, 0, '0', 'f', 'F', 'false', 'FALSE'].to_set
-    BOOLEAN_VALUES = TRUE_VALUES + FALSE_VALUES
+    BOOLEAN_VALUES = (TRUE_VALUES + FALSE_VALUES).freeze
 
     S_SORTS             = %w(s sorts).freeze
-    ASC_DESC            = %w(asc desc).freeze
     AND_OR              = %w(and or).freeze
     IN_NOT_IN           = %w(in not_in).freeze
     SUFFIXES            = %w(_any _all).freeze
     AREL_PREDICATES     = %w(
       eq not_eq matches does_not_match lt lteq gt gteq in not_in
     ).freeze
+    A_S_I               = %w(a s i).freeze
 
     EQ                  = 'eq'.freeze
     NOT_EQ              = 'not_eq'.freeze
     EQ_ANY              = 'eq_any'.freeze
     NOT_EQ_ALL          = 'not_eq_all'.freeze
+    CONT                = 'cont'.freeze
 
-    DERIVED_PREDICATES = [
-      ['cont'.freeze, {
-        :arel_predicate => 'matches'.freeze,
-        :formatter => proc { |v| "%#{escape_wildcards(v)}%" }
-        }
-      ],
-      ['i_cont'.freeze, {
-        :arel_predicate => 'i_matches'.freeze,
-        :formatter => proc { |v| "%#{escape_wildcards(v)}%" }
-      }
-      ],
-      ['not_cont'.freeze, {
-        :arel_predicate => 'does_not_match'.freeze,
-        :formatter => proc { |v| "%#{escape_wildcards(v)}%" }
-        }
-      ],
-      ['i_not_cont'.freeze, {
-        :arel_predicate => 'i_does_not_match'.freeze,
-        :formatter => proc { |v| "%#{escape_wildcards(v)}%" }
-      }
-      ],
-      ['start'.freeze, {
-        :arel_predicate => 'matches'.freeze,
-        :formatter => proc { |v| "#{escape_wildcards(v)}%" }
-        }
-      ],
-      ['not_start'.freeze, {
-        :arel_predicate => 'does_not_match'.freeze,
-        :formatter => proc { |v| "#{escape_wildcards(v)}%" }
-        }
-      ],
-      ['end'.freeze, {
-        :arel_predicate => 'matches'.freeze,
-        :formatter => proc { |v| "%#{escape_wildcards(v)}" }
-        }
-      ],
-      ['not_end'.freeze, {
-        :arel_predicate => 'does_not_match'.freeze,
-        :formatter => proc { |v| "%#{escape_wildcards(v)}" }
-        }
-      ],
-      ['true'.freeze, {
-        :arel_predicate => proc { |v| v ? EQ : NOT_EQ },
-        :compounds => false,
-        :type => :boolean,
-        :validator => proc { |v| BOOLEAN_VALUES.include?(v) },
-        :formatter => proc { |v| true }
-        }
-      ],
-      ['not_true'.freeze, {
-        :arel_predicate => proc { |v| v ? NOT_EQ : EQ },
-        :compounds => false,
-        :type => :boolean,
-        :validator => proc { |v| BOOLEAN_VALUES.include?(v) },
-        :formatter => proc { |v| true }
-        }
-      ],
-      ['false'.freeze, {
-        :arel_predicate => proc { |v| v ? EQ : NOT_EQ },
-        :compounds => false,
-        :type => :boolean,
-        :validator => proc { |v| BOOLEAN_VALUES.include?(v) },
-        :formatter => proc { |v| false }
-        }
-      ],
-      ['not_false'.freeze, {
-        :arel_predicate => proc { |v| v ? NOT_EQ : EQ },
-        :compounds => false,
-        :type => :boolean,
-        :validator => proc { |v| BOOLEAN_VALUES.include?(v) },
-        :formatter => proc { |v| false }
-        }
-      ],
-      ['present'.freeze, {
-        :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, Ransack::Constants::EMPTY] }
-        }
-      ],
-      ['blank'.freeze, {
-        :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, Ransack::Constants::EMPTY] }
-        }
-      ],
-      ['null'.freeze, {
-        :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'.freeze, {
-        :arel_predicate => proc { |v| v ? NOT_EQ : EQ },
-        :compounds => false,
-        :type => :boolean,
-        :validator => proc { |v| BOOLEAN_VALUES.include?(v) },
-        :formatter => proc { |v| nil } }
-      ]
-    ].freeze
+    RAILS_4_1           = '4.1'.freeze
 
-  module_function
-    # replace % \ to \% \\
-    def escape_wildcards(unescaped)
-      case ActiveRecord::Base.connection.adapter_name
-      when "Mysql2".freeze, "PostgreSQL".freeze
-        # Necessary for PostgreSQL and MySQL
-        unescaped.to_s.gsub(/([\\|\%|.])/, '\\\\\\1')
-      else
-        unescaped
-      end
-    end
+    RANSACK_SLASH_SEARCHES = 'ransack/searches'.freeze
+    RANSACK_SLASH_SEARCHES_SLASH_SEARCH = 'ransack/searches/search'.freeze
   end
 end
+

data/lib/ransack/context.rb

@@ -1,12 +1,28 @@
 require 'ransack/visitor'
 
+if defined?(::ActiveRecord::Base)
+  require 'ransack/adapters/active_record/ransack/visitor'
+end
+
+if defined?(::Mongoid)
+  require 'ransack/adapters/mongoid/ransack/visitor'
+end
+
 module Ransack
   class Context
-    attr_reader :object, :klass, :base, :engine, :arel_visitor
+    attr_reader :search, :object, :klass, :base, :engine, :arel_visitor
     attr_accessor :auth_object, :search_key
 
     class << self
 
+      def for_class(klass, options = {})
+        raise "not implemented"
+      end
+
+      def for_object(object, options = {})
+        raise "not implemented"
+      end
+
       def for(object, options = {})
         context = Class === object ?
           for_class(object, options) :
@@ -15,59 +31,14 @@ module Ransack
           "Don't know what context to use for #{object}"
       end
 
-      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
+    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 >= "4.1".freeze
-        @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
+      raise "not implemented"
     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
+      raise "not implemented"
     end
 
     # Convert a string representing a chain of associations and an attribute
@@ -95,7 +66,7 @@ module Ransack
     end
 
     def traverse(str, base = @base)
-      str ||= Ransack::Constants::EMPTY
+      str ||= Constants::EMPTY
 
       if (segments = str.split(/_/)).size > 0
         remainder = []
@@ -103,12 +74,13 @@ module Ransack
         while !found_assoc && segments.size > 0 do
           # Strip the _of_Model_type text from the association name, but hold
           # onto it in klass, for use as the next base
-          assoc, klass = unpolymorphize_association(segments
-                         .join(Ransack::Constants::UNDERSCORE))
+          assoc, klass = unpolymorphize_association(
+            segments.join(Constants::UNDERSCORE)
+            )
           if found_assoc = get_association(assoc, base)
             base = traverse(
               remainder.join(
-                Ransack::Constants::UNDERSCORE), klass || found_assoc.klass
+                Constants::UNDERSCORE), klass || found_assoc.klass
                 )
           end
 
@@ -123,16 +95,16 @@ module Ransack
 
     def association_path(str, base = @base)
       base = klassify(base)
-      str ||= Ransack::Constants::EMPTY
+      str ||= Constants::EMPTY
       path = []
       segments = str.split(/_/)
       association_parts = []
       if (segments = str.split(/_/)).size > 0
         while segments.size > 0 &&
-        !base.columns_hash[segments.join(Ransack::Constants::UNDERSCORE)] &&
+        !base.columns_hash[segments.join(Constants::UNDERSCORE)] &&
         association_parts << segments.shift do
           assoc, klass = unpolymorphize_association(
-            association_parts.join(Ransack::Constants::UNDERSCORE)
+            association_parts.join(Constants::UNDERSCORE)
             )
           if found_assoc = get_association(assoc, base)
             path += association_parts
@@ -142,7 +114,7 @@ module Ransack
         end
       end
 
-      path.join(Ransack::Constants::UNDERSCORE)
+      path.join(Constants::UNDERSCORE)
     end
 
     def unpolymorphize_association(str)
@@ -166,15 +138,15 @@ module Ransack
       klass.ransackable_scopes(auth_object).any? { |s| s.to_s == str }
     end
 
-    def searchable_attributes(str = Ransack::Constants::EMPTY)
+    def searchable_attributes(str = Constants::EMPTY)
       traverse(str).ransackable_attributes(auth_object)
     end
 
-    def sortable_attributes(str = Ransack::Constants::EMPTY)
+    def sortable_attributes(str = Constants::EMPTY)
       traverse(str).ransortable_attributes(auth_object)
     end
 
-    def searchable_associations(str = Ransack::Constants::EMPTY)
+    def searchable_associations(str = Constants::EMPTY)
       traverse(str).ransackable_associations(auth_object)
     end
   end

data/lib/ransack/helpers/form_builder.rb

@@ -1,5 +1,19 @@
 require 'action_view'
 
+# This patch is needed since this Rails commit:
+# https://github.com/rails/rails/commit/c1a118a
+#
+# TODO: Find a better way to solve this.
+#
+module ActionView::Helpers::Tags
+  class Base
+    private
+    def value(object)
+      object.send @method_name if object # use send instead of public_send
+    end
+  end
+end
+
 RANSACK_FORM_BUILDER = 'RANSACK_FORM_BUILDER'.freeze
 
 require 'simple_form' if
@@ -30,13 +44,12 @@ module Ransack
       def attribute_select(options = nil, html_options = nil, action = nil)
         options = options || {}
         html_options = html_options || {}
-        action = action || Ransack::Constants::SEARCH
+        action = action || Constants::SEARCH
         default = options.delete(:default)
         raise ArgumentError, formbuilder_error_message(
           "#{action}_select") unless object.respond_to?(:context)
         options[:include_blank] = true unless options.has_key?(:include_blank)
-        bases = [Ransack::Constants::EMPTY] +
-          association_array(options[:associations])
+        bases = [Constants::EMPTY] + association_array(options[:associations])
         if bases.size > 1
           collection = attribute_collection_for_bases(action, bases)
           object.name ||= default if can_use_default?(
@@ -53,13 +66,15 @@ module Ransack
       end
 
       def sort_direction_select(options = {}, html_options = {})
-        raise ArgumentError, formbuilder_error_message(
-          'sort_direction'.freeze) unless object.respond_to?(:context)
+        unless object.respond_to?(:context)
+          raise ArgumentError,
+          formbuilder_error_message(Constants::SORT_DIRECTION)
+        end
         template_collection_select(:dir, sort_array, options, html_options)
       end
 
       def sort_select(options = {}, html_options = {})
-        attribute_select(options, html_options, Ransack::Constants::SORT) +
+        attribute_select(options, html_options, Constants::SORT) +
         sort_direction_select(options, html_options)
       end
 
@@ -100,35 +115,35 @@ module Ransack
         objects ||= @object.send(name)
         objects = [objects] unless Array === objects
         name = "#{options[:object_name] || object_name}[#{name}]"
-        output = ActiveSupport::SafeBuffer.new
-        objects.each do |child|
-          output << @template.fields_for("#{name}[#{
-            options[:child_index] || nested_child_index(name)
-            }]", child, options, &block)
+        objects.inject(ActiveSupport::SafeBuffer.new) do |output, child|
+          output << @template.fields_for("#{name}[#{options[:child_index] ||
+          nested_child_index(name)}]", child, options, &block)
         end
-        output
       end
 
       def predicate_select(options = {}, html_options = {})
         options[:compounds] = true if options[:compounds].nil?
-        default = options.delete(:default) || 'cont'.freeze
+        default = options.delete(:default) || Constants::CONT
 
-        keys = options[:compounds] ? Predicate.names :
+        keys =
+        if options[:compounds]
+          Predicate.names
+        else
           Predicate.names.reject { |k| k.match(/_(any|all)$/) }
+        end
         if only = options[:only]
           if only.respond_to? :call
             keys = keys.select { |k| only.call(k) }
           else
             only = Array.wrap(only).map(&:to_s)
             keys = keys.select {
-              |k| only.include? k.sub(/_(any|all)$/, Ransack::Constants::EMPTY)
+              |k| only.include? k.sub(/_(any|all)$/, Constants::EMPTY)
             }
           end
         end
         collection = keys.map { |k| [k, Translate.predicate(k)] }
-        object.predicate ||= Predicate.named(default) if can_use_default?(
-          default, :predicate, keys
-          )
+        object.predicate ||= Predicate.named(default) if
+          can_use_default?(default, :predicate, keys)
         template_collection_select(:p, collection, options, html_options)
       end
 
@@ -164,21 +179,21 @@ module Ransack
 
       def sort_array
         [
-          [Ransack::Constants::ASC,  object.translate(Ransack::Constants::ASC)],
-          [Ransack::Constants::DESC, object.translate(Ransack::Constants::DESC)]
+          [Constants::ASC,  object.translate(Constants::ASC)],
+          [Constants::DESC, object.translate(Constants::DESC)]
         ]
       end
 
       def combinator_choices
         if Nodes::Condition === object
           [
-            [Ransack::Constants::OR,  Translate.word(:any)],
-            [Ransack::Constants::AND, Translate.word(:all)]
+            [Constants::OR,  Translate.word(:any)],
+            [Constants::AND, Translate.word(:all)]
           ]
         else
           [
-            [Ransack::Constants::AND, Translate.word(:all)],
-            [Ransack::Constants::OR,  Translate.word(:any)]
+            [Constants::AND, Translate.word(:all)],
+            [Constants::OR,  Translate.word(:any)]
           ]
         end
       end
@@ -186,8 +201,7 @@ module Ransack
       def association_array(obj, prefix = nil)
         ([prefix] + association_object(obj))
         .compact
-        .flatten
-        .map { |v| [prefix, v].compact.join(Ransack::Constants::UNDERSCORE) }
+        .flat_map { |v| [prefix, v].compact.join(Constants::UNDERSCORE) }
       end
 
       def association_object(obj)
@@ -207,7 +221,7 @@ module Ransack
           when Array, Hash
             association_array(value, key.to_s)
           else
-            [key.to_s, [key, value].join(Ransack::Constants::UNDERSCORE)]
+            [key.to_s, [key, value].join(Constants::UNDERSCORE)]
           end
         end
       end
@@ -218,8 +232,10 @@ module Ransack
 
       def get_attribute_element(action, base)
         begin
-          [Translate.association(base, :context => object.context),
-            collection_for_base(action, base)]
+          [
+            Translate.association(base, :context => object.context),
+            collection_for_base(action, base)
+          ]
         rescue UntraversableAssociationError => e
           nil
         end
@@ -227,10 +243,10 @@ module Ransack
 
       def attribute_collection_for_base(attributes, base = nil)
         attributes.map do |c|
-          [attr_from_base_and_column(base, c),
+          [
+            attr_from_base_and_column(base, c),
             Translate.attribute(
-              attr_from_base_and_column(base, c),
-              :context => object.context
+              attr_from_base_and_column(base, c), :context => object.context
             )
           ]
         end
@@ -242,13 +258,11 @@ module Ransack
       end
 
       def attr_from_base_and_column(base, column)
-        [base, column].reject { |v| v.blank? }
-        .join(Ransack::Constants::UNDERSCORE)
+        [base, column].reject(&:blank?).join(Constants::UNDERSCORE)
       end
 
       def formbuilder_error_message(action)
-        "#{
-          action.sub(Ransack::Constants::SEARCH, Ransack::Constants::ATTRIBUTE)
+        "#{action.sub(Constants::SEARCH, Constants::ATTRIBUTE)
           } must be called inside a search FormBuilder!"
       end