ransack 0.1.0 → 0.2.0

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

@@ -0,0 +1,44 @@
+require 'active_record'
+
+module Ransack
+  module Adapters
+    module ActiveRecord
+      class JoinAssociation < ::ActiveRecord::Associations::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/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 ||= join_parts.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
+            @join_parts << 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/context.rb

@@ -1,6 +1,9 @@
+require 'ransack/visitor'
+
 module Ransack
   class Context
     attr_reader :search, :object, :klass, :base, :engine, :arel_visitor
+    attr_accessor :auth_object
 
     class << self
 
@@ -36,9 +39,10 @@ module Ransack
       @engine = @base.arel_engine
       @arel_visitor = Arel::Visitors.visitor_for @engine
       @default_table = Arel::Table.new(@base.table_name, :as => @base.aliased_table_name, :engine => @engine)
-      @attributes = Hash.new do |hash, key|
-        if attribute = get_attribute(key.to_s)
-          hash[key] = attribute
+      @bind_pairs = Hash.new do |hash, key|
+        parent, attr_name = get_parent_and_attribute_name(key.to_s)
+        if parent && attr_name
+          hash[key] = [parent, attr_name]
         end
       end
     end
@@ -46,7 +50,12 @@ module Ransack
     # Convert a string representing a chain of associations and an attribute
     # into the attribute itself
     def contextualize(str)
-      @attributes[str]
+      parent, attr_name = @bind_pairs[str]
+      table_for(parent)[attr_name]
+    end
+
+    def bind(object, str)
+      object.parent, object.attr_name = @bind_pairs[str]
     end
 
     def traverse(str, base = @base)
@@ -56,8 +65,9 @@ module Ransack
         association_parts = []
         found_assoc = nil
         while !found_assoc && segments.size > 0 && association_parts << segments.shift do
-          if found_assoc = get_association(association_parts.join('_'), base)
-            base = traverse(segments.join('_'), found_assoc.klass)
+          assoc, klass = unpolymorphize_association(association_parts.join('_'))
+          if found_assoc = get_association(assoc, base)
+            base = traverse(segments.join('_'), klass || found_assoc.klass)
           end
         end
         raise ArgumentError, "No association matches #{str}" unless found_assoc
@@ -74,10 +84,11 @@ module Ransack
       association_parts = []
       if (segments = str.split(/_/)).size > 0
         while segments.size > 0 && !base.columns_hash[segments.join('_')] && association_parts << segments.shift do
-          if found_assoc = get_association(association_parts.join('_'), base)
+          assoc, klass = unpolymorphize_association(association_parts.join('_'))
+          if found_assoc = get_association(assoc, base)
             path += association_parts
             association_parts = []
-            base = klassify(found_assoc)
+            base = klassify(klass || found_assoc)
           end
         end
       end
@@ -85,67 +96,16 @@ module Ransack
       path.join('_')
     end
 
-    def searchable_columns(str = '')
-      traverse(str).column_names
-    end
-
-    def accept(object)
-      visit(object)
-    end
-
-    def can_accept?(object)
-      respond_to? DISPATCH[object.class]
-    end
-
-    def visit_Array(object)
-      object.map {|o| accept(o)}.compact
-    end
-
-    def visit_Ransack_Nodes_Condition(object)
-      object.apply_predicate if object.valid?
-    end
-
-    def visit_Ransack_Nodes_And(object)
-      nodes = object.values.map {|o| accept(o)}.compact
-      return nil unless nodes.size > 0
-
-      if nodes.size > 1
-        Arel::Nodes::Grouping.new(Arel::Nodes::And.new(nodes))
+    def unpolymorphize_association(str)
+      if (match = str.match(/_of_(.+?)_type$/)) && Kernel.const_defined?(match.captures.first)
+        [match.pre_match, Kernel.const_get(match.captures.first)]
       else
-        nodes.first
+        [str, nil]
       end
     end
 
