ransack 0.7.2 → 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ae3f27c548f10f431a0d5c13b3a9863d7e707e73
+  data.tar.gz: 83840f65158cb74f04e8bd5e0b63d1251bcd3272
+SHA512:
+  metadata.gz: 1883d781609fbae07044a265169f8960c4416e2836d3c332ad66ffb2ec8a4427bd8f3114d7539bb62f7ed0d132478004751763bb51d96e782b6ca904f0d82f88
+  data.tar.gz: 8a817a0a03b09622c527a63c24502d3c9da37c46096ccf376a2577cf05d54c6302c9ba13e866dc2789f79e588c2b262a5e799760a15dfeae0c9339da6d016f8a

data/.travis.yml

@@ -1,9 +1,16 @@
 rvm:
   - 1.8.7
   - 1.9.2
-  - ree
-  - rbx-18mode
-  - ruby-head
+  - 1.9.3
+  - 2.0.0
 
 env:
+  - RAILS=4-0-stable
   - RAILS=3-2-stable
+  - RAILS=3-1-stable
+  - RAILS=3-0-stable
+
+matrix:
+  exclude:
+    - rvm: 1.8.7
+      env: RAILS=4-0-stable

data/CONTRIBUTING.md

@@ -24,8 +24,7 @@ Here's a quick guide:
 to know that you have a clean slate:
 
         $ bundle install
-        $ bundle exec rake test_app
-        $ bundle exec rake
+        $ bundle exec rake spec
 
 3. Add a test for your change. Only refactoring and documentation changes
 require no new tests. If you are adding functionality or fixing a bug, we need

data/Gemfile

@@ -1,11 +1,11 @@
-source "http://rubygems.org"
+source "https://rubygems.org"
 gemspec
 
 gem 'rake'
 
-rails = ENV['RAILS'] || '3-2-stable'
+rails = ENV['RAILS'] || '4-0-stable'
 
-gem 'arel', '3.0.2'
+gem 'arel'
 
 case rails
 when /\// # A path

data/README.md

@@ -1,6 +1,8 @@
 # Ransack
 
