ransack 1.1.0 → 1.2.0

data/lib/ransack/helpers/form_builder.rb

@@ -1,62 +1,62 @@
 require 'action_view'
 
+require 'simple_form' if
+  (ENV['RANSACK_FORM_BUILDER'] || '').match('SimpleForm')
+
 module Ransack
   module Helpers
-    class FormBuilder < ::ActionView::Helpers::FormBuilder
+    class FormBuilder < (ENV['RANSACK_FORM_BUILDER'].try(:constantize) ||
+      ActionView::Helpers::FormBuilder)
+
       def label(method, *args, &block)
         options = args.extract_options!
         text = args.first
         i18n = options[:i18n] || {}
-        text ||= object.translate(method, i18n.reverse_merge(:include_associations => true)) if object.respond_to? :translate
+        text ||= object.translate(
+          method, i18n.reverse_merge(include_associations: true)
+          ) if object.respond_to? :translate
         super(method, text, options, &block)
       end
 
-      def submit(value=nil, options={})
+      def submit(value = nil, options = {})
         value, options = nil, value if value.is_a?(Hash)
         value ||= Translate.word(:search).titleize
         super(value, options)
       end
 
-      def attribute_select(options = {}, html_options = {})
-        raise ArgumentError, "attribute_select must be called inside a search FormBuilder!" unless object.respond_to?(:context)
+      def attribute_select(options = nil, html_options = nil, action = nil)
+        options = options || {}
+        html_options = html_options || {}
+        action = action || '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])
         if bases.size > 1
-          @template.grouped_collection_select(
-            @object_name, :name, searchable_attribute_collection_for_bases(bases), :last, :first, :first, :last,
-            objectify_options(options), @default_options.merge(html_options)
-          )
+          collection = attribute_collection_for_bases(action, bases)
+          object.name ||= default if can_use_default?(
+            default, :name, mapped_values(collection.flatten(2))
+            )
+          template_grouped_collection_select(collection, options, html_options)
         else
-          collection = searchable_attribute_collection_for_base(bases.first)
-          @template.collection_select(
-            @object_name, :name, collection, :first, :last,
-            objectify_options(options), @default_options.merge(html_options)
-          )
+          collection = collection_for_base(action, bases.first)
+          object.name ||= default if can_use_default?(
+            default, :name, mapped_values(collection)
+            )
+          template_collection_select(:name, collection, options, html_options)
         end
       end
 
+      def sort_direction_select(options = {}, html_options = {})
+        raise ArgumentError, formbuilder_error_message(
+          'sort_direction') unless object.respond_to?(:context)
+        template_collection_select(:dir, sort_array, options, html_options)
+      end
+
       def sort_select(options = {}, html_options = {})
-        raise ArgumentError, "sort_select must be called inside a search FormBuilder!" unless object.respond_to?(:context)
-        options[:include_blank] = true unless options.has_key?(:include_blank)
-        bases = [''] + association_array(options[:associations])
-        if bases.size > 1
-          @template.grouped_collection_select(
-            @object_name, :name, sortable_attribute_collection_for_bases(bases), :last, :first, :first, :last,
-            objectify_options(options), @default_options.merge(html_options)
-          ) + @template.collection_select(
-            @object_name, :dir, [['asc', object.translate('asc')], ['desc', object.translate('desc')]], :first, :last,
-            objectify_options(options), @default_options.merge(html_options)
-          )
-        else
-          collection = sortable_attribute_collection_for_base(bases.first)
-          @template.collection_select(
-            @object_name, :name, collection, :first, :last,
-            objectify_options(options), @default_options.merge(html_options)
-          ) + @template.collection_select(
-            @object_name, :dir, [['asc', object.translate('asc')], ['desc', object.translate('desc')]], :first, :last,
-            objectify_options(options), @default_options.merge(html_options)
-          )
-        end
+        attribute_select(options, html_options, 'sort') +
+        sort_direction_select(options, html_options)
       end
 
       def sort_fields(*args, &block)
