ransack 1.7.0 → 1.8.0

data/lib/ransack/adapters/active_record.rb

@@ -1,6 +1,8 @@
 require 'ransack/adapters/active_record/base'
 ActiveRecord::Base.extend Ransack::Adapters::ActiveRecord::Base
 
+require 'ransack/adapters/active_record/context'
+
 case ActiveRecord::VERSION::STRING
 when /^3\.0\./
   require 'ransack/adapters/active_record/3.0/context'
@@ -8,6 +10,4 @@ when /^3\.1\./
   require 'ransack/adapters/active_record/3.1/context'
 when /^3\.2\./
   require 'ransack/adapters/active_record/3.2/context'
-else
-  require 'ransack/adapters/active_record/context'
 end

data/lib/ransack/adapters/active_record/3.0/compat.rb

@@ -138,16 +138,16 @@ module Arel
         "#{
           o.name
           }(#{
-          o.distinct ? Ransack::Constants::DISTINCT : Ransack::Constants::EMPTY
+          o.distinct ? Ransack::Constants::DISTINCT : ''.freeze
           }#{
-          o.expressions.map { |x| visit x }.join(Ransack::Constants::COMMA_SPACE)
+          o.expressions.map { |x| visit x }.join(', '.freeze)
           })#{
-          o.alias ? " AS #{visit o.alias}" : Ransack::Constants::EMPTY
+          o.alias ? " AS #{visit o.alias}" : ''.freeze
           }"
       end
 
       def visit_Arel_Nodes_And o
-        o.children.map { |x| visit x }.join(Ransack::Constants::SPACED_AND)
+        o.children.map { |x| visit x }.join(' AND '.freeze)
       end
 
       def visit_Arel_Nodes_Not o
@@ -164,7 +164,7 @@ module Arel
             quote(value, attr && column_for(attr))
           end
         }
-        .join(Ransack::Constants::COMMA_SPACE)
+        .join(', '.freeze)
         })"
       end
     end

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

@@ -7,9 +7,11 @@ module Ransack
   module Adapters
     module ActiveRecord
       class Context < ::Ransack::Context
+
         # Because the AR::Associations namespace is insane
-        JoinDependency = ::ActiveRecord::Associations::ClassMethods::JoinDependency
-        JoinBase = JoinDependency::JoinBase
+        if defined? ::ActiveRecord::Associations::ClassMethods::JoinDependency
+          JoinDependency = ::ActiveRecord::Associations::ClassMethods::JoinDependency
+        end
 
         # Redefine a few things for ActiveRecord 3.0.
 
@@ -124,7 +126,7 @@ module Ransack
         end
 
         def join_dependency(relation)
-          if relation.respond_to?(:join_dependency) # Squeel will enable this
+          if relation.respond_to?(:join_dependency) # Polyamorous enables this
             relation.join_dependency
           else
             build_join_dependency(relation)

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

@@ -6,9 +6,6 @@ module Ransack
   module Adapters
     module ActiveRecord
       class Context < ::Ransack::Context
-        # Because the AR::Associations namespace is insane
-        JoinDependency = ::ActiveRecord::Associations::JoinDependency
-        JoinPart = JoinDependency::JoinPart
 
         # Redefine a few things for ActiveRecord 3.1.
 
@@ -137,7 +134,7 @@ module Ransack
         end
 
         def join_dependency(relation)
-          if relation.respond_to?(:join_dependency) # Squeel will enable this
+          if relation.respond_to?(:join_dependency) # Polyamorous enables this
             relation.join_dependency
           else
             build_join_dependency(relation)

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

@@ -7,7 +7,9 @@ module Ransack
           alias :search :ransack unless base.respond_to? :search
           base.class_eval do
             class_attribute :_ransackers
+            class_attribute :_ransack_aliases
             self._ransackers ||= {}
+            self._ransack_aliases ||= {}
           end
         end
 
@@ -20,12 +22,21 @@ module Ransack
             .new(self, name, opts, &block)
         end
 
+        def ransack_alias(new_name, old_name)
+          self._ransack_aliases.store(new_name.to_s, old_name.to_s)
+        end
+
         # Ransackable_attributes, by default, returns all column names
         # and any defined ransackers as an array of strings.
         # For overriding with a whitelist array of strings.
         #
         def ransackable_attributes(auth_object = nil)
-          column_names + _ransackers.keys
+          if Ransack::SUPPORTS_ATTRIBUTE_ALIAS
+            column_names + _ransackers.keys + _ransack_aliases.keys +
+            attribute_aliases.keys
+          else
+            column_names + _ransackers.keys + _ransack_aliases.keys
+          end
         end
 
         # Ransackable_associations, by default, returns the names

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

@@ -8,8 +8,9 @@ module Ransack
       class Context < ::Ransack::Context
 
         # Because the AR::Associations namespace is insane
