ransack_ffcrm 0.6.0

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

@@ -0,0 +1,166 @@
+require 'ransack/context'
+require 'polyamorous'
+
+module Ransack
+  module Adapters
+    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 = Arel::Visitors.visitor_for @engine
+        end
+
+        def evaluate(search, opts = {})
+          viz = Visitor.new
+          relation = @object.where(viz.accept(search.base))
+          if search.sorts.any?
+            relation = relation.except(:order).order(viz.accept(search.sorts))
+          end
+          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 && attr.valid?
+          name    = attr.arel_attribute.name.to_s
+          table   = attr.arel_attribute.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
+
+        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
+
+        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::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.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.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/adapters/active_record/base.rb

@@ -0,0 +1,33 @@
+module Ransack
+  module Adapters
+    module ActiveRecord
+      module Base
+
+        def self.extended(base)
+          alias :search :ransack unless base.method_defined? :search
+          base.class_eval do
+            class_attribute :_ransackers
+            self._ransackers ||= {}
+          end
+        end
+
+        def ransack(params = {}, options = {})
+          Search.new(self, params, options)
+        end
+
+        def ransacker(name, opts = {}, &block)
+          self._ransackers = _ransackers.merge name.to_s => Ransacker.new(self, name, opts, &block)
+        end
+
+        def ransackable_attributes(auth_object = nil)
+          column_names + _ransackers.keys
+        end
+
+        def ransackable_associations(auth_object = nil)
+          reflect_on_all_associations.map {|a| a.name.to_s}
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+require 'ransack/context'
+require 'ransack/adapters/active_record/3.1/context'
+require 'polyamorous'
+
+module Ransack
+  module Adapters
+    module ActiveRecord
+      class Context < ::Ransack::Context
+        
+        # Redefine a few things that have changed with 3.2.
+        
+        def initialize(object, options = {})
+          super
+          @arel_visitor = @engine.connection.visitor
+        end
+        
+        def type_for(attr)
+          return nil unless attr && attr.valid?
+          name    = attr.arel_attribute.name.to_s
+          table   = attr.arel_attribute.relation.table_name
+
+          unless @engine.connection.table_exists?(table)
+            raise "No table named #{table} exists"
+          end
+
+          @engine.connection.schema_cache.columns_hash[table][name].type
+        end
+        
+        def evaluate(search, opts = {})
+          viz = Visitor.new
+          relation = @object.where(viz.accept(search.base))
+          if search.sorts.any?
+            relation = relation.except(:order).order(viz.accept(search.sorts))
+          end
+          opts[:distinct] ? relation.uniq : relation
+        end
+        
+      end
+    end
+  end
+end

data/lib/ransack/adapters/active_record.rb

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

data/lib/ransack/configuration.rb

@@ -0,0 +1,35 @@
+require 'ransack/constants'
+require 'ransack/predicate'
+
+module Ransack
+  module Configuration
+
+    mattr_accessor :predicates
+    self.predicates = {}
+
+    def configure
+      yield self
+    end
+
+    def add_predicate(name, opts = {})
+      name = name.to_s
+      opts[:name] = name
+      compounds = opts.delete(:compounds)
+      compounds = true if compounds.nil?
+      opts[:arel_predicate] = opts[:arel_predicate].to_s
+
+      self.predicates[name] = Predicate.new(opts)
+
+      ['_any', '_all'].each do |suffix|
+        self.predicates[name + suffix] = Predicate.new(
+          opts.merge(
+            :name => name + suffix,
+            :arel_predicate => opts[:arel_predicate] + suffix,
+            :compound => true
+          )
+        )
+      end if compounds
+    end
+
+  end
+end

data/lib/ransack/constants.rb

@@ -0,0 +1,23 @@
+module Ransack
+  module Constants
+    TRUE_VALUES = [true, 1, '1', 't', 'T', 'true', 'TRUE'].to_set
+    FALSE_VALUES = [false, 0, '0', 'f', 'F', 'false', 'FALSE'].to_set
+
+    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| "%#{v}%"}}],
+      ['not_cont', {:arel_predicate => 'does_not_match', :formatter => proc {|v| "%#{v}%"}}],
+      ['start', {:arel_predicate => 'matches', :formatter => proc {|v| "#{v}%"}}],
+      ['not_start', {:arel_predicate => 'does_not_match', :formatter => proc {|v| "#{v}%"}}],
+      ['end', {:arel_predicate => 'matches', :formatter => proc {|v| "%#{v}"}}],
+      ['not_end', {:arel_predicate => 'does_not_match', :formatter => proc {|v| "%#{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}}]
+    ]
+  end
+end

data/lib/ransack/context.rb

@@ -0,0 +1,124 @@
+require 'ransack/visitor'
+
+module Ransack
+  class Context
+    attr_reader :search, :object, :klass, :base, :engine, :arel_visitor
+    attr_accessor :auth_object
+
+    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}"
+      end
+
+      def for_class(klass, options = {})
+        if klass < ActiveRecord::Base
+          Adapters::ActiveRecord::Context.new(klass, options)
+        end
+      end
+
+      def for_object(object, options = {})
+        case object
+        when ActiveRecord::Relation
+          Adapters::ActiveRecord::Context.new(object.klass, options)
+        end
+      end
+
+    end
+
+    def initialize(object, options = {})
+      @object = object.scoped
+      @klass = @object.klass
+      @join_dependency = join_dependency(@object)
+      @join_type = options[:join_type] || Arel::OuterJoin
+      @base = @join_dependency.join_base
+      @engine = @base.arel_engine
+      @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
+          hash[key] = [parent, attr_name]
+        end
+      end
+    end
+
+    # Convert a string representing a chain of associations and an attribute
+    # into the attribute itself
+    def contextualize(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)
+      str ||= ''
+
+      if (segments = str.split(/_/)).size > 0
+        remainder = []
+        found_assoc = nil
+        while !found_assoc && segments.size > 0 do
+          # Strip the _of_Model_type text from the association name, but hold
+          # onto it in klass, for use as the next base
+          assoc, klass = unpolymorphize_association(segments.join('_'))
+          if found_assoc = get_association(assoc, base)
+            base = traverse(remainder.join('_'), klass || found_assoc.klass)
+          end
+
+          remainder.unshift segments.pop
+        end
+        raise UntraversableAssociationError, "No association matches #{str}" unless found_assoc
+      end
+
+      klassify(base)
+    end
+
+    def association_path(str, base = @base)
+      base = klassify(base)
+      str ||= ''
+      path = []
+      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('_'))
+          if found_assoc = get_association(assoc, base)
+            path += association_parts
+            association_parts = []
+            base = klassify(klass || found_assoc)
+          end
+        end
+      end
+
+      path.join('_')
+    end
+
+    def unpolymorphize_association(str)
+      if (match = str.match(/_of_([^_]+?)_type$/))
+        [match.pre_match, Kernel.const_get(match.captures.first)]
+      else
+        [str, nil]
+      end
+    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 searchable_attributes(str = '')
+      traverse(str).ransackable_attributes(auth_object)
+    end
+
+    def searchable_associations(str = '')
+      traverse(str).ransackable_associations(auth_object)
+    end
+
+  end
+end

