ransack 0.1.0 → 0.2.0

data/lib/ransack.rb

@@ -16,9 +16,9 @@ end
 
 require 'ransack/translate'
 require 'ransack/search'
+require 'ransack/ransacker'
 require 'ransack/adapters/active_record'
 require 'ransack/helpers'
 require 'action_controller'
 
-ActiveRecord::Base.extend Ransack::Adapters::ActiveRecord::Base
 ActionController::Base.helper Ransack::Helpers::FormHelper

data/lib/ransack/adapters/active_record.rb

@@ -1,2 +1,18 @@
-require 'ransack/adapters/active_record/base'
-require 'ransack/adapters/active_record/context'
+case ActiveRecord::VERSION::STRING
+when /^3\.0\./
+  require 'ransack/adapters/active_record/3.0/base'
+  require 'ransack/adapters/active_record/3.0/join_dependency'
+  require 'ransack/adapters/active_record/3.0/join_association'
+  require 'ransack/adapters/active_record/3.0/context'
+
+  ActiveRecord::Base.extend Ransack::Adapters::ActiveRecord::Base
+  ActiveRecord::Associations::ClassMethods::JoinDependency.send :include, Ransack::Adapters::ActiveRecord::JoinDependency
+else
+  require 'ransack/adapters/active_record/base'
+  require 'ransack/adapters/active_record/join_dependency'
+  require 'ransack/adapters/active_record/join_association'
+  require 'ransack/adapters/active_record/context'
+
+  ActiveRecord::Base.extend Ransack::Adapters::ActiveRecord::Base
+  ActiveRecord::Associations::JoinDependency.send :include, Ransack::Adapters::ActiveRecord::JoinDependency
+end

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

@@ -0,0 +1,34 @@
+module Ransack
+  module Adapters
+    module ActiveRecord
+      module Base
+
+        def self.extended(base)
+          alias :search :ransack unless base.method_defined? :search
+          base.instance_eval do
+            class_attribute :_ransackers
+            self._ransackers ||= {}
+          end
+        end
+
+        def ransack(params = {}, options = {})
+          Search.new(self, params, options)
+        end
+
+        def ransacker(name, opts = {}, &block)
+          Ransacker.new(self, name, opts, &block)
+        end
+
+        # TODO: Let's actually do some authorization. Whitelist-only.
+        def ransackable_attributes(auth_object)
+          column_names + _ransackers.keys
+        end
+
+        def ransackable_associations(auth_object)
+          reflect_on_all_associations.map {|a| a.name.to_s}
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# UGLY, UGLY MONKEY PATCHES FOR BACKWARDS COMPAT!!! AVERT YOUR EYES!!
+if Arel::Nodes::And < Arel::Nodes::Binary
+  class Ransack::Visitor
+    def visit_Ransack_Nodes_And(object)
+      nodes = object.values.map {|o| accept(o)}.compact
+      return nil unless nodes.size > 0
+
+      if nodes.size > 1
+        nodes.inject(&:and)
+      else
+        nodes.first
+      end
+    end
+  end
+end
+
+class ::ActiveRecord::Associations::ClassMethods::JoinDependency::JoinBase
+  def table
+    Arel::Table.new(table_name, :as      => aliased_table_name,
+                                :engine  => active_record.arel_engine,
+                                :columns => active_record.columns)
+  end
+end

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

@@ -0,0 +1,168 @@
+require 'ransack/context'
+require 'active_record'
+require 'ransack/adapters/active_record/3.0/compat'
+
+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
+
+        def evaluate(search, opts = {})
+          viz = Visitor.new
+          relation = @object.where(viz.accept(search.base)).order(viz.accept(search.sorts))
+          opts[:distinct] ? relation.select("DISTINCT #{@klass.quoted_table_name}.*") : 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? :active_record
+            obj.active_record
+          else
+            raise ArgumentError, "Don't know how to klassify #{obj}"
+          end
+        end
+
+        def type_for(attr)
+          return nil unless attr
+          name    = attr.name.to_s
+          table   = attr.relation.name
+
+          unless @engine.connection.table_exists?(table)
+            raise "No table named #{table} exists"
+          end
+
+          # TODO: optimize
+          @engine.connection.columns(table).detect {|c| c.name == name}.type
+        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 ransackable_association?(assoc, klassify(parent))
+                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 ransackable_attribute?(str, klass)
+          klass.ransackable_attributes(auth_object).include? str
+        end
+
+        def ransackable_association?(str, klass)
+          klass.ransackable_associations(auth_object).include? str
+        end
+
+        def get_association(str, parent = @base)
+          klassify(parent).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
+
+        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 ::ActiveRecord::Associations::ClassMethods::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_sql, (string_joins + join_nodes)
+
+          join_dependency = JoinDependency.new(
+            relation.klass,
+            association_joins,
+            join_list
+          )
+
+          join_nodes.each do |join|
+            join_dependency.table_aliases[join.left.name.downcase] = 1
+          end
+
+          join_dependency.graft(*stashed_association_joins)
+        end
+
+        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.klass == klass)
+          end
+          unless found_association
+            @join_dependency.send(:build_polymorphic, name.to_sym, parent, Arel::Nodes::OuterJoin, klass)
+            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/adapters/active_record/3.0/join_association.rb

