ransack 1.4.1 → 1.5.0

data/lib/ransack/context.rb

@@ -37,7 +37,7 @@ module Ransack
       @join_type = options[:join_type] || Polyamorous::OuterJoin
       @search_key = options[:search_key] || Ransack.options[:search_key]
 
-      if ::ActiveRecord::VERSION::STRING >= "4.1"
+      if ::ActiveRecord::VERSION::STRING >= "4.1".freeze
         @base = @join_dependency.join_root
         @engine = @base.base_klass.arel_engine
       else
@@ -95,7 +95,7 @@ module Ransack
     end
 
     def traverse(str, base = @base)
-      str ||= ''
+      str ||= Ransack::Constants::EMPTY
 
       if (segments = str.split(/_/)).size > 0
         remainder = []
@@ -103,9 +103,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('_'))
+          assoc, klass = unpolymorphize_association(segments
+                         .join(Ransack::Constants::UNDERSCORE))
           if found_assoc = get_association(assoc, base)
-            base = traverse(remainder.join('_'), klass || found_assoc.klass)
+            base = traverse(
+              remainder.join(
+                Ransack::Constants::UNDERSCORE), klass || found_assoc.klass
+                )
           end
 
           remainder.unshift segments.pop
@@ -119,15 +123,17 @@ module Ransack
 
     def association_path(str, base = @base)
       base = klassify(base)
-      str ||= ''
+      str ||= Ransack::Constants::EMPTY
       path = []
       segments = str.split(/_/)
       association_parts = []
       if (segments = str.split(/_/)).size > 0
-        while segments.size > 0 && !base.columns_hash[segments.join('_')] &&
+        while segments.size > 0 &&
+        !base.columns_hash[segments.join(Ransack::Constants::UNDERSCORE)] &&
         association_parts << segments.shift do
-          assoc, klass = unpolymorphize_association(association_parts
-          .join('_'))
+          assoc, klass = unpolymorphize_association(
+            association_parts.join(Ransack::Constants::UNDERSCORE)
+            )
           if found_assoc = get_association(assoc, base)
             path += association_parts
             association_parts = []
@@ -136,7 +142,7 @@ module Ransack
         end
       end
 
-      path.join('_')
+      path.join(Ransack::Constants::UNDERSCORE)
     end
 
     def unpolymorphize_association(str)
@@ -160,15 +166,15 @@ module Ransack
       klass.ransackable_scopes(auth_object).any? { |s| s.to_s == str }
     end
 
-    def searchable_attributes(str = '')
+    def searchable_attributes(str = Ransack::Constants::EMPTY)
       traverse(str).ransackable_attributes(auth_object)
     end
 
-    def sortable_attributes(str = '')
+    def sortable_attributes(str = Ransack::Constants::EMPTY)
       traverse(str).ransortable_attributes(auth_object)
     end
 
-    def searchable_associations(str = '')
+    def searchable_associations(str = Ransack::Constants::EMPTY)
       traverse(str).ransackable_associations(auth_object)
     end
   end

data/lib/ransack/helpers/form_builder.rb

@@ -1,11 +1,14 @@
 require 'action_view'
 
+RANSACK_FORM_BUILDER = 'RANSACK_FORM_BUILDER'.freeze
+
 require 'simple_form' if
-  (ENV['RANSACK_FORM_BUILDER'] || '').match('SimpleForm')
+  (ENV[RANSACK_FORM_BUILDER] || Ransack::Constants::EMPTY)
+  .match('SimpleForm'.freeze)
 
 module Ransack
   module Helpers