@@ -98,37 +98,70 @@ module Ransack
         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)
+          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?
-        keys = options[:compounds] ? Predicate.names : Predicate.names.reject {|k| k.match(/_(any|all)$/)}
+        if ::ActiveRecord::VERSION::STRING >= "4"
+          default = options.delete(:default) || 'cont'
+        else
+          default = options.delete(:default) || 'eq'
+        end
+
+        keys = options[:compounds] ? Predicate.names : 
+          Predicate.names.reject { |k| k.match(/_(any|all)$/) }
         if only = options[:only]
           if only.respond_to? :call
-            keys = keys.select {|k| only.call(k)}
+            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)$/, '') }
           end
         end
+        collection = keys.map { |k| [k, Translate.predicate(k)] }
+        object.predicate ||= Predicate.named(default) if can_use_default?(
+          default, :predicate, keys
+          )
+        template_collection_select(:p, collection, options, html_options)
+      end
 
-        @template.collection_select(
-          @object_name, :p, keys.map {|k| [k, Translate.predicate(k)]}, :first, :last,
+      def combinator_select(options = {}, html_options = {})
+        template_collection_select(:m, combinator_choices, options, html_options)
+      end
+
+      private
+
+      def template_grouped_collection_select(collection, options, html_options)
+        @template.grouped_collection_select(
+          @object_name, :name, collection, :last, :first, :first, :last,
           objectify_options(options), @default_options.merge(html_options)
-        )
+          )
       end
 
-      def combinator_select(options = {}, html_options = {})
+      def template_collection_select(name, collection, options, html_options)
         @template.collection_select(
-          @object_name, :m, combinator_choices, :first, :last,
+          @object_name, name, collection, :first, :last,
           objectify_options(options), @default_options.merge(html_options)
-        )
+          )
       end
 
-      private
+      def can_use_default?(default, attribute, values)
+        object.respond_to?("#{attribute}=") && default &&
+          values.include?(default.to_s)
+      end
+
+      def mapped_values(values)
+        values.map { |v| v.is_a?(Array) ? v.first : nil }.compact
+      end
+
+      def sort_array
+        [['asc', object.translate('asc')], ['desc', object.translate('desc')]]
+      end
 
       def combinator_choices
         if Nodes::Condition === object
@@ -139,70 +172,72 @@ module Ransack
       end
 
       def association_array(obj, prefix = nil)
-        ([prefix] + case obj
+        ([prefix] + association_object(obj))
+        .compact
+        .flatten
+        .map { |v| [prefix, v].compact.join('_') }
+      end
+
+      def association_object(obj)
+        case obj
         when Array
           obj
         when Hash
-          obj.map do |key, value|
-            case value
-            when Array, Hash
-              association_array(value, key.to_s)
-            else
-              [key.to_s, [key, value].join('_')]
-            end
-          end
+          association_hash(obj)
         else
           [obj]
-        end).
-        compact.flatten.map { |v| [prefix, v].compact.join('_') }
+        end
       end
 
-      def attr_from_base_and_column(base, column)
-        [base, column].reject {|v| v.blank?}.join('_')
+      def association_hash(obj)
+        obj.map do |key, value|
+          case value
+          when Array, Hash
+            association_array(value, key.to_s)
+          else
+            [key.to_s, [key, value].join('_')]
+          end
+        end
+      end
+
+      def attribute_collection_for_bases(action, bases)
+        bases.map { |base| get_attribute_element(action, base) }.compact
+      end
+
+      def get_attribute_element(action, base)
+        begin
+          [Translate.association(base, context: object.context),
+            collection_for_base(action, base)]
+        rescue UntraversableAssociationError => e
+          nil
+        end
       end
 
-      def attribute_collection_for_base(attributes, base=nil)
+      def attribute_collection_for_base(attributes, base = nil)
         attributes.map do |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),
