ransack 1.5.1 → 1.6.0

data/lib/ransack/helpers/form_helper.rb

@@ -2,21 +2,25 @@ module Ransack
   module Helpers
     module FormHelper
 
+      # +search_form_for+
+      #
+      #   <%= search_form_for(@q) do |f| %>
+      #
       def search_form_for(record, options = {}, &proc)
-        if record.is_a?(Ransack::Search)
+        if record.is_a? Ransack::Search
           search = record
           options[:url] ||= polymorphic_path(
             search.klass, format: options.delete(:format)
             )
-        elsif record.is_a?(Array) &&
-            (search = record.detect { |o| o.is_a?(Ransack::Search) })
+        elsif record.is_a? Array &&
+            (search = record.detect { |o| o.is_a? Ransack::Search })
           options[:url] ||= polymorphic_path(
-            record.map { |o| o.is_a?(Ransack::Search) ? o.klass : o },
+            record.map { |o| o.is_a? Ransack::Search ? o.klass : o },
             format: options.delete(:format)
             )
         else
           raise ArgumentError,
-            "No Ransack::Search object was provided to search_form_for!"
+            'No Ransack::Search object was provided to search_form_for!'
         end
         options[:html] ||= {}
         html_options = {
@@ -28,135 +32,175 @@ module Ransack
             "#{search.klass.to_s.underscore}_search",
           :method => :get
         }
-        options[:as] ||= Ransack::Constants::DEFAULT_SEARCH_KEY
+        options[:as] ||= Ransack.options[: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)
-          routing_proxy = search.shift
-          search = search.first
+      # +sort_link+
+      #
+      #   <%= sort_link(@q, :name, [:name, 'kind ASC'], 'Player Name') %>
+      #
+      def sort_link(search_object, attribute, *args)
+        search, routing_proxy = extract_search_and_routing_proxy(search_object)
+        unless Search === search
+          raise TypeError, 'First argument must be a Ransack::Search!'
         end
+        s = SortLink.new(search, attribute, args, params)
+        link_to(s.name, url(routing_proxy, s.url_options), s.html_options(args))
+      end
 
-        raise TypeError, "First argument must be a Ransack::Search!" unless
-          Search === search
-
-        # 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
+      private
 
-        # Determine the fields we want to sort on
-        sort_fields = if Array === args.first
-          args.shift
-        else
-          Array(field_name)
+        def extract_search_and_routing_proxy(search)
+          if search.is_a? Array
+            [search.second, search.first]
+          else
+            [search, nil]
+          end
         end
 
-        label_text =
-          if String === args.first
-            args.shift.to_s
+        def url(routing_proxy, options_for_url)
+          if routing_proxy && respond_to?(routing_proxy)
+            send(routing_proxy).url_for(options_for_url)
           else
-            Translate.attribute(field_name, :context => search.context)
+            url_for(options_for_url)
           end
+        end
 
-        options = args.first.is_a?(Hash) ? args.shift.dup : {}
-        default_order = options.delete :default_order
-        default_order_is_a_hash = Hash === default_order
+      class SortLink
+        def initialize(search, attribute, args, params)
+          @search         = search
+          @params         = params
+          @field          = attribute.to_s
+          sort_fields     = extract_sort_fields_and_mutate_args!(args).compact
+          @current_dir    = existing_sort_direction
+          @label_text     = extract_label_and_mutate_args!(args)
+          @options        = extract_options_and_mutate_args!(args)
+          @hide_indicator = @options.delete :hide_indicator
+          @default_order  = @options.delete :default_order
+          @sort_params    = build_sort(sort_fields)
+          @sort_params    = @sort_params.first if @sort_params.size == 1
+        end
 
-        # 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
+        def name
+          [ERB::Util.h(@label_text), order_indicator]
+          .compact
+          .join(Constants::NON_BREAKING_SPACE)
+          .html_safe
+        end
 
-        search_params = params[search.context.search_key].presence ||
-          {}.with_indifferent_access
+        def url_options
+          @params.merge(
+            @options.merge(
+              @search.context.search_key => search_and_sort_params))
+        end
 
-        # 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
+        def html_options(args)
+          html_options = extract_options_and_mutate_args!(args)
+          html_options.merge(class:
+            [[Constants::SORT_LINK, @current_dir], html_options[:class]]
+            .compact.join(Constants::SPACE)
+            )
         end
 
-        sort_params = []
+        private
 