-    def visit_Ransack_Nodes_Sort(object)
-      object.attr.send(object.dir) if object.valid?
-    end
-
-    def visit_Ransack_Nodes_Or(object)
-      nodes = object.values.map {|o| accept(o)}.compact
-      return nil unless nodes.size > 0
-
-      if nodes.size > 1
-        nodes.inject(&:or)
-      else
-        nodes.first
-      end
-    end
-
-    def quoted?(object)
-      case object
-      when Arel::Nodes::SqlLiteral, Bignum, Fixnum
-        false
-      else
-        true
-      end
-    end
-
-    def visit(object)
-      send(DISPATCH[object.class], object)
-    end
-
-    DISPATCH = Hash.new do |hash, klass|
-      hash[klass] = "visit_#{klass.name.gsub('::', '_')}"
+    def searchable_attributes(str = '')
+      traverse(str).ransackable_attributes(auth_object)
     end
 
   end

data/lib/ransack/helpers/form_builder.rb

@@ -11,6 +11,12 @@ module Ransack
         super(method, text, options, &block)
       end
 
+      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)
         options[:include_blank] = true unless options.has_key?(:include_blank)
@@ -19,7 +25,7 @@ module Ransack
           collection = bases.map do |base|
             [
               Translate.association(base, :context => object.context),
-              object.context.searchable_columns(base).map do |c|
+              object.context.searchable_attributes(base).map do |c|
                 [
                   attr_from_base_and_column(base, c),
                   Translate.attribute(attr_from_base_and_column(base, c), :context => object.context)
@@ -32,7 +38,7 @@ module Ransack
             objectify_options(options), @default_options.merge(html_options)
           )
         else
-          collection = object.context.searchable_columns(bases.first).map do |c|
+          collection = object.context.searchable_attributes(bases.first).map do |c|
             [
               attr_from_base_and_column(bases.first, c),
               Translate.attribute(attr_from_base_and_column(bases.first, c), :context => object.context)
@@ -53,7 +59,7 @@ module Ransack
           collection = bases.map do |base|
             [
               Translate.association(base, :context => object.context),
-              object.context.searchable_columns(base).map do |c|
+              object.context.searchable_attributes(base).map do |c|
                 [
                   attr_from_base_and_column(base, c),
                   Translate.attribute(attr_from_base_and_column(base, c), :context => object.context)
@@ -69,7 +75,7 @@ module Ransack
             objectify_options(options), @default_options.merge(html_options)
           )
         else
-          collection = object.context.searchable_columns(bases.first).map do |c|
+          collection = object.context.searchable_attributes(bases.first).map do |c|
             [
               attr_from_base_and_column(bases.first, c),
               Translate.attribute(attr_from_base_and_column(bases.first, c), :context => object.context)

data/lib/ransack/helpers/form_helper.rb

@@ -16,6 +16,7 @@ module Ransack
           :id => options[:as] ? "#{options[:as]}_search" : "#{search.klass.to_s.underscore}_search",
           :method => :get
         }
+        options[:as] ||= 'q'
         options[:html].reverse_merge!(html_options)
         options[:builder] ||= FormBuilder
 

data/lib/ransack/locale/en.yml

@@ -1,5 +1,6 @@
 en:
   ransack:
+    search: "search"
     predicate: "predicate"
     and: "and"
     or: "or"

data/lib/ransack/nodes.rb

@@ -1,3 +1,4 @@
+require 'ransack/nodes/bindable'
 require 'ransack/nodes/node'
 require 'ransack/nodes/attribute'
 require 'ransack/nodes/value'

data/lib/ransack/nodes/attribute.rb

@@ -1,8 +1,12 @@
 module Ransack
   module Nodes
     class Attribute < Node
-      attr_reader :name, :attr
-      delegate :blank?, :==, :to => :name
+      include Bindable
+
+      attr_reader :name
+
+      delegate :blank?, :present?, :==, :to => :name
+      delegate :engine, :to => :context
 
       def initialize(context, name = nil)
         super(context)
@@ -11,11 +15,23 @@ module Ransack
 
       def name=(name)
         @name = name
-        @attr = contextualize(name) unless name.blank?
+        context.bind(self, name) unless name.blank?
       end
 
       def valid?
-        @attr
+        bound? && attr
+      end
+
+      def type
+        if ransacker
+          return ransacker.type
+        else
+          context.type_for(attr)
+        end
+      end
+
+      def cast_value(value)
+        value.cast_to_type(type)
       end
 
       def eql?(other)
@@ -31,6 +47,7 @@ module Ransack
       def persisted?
         false
       end
+
     end
   end
 end

data/lib/ransack/nodes/bindable.rb

@@ -0,0 +1,29 @@
+module Ransack
+  module Nodes
+    module Bindable
+
+      attr_accessor :parent, :attr_name
+
+      def attr
+        @attr ||= ransacker ? ransacker.attr_from(self) : context.table_for(parent)[attr_name]
+      end
+
+      def ransacker
+        klass._ransackers[attr_name]
+      end
+
+      def klass
+        @klass ||= context.klassify(parent)
+      end
+
+      def bound?
+        attr_name.present? && parent.present?
+      end
+
+      def reset_binding!
+        @parent = @attr_name = @attr = @klass = nil
+      end
+
+    end
+  end
+end

data/lib/ransack/nodes/condition.rb

@@ -4,6 +4,8 @@ module Ransack
       i18n_word :attribute, :predicate, :combinator, :value
       i18n_alias :a => :attribute, :p => :predicate, :m => :combinator, :v => :value
 
+      delegate :cast_value, :to => :first_attribute
+
       attr_reader :predicate
 
       class << self
@@ -42,6 +44,10 @@ module Ransack
         values.size <= 1 || predicate.compound || %w(in not_in).include?(predicate.name)
       end
 
+      def first_attribute
+        attributes.first
+      end
+
       def attributes
         @attributes ||= []
       end
@@ -74,12 +80,12 @@ module Ransack
         case args
         when Array
           args.each do |val|
-            val = Value.new(@context, val, current_type)
+            val = Value.new(@context, val)
             self.values << val
           end
         when Hash
           args.each do |index, attrs|
-            val = Value.new(@context, attrs[:value], current_type)
+            val = Value.new(@context, attrs[:value])
             self.values << val
           end
         else
@@ -105,13 +111,13 @@ module Ransack
       end
 
       def build_value(val = nil)
-        Value.new(@context, val, current_type).tap do |value|
+        Value.new(@context, val).tap do |value|
           self.values << value
         end
       end
 
       def value
-        predicate.compound ? values.map(&:value) : values.first.value
+        predicate.compound ? values.map {|v| cast_value(v)} : cast_value(values.first)
       end
 
       def build(params)
@@ -121,8 +127,6 @@ module Ransack
           end
         end
 
-        set_value_types!
-
         self
       end
 
@@ -162,48 +166,46 @@ module Ransack
       end
       alias :p :predicate_name
 
-      def apply_predicate
-        attributes = arel_attributes.compact
+      def arel_predicate
+        predicates = attributes.map do |attr|
+          attr.attr.send(predicate.arel_predicate, formatted_values_for_attribute(attr))
+        end
 
-        if attributes.size > 1
+        if predicates.size > 1
           case combinator
           when 'and'
-            Arel::Nodes::Grouping.new(Arel::Nodes::And.new(
-              attributes.map {|a| a.send(predicate.arel_predicate, predicate.format(values))}
-            ))
+            Arel::Nodes::Grouping.new(Arel::Nodes::And.new(predicates))
           when 'or'
-            attributes.inject(attributes.shift.send(predicate.arel_predicate, predicate.format(values))) do |memo, a|
-              memo.or(a.send(predicate.arel_predicate, predicate.format(values)))
-            end
+            predicates.inject(&:or)
           end
         else
-          attributes.first.send(predicate.arel_predicate, predicate.format(values))
+          predicates.first
         end
       end
 
-      private
+      def validated_values
+        values.select {|v| predicate.validator ? predicate.validator.call(v.value) : v.present?}
+      end
 
-      def set_value_types!
-        self.values.each {|v| v.type = current_type}
+      def casted_values_for_attribute(attr)
+        validated_values.map {|v| v.cast_to_type(predicate.type || attr.type)}
       end
 
-      def current_type
-        if predicate && predicate.type
-          predicate.type
-        elsif attributes.size > 0
-          @context.type_for(attributes.first.attr)
+      def formatted_values_for_attribute(attr)
+        casted_values_for_attribute(attr).map do |val|
+          val = attr.ransacker.formatter.call(val) if attr.ransacker && attr.ransacker.formatter
+          val = predicate.formatter.call(val) if predicate.formatter
+          val
         end
       end
 
+      private
+
       def valid_combinator?
         attributes.size < 2 ||
         ['and', 'or'].include?(combinator)
       end
 
-      def arel_attributes
-        attributes.map(&:attr)
-      end
-
     end
   end
 end