+            Translate.attribute(
+              attr_from_base_and_column(base, c),
+              context: object.context
+            )
           ]
         end
       end
 
-      def sortable_attribute_collection_for_base(base=nil)
-        attribute_collection_for_base(object.context.sortable_attributes(base), base)
+      def collection_for_base(action, base)
+        attribute_collection_for_base(
+          object.context.send("#{action}able_attributes", base), base)
       end
 
-      def searchable_attribute_collection_for_base(base=nil)
-        attribute_collection_for_base(object.context.searchable_attributes(base), base)
+      def attr_from_base_and_column(base, column)
+        [base, column].reject { |v| v.blank? }.join('_')
       end
 
-      def sortable_attribute_collection_for_bases(bases)
-        bases.map do |base|
-          begin
-          [
-            Translate.association(base, :context => object.context),
-            sortable_attribute_collection_for_base(base)
-          ]
-          rescue UntraversableAssociationError => e
-            nil
-          end
-        end.compact
+      def formbuilder_error_message(action)
+        "#{action.sub('search', 'attribute')
+          } must be called inside a search FormBuilder!"
       end
 
-      def searchable_attribute_collection_for_bases(bases)
-        bases.map do |base|
-          begin
-          [
-            Translate.association(base, :context => object.context),
-            searchable_attribute_collection_for_base(base)
-          ]
-          rescue UntraversableAssociationError => e
-            nil
-          end
-        end.compact
-      end
     end
   end
-end
+end

data/lib/ransack/helpers/form_helper.rb

@@ -6,16 +6,24 @@ module Ransack
         if record.is_a?(Ransack::Search)
           search = record
           options[:url] ||= polymorphic_path(search.klass)
-        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})
+        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 }
+            )
         else
-          raise ArgumentError, "No Ransack::Search object was provided to search_form_for!"
+          raise ArgumentError,
+            "No Ransack::Search object was provided to search_form_for!"
         end
         options[:html] ||= {}
         html_options = {
-          :class  => options[:class].present? ? "#{options[:class]}" : "#{search.klass.to_s.underscore}_search",
-          :id => options[:id].present? ? "#{options[:id]}" : "#{search.klass.to_s.underscore}_search",
-          :method => :get
+          class: options[:class].present? ?
+            "#{options[:class]}" :
+            "#{search.klass.to_s.underscore}_search",
+          id: options[:id].present? ?
+            "#{options[:id]}" :
+            "#{search.klass.to_s.underscore}_search",
+          method: :get
         }
         options[:as] ||= 'q'
         options[:html].reverse_merge!(html_options)
@@ -31,15 +39,23 @@ module Ransack
           search = search.first
         end
 
-        raise TypeError, "First argument must be a Ransack::Search!" unless Search === search
+        raise TypeError, "First argument must be a Ransack::Search!" unless
+          Search === search
 
-        search_params = params[search.context.search_key] || {}.with_indifferent_access
+        search_params = params[search.context.search_key] ||
+          {}.with_indifferent_access
 
         attr_name = attribute.to_s
 
-        name = (args.size > 0 && !args.first.is_a?(Hash)) ? args.shift.to_s : Translate.attribute(attr_name, :context => search.context)
+        name = (
+          if args.size > 0 && !args.first.is_a?(Hash)
+            args.shift.to_s
+          else
+            Translate.attribute(attr_name, context: search.context)
+          end
+          )
 
-        if existing_sort = search.sorts.detect {|s| s.name == attr_name}
+        if existing_sort = search.sorts.detect { |s| s.name == attr_name }
           prev_attr, prev_dir = existing_sort.name, existing_sort.dir
         end
 
@@ -57,7 +73,8 @@ module Ransack
         css = ['sort_link', current_dir].compact.join(' ')
         html_options[:class] = [css, html_options[:class]].compact.join(' ')
         query_hash = {}
