ransack 1.1.0 → 1.2.0

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

@@ -41,4 +41,4 @@ module Ransack
       end
     end
   end
-end
+end

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

@@ -4,7 +4,7 @@ module Ransack
       module Base
 
         def self.extended(base)
-          alias :search :ransack unless base.method_defined? :search
+          alias :search :ransack unless base.respond_to? :search
           base.class_eval do
             class_attribute :_ransackers
             self._ransackers ||= {}
@@ -12,11 +12,13 @@ module Ransack
         end
 
         def ransack(params = {}, options = {})
-          Search.new(self, params, options)
+          Search.new(self, params ? params.delete_if {
+            |k, v| v.blank? && v != false } : params, options)
         end
 
         def ransacker(name, opts = {}, &block)
-          self._ransackers = _ransackers.merge name.to_s => Ransacker.new(self, name, opts, &block)
+          self._ransackers = _ransackers.merge name.to_s => Ransacker
+            .new(self, name, opts, &block)
         end
 
         def ransackable_attributes(auth_object = nil)
@@ -24,15 +26,16 @@ module Ransack
         end
 
         def ransortable_attributes(auth_object = nil)
-          # Here so users can overwrite the attributes that show up in the sort_select
+          # 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.map {|a| a.name.to_s}
+          reflect_on_all_associations.map { |a| a.name.to_s }
         end
 
       end
     end
   end
-end
+end

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

@@ -1,5 +1,4 @@
 require 'ransack/context'
-require 'ransack/adapters/active_record/3.2/context'
 require 'ransack/adapters/active_record/compat'
 require 'polyamorous'
 
@@ -8,6 +7,10 @@ module Ransack
     module ActiveRecord
       class Context < ::Ransack::Context
 
+        # Because the AR::Associations namespace is insane
+        JoinDependency = ::ActiveRecord::Associations::JoinDependency
+        JoinPart = JoinDependency::JoinPart
+
         def initialize(object, options = {})
           super
           @arel_visitor = @engine.connection.visitor
@@ -31,11 +34,199 @@ module Ransack
           viz = Visitor.new
           relation = @object.where(viz.accept(search.base))
           if search.sorts.any?
-            relation = relation.except(:order).reorder(viz.accept(search.sorts))
+            relation = relation.except(:order)
+            .reorder(viz.accept(search.sorts))
           end
           opts[:distinct] ? relation.distinct : relation
         end
 