-        Array(sort_fields).each do |sort_field|
-          attr_name, new_dir = sort_field.to_s.downcase.split(/\s+/)
-          current_dir = nil
+          def extract_sort_fields_and_mutate_args!(args)
+            if args.first.is_a? Array
+              args.shift
+            else
+              [@field]
+            end
+          end
 
-          # 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
+          def extract_label_and_mutate_args!(args)
+            if args.first.is_a? String
+              args.shift
+            else
+              Translate.attribute(@field, :context => @search.context)
             end
+          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
+          def extract_options_and_mutate_args!(args)
+            if args.first.is_a? Hash
+              args.shift.with_indifferent_access
+            else
+              {}
+            end
+          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 = [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 => sort_params)
-        options.merge!(query_hash)
-        options_for_url = params.merge(options)
-
-        url =
-        if routing_proxy && respond_to?(routing_proxy)
-          send(routing_proxy).url_for(options_for_url)
-        else
-          url_for(options_for_url)
-        end
+          def search_and_sort_params
+            search_params.merge(:s => @sort_params)
+          end
 
-        name = link_name(label_text, field_current_dir)
+          def search_params
+            @params[@search.context.search_key].presence || {}
+          end
 
-        link_to(name, url, html_options)
-      end
+          def build_sort(fields)
+            return [] if fields.empty?
+            [parse_sort(fields[0])] + build_sort(fields.drop(1))
+          end
 
-      private
+          def parse_sort(field)
+            attr_name, new_dir = field.to_s.split(/\s+/)
+            if no_sort_direction_specified?(new_dir)
+              new_dir = detect_previous_sort_direction_and_invert_it(attr_name)
+            end
+            "#{attr_name} #{new_dir}"
+          end
 
-      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 detect_previous_sort_direction_and_invert_it(attr_name)
+            sort_dir = existing_sort_direction(attr_name)
+            if sort_dir
+              direction_text(sort_dir)
+            else
+              default_sort_order(attr_name) || Constants::ASC
+            end
+          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
-      end
+          def existing_sort_direction(attr_name = @field)
+            if sort = @search.sorts.detect { |s| s && s.name == attr_name }
+              sort.dir
+            end
+          end
+
+          def default_sort_order(attr_name)
+            Hash === @default_order ? @default_order[attr_name] : @default_order
+          end
 
+          def order_indicator
+            if @hide_indicator || no_sort_direction_specified?
+              nil
+            else
+              direction_arrow
+            end
+          end
+
+          def no_sort_direction_specified?(dir = @current_dir)
+            !Constants::ASC_DESC.include?(dir)
+          end
+
+          def direction_arrow
+            if @current_dir == Constants::DESC
+              Constants::DESC_ARROW
+            else
+              Constants::ASC_ARROW
+            end
+          end
+
+          def direction_text(dir)
+            if dir == Constants::DESC
+              Constants::ASC
+            else
+              Constants::DESC
+            end
+          end
+
+      end
     end
   end
 end

data/lib/ransack/naming.rb

@@ -28,16 +28,16 @@ module Ransack
     alias_method :cache_key, :collection
 
     def initialize
-      super("Search".freeze)
-      @singular = "search".freeze
-      @plural = "searches".freeze
-      @element = "search".freeze
-      @human = "Search".freeze
-      @collection = "ransack/searches".freeze
-      @partial_path = "#{@collection}/#{@element}".freeze
-      @param_key = "q".freeze
-      @route_key = "searches".freeze
-      @i18n_key = :ransack
+      super(Constants::CAP_SEARCH)
+      @singular     = Constants::SEARCH
+      @plural       = Constants::SEARCHES
+      @element      = Constants::SEARCH
+      @human        = Constants::CAP_SEARCH
+      @collection   = Constants::RANSACK_SLASH_SEARCHES
+      @partial_path = Constants::RANSACK_SLASH_SEARCHES_SLASH_SEARCH
+      @param_key    = Constants::Q
+      @route_key    = Constants::SEARCHES
+      @i18n_key     = :ransack
     end
   end
 
@@ -51,4 +51,4 @@ module Ransack
     end
   end
 
-end
+end

data/lib/ransack/nodes.rb

@@ -3,5 +3,7 @@ require 'ransack/nodes/node'
 require 'ransack/nodes/attribute'
 require 'ransack/nodes/value'
 require 'ransack/nodes/condition'