-Ransack is a rewrite of [MetaSearch](http://metautonomo.us/projects/metasearch). While it
+[![Build Status](https://travis-ci.org/ernie/ransack.png?branch=master)](https://travis-ci.org/ernie/ransack)
+
+Ransack is a rewrite of [MetaSearch](https://github.com/ernie/meta_search). 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._
 
@@ -8,18 +10,21 @@ Ransack enables the creation of both simple and [advanced](http://ransack-demo.h
 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.
+[Squeel](https://github.com/ernie/squeel) instead.
 
 ## Getting started
 
 In your Gemfile:
 
-    gem "ransack"  # Last officially released gem
+```ruby
+gem "ransack"  # Last officially released gem (Rails 3 and 4)
+```
 
 Or if you want to use the bleeding edge:
 
-    gem "ransack", :git => "git://github.com/ernie/ransack.git" # Track git repo
-
+```ruby
+gem "ransack", github: "ernie/ransack"  # Track git repo
+```
 
 ## Usage
 
@@ -41,32 +46,36 @@ If you're coming from MetaSearch, things to note:
      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`,
+     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,
+     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
+```ruby
+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 %>
+```erb
+<%= 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](https://github.com/ernie/ransack/blob/master/lib/ransack/constants.rb) for a full list and the [wiki](https://github.com/ernie/ransack/wiki/Basic-Searching) for more description.
@@ -81,23 +90,29 @@ parameter string will typically force you to use the HTTP POST method instead of
 
 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
+```ruby
+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
+```ruby
+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| %>
+```erb
+<%= 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
@@ -109,48 +124,54 @@ You can easily use Ransack to search in associated objects.
 
 Given you have these associations ...
 
-    class Employee < ActiveRecord::Base
-      belongs_to :supervisor
+```ruby
+class Employee < ActiveRecord::Base
+  belongs_to :supervisor
 
-      # has attribute last_name:string
-    end
+  # has attribute last_name:string
+end
 
-    class Department < ActiveRecord::Base
-      has_many :supervisors
+class Department < ActiveRecord::Base
+  has_many :supervisors
 
-      # has attribute title:string
-    end
+  # has attribute title:string
+end
 
-    class Supervisor < ActiveRecord::Base
-      belongs_to :department
-      has_many :employees
+class Supervisor < ActiveRecord::Base
+  belongs_to :department
+  has_many :employees
 
-      # has attribute last_name:string
-    end
+  # has attribute last_name:string
+end
+```
 
 ... and a controller ...
 
-    class SupervisorsController < ApplicationController
-      def index
-        @search = Supervisor.search(params[:q])
-        @supervisors = @search.result(:distinct => true)
-      end
-    end
+```ruby
+class SupervisorsController < ApplicationController
+  def index
+    @search = Supervisor.search(params[:q])
+    @supervisors = @search.result(distinct: true)
+  end
+end
+```
 
 ... you might set up your form like this ...
 
-    <%= search_form_for @search do |f| %>
-      <%= f.label :last_name_cont %>
-      <%= f.text_field :last_name_cont %>
+```erb
+<%= search_form_for @search do |f| %>
+  <%= f.label :last_name_cont %>
+  <%= f.text_field :last_name_cont %>
 
-      <%= f.label :department_title_cont %>
-      <%= f.text_field :department_title_cont %>
+  <%= f.label :department_title_cont %>
+  <%= f.text_field :department_title_cont %>
 
-      <%= f.label :employees_last_name_cont %>
-      <%= f.text_field :employees_last_name_cont %>
+  <%= f.label :employees_last_name_cont %>
+  <%= f.text_field :employees_last_name_cont %>
 
-      <%= f.submit "search" %>
-    <% end %>
+  <%= f.submit "search" %>
+<% end %>
+```
 
 
 ## Contributions

data/lib/ransack/adapters/active_record.rb

@@ -7,6 +7,8 @@ when /^3\.0\./
   require 'ransack/adapters/active_record/3.0/context'
 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/context.rb

@@ -10,17 +10,23 @@ module Ransack
         # Because the AR::Associations namespace is insane
         JoinDependency = ::ActiveRecord::Associations::ClassMethods::JoinDependency
         JoinBase = JoinDependency::JoinBase
-        
+
+        # Redefine a few things for ActiveRecord 3.0.
+
         def initialize(object, options = {})
           super
           @arel_visitor = Arel::Visitors.visitor_for @engine
         end
 
+        def relation_for(object)
+          object.scoped
+        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))
+            relation = relation.except(:order).reorder(viz.accept(search.sorts))
           end
           opts[:distinct] ? relation.select("DISTINCT #{@klass.quoted_table_name}.*") : relation
         end
@@ -48,18 +54,6 @@ module Ransack
           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
@@ -158,4 +152,4 @@ module Ransack
       end
     end
   end
-end
+end

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

@@ -1,4 +1,5 @@
 require 'ransack/context'
+require 'ransack/adapters/active_record/compat'
 require 'polyamorous'
 
 module Ransack
@@ -8,17 +9,23 @@ module Ransack
         # Because the AR::Associations namespace is insane
         JoinDependency = ::ActiveRecord::Associations::JoinDependency
         JoinPart = JoinDependency::JoinPart
-        
+
+        # Redefine a few things for ActiveRecord 3.1.
+
         def initialize(object, options = {})
           super
           @arel_visitor = Arel::Visitors.visitor_for @engine
         end
 
+        def relation_for(object)
+          object.scoped
+        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))
+            relation = relation.except(:order).reorder(viz.accept(search.sorts))
           end
           opts[:distinct] ? relation.select("DISTINCT #{@klass.quoted_table_name}.*") : relation
         end
@@ -46,18 +53,6 @@ module Ransack
           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

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

@@ -0,0 +1,44 @@
+require 'ransack/context'
+require 'ransack/adapters/active_record/3.1/context'
+require 'ransack/adapters/active_record/compat'
+require 'polyamorous'
+
+module Ransack
+  module Adapters
+    module ActiveRecord
+      class Context < ::Ransack::Context
+
+        # Redefine a few things for ActiveRecord 3.2.
+
+        def initialize(object, options = {})
+          super
+          @arel_visitor = @engine.connection.visitor
+        end
+
+        def relation_for(object)
+          object.scoped
+        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
+
+          schema_cache = @engine.connection.schema_cache
+          raise "No table named #{table} exists" unless schema_cache.table_exists?(table)
+          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).reorder(viz.accept(search.sorts))
+          end
+          opts[:distinct] ? relation.uniq : relation
+        end
+
+      end
+    end
+  end
+end

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

@@ -1,5 +1,5 @@
 require 'ransack/context'
-require 'ransack/adapters/active_record/3.1/context'
+require 'ransack/adapters/active_record/3.2/context'
 require 'ransack/adapters/active_record/compat'
 require 'polyamorous'
 
@@ -8,33 +8,35 @@ module Ransack
     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 relation_for(object)
+          object.all
+        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
 
-          schema_cache = @engine.connection.schema_cache    
-          raise "No table named #{table} exists" unless schema_cache.table_exists?(table)  
-          schema_cache.columns_hash[table][name].type
+          schema_cache = @engine.connection.schema_cache
+          raise "No table named #{table} exists" unless schema_cache.table_exists?(table)
+          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))
+            relation = relation.except(:order).reorder(viz.accept(search.sorts))
           end
-          opts[:distinct] ? relation.uniq : relation
+          opts[:distinct] ? relation.distinct : relation
         end
 
       end
     end
   end
-end
+end