+        def attribute_method?(str, klass = @klass)
+          exists = false
+          if ransackable_attribute?(str, klass)
+            exists = true
+          elsif (segments = str.split(/_/)).size > 1
+            remainder = []
+            found_assoc = nil
+            while !found_assoc && remainder.unshift(
+              segments.pop) && segments.size > 0 do
+              assoc, poly_class = unpolymorphize_association(
+                segments.join('_')
+                )
+              if found_assoc = get_association(assoc, klass)
+                exists = attribute_method?(remainder.join('_'),
+                  poly_class || found_assoc.klass
+                )
+              end
+            end
+          end
+          exists
+        end
+
+        def table_for(parent)
+          parent.table
+        end
+
+        def klassify(obj)
+          if Class === obj && ::ActiveRecord::Base > obj
+            obj
+          elsif obj.respond_to? :klass
+            obj.klass
+          elsif obj.respond_to? :base_klass
+            obj.base_klass
+          else
+            raise ArgumentError, "Don't know how to klassify #{obj}"
+          end
+        end
+
+      private
+
+        def get_parent_and_attribute_name(str, parent = @base)
+          attr_name = nil
+
+          if ransackable_attribute?(str, klassify(parent))
+            attr_name = str
+          elsif (segments = str.split(/_/)).size > 1
+            remainder = []
+            found_assoc = nil
+            while remainder.unshift(
+              segments.pop) && segments.size > 0 && !found_assoc do
+              assoc, klass = unpolymorphize_association(segments.join('_'))
+              if found_assoc = get_association(assoc, parent)
+                join = build_or_find_association(found_assoc.name, parent, klass)
+                parent, attr_name = get_parent_and_attribute_name(
+                  remainder.join('_'), join
+                  )
+              end
+            end
+          end
+
+          [parent, attr_name]
+        end
+
+        def get_association(str, parent = @base)
+          klass = klassify parent
+          ransackable_association?(str, klass) &&
+            klass.reflect_on_all_associations.detect { |a| a.name.to_s == str }
+        end
+
+        def join_dependency(relation)
+          if relation.respond_to?(:join_dependency) # Squeel will enable this
+            relation.join_dependency
+          else
+            build_join_dependency(relation)
+          end
+        end
+
+        # Checkout active_record/relation/query_methods.rb +build_joins+ for
+        # reference. Lots of duplicated code maybe we can avoid it
+        def build_join_dependency(relation)
+          buckets = relation.joins_values.group_by do |join|
+            case join
+            when String
+              'string_join'
+            when Hash, Symbol, Array
+              'association_join'
+            when JoinDependency, JoinDependency::JoinAssociation
+              'stashed_join'
+            when Arel::Nodes::Join
+              'join_node'
+            else
+              raise 'unknown class: %s' % join.class.name
+            end
+          end
+
+          association_joins         = buckets['association_join'] || []
+
+          stashed_association_joins = buckets['stashed_join'] || []
+
+          join_nodes                = buckets['join_node'] || []
+
+          string_joins              = (buckets['string_join'] || [])
+                                      .map { |x| x.strip }
+                                      .uniq
+
+          join_list = relation.send :custom_join_ast,
+            relation.table.from(relation.table), string_joins
+
+          join_dependency = JoinDependency.new(
+            relation.klass, association_joins, join_list
+          )
+
+          join_nodes.each do |join|
+            join_dependency.alias_tracker.aliases[join.left.name.downcase] = 1
+          end
+
+          if ::ActiveRecord::VERSION::STRING >= "4.1"
+            join_dependency
+          else
+            join_dependency.graft(*stashed_association_joins)
+          end
+        end
+
+        if ::ActiveRecord::VERSION::STRING >= "4.1"
+
+          def build_or_find_association(name, parent = @base, klass = nil)
+            list = if ::ActiveRecord::VERSION::STRING >= "4.1"
+                     @join_dependency.join_root.children.detect
+                   else
+                     @join_dependency.join_associations
+                   end
+
+            found_association = list.detect do |assoc|
+              assoc.reflection.name == name &&
+              @associations_pot[assoc] == parent &&
+              (!klass || assoc.reflection.klass == klass)
+            end
+
+            unless found_association
+              jd = JoinDependency.new(
+                parent.base_klass,
+                Polyamorous::Join.new(name, @join_type, klass),
+                []
+              )
+              found_association = jd.join_root.children.last
+              associations found_association, parent
+
+              # TODO maybe we dont need to push associations here, we could loop
+              # through the @associations_pot instead
+              @join_dependency.join_root.children.push found_association
+
+              # Builds the arel nodes properly for this association
+              @join_dependency.send(
+                :construct_tables!, jd.join_root, found_association
+                )
+
+              # Leverage the stashed association functionality in AR
+              @object = @object.joins(jd)
+            end
+
+            found_association
+          end
+
+          def associations(assoc, parent)
+            @associations_pot ||= {}
+            @associations_pot[assoc] = parent
+          end
+        else
+
+          def build_or_find_association(name, parent = @base, klass = nil)
+            found_association = @join_dependency.join_associations
+            .detect do |assoc|
+              assoc.reflection.name == name &&
+              assoc.parent == parent &&
+              (!klass || assoc.reflection.klass == klass)
+            end
+            unless found_association
+              @join_dependency.send(:build, Polyamorous::Join.new(
+                name, @join_type, klass), parent)
+              found_association = @join_dependency.join_associations.last
+              # Leverage the stashed association functionality in AR
+              @object = @object.joins(found_association)
+            end
+
+            found_association
+          end
+        end
       end
     end
   end

data/lib/ransack/configuration.rb

@@ -7,7 +7,7 @@ module Ransack
     mattr_accessor :predicates, :options
     self.predicates = {}
     self.options = {
-        :search_key => :q
+        search_key: :q
     }
 
     def configure