-    class FormBuilder < (ENV['RANSACK_FORM_BUILDER'].try(:constantize) ||
+    class FormBuilder < (ENV[RANSACK_FORM_BUILDER].try(:constantize) ||
       ActionView::Helpers::FormBuilder)
 
       def label(method, *args, &block)
@@ -27,12 +30,13 @@ module Ransack
       def attribute_select(options = nil, html_options = nil, action = nil)
         options = options || {}
         html_options = html_options || {}
-        action = action || 'search'
+        action = action || Ransack::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 = [''] + association_array(options[:associations])
+        bases = [Ransack::Constants::EMPTY] +
+          association_array(options[:associations])
         if bases.size > 1
           collection = attribute_collection_for_bases(action, bases)
           object.name ||= default if can_use_default?(
@@ -50,12 +54,12 @@ module Ransack
 
       def sort_direction_select(options = {}, html_options = {})
         raise ArgumentError, formbuilder_error_message(
-          'sort_direction') unless object.respond_to?(:context)
+          'sort_direction'.freeze) unless object.respond_to?(:context)
         template_collection_select(:dir, sort_array, options, html_options)
       end
 
       def sort_select(options = {}, html_options = {})
-        attribute_select(options, html_options, 'sort') +
+        attribute_select(options, html_options, Ransack::Constants::SORT) +
         sort_direction_select(options, html_options)
       end
 
@@ -107,7 +111,7 @@ module Ransack
 
       def predicate_select(options = {}, html_options = {})
         options[:compounds] = true if options[:compounds].nil?
-        default = options.delete(:default) || 'cont'
+        default = options.delete(:default) || 'cont'.freeze
 
         keys = options[:compounds] ? Predicate.names :
           Predicate.names.reject { |k| k.match(/_(any|all)$/) }
@@ -116,7 +120,9 @@ module Ransack
             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)$/, '') }
+            keys = keys.select {
+              |k| only.include? k.sub(/_(any|all)$/, Ransack::Constants::EMPTY)
+            }
           end
         end
         collection = keys.map { |k| [k, Translate.predicate(k)] }
@@ -157,14 +163,23 @@ module Ransack
       end
 
       def sort_array
-        [['asc', object.translate('asc')], ['desc', object.translate('desc')]]
+        [
+          [Ransack::Constants::ASC,  object.translate(Ransack::Constants::ASC)],
+          [Ransack::Constants::DESC, object.translate(Ransack::Constants::DESC)]
+        ]
       end
 
       def combinator_choices
         if Nodes::Condition === object
-          [['or', Translate.word(:any)], ['and', Translate.word(:all)]]
+          [
+            [Ransack::Constants::OR,  Translate.word(:any)],
+            [Ransack::Constants::AND, Translate.word(:all)]
+          ]
         else
-          [['and', Translate.word(:all)], ['or', Translate.word(:any)]]
+          [
+            [Ransack::Constants::AND, Translate.word(:all)],
+            [Ransack::Constants::OR,  Translate.word(:any)]
+          ]
         end
       end
 
@@ -172,7 +187,7 @@ module Ransack
         ([prefix] + association_object(obj))
         .compact
         .flatten
-        .map { |v| [prefix, v].compact.join('_') }
+        .map { |v| [prefix, v].compact.join(Ransack::Constants::UNDERSCORE) }
       end
 
       def association_object(obj)
@@ -192,7 +207,7 @@ module Ransack
           when Array, Hash
             association_array(value, key.to_s)
           else
-            [key.to_s, [key, value].join('_')]
+            [key.to_s, [key, value].join(Ransack::Constants::UNDERSCORE)]
           end
         end
       end
@@ -227,11 +242,13 @@ module Ransack
       end
 
       def attr_from_base_and_column(base, column)
-        [base, column].reject { |v| v.blank? }.join('_')
+        [base, column].reject { |v| v.blank? }
+        .join(Ransack::Constants::UNDERSCORE)
       end
 
       def formbuilder_error_message(action)
-        "#{action.sub('search', 'attribute')
+        "#{
+          action.sub(Ransack::Constants::SEARCH, Ransack::Constants::ATTRIBUTE)
           } must be called inside a search FormBuilder!"
       end
 

data/lib/ransack/helpers/form_helper.rb

@@ -2,26 +2,6 @@ module Ransack
   module Helpers
     module FormHelper
 
