ransack_abbreviator 0.0.1

data/lib/ransack_abbreviator.rb

@@ -0,0 +1,28 @@
+require "ostruct"
+require "yaml"
+require 'ransack_abbreviator/configuration'
+require 'ransack_abbreviator/constants'
+
+module RansackAbbreviator
+  extend Configuration
+  
+  class DuplicateColumnAbbreviation < StandardError; end;
+end
+
+RansackAbbreviator.configure do |config|
+  parsed_config = OpenStruct.new((YAML.load_file(config.config_dir.join("ransack_abbreviator.yml")) rescue {}))
+  ransack_abbreviations = parsed_config.ransack_abbreviations
+  if !(ransack_abbreviations["columns"].values & RansackAbbreviator::Constants::RESERVED_KEYWORDS).blank? ||
+    !(ransack_abbreviations["associations"].values & RansackAbbreviator::Constants::RESERVED_KEYWORDS).blank?
+    fail "You used a reserved keyword as an abbreviation. Reserverd keywords: #{RansackAbbreviator::Constants::RESERVED_KEYWORDS.join(", ")}"
+  end
+  config.column_abbreviations = ransack_abbreviations["columns"] if ransack_abbreviations["columns"]
+  config.assoc_abbreviations = ransack_abbreviations["associations"] if ransack_abbreviations["associations"]
+end
+
+require "ransack_abbreviator/ransack_extensions/nodes/condition"
+require "ransack_abbreviator/ransack_extensions/nodes/grouping"
+require "ransack_abbreviator/ransack_extensions/context"
+require "ransack_abbreviator/ransack_extensions/search"
+require 'ransack_abbreviator/adapters/active_record'
+require "ransack_abbreviator/view_helpers"

data/ransack_abbreviator.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "ransack_abbreviator/version"
+
+Gem::Specification.new do |s|
+  s.name        = "ransack_abbreviator"
+  s.version     = RansackAbbreviator::VERSION
+  s.authors     = ["Jamie Davidson"]
+  s.email       = ["jhdavids8@gmail.com"]
+  s.homepage    = "https://github.com/jhdavids8/ransack-abbreviator"
+  s.summary     = "Avoid POSTs. Abbreviate those Ransack queries."
+  s.description = "Avoid POSTs. Abbreviate those Ransack queries."
+
+  s.rubyforge_project = "ransack_abbreviator"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency 'ransack', '~> 0.7'
+  s.add_development_dependency "pry"
+  s.add_development_dependency 'rspec', '~> 2.8.0'
+  s.add_development_dependency 'machinist', '~> 1.0.6'
+  s.add_development_dependency 'faker', '~> 0.9.5'
+  s.add_development_dependency 'sqlite3', '~> 1.3.3'
+end

data/spec/blueprints/articles.rb

@@ -0,0 +1,5 @@
+Article.blueprint do
+  person
+  title
+  body
+end

data/spec/blueprints/comments.rb

@@ -0,0 +1,5 @@
+Comment.blueprint do
+  article
+  person
+  body
+end

data/spec/blueprints/notes.rb

@@ -0,0 +1,3 @@
+Note.blueprint do
+  note
+end

data/spec/blueprints/people.rb

@@ -0,0 +1,5 @@
+Person.blueprint do
+  name
+  middle_name
+  salary
+end

data/spec/blueprints/tags.rb

@@ -0,0 +1,3 @@
+Tag.blueprint do
+  name    { Sham.tag_name }
+end