-        JoinDependency = ::ActiveRecord::Associations::JoinDependency
-        JoinPart = JoinDependency::JoinPart
+        if defined? ::ActiveRecord::Associations::JoinDependency
+          JoinDependency = ::ActiveRecord::Associations::JoinDependency
+        end
 
         def initialize(object, options = {})
           super
@@ -22,13 +23,13 @@ module Ransack
 
         def type_for(attr)
           return nil unless attr && attr.valid?
-          name        = attr.arel_attribute.name.to_s
-          table       = attr.arel_attribute.relation.table_name
-          connection  = attr.klass.connection
-          unless connection.table_exists?(table)
-            raise "No table named #{table} exists"
+          name         = attr.arel_attribute.name.to_s
+          table        = attr.arel_attribute.relation.table_name
+          schema_cache = @engine.connection.schema_cache
+          unless schema_cache.send(database_table_exists?, table)
+            raise "No table named #{table} exists."
           end
-          connection.schema_cache.columns_hash(table)[name].type
+          schema_cache.columns_hash(table)[name].type
         end
 
         def evaluate(search, opts = {})
@@ -86,7 +87,7 @@ module Ransack
             "ActiveRecord 4.1 and later does not use join_associations. Use join_sources."
           end
 
-          # All dependent Arel::Join nodes used in the search query
+          # All dependent Arel::Join nodes used in the search query.
           #
           # This could otherwise be done as `@object.arel.join_sources`, except
           # that ActiveRecord's build_joins sets up its own JoinDependency.
@@ -94,13 +95,18 @@ module Ransack
           # JoinDependency to track table aliases.
           #
           def join_sources
-            base =
-              if ::ActiveRecord::VERSION::MAJOR >= 5
-                Arel::SelectManager.new(@object.table)
-              else
-                Arel::SelectManager.new(@object.engine, @object.table)
-              end
-            joins = @join_dependency.join_constraints(@object.joins_values)
+            base, joins =
+            if ::ActiveRecord::VERSION::MAJOR >= 5
+              [
+                Arel::SelectManager.new(@object.table),
+                @join_dependency.join_constraints(@object.joins_values, @join_type)
+              ]
+            else
+              [
+                Arel::SelectManager.new(@object.engine, @object.table),
+                @join_dependency.join_constraints(@object.joins_values)
+              ]
+            end
             joins.each do |aliased_join|
               base.from(aliased_join)
             end
@@ -109,7 +115,7 @@ module Ransack
 
         else
 
-          # All dependent JoinAssociation items used in the search query
+          # All dependent JoinAssociation items used in the search query.
           #
           # Deprecated: this goes away in ActiveRecord 4.1. Use join_sources.
           #
@@ -132,8 +138,74 @@ module Ransack
           @join_dependency.alias_tracker
         end
 
+        def lock_association(association)
+          @lock_associations << association
+        end
+
+        if ::ActiveRecord::VERSION::STRING >= Constants::RAILS_4_1
+          def remove_association(association)
+            return if @lock_associations.include?(association)
+            @join_dependency.join_root.children.delete_if { |stashed|
+              stashed.eql?(association)
+            }
+            @object.joins_values.delete_if { |jd|
+              jd.join_root.children.map(&:object_id) == [association.object_id]
+            }
+          end
+        else
+          def remove_association(association)
+            return if @lock_associations.include?(association)
+            @join_dependency.join_parts.delete(association)
+            @object.joins_values.delete(association)
+          end
+        end
+
+        # Build an Arel subquery that selects keys for the top query,
+        # drawn from the first join association's foreign_key.
+        #
+        # Example: for an Article that has_and_belongs_to_many Tags
+        #
+        #   context = Article.search.context
+        #   attribute = Attribute.new(context, "tags_name").tap do |a|
+        #     context.bind(a, a.name)
+        #   end
+        #   context.build_correlated_subquery(attribute.parent).to_sql
+        #
+        #   # SELECT "articles_tags"."article_id" FROM "articles_tags"
+        #   # INNER JOIN "tags" ON "tags"."id" = "articles_tags"."tag_id"
+        #   # WHERE "articles_tags"."article_id" = "articles"."id"
+        #
+        # The WHERE condition on this query makes it invalid by itself,
+        # because it is correlated to the primary key on the outer query.
+        #
+        def build_correlated_subquery(association)
+          join_constraints = extract_joins(association)
+          join_root = join_constraints.shift
+          join_table = join_root.left
+          correlated_key = join_root.right.expr.left
+          subquery = Arel::SelectManager.new(association.base_klass)
+          subquery.from(join_root.left)
+          subquery.project(correlated_key)
+          join_constraints.each do |j|
+            subquery.join_sources << Arel::Nodes::InnerJoin.new(j.left, j.right)
+          end
+          subquery.where(correlated_key.eq(primary_key))
+        end
+
+        def primary_key
+          @object.table[@object.primary_key]
+        end
+
         private
 