@@ -27,9 +27,9 @@ module Ransack
       ['_any', '_all'].each do |suffix|
         self.predicates[name + suffix] = Predicate.new(
           opts.merge(
-            :name => name + suffix,
-            :arel_predicate => opts[:arel_predicate] + suffix,
-            :compound => true
+            name: name + suffix,
+            arel_predicate: opts[:arel_predicate] + suffix,
+            compound: true
           )
         )
       end if compounds

data/lib/ransack/constants.rb

@@ -6,31 +6,94 @@ module Ransack
     AREL_PREDICATES = %w(eq not_eq matches does_not_match lt lteq gt gteq in not_in)
 
     DERIVED_PREDICATES = [
-      ['cont', {:arel_predicate => 'matches', :formatter => proc {|v| "%#{escape_wildcards(v)}%"}}],
-      ['not_cont', {:arel_predicate => 'does_not_match', :formatter => proc {|v| "%#{escape_wildcards(v)}%"}}],
-      ['start', {:arel_predicate => 'matches', :formatter => proc {|v| "#{escape_wildcards(v)}%"}}],
-      ['not_start', {:arel_predicate => 'does_not_match', :formatter => proc {|v| "#{escape_wildcards(v)}%"}}],
-      ['end', {:arel_predicate => 'matches', :formatter => proc {|v| "%#{escape_wildcards(v)}"}}],
-      ['not_end', {:arel_predicate => 'does_not_match', :formatter => proc {|v| "%#{escape_wildcards(v)}"}}],
-      ['true', {:arel_predicate => 'eq', :compounds => false, :type => :boolean, :validator => proc {|v| TRUE_VALUES.include?(v)}}],
-      ['false', {:arel_predicate => 'eq', :compounds => false, :type => :boolean, :validator => proc {|v| TRUE_VALUES.include?(v)}, :formatter => proc {|v| !v}}],
-      ['present', {:arel_predicate => 'not_eq_all', :compounds => false, :type => :boolean, :validator => proc {|v| TRUE_VALUES.include?(v)}, :formatter => proc {|v| [nil, '']}}],
-      ['blank', {:arel_predicate => 'eq_any', :compounds => false, :type => :boolean, :validator => proc {|v| TRUE_VALUES.include?(v)}, :formatter => proc {|v| [nil, '']}}],
-      ['null', {:arel_predicate => 'eq', :compounds => false, :type => :boolean, :validator => proc {|v| TRUE_VALUES.include?(v)}, :formatter => proc {|v| nil}}],
-      ['not_null', {:arel_predicate => 'not_eq', :compounds => false, :type => :boolean, :validator => proc {|v| TRUE_VALUES.include?(v)}, :formatter => proc {|v| nil}}]
+      ['cont', {
+        arel_predicate: 'matches',
+        formatter: proc { |v| "%#{escape_wildcards(v)}%" }
+        }
+      ],
+      ['not_cont', {
+        arel_predicate: 'does_not_match',
+        formatter: proc { |v| "%#{escape_wildcards(v)}%" }
+        }
+      ],
+      ['start', {
+        arel_predicate: 'matches',
+        formatter: proc { |v| "#{escape_wildcards(v)}%" }
+        }
+      ],
+      ['not_start', {
+        arel_predicate: 'does_not_match',
+        formatter: proc { |v| "#{escape_wildcards(v)}%" }
+        }
+      ],
+      ['end', {
+        arel_predicate: 'matches',
+        formatter: proc { |v| "%#{escape_wildcards(v)}" }
+        }
+      ],
+      ['not_end', {
+        arel_predicate: 'does_not_match',
+        formatter: proc { |v| "%#{escape_wildcards(v)}" }
+        }
+      ],
+      ['true', {
+        arel_predicate: 'eq',
+        compounds: false,
+        type: :boolean,
+        validator: proc { |v| TRUE_VALUES.include?(v) }
+        }
+      ],
+      ['false', {
+        arel_predicate: 'eq',
+        compounds: false,
+        type: :boolean,
+        validator: proc { |v| TRUE_VALUES.include?(v) },
+        formatter: proc { |v| !v }
+        }
+      ],
+      ['present', {
+        arel_predicate: 'not_eq_all',
+        compounds: false,
+        type: :boolean,
+        validator: proc { |v| TRUE_VALUES.include?(v) },
+        formatter: proc { |v| [nil, ''] }
+        }
+      ],
+      ['blank', {
+        arel_predicate: 'eq_any',
+        compounds: false,
+        type: :boolean,
+        validator: proc { |v| TRUE_VALUES.include?(v) },
+        formatter: proc { |v| [nil, ''] }
+        }
+      ],
+      ['null', {
+        arel_predicate: 'eq',
+        compounds: false,
+        type: :boolean,
+        validator: proc { |v| TRUE_VALUES.include?(v)},
+        formatter: proc { |v| nil }
+        }
+      ],
+      ['not_null', {
+        arel_predicate: 'not_eq',
+        compounds: false,
+        type: :boolean,
+        validator: proc { |v| TRUE_VALUES.include?(v) },
+        formatter: proc { |v| nil } }
+      ]
     ]
 
     module_function
     # replace % \ to \% \\
     def escape_wildcards(unescaped)
       case ActiveRecord::Base.connection.adapter_name