data/spec/ransack_abbreviator/adapters/active_record/base_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+module RansackAbbreviator
+  module Adapters
+    module ActiveRecord
+      describe Base do
+        subject { ::ActiveRecord::Base }
+        
+        describe '#ransackable_column_abbreviations' do
+          subject { Person.ransackable_column_abbreviations }
+
+          it { should include 'name' => 'nm' }
+          it { should include 'middle_name' => 'mn' }
+        end
+
+        describe '#ransackable_assoc_abbreviations' do
+          subject { Person.ransackable_assoc_abbreviations }
+
+          it { should include 'children' => 'ch' }
+          it { should include 'parent' => 'pa' }
+        end
+
+        describe '#ransackable_column_name_for' do
+          context 'when a defined abbreviation' do
+            it "returns the full column name" do
+              Person.ransackable_column_name_for("nm").should eq "name"
+              Person.ransackable_column_name_for("mn").should eq "middle_name"
+            end
+          end
+          
+          context 'when an undefined abbreviation' do
+            it "returns nil" do
+              Person.ransackable_column_name_for("you_fake").should be_nil
+            end
+          end
+        end
+        
+        describe '#ransackable_column_abbr_for' do
+          context 'when a defined column' do
+            it "returns the abbreviation" do
+              Person.ransackable_column_abbr_for("name").should eq "nm"
+              Person.ransackable_column_abbr_for("middle_name").should eq "mn"
+            end
+          end
+          
+          context 'when an undefined column' do
+            it "returns the passed-in column" do
+              Person.ransackable_column_abbr_for("you_fake").should eq "you_fake"
+            end
+          end
+        end
+        
+        describe '#ransackable_assoc_name_for' do
+          context 'when a defined abbreviation' do
+            it "returns the full association name" do
+              Person.ransackable_assoc_name_for("ch").should eq "children"
+              Person.ransackable_assoc_name_for("pa").should eq "parent"
+            end
+          end
+          
+          context 'when an undefined abbreviation' do
+            it "returns nil" do
+              Person.ransackable_assoc_name_for("you_fake").should be_nil
+            end
+          end
+        end
+        
+        describe '#ransackable_assoc_abbr_for' do
+          context 'when a defined association' do
+            it "returns the abbreviation" do
+              Person.ransackable_assoc_abbr_for("children").should eq "ch"
+              Person.ransackable_assoc_abbr_for("parent").should eq "pa"
+            end
+          end
+          
+          context 'when an undefined association' do
+            it "returns the passed-in association" do
+              Person.ransackable_assoc_abbr_for("you_fake").should eq "you_fake"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/ransack_abbreviator/configuration_spec.rb

@@ -0,0 +1,14 @@
+require "spec_helper"
+
+module RansackAbbreviator
+  describe Configuration do
+    context "parsing a config.yml" do
+      it "initializes the abbreviations" do
+        RansackAbbreviator.column_abbreviations.should_not be_blank
+        RansackAbbreviator.column_abbreviations["name"].should == "nm"
+        RansackAbbreviator.assoc_abbreviations.should_not be_blank
+        RansackAbbreviator.assoc_abbreviations[:authored_article_comments].should == "a_ac"
+      end
+    end
+  end
+end

data/spec/ransack_abbreviator/helper_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+module RansackAbbreviator
+  module ViewHelpers
+    describe "#ransack_abbreviation_for" do
+      context "a lookup of a defined column" do
+        it "returns an abbreviated column name" do
+          search = Ransack::Search.new(Person)
+          ransack_abbreviation_for(search, :name_eq).should == "nm_eq"
+          ransack_abbreviation_for(search, :middle_name_eq).should == "mn_eq"          
+        end
+      end
+      
+      context "a lookup of an undefined column" do
+        it "returns the full column name" do
+          search = Ransack::Search.new(Person)
+          ransack_abbreviation_for(search, :salary_eq).should == "salary_eq"
+        end
+      end
+      
+      context "a lookup of a defined association" do
+        context "a lookup of a defined column" do
+          it "returns an abbreviated assoc & column pair" do
+            search = Ransack::Search.new(Article)
+            ransack_abbreviation_for(search, :person_name_eq).should == "pr.nm_eq"
+            ransack_abbreviation_for(search, :person_middle_name_eq).should == "pr.mn_eq"
+            search = Ransack::Search.new(Person)
+            ransack_abbreviation_for(search, :authored_article_comments_vote_count_lteq).should == "a_ac.vc_lteq"
+          end
+        end
+        
+        context "a lookup of an undefined column" do
+          it "returns an abbreviated table but full column" do
+            search = Ransack::Search.new(Article)
+            ransack_abbreviation_for(search, :person_salary_eq).should == "pr.salary_eq"
+          end
+        end
+      end
+      
+      context "a lookup of an undefined association" do
+        context "a lookup of a defined column" do
+          it "returns the full association but abbreviated column" do
+            search = Ransack::Search.new(Person)
+            ransack_abbreviation_for(search, :articles_title_cont).should == "articles.tl_cont"
+          end
+        end
+        
+        context "a lookup of an undefined column" do
+          it "returns a full association & column pair" do
+            search = Ransack::Search.new(Person)
+            ransack_abbreviation_for(search, :articles_body_cont).should == "articles.body_cont"
+          end
+        end
+      end
+      
+      context "a lookup of a multi-condition string" do
+        it "returns abbreviated forms for all conditions" do
+          search = Ransack::Search.new(Person)
+          ransack_abbreviation_for(search, :children_name_or_children_salary_eq).should == "ch.nm_or_ch.salary_eq"
+        end
+      end
+      
+      context "a lookup of a defined polymorphic belongs_to association" do
+        it "returns the abbreviated name for the polymorphic association" do
+          search = Ransack::Search.new(Note)
+          ransack_abbreviation_for(search, :notable_of_Person_type_name_eq).should == "nbl_of_pr_type.nm_eq"
+        end
+      end
+      
+      context "a lookup of a nested condition" do
+        it "abbreviates each association and column" do
+          search = Ransack::Search.new(Person)
+          ransack_abbreviation_for(search, :articles_comments_body_cont).should == "articles_cm.body_cont"
+        end
+        
+        it "abbreviates nested conditions for polymorphic associations" do
+          search = Ransack::Search.new(Note)
+          ransack_abbreviation_for(search, :notable_of_Person_type_children_name_eq).should == "nbl_of_pr_type_ch.nm_eq"
+        end
+      end
+      
+      context "a lookup of something totally random" do
+        it "does absolutely nothing" do
+          search = Ransack::Search.new(Note)
+          ransack_abbreviation_for(search, :i_am_garbage).should == "i_am_garbage"
+        end
+      end
+    end
+  end
+end