-      def asc
-        'asc'.freeze
-      end
-
-      def desc
-        'desc'.freeze
-      end
-
-      def asc_arrow
-        '▲'.freeze
-      end
-
-      def desc_arrow
-        '▼'.freeze
-      end
-
-      def non_breaking_space
-        ' '.freeze
-      end
-
       def search_form_for(record, options = {}, &proc)
         if record.is_a?(Ransack::Search)
           search = record
@@ -48,13 +28,14 @@ module Ransack
             "#{search.klass.to_s.underscore}_search",
           :method => :get
         }
-        options[:as] ||= 'q'.freeze
+        options[:as] ||= Ransack::Constants::DEFAULT_SEARCH_KEY
         options[:html].reverse_merge!(html_options)
         options[:builder] ||= FormBuilder
 
         form_for(record, options, &proc)
       end
 
+      # sort_link @q, :name, [:name, 'kind ASC'], 'Player Name'
       def sort_link(search, attribute, *args)
         # Extract out a routing proxy for url_for scoping later
         if search.is_a?(Array)
@@ -65,65 +46,112 @@ module Ransack
         raise TypeError, "First argument must be a Ransack::Search!" unless
           Search === search
 
-        search_params = params[search.context.search_key].presence ||
-          {}.with_indifferent_access
+        # This is the field that this link represents. The direction of the sort icon (up/down arrow) will
+        # depend on the sort status of this field
+        field_name = attribute.to_s
 
-        attr_name = attribute.to_s
+        # Determine the fields we want to sort on
+        sort_fields = if Array === args.first
+          args.shift
+        else
+          Array(field_name)
+        end
 
-        name = (
-          if args.size > 0 && !args.first.is_a?(Hash)
+        label_text =
+          if String === args.first
             args.shift.to_s
           else
-            Translate.attribute(attr_name, :context => search.context)
+            Translate.attribute(field_name, :context => search.context)
           end
-          )
-
-        if existing_sort = search.sorts.detect { |s| s.name == attr_name }
-          prev_attr, prev_dir = existing_sort.name, existing_sort.dir
-        end
 
         options = args.first.is_a?(Hash) ? args.shift.dup : {}
         default_order = options.delete :default_order
-        current_dir = prev_attr == attr_name ? prev_dir : nil
+        default_order_is_a_hash = Hash === default_order
 
-        if current_dir
-          new_dir = current_dir == desc ? asc : desc
-        else
-          new_dir = default_order || asc
+        # If the default order is a hash of fields, duplicate it and let us access it with strings or symbols
+        default_order = default_order.dup.with_indifferent_access if
+          default_order_is_a_hash
+
+        search_params = params[search.context.search_key].presence ||
+          {}.with_indifferent_access
+
+        # Find the current direction (if there is one) of the primary sort field
+        if existing_sort = search.sorts.detect { |s| s.name == field_name }
+          field_current_dir = existing_sort.dir
         end
 
+        sort_params = []
+
+        Array(sort_fields).each do |sort_field|
+          attr_name, new_dir = sort_field.to_s.downcase.split(/\s+/)
+          current_dir = nil
+
+          # if the user didn't specify the sort direction, detect the previous
+          # sort direction on this field and reverse it
+          if Ransack::Constants::ASC_DESC.none? { |d| d == new_dir }
+            if existing_sort = search.sorts.detect { |s| s.name == attr_name }
+              current_dir = existing_sort.dir
+            end
+
+            new_dir =
+              if current_dir
+                if current_dir == Ransack::Constants::DESC
+                  Ransack::Constants::ASC
+                else
+                  Ransack::Constants::DESC
+                end
+              elsif default_order_is_a_hash
+                default_order[attr_name] || Ransack::Constants::ASC
+              else
+                default_order || Ransack::Constants::ASC
+              end
+          end
+
+          sort_params << "#{attr_name} #{new_dir}"
+        end
+
+        # if there is only one sort parameter, remove it from the array and just
+        # use the string as the parameter
+        sort_params = sort_params.first if sort_params.size == 1
+
         html_options = args.first.is_a?(Hash) ? args.shift.dup : {}