-        when "SQLite"
-          unescaped
-        else
-          # Necessary for PostgreSQL and MySQL
-          unescaped.to_s.gsub(/([\\|\%|.])/, '\\\\\\1')
+      when "SQLite"
+        unescaped
+      else
+        # Necessary for PostgreSQL and MySQL
+        unescaped.to_s.gsub(/([\\|\%|.])/, '\\\\\\1')
       end
     end
-
   end
 end

data/lib/ransack/context.rb

@@ -8,8 +8,11 @@ module Ransack
     class << self
 
       def for(object, options = {})
-        context = Class === object ? for_class(object, options) : for_object(object, options)
-        context or raise ArgumentError, "Don't know what context to use for #{object}"
+        context = Class === object ?
+          for_class(object, options) :
+          for_object(object, options)
+        context or raise ArgumentError,
+          "Don't know what context to use for #{object}"
       end
 
       def for_class(klass, options = {})
@@ -33,9 +36,18 @@ module Ransack
       @join_dependency = join_dependency(@object)
       @join_type = options[:join_type] || Arel::OuterJoin
       @search_key = options[:search_key] || Ransack.options[:search_key]
-      @base = @join_dependency.join_base
-      @engine = @base.arel_engine
-      @default_table = Arel::Table.new(@base.table_name, :as => @base.aliased_table_name, :engine => @engine)
+
+      if ::ActiveRecord::VERSION::STRING >= "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
@@ -54,7 +66,7 @@ module Ransack
       elsif obj.respond_to? :base_klass     # Rails 4
         obj.base_klass
       else
-        raise ArgumentError, "Don't know how to klassify #{obj}"
+        raise ArgumentError, "Don't know how to klassify #{obj.inspect}"
       end
     end
 
@@ -85,7 +97,8 @@ module Ransack
 
           remainder.unshift segments.pop
         end
-        raise UntraversableAssociationError, "No association matches #{str}" unless found_assoc
+        raise UntraversableAssociationError,
+          "No association matches #{str}" unless found_assoc
       end
 
       klassify(base)
@@ -98,8 +111,10 @@ module Ransack
       segments = str.split(/_/)
       association_parts = []
       if (segments = str.split(/_/)).size > 0
-        while segments.size > 0 && !base.columns_hash[segments.join('_')] && association_parts << segments.shift do
-          assoc, klass = unpolymorphize_association(association_parts.join('_'))
+        while segments.size > 0 && !base.columns_hash[segments.join('_')] &&
+        association_parts << segments.shift do
+          assoc, klass = unpolymorphize_association(association_parts
+          .join('_'))
           if found_assoc = get_association(assoc, base)
             path += association_parts
             association_parts = []
@@ -120,7 +135,8 @@ module Ransack
     end
 
     def ransackable_attribute?(str, klass)
-      klass.ransackable_attributes(auth_object).include? str
+      klass.ransackable_attributes(auth_object).include?(str) ||
+      klass.ransortable_attributes(auth_object).include?(str)
     end
 
     def ransackable_association?(str, klass)
@@ -138,6 +154,5 @@ module Ransack
     def searchable_associations(str = '')
       traverse(str).ransackable_associations(auth_object)
     end
-
   end
-end
+end