data/spec/ransack_abbreviator/search_spec.rb

@@ -0,0 +1,379 @@
+require "spec_helper"
+
+module Ransack # We're testing Ransack's Search wih abbreviations
+  describe Search do
+    describe '#build' do
+      context "with abbreviations" do
+        it 'creates Conditions for top-level attributes' do
+          search = Search.new(Person)
+          search.build(ransack_abbreviation_for(search, :name_eq) => 'Ernie')
+          condition = search.base[:name_eq]
+          condition.should be_a Nodes::Condition
+          condition.predicate.name.should eq 'eq'
+          condition.attributes.first.name.should eq 'name'
+          condition.value.should eq 'Ernie'
+        end
+      
+        it 'creates Conditions for association attributes' do
+          search = Search.new(Person)
+          search.build(ransack_abbreviation_for(search, :children_name_eq) => 'Ernie')
+          condition = search.base[:children_name_eq]
+          condition.should be_a Nodes::Condition
+          condition.predicate.name.should eq 'eq'
+          condition.attributes.first.name.should eq 'children_name'
+          condition.value.should eq 'Ernie'
+        end
+        
+        it 'creates Conditions for polymorphic belongs_to association attributes' do
+          search = Search.new(Note)
+          search.build(ransack_abbreviation_for(search, :notable_of_Person_type_name_eq) => 'Ernie')
+          condition = search.base[:notable_of_Person_type_name_eq]
+          condition.should be_a Nodes::Condition
+          condition.predicate.name.should eq 'eq'
+          condition.attributes.first.name.should eq 'notable_of_Person_type_name'
+          condition.value.should eq 'Ernie'
+        end
+        
+        it 'creates Conditions for multiple polymorphic belongs_to association attributes' do
+          search = Search.new(Note)
+          search.build(ransack_abbreviation_for(search, :notable_of_Person_type_name_or_notable_of_Article_type_title_eq) => 'Ernie')
+          condition = search.base[:notable_of_Person_type_name_or_notable_of_Article_type_title_eq]
+          condition.should be_a Nodes::Condition
+          condition.predicate.name.should eq 'eq'
+          condition.attributes.first.name.should eq 'notable_of_Person_type_name'
+          condition.attributes.last.name.should eq 'notable_of_Article_type_title'
+          condition.value.should eq 'Ernie'
+        end
+
+        it 'discards empty conditions' do
+          search = Search.new(Person)
+          search.build(ransack_abbreviation_for(search, :children_name_eq) => '')
+          condition = search.base[:children_name_eq]
+          condition.should be_nil
+        end
+
+        it 'accepts arrays of groupings' do
+          search = Search.new(Person)
+          search.build(
+            :g => [
+              ransack_abbreviations_for(search, :m => 'or', :name_eq => 'Ernie', :children_name_eq => 'Ernie'),
+              ransack_abbreviations_for(search, :m => 'or', :name_eq => 'Bert', :children_name_eq => 'Bert')
+            ]
+          )
+          ors = search.groupings
+          ors.should have(2).items
+          or1, or2 = ors
+          or1.should be_a Nodes::Grouping
+          or1.combinator.should eq 'or'
+          or2.should be_a Nodes::Grouping
+          or2.combinator.should eq 'or'
+        end
+
+        it 'accepts "attributes" hashes for groupings' do
+          search = Search.new(Person)
+          search.build(
+            :g => {
+              '0' => ransack_abbreviations_for(search, :m => 'or', :name_eq => 'Ernie', :children_name_eq => 'Ernie'),
+              '1' => ransack_abbreviations_for(search, :m => 'or', :name_eq => 'Bert', :children_name_eq => 'Bert'),
+            }
+          )
+          ors = search.groupings
+          ors.should have(2).items
+          or1, or2 = ors
+          or1.should be_a Nodes::Grouping
+          or1.combinator.should eq 'or'
+          or2.should be_a Nodes::Grouping
+          or2.combinator.should eq 'or'
+        end
+
+        it 'accepts "attributes" hashes for conditions' do
+          search = Search.new(Person)
+          search.build(
+            :c => {
+              '0' => {:a => ransack_abbreviations_for(search, ['name']), :p => 'eq', :v => ['Ernie']},
+              '1' => {:a => ransack_abbreviations_for(search, ['children_name', 'parent_name']), :p => 'eq', :v => ['Ernie'], :m => 'or'}
+            }
+          )
+          conditions = search.base.conditions
+          conditions.should have(2).items
+          conditions.map {|c| c.class}.should eq [Nodes::Condition, Nodes::Condition]
+        end
+
+        it 'creates Conditions for custom predicates that take arrays' do
+          Ransack.configure do |config|
+            config.add_predicate 'ary_pred',
+            :wants_array => true
+          end
+
+          search = Search.new(Person)
+          search.build(ransack_abbreviation_for(search, :name_ary_pred) => ['Ernie', 'Bert'])
+          condition = search.base[:name_ary_pred]
+          condition.should be_a Nodes::Condition
+          condition.predicate.name.should eq 'ary_pred'
+          condition.attributes.first.name.should eq 'name'
+          condition.value.should eq ['Ernie', 'Bert']
+        end
+
+        it 'does not evaluate the query on #inspect' do
+          search = Search.new(Person)
+          search.build(ransack_abbreviation_for(search, :children_id_in) => [1, 2, 3])
+          search.inspect.should_not match /ActiveRecord/
+        end
+      end
+    end
+    
+    context "without abbreviations" do
+      it 'creates Conditions for top-level attributes' do
+        search = Search.new(Person, :name_eq => 'Ernie')
+        condition = search.base[:name_eq]
+        condition.should be_a Nodes::Condition
+        condition.predicate.name.should eq 'eq'
+        condition.attributes.first.name.should eq 'name'
+        condition.value.should eq 'Ernie'
+      end
+
+      it 'creates Conditions for association attributes' do
+        search = Search.new(Person, :children_name_eq => 'Ernie')
+        condition = search.base[:children_name_eq]
+        condition.should be_a Nodes::Condition
+        condition.predicate.name.should eq 'eq'
+        condition.attributes.first.name.should eq 'children_name'
+        condition.value.should eq 'Ernie'
+      end
+
+      it 'creates Conditions for polymorphic belongs_to association attributes' do
+        search = Search.new(Note, :notable_of_Person_type_name_eq => 'Ernie')
+        condition = search.base[:notable_of_Person_type_name_eq]
+        condition.should be_a Nodes::Condition
+        condition.predicate.name.should eq 'eq'
+        condition.attributes.first.name.should eq 'notable_of_Person_type_name'
+        condition.value.should eq 'Ernie'
+      end
+
+      it 'creates Conditions for multiple polymorphic belongs_to association attributes' do
+        search = Search.new(Note, :notable_of_Person_type_name_or_notable_of_Article_type_title_eq => 'Ernie')
+        condition = search.base[:notable_of_Person_type_name_or_notable_of_Article_type_title_eq]
+        condition.should be_a Nodes::Condition
+        condition.predicate.name.should eq 'eq'
+        condition.attributes.first.name.should eq 'notable_of_Person_type_name'
+        condition.attributes.last.name.should eq 'notable_of_Article_type_title'
+        condition.value.should eq 'Ernie'
+      end
+
+      it 'discards empty conditions' do
+        search = Search.new(Person, :children_name_eq => '')
+        condition = search.base[:children_name_eq]
+        condition.should be_nil
+      end
+
+      it 'accepts arrays of groupings' do
+        search = Search.new(Person,
+          :g => [
+            {:m => 'or', :name_eq => 'Ernie', :children_name_eq => 'Ernie'},
+            {:m => 'or', :name_eq => 'Bert', :children_name_eq => 'Bert'},
+          ]
+        )
+        ors = search.groupings
+        ors.should have(2).items
+        or1, or2 = ors
+        or1.should be_a Nodes::Grouping
+        or1.combinator.should eq 'or'
+        or2.should be_a Nodes::Grouping
+        or2.combinator.should eq 'or'
+      end
+
+      it 'accepts "attributes" hashes for groupings' do
+        search = Search.new(Person,
+          :g => {
+            '0' => {:m => 'or', :name_eq => 'Ernie', :children_name_eq => 'Ernie'},
+            '1' => {:m => 'or', :name_eq => 'Bert', :children_name_eq => 'Bert'},
+          }
+        )
+        ors = search.groupings
+        ors.should have(2).items
+        or1, or2 = ors
+        or1.should be_a Nodes::Grouping
+        or1.combinator.should eq 'or'
+        or2.should be_a Nodes::Grouping
+        or2.combinator.should eq 'or'
+      end
+
+      it 'accepts "attributes" hashes for conditions' do
+        search = Search.new(Person,
+          :c => {
+            '0' => {:a => ['name'], :p => 'eq', :v => ['Ernie']},
+            '1' => {:a => ['children_name', 'parent_name'], :p => 'eq', :v => ['Ernie'], :m => 'or'}
+          }
+        )
+        conditions = search.base.conditions
+        conditions.should have(2).items
+        conditions.map {|c| c.class}.should eq [Nodes::Condition, Nodes::Condition]
+      end
+
+      it 'creates Conditions for custom predicates that take arrays' do
+        Ransack.configure do |config|
+          config.add_predicate 'ary_pred',
+          :wants_array => true
+        end
+
+        search = Search.new(Person, :name_ary_pred => ['Ernie', 'Bert'])
+        condition = search.base[:name_ary_pred]
+        condition.should be_a Nodes::Condition
+        condition.predicate.name.should eq 'ary_pred'
+        condition.attributes.first.name.should eq 'name'
+        condition.value.should eq ['Ernie', 'Bert']
+      end
+
+      it 'does not evaluate the query on #inspect' do
+        search = Search.new(Person, :children_id_in => [1, 2, 3])
+        search.inspect.should_not match /ActiveRecord/
+      end
+    end
+    
+    describe '#result' do
+      context "with abbreviations" do
+        it "evaluates a basic condition" do
+          search = Search.new(Person)
+          search.build(ransack_abbreviation_for(search, :name_eq) => 'Ernie')
+          search.result.should be_an ActiveRecord::Relation
+          where = search.result.where_values.first
+          where.to_sql.should match /"people"\."name" = 'Ernie'/
+        end
+      
+        it 'evaluates conditions contextually' do
+          search = Search.new(Person)
+          search.build(ransack_abbreviation_for(search, :children_name_eq) => 'Ernie')
+          search.result.should be_an ActiveRecord::Relation
+          where = search.result.where_values.first
+          where.to_sql.should match /"children_people"\."name" = 'Ernie'/
+        end
+        
+        it 'evaluates polymorphic belongs_to association conditions contextually' do
+          search = Search.new(Note)
+          search.build(ransack_abbreviation_for(search, :notable_of_Person_type_name_eq) => 'Ernie')
+          search.result.should be_an ActiveRecord::Relation
+          where = search.result.where_values.first
+          where.to_sql.should match /"people"."name" = 'Ernie'/
+        end
+
+        it 'evaluates nested conditions' do
+          search = Search.new(Person)
+          search.build(
+            ransack_abbreviation_for(search, :children_name_eq) => 'Ernie',
+            :g => [
+              ransack_abbreviations_for(search, :m => 'or', :name_eq => 'Ernie', :children_children_name_eq => 'Ernie')
+            ]
+          )
+          search.result.should be_an ActiveRecord::Relation
+          where = search.result.where_values.first
+          where.to_sql.should match /"children_people"."name" = 'Ernie'/
+          where.to_sql.should match /"people"."name" = 'Ernie'/
+          where.to_sql.should match /"children_people_2"."name" = 'Ernie'/
+        end
+
+        it 'evaluates arrays of groupings' do
+          search = Search.new(Person)
+          search.build(
+            :g => [
+              ransack_abbreviations_for(search, :m => 'or', :name_eq => 'Ernie', :children_name_eq => 'Ernie'),
+              ransack_abbreviations_for(search, :m => 'or', :name_eq => 'Bert', :children_name_eq => 'Bert'),
+            ]
+          )
+          search.result.should be_an ActiveRecord::Relation
+          where = search.result.where_values.first
+          sql = where.to_sql
+          first, second = sql.split(/ AND /)
+          first.should match /"people"."name" = 'Ernie'/
+          first.should match /"children_people"."name" = 'Ernie'/
+          second.should match /"people"."name" = 'Bert'/
+          second.should match /"children_people"."name" = 'Bert'/
+        end
+
+        it 'returns distinct records when passed :distinct => true' do
+          search = Search.new(Person)
+          search.build(
+            :g => [ransack_abbreviations_for(search, :m => 'or', :comments_body_cont => 'e', :articles_comments_body_cont => 'e')]
+          )
+          search.result.all.should have(920).items
+          search.result(:distinct => true).should have(330).items
+          search.result.all.uniq.should eq search.result(:distinct => true).all
+        end
+      end
+      
+      context "without abbreviations" do
+        it 'evaluates conditions contextually' do
+          search = Search.new(Person, :children_name_eq => 'Ernie')
+          search.result.should be_an ActiveRecord::Relation
+          where = search.result.where_values.first
+          where.to_sql.should match /"children_people"\."name" = 'Ernie'/
+        end
+
+        it 'evaluates compound conditions contextually' do
+          search = Search.new(Person, :children_name_or_name_eq => 'Ernie')
+          search.result.should be_an ActiveRecord::Relation
+          where = search.result.where_values.first
+          where.to_sql.should match /"children_people"\."name" = 'Ernie' OR "people"\."name" = 'Ernie'/
+        end
+
+        it 'evaluates polymorphic belongs_to association conditions contextually' do
+          search = Search.new(Note, :notable_of_Person_type_name_eq => 'Ernie')
+          search.result.should be_an ActiveRecord::Relation
+          where = search.result.where_values.first
+          where.to_sql.should match /"people"."name" = 'Ernie'/
+        end
+
+        it 'evaluates nested conditions' do
+          search = Search.new(Person, :children_name_eq => 'Ernie',
+            :g => [{
+              :m => 'or',
+              :name_eq => 'Ernie',
+              :children_children_name_eq => 'Ernie'
+            }]
+          )
+          search.result.should be_an ActiveRecord::Relation
+          where = search.result.where_values.first
+          where.to_sql.should match /"children_people"."name" = 'Ernie'/
+          where.to_sql.should match /"people"."name" = 'Ernie'/
+          where.to_sql.should match /"children_people_2"."name" = 'Ernie'/
+        end
+
+        it 'evaluates arrays of groupings' do
+          search = Search.new(Person,
+            :g => [
+              {:m => 'or', :name_eq => 'Ernie', :children_name_eq => 'Ernie'},
+              {:m => 'or', :name_eq => 'Bert', :children_name_eq => 'Bert'},
+            ]
+          )
+          search.result.should be_an ActiveRecord::Relation
+          where = search.result.where_values.first
+          sql = where.to_sql
+          first, second = sql.split(/ AND /)
+          first.should match /"people"."name" = 'Ernie'/
+          first.should match /"children_people"."name" = 'Ernie'/
+          second.should match /"people"."name" = 'Bert'/
+          second.should match /"children_people"."name" = 'Bert'/
+        end
+
+        it 'returns distinct records when passed :distinct => true' do
+          search = Search.new(Person, :g => [{:m => 'or', :comments_body_cont => 'e', :articles_comments_body_cont => 'e'}])
+          search.result.all.should have(920).items
+          search.result(:distinct => true).should have(330).items
+          search.result.all.uniq.should eq search.result(:distinct => true).all
+        end
+      end
+      
+      it "has the same results for a query with and without abbreviations" do
+        # Just some random sanity checks
+        search = Search.new(Person, :authored_article_comments_vote_count_lteq => 10)
+        abbr_search = Search.new(Person)
+        abbr_search.build(ransack_abbreviation_for(abbr_search, :authored_article_comments_vote_count_lteq) => 10)
+        search.result.where_values.first.to_sql.should eq abbr_search.result.where_values.first.to_sql
+        
+        search = Search.new(Note, :notable_of_Person_type_children_name_eq => "Ernie")
+        abbr_search = Search.new(Note)
+        abbr_search.build(ransack_abbreviation_for(abbr_search, :notable_of_Person_type_children_name_eq) => "Ernie")
+        search.result.where_values.first.to_sql.should eq abbr_search.result.where_values.first.to_sql
+      end
+    end
+  end
+end