@@ -0,0 +1,44 @@
+require 'active_record'
+
+module Ransack
+  module Adapters
+    module ActiveRecord
+      class JoinAssociation < ::ActiveRecord::Associations::ClassMethods::JoinDependency::JoinAssociation
+
+        def initialize(reflection, join_dependency, parent = nil, polymorphic_class = nil)
+          if polymorphic_class && ::ActiveRecord::Base > polymorphic_class
+            swapping_reflection_klass(reflection, polymorphic_class) do |reflection|
+              super(reflection, join_dependency, parent)
+            end
+          else
+            super(reflection, join_dependency, parent)
+          end
+        end
+
+        def swapping_reflection_klass(reflection, klass)
+          reflection = reflection.clone
+          original_polymorphic = reflection.options.delete(:polymorphic)
+          reflection.instance_variable_set(:@klass, klass)
+          yield reflection
+        ensure
+          reflection.options[:polymorphic] = original_polymorphic
+        end
+
+        def ==(other)
+          super && active_record == other.active_record
+        end
+
+        def build_constraint(reflection, table, key, foreign_table, foreign_key)
+          if reflection.options[:polymorphic]
+            super.and(
+              foreign_table[reflection.foreign_type].eq(reflection.klass.name)
+            )
+          else
+            super
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+require 'active_record'
+
+module Ransack
+  module Adapters
+    module ActiveRecord
+      module JoinDependency
+
+        # Yes, I'm using alias_method_chain here. No, I don't feel too
+        # bad about it. JoinDependency, or, to call it by its full proper
+        # name, ::ActiveRecord::Associations::JoinDependency, is one of the
+        # most "for internal use only" chunks of ActiveRecord.
+        def self.included(base)
+          base.class_eval do
+            alias_method_chain :graft, :ransack
+          end
+        end
+
+        def graft_with_ransack(*associations)
+          associations.each do |association|
+            join_associations.detect {|a| association == a} ||
+              build_polymorphic(association.reflection.name, association.find_parent_in(self) || join_base, association.join_type, association.reflection.klass)
+          end
+          self
+        end
+
+        # Should only be called by Ransack, and only with a single association name
+        def build_polymorphic(association, parent = nil, join_type = Arel::OuterJoin, klass = nil)
+          parent ||= joins.last
+          reflection = parent.reflections[association] or
+            raise ::ActiveRecord::ConfigurationError, "Association named '#{ association }' was not found; perhaps you misspelled it?"
+          unless join_association = find_join_association_respecting_polymorphism(reflection, parent, klass)
+            @reflections << reflection
+            join_association = build_join_association_respecting_polymorphism(reflection, parent, klass)
+            join_association.join_type = join_type
+            @joins << join_association
+            cache_joined_association(join_association)
+          end
+
+          join_association
+        end
+
+        def find_join_association_respecting_polymorphism(reflection, parent, klass)
+          if association = find_join_association(reflection, parent)
+            unless reflection.options[:polymorphic]
+              association
+            else
+              association if association.active_record == klass
+            end
+          end
+        end
+
+        def build_join_association_respecting_polymorphism(reflection, parent, klass = nil)
+          if reflection.options[:polymorphic] && klass
+            JoinAssociation.new(reflection, self, parent, klass)
+          else
+            JoinAssociation.new(reflection, self, parent)
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -5,10 +5,27 @@ module Ransack
 
         def self.extended(base)
           alias :search :ransack unless base.method_defined? :search
+          base.instance_eval do
+            class_attribute :_ransackers
+            self._ransackers ||= {}
+          end
         end
 