+require 'ransack/adapters/active_record/ransack/nodes/condition' if defined?(::ActiveRecord::Base)
+require 'ransack/adapters/mongoid/ransack/nodes/condition' if defined?(::Mongoid)
 require 'ransack/nodes/sort'
 require 'ransack/nodes/grouping'

data/lib/ransack/nodes/bindable.rb

@@ -5,9 +5,7 @@ module Ransack
       attr_accessor :parent, :attr_name
 
       def attr
-        @attr ||= ransacker ?
-          ransacker.attr_from(self) :
-          context.table_for(parent)[attr_name]
+        @attr ||= get_arel_attribute
       end
       alias :arel_attribute :attr
 
@@ -27,6 +25,16 @@ module Ransack
         @parent = @attr_name = @attr = @klass = nil
       end
 
+      private
+
+        def get_arel_attribute
+          if ransacker
+            ransacker.attr_from(self)
+          else
+            context.table_for(parent)[attr_name]
+          end
+        end
+
     end
   end
-end
+end

data/lib/ransack/nodes/condition.rb

@@ -105,7 +105,7 @@ module Ransack
       end
 
       def combinator=(val)
-        @combinator = Ransack::Constants::AND_OR.detect { |v| v == val.to_s } || nil
+        @combinator = Constants::AND_OR.detect { |v| v == val.to_s } || nil
       end
       alias :m= :combinator=
       alias :m :combinator
@@ -171,23 +171,7 @@ module Ransack
       alias :p :predicate_name
 
       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 Ransack::Constants::AND
-            Arel::Nodes::Grouping.new(Arel::Nodes::And.new(predicates))
-          when Ransack::Constants::OR
-            predicates.inject(&:or)
-          end
-        else
-          predicates.first
-        end
+        raise "not implemented"
       end
 
       def validated_values
@@ -228,20 +212,19 @@ module Ransack
         data = [
           ['attributes'.freeze, a.try(:map, &:name)],
           ['predicate'.freeze, p],
-          [Ransack::Constants::COMBINATOR, m],
+          [Constants::COMBINATOR, m],
           ['values'.freeze, v.try(:map, &:value)]
         ]
         .reject { |e| e[1].blank? }
         .map { |v| "#{v[0]}: #{v[1]}" }
-        .join(Ransack::Constants::COMMA_SPACE)
+        .join(Constants::COMMA_SPACE)
         "Condition <#{data}>"
       end
 
       private
 
       def valid_combinator?
-        attributes.size < 2 ||
-        Ransack::Constants::AND_OR.include?(combinator)
+        attributes.size < 2 || Constants::AND_OR.include?(combinator)
       end
 
     end

data/lib/ransack/nodes/grouping.rb

@@ -44,7 +44,6 @@ module Ransack
             self.conditions << condition if condition.valid?
           end
         end
-
         self.conditions.uniq!
       end
       alias :c= :conditions=
@@ -69,7 +68,7 @@ module Ransack
       def respond_to?(method_id)
         super or begin
           method_name = method_id.to_s
-          writer = method_name.sub!(/\=$/, Ransack::Constants::EMPTY)
+          writer = method_name.sub!(/\=$/, Constants::EMPTY)
           attribute_method?(method_name) ? true : false
         end
       end
@@ -115,11 +114,13 @@ module Ransack
 
       def method_missing(method_id, *args)
         method_name = method_id.to_s
-        writer = method_name.sub!(/\=$/, Ransack::Constants::EMPTY)
+        writer = method_name.sub!(/\=$/, Constants::EMPTY)
         if attribute_method?(method_name)
-          writer ?
-            write_attribute(method_name, *args) :
+          if writer
+            write_attribute(method_name, *args)
+          else
             read_attribute(method_name)
+          end
         else
           super
         end
@@ -135,8 +136,7 @@ module Ransack
         else
           stripped_name
           .split(/_and_|_or_/)
-          .select { |n| !@context.attribute_method?(n) }
-          .empty?
+          .none? { |n| !@context.attribute_method?(n) }
         end
       end
 
@@ -165,12 +165,11 @@ module Ransack
 
       def inspect
         data = [
-          ['conditions'.freeze, conditions],
-          [Ransack::Constants::COMBINATOR, combinator]
+          ['conditions'.freeze, conditions], [Constants::COMBINATOR, combinator]
         ]
         .reject { |e| e[1].blank? }
         .map { |v| "#{v[0]}: #{v[1]}" }
-        .join(Ransack::Constants::COMMA_SPACE)
+        .join(Constants::COMMA_SPACE)
         "Grouping <#{data}>"
       end