-        query_hash[search.context.search_key] = search_params.merge(:s => "#{attr_name} #{new_dir}")
+        query_hash[search.context.search_key] = search_params
+          .merge(s: "#{attr_name} #{new_dir}")
         options.merge!(query_hash)
         options_for_url = params.merge options
 
@@ -67,9 +84,14 @@ module Ransack
           url_for(options_for_url)
         end
 
-        link_to [ERB::Util.h(name), order_indicator_for(current_dir)].compact.join(' ').html_safe,
+        link_to(
+          [ERB::Util.h(name), order_indicator_for(current_dir)]
+            .compact
+            .join(' ')
+            .html_safe,
           url,
           html_options
+          )
       end
 
       private

data/lib/ransack/naming.rb

@@ -23,7 +23,8 @@ module Ransack
   end
 
   class Name < String
-    attr_reader :singular, :plural, :element, :collection, :partial_path, :human, :param_key, :route_key, :i18n_key
+    attr_reader :singular, :plural, :element, :collection, :partial_path,
+                :human, :param_key, :route_key, :i18n_key
     alias_method :cache_key, :collection
 
     def initialize

data/lib/ransack/nodes/attribute.rb

@@ -5,8 +5,8 @@ module Ransack
 
       attr_reader :name
 
-      delegate :blank?, :present?, :==, :to => :name
-      delegate :engine, :to => :context
+      delegate :blank?, :present?, :==, to: :name
+      delegate :engine, to: :context
 
       def initialize(context, name = nil)
         super(context)
@@ -19,7 +19,9 @@ module Ransack
       end
 
       def valid?
-        bound? && attr
+        bound? && attr &&
+        context.klassify(parent).ransackable_attributes(context.auth_object)
+        .include?(attr_name)
       end
 
       def type
@@ -50,4 +52,4 @@ module Ransack
 
     end
   end
-end
+end

data/lib/ransack/nodes/bindable.rb

@@ -5,7 +5,9 @@ module Ransack
       attr_accessor :parent, :attr_name
 
       def attr
-        @attr ||= ransacker ? ransacker.attr_from(self) : context.table_for(parent)[attr_name]
+        @attr ||= ransacker ?
+          ransacker.attr_from(self) :
+          context.table_for(parent)[attr_name]
       end
       alias :arel_attribute :attr
 

data/lib/ransack/nodes/condition.rb

@@ -2,9 +2,10 @@ module Ransack
   module Nodes
     class Condition < Node
       i18n_word :attribute, :predicate, :combinator, :value
-      i18n_alias :a => :attribute, :p => :predicate, :m => :combinator, :v => :value
+      i18n_alias :a => :attribute, :p => :predicate,
+                 :m => :combinator, :v => :value
 
-      attr_reader :predicate
+      attr_accessor :predicate
 
       class << self
         def extract(context, key, values)
@@ -13,14 +14,16 @@ module Ransack
             combinator = key.match(/_(or|and)_/) ? $1 : nil
             condition = self.new(context)
             condition.build(
-              :a => attributes,
-              :p => predicate.name,
-              :m => combinator,
-              :v => predicate.wants_array ? Array(values) : [values]
+              a: attributes,
+              p: predicate.name,
+              m: combinator,
+              v: predicate.wants_array ? Array(values) : [values]
             )
-            # TODO: Figure out what to do with multiple types of attributes, if anything.
+            # TODO: Figure out what to do with multiple types of attributes,
+            # if anything.
             # Tempted to go with "garbage in, garbage out" on this one
-            predicate.validate(condition.values, condition.default_type) ? condition : nil
+            predicate.validate(condition.values, condition.default_type) ?
+              condition : nil
           end
         end
 
@@ -37,7 +40,8 @@ module Ransack
       end
 
       def valid?
-        attributes.detect(&:valid?) && predicate && valid_arity? && predicate.validate(values, default_type) && valid_combinator?
+        attributes.detect(&:valid?) && predicate && valid_arity? &&
+          predicate.validate(values, default_type) && valid_combinator?
       end
 
       def valid_arity?
