ransack_ffcrm 0.6.0

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.travis.yml

@@ -0,0 +1,9 @@
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - ree
+  - rbx-18mode
+  - ruby-head
+
+env:
+  - RAILS=3-2-stable

data/Gemfile

@@ -0,0 +1,40 @@
+source "http://rubygems.org"
+gemspec
+
+gem 'rake'
+
+rails = ENV['RAILS'] || 'master'
+arel = ENV['AREL'] || 'master'
+
+arel_opts = case arel
+when /\// # A path
+  {:path => arel}
+when /^v/ # A tagged version
+  {:git => 'git://github.com/rails/arel.git', :tag => arel}
+else
+  {:git => 'git://github.com/rails/arel.git', :branch => arel}
+end
+
+gem 'arel', arel_opts
+
+case rails
+when /\// # A path
+  gem 'activesupport', :path => "#{rails}/activesupport"
+  gem 'activemodel', :path => "#{rails}/activemodel"
+  gem 'activerecord', :path => "#{rails}/activerecord"
+  gem 'actionpack', :path => "#{rails}/activerecord"
+when /^v/ # A tagged version
+  git 'git://github.com/rails/rails.git', :tag => rails do
+    gem 'activesupport'
+    gem 'activemodel'
+    gem 'activerecord'
+    gem 'actionpack'
+  end
+else
+  git 'git://github.com/rails/rails.git', :branch => rails do
+    gem 'activesupport'
+    gem 'activemodel'
+    gem 'activerecord'
+    gem 'actionpack'
+  end
+end

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Ernie Miller
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,137 @@
+# Ransack
+
+Ransack is a rewrite of [MetaSearch](http://metautonomo.us/projects/metasearch). While it
+supports many of the same features as MetaSearch, its underlying implementation differs
+greatly from MetaSearch, and _backwards compatibility is not a design goal._
+
+Ransack enables the creation of both simple and [advanced](http://ransack-demo.heroku.com)
+search forms against your application's models. If you're looking for something that
+simplifies query generation at the model or controller layer, you're probably not looking
+for Ransack (or MetaSearch, for that matter). Try 
+[Squeel](http://metautonomo.us/projects/squeel) instead.
+
+## Getting started
+
+In your Gemfile:
+
+    gem "ransack"  # Last officially released gem
+    # gem "ransack", :git => "git://github.com/ernie/ransack.git" # Track git repo
+
+If you'd like to add your own custom Ransack predicates:
+
+    Ransack.configure do |config|
+      config.add_predicate 'equals_diddly', # Name your predicate
+                           # What non-compound ARel predicate will it use? (eq, matches, etc)
+                           :arel_predicate => 'eq',
+                           # Format incoming values as you see fit. (Default: Don't do formatting)
+                           :formatter => proc {|v| "#{v}-diddly"},
+                           # Validate a value. An "invalid" value won't be used in a search.
+                           # Below is default.
+                           :validator => proc {|v| v.present?},
+                           # Should compounds be created? Will use the compound (any/all) version
+                           # of the arel_predicate to create a corresponding any/all version of
+                           # your predicate. (Default: true)
+                           :compounds => true,
+                           # Force a specific column type for type-casting of supplied values.
+                           # (Default: use type from DB column)
+                           :type => :string
+    end
+
+## Usage
+
+Ransack can be used in one of two modes, simple or advanced.
+
+### Simple Mode
+
+This mode works much like MetaSearch, for those of you who are familiar with it, and
+requires very little setup effort.
+
+If you're coming from MetaSearch, things to note:
+
+  1. The default param key for search params is now `:q`, instead of `:search`. This is
+     primarily to shorten query strings, though advanced queries (below) will still 
+     run afoul of URL length limits in most browsers and require a switch to HTTP 
+     POST requests.
+  2. `form_for` is now `search_form_for`, and validates that a Ransack::Search object
+     is passed to it.
+  3. Common ActiveRecord::Relation methods are no longer delegated by the search object.
+     Instead, you will get your search results (an ActiveRecord::Relation in the case of
+     the ActiveRecord adapter) via a call to `Search#result`. If passed `:distinct => true`,
+     `result` will generate a `SELECT DISTINCT` to avoid returning duplicate rows, even if
+     conditions on a join would otherwise result in some.
+     
+     Please note that for many databases, a sort on an associated table's columns will
+     result in invalid SQL with `:distinct => true` -- in those cases, you're on your own,
+     and will need to modify the result as needed to allow these queries to work. Thankfully,
+     9 times out of 10, sort against the search's base is sufficient, though, as that's
+     generally what's being displayed on your results page.
+
+In your controller:
+
+    def index
+      @q = Person.search(params[:q])
+      @people = @q.result(:distinct => true)
+    end
+
+In your view:
+
+    <%= search_form_for @q do |f| %>
+      <%= f.label :name_cont %>
+      <%= f.text_field :name_cont %>
+      <%= f.label :articles_title_start %>
+      <%= f.text_field :articles_title_start %>
+      <%= f.submit %>
+    <% end %>
+
+`cont` (contains) and `start` (starts with) are just two of the available search predicates.
+See Constants for a full list.
+    
+### Advanced Mode
+
+"Advanced" searches (ab)use Rails' nested attributes functionality in order to generate
+complex queries with nested AND/OR groupings, etc. This takes a bit more work but can
+generate some pretty cool search interfaces that put a lot of power in the hands of
+your users. A notable drawback with these searches is that the increased size of the
+parameter string will typically force you to use the HTTP POST method instead of GET. :(
+
+This means you'll need to tweak your routes...
+
+    resources :people do
+      collection do
+        match 'search' => 'people#search', :via => [:get, :post], :as => :search
+      end
+    end
+
+... and add another controller action ...
+
+    def search
+      index
+      render :index
+    end
+    
+... and update your `search_form_for` line in the view ...
+
+    <%= search_form_for @q, :url => search_people_path, 
+                            :html => {:method => :post} do |f| %>
+
+Once you've done so, you can make use of the helpers in Ransack::Helpers::FormBuilder to
+construct much more complex search forms, such as the one on the
+[demo page](http://ransack-demo.heroku.com).
+
+**more docs to come**
+
+## Contributions
+
+If you'd like to support the continued development of Ransack, please consider
+[making a donation](https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=48Q9HY64L3TWA).
+
+To support the project in other ways:
+
+* Use Ransack in your apps, and let me know if you encounter anything that's broken or missing.
+  A failing spec is awesome. A pull request is even better!
+* Spread the word on Twitter, Facebook, and elsewhere if Ransack's been useful to you. The more
+  people who are using the project, the quicker we can find and fix bugs!
+
+## Copyright
+
+Copyright &copy; 2011 [Ernie Miller](http://twitter.com/erniemiller)

data/Rakefile

@@ -0,0 +1,19 @@
+require 'bundler'
+require 'rspec/core/rake_task'
+
+Bundler::GemHelper.install_tasks
+
+RSpec::Core::RakeTask.new(:spec) do |rspec|
+  rspec.rspec_opts = ['--backtrace']
+end
+
+task :default => :spec
+
+desc "Open an irb session with Ransack and the sample data used in specs"
+task :console do
+  require 'irb'
+  require 'irb/completion'
+  require 'console'
+  ARGV.clear
+  IRB.start
+end

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

@@ -0,0 +1,166 @@
+# 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
+
+module Arel
+
+  class Table
+    alias :table_name :name
+
+    def [] name
+      ::Arel::Attribute.new self, name.to_sym
+    end
+  end
+
+  module Nodes
+    class Node
+      def not
+        Nodes::Not.new self
+      end
+    end
+
+    remove_const :And
+    class And < Arel::Nodes::Node
+      attr_reader :children
+
+      def initialize children, right = nil
+        unless Array === children
+          children = [children, right]
+        end
+        @children = children
+      end
+
+      def left
+        children.first
+      end
+
+      def right
+        children[1]
+      end
+    end
+
+    class NamedFunction < Arel::Nodes::Function
+      attr_accessor :name, :distinct
+
+      include Arel::Predications
+
+      def initialize name, expr, aliaz = nil
+        super(expr, aliaz)
+        @name = name
+        @distinct = false
+      end
+    end
+
+    class InfixOperation < Binary
+      include Arel::Expressions
+      include Arel::Predications
+
+      attr_reader :operator
+
+      def initialize operator, left, right
+        super(left, right)
+        @operator = operator
+      end
+    end
+
+    class Multiplication < InfixOperation
+      def initialize left, right
+        super(:*, left, right)
+      end
+    end
+
+    class Division < InfixOperation
+      def initialize left, right
+        super(:/, left, right)
+      end
+    end
+
+    class Addition < InfixOperation
+      def initialize left, right
+        super(:+, left, right)
+      end
+    end
+
+    class Subtraction < InfixOperation
+      def initialize left, right
+        super(:-, left, right)
+      end
+    end
+  end
+
+  module Visitors
+    class ToSql
+      def column_for attr
+        name    = attr.name.to_s
+        table   = attr.relation.table_name
+
+        column_cache[table][name]
+      end
+
+      def column_cache
+        @column_cache ||= Hash.new do |hash, key|
+          hash[key] = Hash[
+            @engine.connection.columns(key, "#{key} Columns").map do |c|
+              [c.name, c]
+            end
+          ]
+        end
+      end
+
+      def visit_Arel_Nodes_InfixOperation o
+        "#{visit o.left} #{o.operator} #{visit o.right}"
+      end
+
+      def visit_Arel_Nodes_NamedFunction o
+        "#{o.name}(#{o.distinct ? 'DISTINCT ' : ''}#{o.expressions.map { |x|
+          visit x
+        }.join(', ')})#{o.alias ? " AS #{visit o.alias}" : ''}"
+      end
+
+      def visit_Arel_Nodes_And o
+        o.children.map { |x| visit x }.join ' AND '
+      end
+
+      def visit_Arel_Nodes_Not o
+        "NOT (#{visit o.expr})"
+      end
+
+      def visit_Arel_Nodes_Values o
+        "VALUES (#{o.expressions.zip(o.columns).map { |value, attr|
+          if Nodes::SqlLiteral === value
+            visit_Arel_Nodes_SqlLiteral value
+          else
+            quote(value, attr && column_for(attr))
+          end
+        }.join ', '})"
+      end
+    end
+  end
+
+  module Predications
+    def as other
+      Nodes::As.new self, Nodes::SqlLiteral.new(other)
+    end
+  end
+
+end

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

@@ -0,0 +1,161 @@
+require 'ransack/context'
+require 'polyamorous'
+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 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?
+          klassify(attr.parent).columns_hash[attr.arel_attribute.name.to_s].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::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.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