data/lib/ransack/helpers/form_builder.rb

@@ -0,0 +1,203 @@
+require 'action_view'
+
+module Ransack
+  module Helpers
+    class FormBuilder < ::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
+        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)
+        bases = [''] + association_array(options[:associations])
+        if bases.size > 1
+          @template.grouped_collection_select(
+            @object_name, :name, attribute_collection_for_bases(bases), :last, :first, :first, :last,
+            objectify_options(options), @default_options.merge(html_options)
+          )
+        else
+          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)
+            ]
+          end
+          @template.collection_select(
+            @object_name, :name, collection, :first, :last,
+            objectify_options(options), @default_options.merge(html_options)
+          )
+        end
+      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, 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 = 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)
+            ]
+          end
+          @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
+      end
+
+      def sort_fields(*args, &block)
+        search_fields(:s, args, block)
+      end
+
+      def sort_link(attribute, *args)
+        @template.sort_link @object, attribute, *args
+      end
+
+      def condition_fields(*args, &block)
+        search_fields(:c, args, block)
+      end
+
+      def grouping_fields(*args, &block)
+        search_fields(:g, args, block)
+      end
+
+      def attribute_fields(*args, &block)
+        search_fields(:a, args, block)
+      end
+
+      def predicate_fields(*args, &block)
+        search_fields(:p, args, block)
+      end
+
+      def value_fields(*args, &block)
+        search_fields(:v, args, block)
+      end
+
+      def search_fields(name, args, block)
+        args << {} unless args.last.is_a?(Hash)
+        args.last[:builder] ||= options[:builder]
+        args.last[:parent_builder] = self
+        options = args.extract_options!
+        objects = args.shift
+        objects ||= @object.send(name)
+        objects = [objects] unless Array === objects
+        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)
+        end
+        output
+      end
+
+      def predicate_select(options = {}, html_options = {})
+        options[:compounds] = true if options[:compounds].nil?
+        keys = predicate_keys(options)
+        # If condition is newly built with build_condition(),
+        # then replace the default predicate with the first in the ordered list
+        @object.predicate_name = keys.first if @object.default?
+        @template.collection_select(
+          @object_name, :p, keys.map {|k| [k, Translate.predicate(k)]}, :first, :last,
+          objectify_options(options), @default_options.merge(html_options)
+        )
+      end
+
+      def combinator_select(options = {}, html_options = {})
+        @template.collection_select(
+          @object_name, :m, combinator_choices, :first, :last,
+          objectify_options(options), @default_options.merge(html_options)
+        )
+      end
+
+      private
+
+      def predicate_keys(options)
+        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)}
+          else
+            only = Array.wrap(only).map(&:to_s)
+            # Create compounds hash, e.g. {"eq" => ["eq", "eq_any", "eq_all"], "blank" => ["blank"]}
+            key_groups = keys.inject(Hash.new([])){ |h,k| h[k.sub(/_(any|all)$/, '')] += [k]; h }
+            # Order compounds hash by 'only' keys
+            keys = only.map {|k| key_groups[k] }.flatten.compact
+          end
+        end
+        keys
+      end
+
+      def combinator_choices
+        if Nodes::Condition === object
+          [['or', Translate.word(:any)], ['and', Translate.word(:all)]]
+        else
+          [['and', Translate.word(:all)], ['or', Translate.word(:any)]]
+        end
+      end
+
+      def association_array(obj, prefix = nil)
+        ([prefix] + 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
+        else
+          [obj]
+        end).compact.flatten.map {|v| [prefix, v].compact.join('_')}
+      end
+
+      def attr_from_base_and_column(base, column)
+        [base, column].reject {|v| v.blank?}.join('_')
+      end
+
+      def attribute_collection_for_bases(bases)
+        bases.map do |base|
+          begin
+          [
+            Translate.association(base, :context => object.context),
+            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)
+              ]
+            end
+          ]
+          rescue UntraversableAssociationError => e
+            nil
+          end
+        end.compact
+      end
+
+    end
+  end
+end