-        css = ['sort_link', current_dir].compact.join(' ')
-        html_options[:class] = [css, html_options[:class]].compact.join(' ')
+        css = [Ransack::Constants::SORT_LINK, field_current_dir]
+          .compact.join(Ransack::Constants::SPACE)
+        html_options[:class] = [css, html_options[:class]]
+          .compact.join(Ransack::Constants::SPACE)
+
         query_hash = {}
         query_hash[search.context.search_key] = search_params
-        .merge(:s => "#{attr_name} #{new_dir}")
+          .merge(:s => sort_params)
         options.merge!(query_hash)
-        options_for_url = params.merge options
+        options_for_url = params.merge(options)
 
-        url = if routing_proxy && respond_to?(routing_proxy)
+        url =
+        if routing_proxy && respond_to?(routing_proxy)
           send(routing_proxy).url_for(options_for_url)
         else
           url_for(options_for_url)
         end
 
-        link_to(
-          [ERB::Util.h(name), order_indicator_for(current_dir)]
-            .compact
-            .join(non_breaking_space)
-            .html_safe,
-          url,
-          html_options
-          )
+        name = link_name(label_text, field_current_dir)
+
+        link_to(name, url, html_options)
       end
 
       private
 
-      def order_indicator_for(order)
-        if order == asc
-          asc_arrow
-        elsif order == desc
-          desc_arrow
+      def link_name(label_text, dir)
+        [ERB::Util.h(label_text), order_indicator_for(dir)]
+        .compact
+        .join(Ransack::Constants::NON_BREAKING_SPACE)
+        .html_safe
+      end
+
+      def order_indicator_for(dir)
+        if dir == Ransack::Constants::ASC
+          Ransack::Constants::ASC_ARROW
+        elsif dir == Ransack::Constants::DESC
+          Ransack::Constants::DESC_ARROW
         else
           nil
         end

data/lib/ransack/naming.rb

@@ -28,7 +28,7 @@ module Ransack
     alias_method :cache_key, :collection
 
     def initialize
-      super("Search")
+      super("Search".freeze)
       @singular = "search".freeze
       @plural = "searches".freeze
       @element = "search".freeze

data/lib/ransack/nodes/condition.rb

@@ -105,7 +105,7 @@ module Ransack
       end
 
       def combinator=(val)
-        @combinator = ['and', 'or'].detect { |v| v == val.to_s } || nil
+        @combinator = Ransack::Constants::AND_OR.detect { |v| v == val.to_s } || nil
       end
       alias :m= :combinator=
       alias :m :combinator
@@ -180,9 +180,9 @@ module Ransack
 
         if predicates.size > 1
           case combinator
-          when 'and'
+          when Ransack::Constants::AND
             Arel::Nodes::Grouping.new(Arel::Nodes::And.new(predicates))
-          when 'or'
+          when Ransack::Constants::OR
             predicates.inject(&:or)
           end
         else
@@ -226,14 +226,14 @@ module Ransack
 
       def inspect
         data = [
-          ['attributes', a.try(:map, &:name)],
-          ['predicate', p],
-          ['combinator', m],
-          ['values', v.try(:map, &:value)]
+          ['attributes'.freeze, a.try(:map, &:name)],
+          ['predicate'.freeze, p],
+          [Ransack::Constants::COMBINATOR, m],
+          ['values'.freeze, v.try(:map, &:value)]
         ]
         .reject { |e| e[1].blank? }
         .map { |v| "#{v[0]}: #{v[1]}" }
-        .join(', ')
+        .join(Ransack::Constants::COMMA_SPACE)
         "Condition <#{data}>"
       end
 
@@ -241,7 +241,7 @@ module Ransack
 
       def valid_combinator?
         attributes.size < 2 ||
-        ['and', 'or'].include?(combinator)
+        Ransack::Constants::AND_OR.include?(combinator)
       end
 
     end