+        def database_table_exists?
+          if ::ActiveRecord::VERSION::MAJOR >= 5
+            :data_source_exists?
+          else
+            :table_exists?
+          end
+        end
+
         def get_parent_and_attribute_name(str, parent = @base)
           attr_name = nil
 
@@ -168,7 +240,7 @@ module Ransack
         end
 
         def join_dependency(relation)
-          if relation.respond_to?(:join_dependency) # Squeel will enable this
+          if relation.respond_to?(:join_dependency) # Polyamorous enables this
             relation.join_dependency
           else
             build_joins(relation)
@@ -229,65 +301,86 @@ module Ransack
           .map { |join| table.create_string_join(Arel.sql(join)) }
         end
 
+        def build_or_find_association(name, parent = @base, klass = nil)
+          find_association(name, parent, klass) or build_association(name, parent, klass)
+        end
+
         if ::ActiveRecord::VERSION::STRING >= Constants::RAILS_4_1
 
-          def build_or_find_association(name, parent = @base, klass = nil)
-            found_association = @join_dependency.join_root.children
-            .detect do |assoc|
+          def find_association(name, parent = @base, klass = nil)
+            @join_dependency.join_root.children.detect do |assoc|
               assoc.reflection.name == name &&
-              (@associations_pot.nil? || @associations_pot[assoc] == parent) &&
+              (@associations_pot.empty? || @associations_pot[assoc] == parent) &&
               (!klass || assoc.reflection.klass == klass)
             end
+          end
 
-            unless found_association
-              jd = JoinDependency.new(
-                parent.base_klass,
-                Polyamorous::Join.new(name, @join_type, klass),
-                []
+          def build_association(name, parent = @base, klass = nil)
+            jd = JoinDependency.new(
+              parent.base_klass,
+              Polyamorous::Join.new(name, @join_type, klass),
+              []
+            )
+            found_association = jd.join_root.children.last
+            @associations_pot[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
               )
-              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
+            # Leverage the stashed association functionality in AR
+            @object = @object.joins(jd)
 
-              # 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
+          def extract_joins(association)
+            parent = @join_dependency.join_root
+            reflection = association.reflection
+            join_constraints = association.join_constraints(
+              parent.table,
+              parent.base_klass,
+              association,
+              Arel::Nodes::OuterJoin,
+              association.tables,
+              reflection.scope_chain,
+              reflection.chain
+            )
+            join_constraints.to_a.flatten
           end
 
         else
 
-          def build_or_find_association(name, parent = @base, klass = nil)
+          def build_association(name, parent = @base, klass = nil)
+            @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)
+
+            found_association
+          end
+
+          def extract_joins(association)
+            query = Arel::SelectManager.new(association.base_klass, association.table)
+            association.join_to(query).join_sources
+          end
+
+          def 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

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

@@ -4,97 +4,97 @@ module Ransack
 
     DERIVED_PREDICATES = [
       [CONT, {
-        :arel_predicate => 'matches'.freeze,
-        :formatter => proc { |v| "%#{escape_wildcards(v)}%" }
+        arel_predicate: 'matches'.freeze,
+        formatter: proc { |v| "%#{escape_wildcards(v)}%" }
         }
       ],
       ['not_cont'.freeze, {
-        :arel_predicate => 'does_not_match'.freeze,
-        :formatter => proc { |v| "%#{escape_wildcards(v)}%" }
+        arel_predicate: 'does_not_match'.freeze,
+        formatter: proc { |v| "%#{escape_wildcards(v)}%" }
         }
       ],
       ['start'.freeze, {
-        :arel_predicate => 'matches'.freeze,
-        :formatter => proc { |v| "#{escape_wildcards(v)}%" }
+        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)}%" }
+        arel_predicate: 'does_not_match'.freeze,
+        formatter: proc { |v| "#{escape_wildcards(v)}%" }
         }
       ],
       ['end'.freeze, {
-        :arel_predicate => 'matches'.freeze,
-        :formatter => proc { |v| "%#{escape_wildcards(v)}" }
+        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)}" }
+        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 }
+        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 }
+        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 }
+        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 }
+        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, EMPTY] }
+        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, ''.freeze].freeze }
         }
       ],
       ['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, EMPTY] }
+        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, ''.freeze].freeze }
         }
       ],
       ['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 }
+        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 } }
+        arel_predicate: proc { |v| v ? NOT_EQ : EQ },
+        compounds: false,
+        type: :boolean,
+        validator: proc { |v| BOOLEAN_VALUES.include?(v) },
+        formatter: proc { |v| nil } }
       ]
     ].freeze
 
@@ -104,7 +104,7 @@ module Ransack
       case ActiveRecord::Base.connection.adapter_name
       when "Mysql2".freeze, "PostgreSQL".freeze
         # Necessary for PostgreSQL and MySQL
-        unescaped.to_s.gsub(/([\\|\%|.])/, '\\\\\\1')
+        unescaped.to_s.gsub(/([\\|\%|_|.])/, '\\\\\\1')
       else
         unescaped
       end