@@ -62,7 +66,8 @@ module Ransack
             self.attributes << attr if attr.valid?
           end
         else
-          raise ArgumentError, "Invalid argument (#{args.class}) supplied to attributes="
+          raise ArgumentError,
+            "Invalid argument (#{args.class}) supplied to attributes="
         end
       end
       alias :a= :attributes=
@@ -85,7 +90,8 @@ module Ransack
             self.values << val
           end
         else
-          raise ArgumentError, "Invalid argument (#{args.class}) supplied to values="
+          raise ArgumentError,
+            "Invalid argument (#{args.class}) supplied to values="
         end
       end
       alias :v= :values=
@@ -95,7 +101,7 @@ module Ransack
       end
 
       def combinator=(val)
-        @combinator = ['and', 'or'].detect {|v| v == val.to_s} || nil
+        @combinator = ['and', 'or'].detect { |v| v == val.to_s } || nil
       end
       alias :m= :combinator=
       alias :m :combinator
@@ -113,7 +119,9 @@ module Ransack
       end
 
       def value
-        predicate.wants_array ? values.map {|v| v.cast(default_type)} : values.first.cast(default_type)
+        predicate.wants_array ?
+          values.map { |v| v.cast(default_type) } :
+          values.first.cast(default_type)
       end
 
       def build(params)
@@ -131,7 +139,8 @@ module Ransack
       end
 
       def key
-        @key ||= attributes.map(&:name).join("_#{combinator}_") + "_#{predicate.name}"
+        @key ||= attributes.map(&:name).join("_#{combinator}_") +
+          "_#{predicate.name}"
       end
 
       def eql?(other)
@@ -152,11 +161,6 @@ module Ransack
       end
       alias :p= :predicate_name=
 
-      def predicate=(predicate)
-        @predicate = predicate
-        predicate
-      end
-
       def predicate_name
         predicate.name if predicate
       end
@@ -164,7 +168,9 @@ module Ransack
 
       def arel_predicate
         predicates = attributes.map do |attr|
-          attr.attr.send(predicate.arel_predicate, formatted_values_for_attribute(attr))
+          attr.attr.send(
+            predicate.arel_predicate, formatted_values_for_attribute(attr)
+            )
         end
 
         if predicates.size > 1
@@ -180,16 +186,17 @@ module Ransack
       end
 
       def validated_values
-        values.select {|v| predicate.validator.call(v.value)}
+        values.select { |v| predicate.validator.call(v.value) }
       end
 
       def casted_values_for_attribute(attr)
-        validated_values.map {|v| v.cast(predicate.type || attr.type)}
+        validated_values.map { |v| v.cast(predicate.type || attr.type) }
       end
 
       def formatted_values_for_attribute(attr)
         formatted = casted_values_for_attribute(attr).map do |val|
-          val = attr.ransacker.formatter.call(val) if attr.ransacker && attr.ransacker.formatter
+          val = attr.ransacker.formatter.call(val) if
+            attr.ransacker && attr.ransacker.formatter
           val = predicate.format(val)
           val
         end
@@ -201,9 +208,15 @@ module Ransack
       end
 
       def inspect
-        data =[['attributes', a.try(:map, &:name)], ['predicate', p], ['combinator', m], ['values', v.try(:map, &:value)]].reject { |e|
-          e[1].blank?
-        }.map { |v| "#{v[0]}: #{v[1]}" }.join(', ')
+        data = [
+          ['attributes', a.try(:map, &:name)],
+          ['predicate', p],
+          ['combinator', m],
+          ['values', v.try(:map, &:value)]
+        ]
+        .reject { |e| e[1].blank? }
+        .map { |v| "#{v[0]}: #{v[1]}" }
+        .join(', ')
         "Condition <#{data}>"
       end
 
@@ -216,4 +229,4 @@ module Ransack
 
     end
   end
-end
+end