-        def ransack(params = {})
-          Search.new(self, params)
+        def ransack(params = {}, options = {})
+          Search.new(self, params, options)
+        end
+
+        def ransacker(name, opts = {}, &block)
+          Ransacker.new(self, name, opts, &block)
+        end
+
+        # TODO: Let's actually do some authorization. Whitelist-only.
+        def ransackable_attributes(auth_object)
+          column_names + _ransackers.keys
+        end
+
+        def ransackable_associations(auth_object)
+          reflect_on_all_associations.map {|a| a.name.to_s}
         end
 
       end

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

@@ -8,24 +8,25 @@ module Ransack
         # Because the AR::Associations namespace is insane
         JoinDependency = ::ActiveRecord::Associations::JoinDependency
         JoinPart = JoinDependency::JoinPart
-        JoinAssociation = JoinDependency::JoinAssociation
 
         def evaluate(search, opts = {})
-          relation = @object.where(accept(search.base)).order(accept(search.sorts))
-          opts[:distinct] ? relation.group(@klass.arel_table[@klass.primary_key]) : relation
+          viz = Visitor.new
+          relation = @object.where(viz.accept(search.base)).order(viz.accept(search.sorts))
+          opts[:distinct] ? relation.select("DISTINCT #{@klass.quoted_table_name}.*") : relation
         end
 
         def attribute_method?(str, klass = @klass)
           exists = false
 
-          if column = get_column(str, klass)
+          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
-              if found_assoc = get_association(segments.join('_'), klass)
-                exists = attribute_method?(remainder.join('_'), found_assoc.klass)
+              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
@@ -33,20 +34,10 @@ module Ransack
           exists
         end
 
-        def type_for(attr)
-          return nil unless attr
-          name    = attr.name.to_s
-          table   = attr.relation.table_name
-
-          unless @engine.connection_pool.table_exists?(table)
-            raise "No table named #{table} exists"
-          end
-
-          @engine.connection_pool.columns_hash[table][name].type
+        def table_for(parent)
+          parent.table
         end
 
-        private
-
         def klassify(obj)
           if Class === obj && ::ActiveRecord::Base > obj
             obj
@@ -59,27 +50,47 @@ module Ransack
           end
         end
 
-        def get_attribute(str, parent = @base)
-          attribute = nil
+        def type_for(attr)
+          return nil unless attr
+          name    = attr.name.to_s
+          table   = attr.relation.table_name
+
+          unless @engine.connection_pool.table_exists?(table)
+            raise "No table named #{table} exists"
+          end
+
+          @engine.connection_pool.columns_hash[table][name].type
+        end
+
+        private
 
-          if column = get_column(str, parent)
-            attribute = parent.table[str]
+        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
-              if found_assoc = get_association(segments.join('_'), parent)
-                join = build_or_find_association(found_assoc.name, parent)
-                attribute = get_attribute(remainder.join('_'), join)
+              assoc, klass = unpolymorphize_association(segments.join('_'))
+              if ransackable_association?(assoc, klassify(parent))
+                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
 
-          attribute
+          [parent, attr_name]
+        end
+
+        def ransackable_attribute?(str, klass)
+          klass.ransackable_attributes(auth_object).include? str
         end
 
-        def get_column(str, parent = @base)
-          klassify(parent).columns_hash[str]
+        def ransackable_association?(str, klass)
+          klass.ransackable_associations(auth_object).include? str
         end
 
         def get_association(str, parent = @base)
@@ -87,7 +98,7 @@ module Ransack
         end
 
         def join_dependency(relation)
-          if relation.respond_to?(:join_dependency) # MetaWhere will enable this
+          if relation.respond_to?(:join_dependency) # Squeel will enable this
             relation.join_dependency
           else
             build_join_dependency(relation)
@@ -101,7 +112,7 @@ module Ransack
               'string_join'
             when Hash, Symbol, Array
               'association_join'
-            when ActiveRecord::Associations::JoinDependency::JoinAssociation
+            when ::ActiveRecord::Associations::JoinDependency::JoinAssociation
               'stashed_join'
             when Arel::Nodes::Join
               'join_node'
@@ -132,13 +143,14 @@ module Ransack
           join_dependency.graft(*stashed_association_joins)
         end
 
-        def build_or_find_association(name, parent = @base)
+        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
+            assoc.parent == parent &&
+            (!klass || assoc.klass == klass)
           end
           unless found_association
-            @join_dependency.send(:build, name.to_sym, parent, Arel::Nodes::OuterJoin)
+            @join_dependency.send(:build_polymorphic, name.to_sym, parent, Arel::Nodes::OuterJoin, klass)
             found_association = @join_dependency.join_associations.last
             # Leverage the stashed association functionality in AR
             @object = @object.joins(found_association)