ransack_abbreviator 0.0.7 → 0.0.8

data/lib/ransack_abbreviator.rb

@@ -23,5 +23,4 @@ require "ransack_abbreviator/ransack_extensions/nodes/condition"
 require "ransack_abbreviator/ransack_extensions/context"
 require "ransack_abbreviator/ransack_extensions/search"
 require 'ransack_abbreviator/adapters/active_record'
-require "ransack_abbreviator/view_helpers"
 require "ransack_abbreviator/ransack_extensions/helpers/form_builder"

data/lib/ransack_abbreviator/abbreviators/decoder.rb

@@ -82,7 +82,8 @@ module RansackAbbreviator
       private
     
       def get_polymorphic_assoc_and_class_type(possible_assoc_abbr)
-        assoc_name = class_type = nil
+        assoc_name = nil
+        class_type = nil
         if (match = possible_assoc_abbr.match(/_of_([^_]+?)_type$/))
           assoc_name = @context.klass.ransackable_assoc_name_for(match.pre_match)
           class_type = RansackAbbreviator.assoc_name_for(match.captures.first).camelize
@@ -91,7 +92,8 @@ module RansackAbbreviator
       end
       
       def extract_possible_assoc_and_attribute_abbr(s)
-        possible_assoc = possible_attr_name = nil
+        possible_assoc = nil
+        possible_attr_name = nil
         if s.include?(".")
           parts = s.split(".")
           possible_assoc = parts[0]

data/lib/ransack_abbreviator/configuration.rb

@@ -3,7 +3,8 @@ require "pathname"
 module RansackAbbreviator
   module Configuration
     mattr_accessor :column_abbreviations, :assoc_abbreviations
-    self.column_abbreviations = self.assoc_abbreviations = {}
+    self.column_abbreviations = {}
+    self.assoc_abbreviations = {}
     
     def configure
       yield self

data/lib/ransack_abbreviator/version.rb

@@ -1,3 +1,3 @@
 module RansackAbbreviator
-  VERSION = "0.0.7"
+  VERSION = "0.0.8"
 end

data/spec/ransack_abbreviator/configuration_spec.rb

@@ -15,7 +15,7 @@ module RansackAbbreviator
       
       RansackAbbreviator.column_abbreviations.should have_key('tag_id')
       RansackAbbreviator.column_abbreviation_for(:tag_id).should eq 'tid'
-      RansackAbbreviator.assoc_name_for('tid').should eq 'tag_id'
+      RansackAbbreviator.column_name_for('tid').should eq 'tag_id'
     end
     
     it "adds association abbreviations" do

data/spec/ransack_abbreviator/decoder_spec.rb

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

data/spec/ransack_abbreviator/encoder_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+module RansackAbbreviator
+  module Abbreviators
+    describe Encoder do
+      describe '#encode_parameter' do
+        context "a lookup of a defined column" do
+          it "returns an abbreviated column name" do
+            search = Ransack::Search.new(Person)
+            search.context.encode_parameter(:name_eq).should == "nm_eq"
+            search.context.encode_parameter(: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)
+            search.context.encode_parameter(: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)
+              search.context.encode_parameter(:person_name_eq).should == "pr.nm_eq"
+              search.context.encode_parameter(:person_middle_name_eq).should == "pr.mn_eq"
+              search = Ransack::Search.new(Person)
+              search.context.encode_parameter(: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)
+              search.context.encode_parameter(: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)
+              search.context.encode_parameter(: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)
+              search.context.encode_parameter(: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)
+            search.context.encode_parameter(: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)
+            search.context.encode_parameter(: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)
+            search.context.encode_parameter(:articles_comments_body_cont).should == "articles_cm.body_cont"
+          end
+        
+          it "abbreviates nested conditions for polymorphic associations" do
+            search = Ransack::Search.new(Note)
+            search.context.encode_parameter(: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)
+            search.context.encode_parameter(:i_am_garbage).should == "i_am_garbage"
+          end
+        end
+      end
+    end
+  end
+end

data/spec/ransack_abbreviator/search_spec.rb

@@ -6,7 +6,7 @@ module Ransack # We're testing Ransack's Search wih abbreviations
       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')
+          search.build(search.context.encode_parameter(:name_eq) => 'Ernie')
           condition = search.base[:name_eq]
           condition.should be_a Nodes::Condition
           condition.predicate.name.should eq 'eq'
@@ -16,7 +16,7 @@ module Ransack # We're testing Ransack's Search wih abbreviations
       
         it 'creates Conditions for association attributes' do
           search = Search.new(Person)
-          search.build(ransack_abbreviation_for(search, :children_name_eq) => 'Ernie')
+          search.build(search.context.encode_parameter(:children_name_eq) => 'Ernie')
           condition = search.base[:children_name_eq]
           condition.should be_a Nodes::Condition
           condition.predicate.name.should eq 'eq'
@@ -26,7 +26,7 @@ module Ransack # We're testing Ransack's Search wih abbreviations
         
         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')
+          search.build(search.context.encode_parameter(: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'
@@ -36,7 +36,7 @@ module Ransack # We're testing Ransack's Search wih abbreviations
         
         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')
+          search.build(search.context.encode_parameter(: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'
@@ -47,7 +47,7 @@ module Ransack # We're testing Ransack's Search wih abbreviations
 
         it 'discards empty conditions' do
           search = Search.new(Person)
-          search.build(ransack_abbreviation_for(search, :children_name_eq) => '')
+          search.build(search.context.encode_parameter(:children_name_eq) => '')
           condition = search.base[:children_name_eq]
           condition.should be_nil
         end
@@ -56,8 +56,8 @@ module Ransack # We're testing Ransack's Search wih abbreviations
           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')
+              {:m => 'or', search.context.encode_parameter(:name_eq) => 'Ernie', search.context.encode_parameter(:children_name_eq) => 'Ernie'},
+              {:m => 'or', search.context.encode_parameter(:name_eq) => 'Bert', search.context.encode_parameter(:children_name_eq) => 'Bert'}
             ]
           )
           ors = search.groupings
@@ -73,8 +73,8 @@ module Ransack # We're testing Ransack's Search wih abbreviations
           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'),
+              '0' => {:m => 'or', search.context.encode_parameter(:name_eq) => 'Ernie', search.context.encode_parameter(:children_name_eq) => 'Ernie'},
+              '1' => {:m => 'or', search.context.encode_parameter(:name_eq) => 'Bert', search.context.encode_parameter(:children_name_eq) => 'Bert'}
             }
           )
           ors = search.groupings
@@ -86,19 +86,6 @@ module Ransack # We're testing Ransack's Search wih abbreviations
           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',
@@ -106,7 +93,7 @@ module Ransack # We're testing Ransack's Search wih abbreviations
           end
 
           search = Search.new(Person)
-          search.build(ransack_abbreviation_for(search, :name_ary_pred) => ['Ernie', 'Bert'])
+          search.build(search.context.encode_parameter(:name_ary_pred) => ['Ernie', 'Bert'])
           condition = search.base[:name_ary_pred]
           condition.should be_a Nodes::Condition
           condition.predicate.name.should eq 'ary_pred'
@@ -116,7 +103,7 @@ module Ransack # We're testing Ransack's Search wih abbreviations
 
         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.build(search.context.encode_parameter(:children_id_in) => [1, 2, 3])
           search.inspect.should_not match /ActiveRecord/
         end
       end
@@ -235,7 +222,7 @@ module Ransack # We're testing Ransack's Search wih abbreviations
       context "with abbreviations" do
         it "evaluates a basic condition" do
           search = Search.new(Person)
-          search.build(ransack_abbreviation_for(search, :name_eq) => 'Ernie')
+          search.build(search.context.encode_parameter(:name_eq) => 'Ernie')
           search.result.should be_an ActiveRecord::Relation
           where = search.result.where_values.first
           where.to_sql.should match /"people"\."name" = 'Ernie'/
@@ -243,7 +230,7 @@ module Ransack # We're testing Ransack's Search wih abbreviations
       
         it 'evaluates conditions contextually' do
           search = Search.new(Person)
-          search.build(ransack_abbreviation_for(search, :children_name_eq) => 'Ernie')
+          search.build(search.context.encode_parameter(: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'/
@@ -251,12 +238,12 @@ module Ransack # We're testing Ransack's Search wih abbreviations
         
         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.build(search.context.encode_parameter(: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'/
           
-          search.build(ransack_abbreviation_for(search, :notable_of_Article_type_title_eq) => 'Test')
+          search.build(search.context.encode_parameter(:notable_of_Article_type_title_eq) => 'Test')
           search.result.should be_an ActiveRecord::Relation
           where = search.result.where_values.first
           where.to_sql.should match /"articles"."title" = 'Test'/
@@ -265,9 +252,9 @@ module Ransack # We're testing Ransack's Search wih abbreviations
         it 'evaluates nested conditions' do
           search = Search.new(Person)
           search.build(
-            ransack_abbreviation_for(search, :children_name_eq) => 'Ernie',
+            search.context.encode_parameter(:children_name_eq) => 'Ernie',
             :g => [
-              ransack_abbreviations_for(search, :m => 'or', :name_eq => 'Ernie', :children_children_name_eq => 'Ernie')
+              {:m => 'or', search.context.encode_parameter(:name_eq) => 'Ernie', search.context.encode_parameter(:children_children_name_eq) => 'Ernie'}
             ]
           )
           search.result.should be_an ActiveRecord::Relation
@@ -281,8 +268,8 @@ module Ransack # We're testing Ransack's Search wih abbreviations
           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'),
+              {:m => 'or', search.context.encode_parameter(:name_eq) => 'Ernie', search.context.encode_parameter(:children_name_eq) => 'Ernie'},
+              {:m => 'or', search.context.encode_parameter(:name_eq) => 'Bert', search.context.encode_parameter(:children_name_eq) => 'Bert'}
             ]
           )
           search.result.should be_an ActiveRecord::Relation
@@ -298,7 +285,7 @@ module Ransack # We're testing Ransack's Search wih abbreviations
         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')]
+            :g => [{:m => 'or', search.context.encode_parameter(:comments_body_cont) => 'e', search.context.encode_parameter(:articles_comments_body_cont) => 'e'}]
           )
           search.result.all.should have(920).items
           search.result(:distinct => true).should have(330).items
@@ -372,12 +359,12 @@ module Ransack # We're testing Ransack's Search wih abbreviations
         # 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)
+        abbr_search.build(abbr_search.context.encode_parameter(: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")
+        abbr_search.build(abbr_search.context.encode_parameter(: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
@@ -389,16 +376,16 @@ module Ransack # We're testing Ransack's Search wih abbreviations
         end
         
         it 'sets condition attributes' do
-          abbr_search = ransack_abbreviation_for(@search, :middle_name_eq)
+          abbr_search = @search.context.encode_parameter(:middle_name_eq)
           @search.send "#{abbr_search}=", 'Ernie'
           @search.middle_name_eq.should eq 'Ernie'
         
-          abbr_search = ransack_abbreviation_for(@search, :authored_article_comments_vote_count_lteq)
+          abbr_search = @search.context.encode_parameter(:authored_article_comments_vote_count_lteq)
           @search.send "#{abbr_search}=", 10
           @search.authored_article_comments_vote_count_lteq.should eq 10
         
           note_search = Search.new(Note)
-          abbr_search = ransack_abbreviation_for(note_search, :notable_of_Person_type_name_eq)
+          abbr_search = note_search.context.encode_parameter(:notable_of_Person_type_name_eq)
           note_search.send "#{abbr_search}=", 'Ernie'
           note_search.notable_of_Person_type_name_eq.should eq 'Ernie'
         end

data/spec/spec_helper.rb

@@ -20,8 +20,6 @@ Sham.define do
 end
 
 RSpec.configure do |config|
-  config.include RansackAbbreviator::ViewHelpers
-  
   config.before(:suite) do
     puts '=' * 80
     puts "Running specs against ActiveRecord #{ActiveRecord::VERSION::STRING} and ARel #{Arel::VERSION}..."

metadata

@@ -2,7 +2,7 @@
 name: ransack_abbreviator
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.7
+  version: 0.0.8
 platform: ruby
 authors: 
 - Jamie Davidson
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2013-02-08 00:00:00 Z
+date: 2013-02-14 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: ransack
@@ -108,7 +108,6 @@ files:
 - lib/ransack_abbreviator/ransack_extensions/nodes/condition.rb
 - lib/ransack_abbreviator/ransack_extensions/search.rb
 - lib/ransack_abbreviator/version.rb
-- lib/ransack_abbreviator/view_helpers.rb
 - ransack_abbreviator.gemspec
 - spec/blueprints/articles.rb
 - spec/blueprints/comments.rb
@@ -117,7 +116,8 @@ files:
 - spec/blueprints/tags.rb
 - spec/ransack_abbreviator/adapters/active_record/base_spec.rb
 - spec/ransack_abbreviator/configuration_spec.rb
-- spec/ransack_abbreviator/helper_spec.rb
+- spec/ransack_abbreviator/decoder_spec.rb
+- spec/ransack_abbreviator/encoder_spec.rb
 - spec/ransack_abbreviator/helpers/form_builder_spec.rb
 - spec/ransack_abbreviator/search_spec.rb
 - spec/spec_helper.rb
@@ -157,7 +157,8 @@ test_files:
 - spec/blueprints/tags.rb
 - spec/ransack_abbreviator/adapters/active_record/base_spec.rb
 - spec/ransack_abbreviator/configuration_spec.rb
-- spec/ransack_abbreviator/helper_spec.rb
+- spec/ransack_abbreviator/decoder_spec.rb
+- spec/ransack_abbreviator/encoder_spec.rb
 - spec/ransack_abbreviator/helpers/form_builder_spec.rb
 - spec/ransack_abbreviator/search_spec.rb
 - spec/spec_helper.rb

data/lib/ransack_abbreviator/view_helpers.rb

@@ -1,30 +0,0 @@
-module RansackAbbreviator
-  module ViewHelpers
-    def ransack_abbreviation_for(ransack_search_object, param)
-      ransack_search_object.context.encode_parameter(param)
-    end
-    
-    def ransack_abbreviations_for(ransack_search_object, params)
-      new_params = nil
-      
-      case params
-      when Hash
-        new_params = {}
-        params.each do |ransack_name, value|
-          new_params[ransack_abbreviation_for(ransack_search_object, ransack_name)] = value
-        end
-      when Array
-        new_params = []
-        params.each do |ransack_name|
-          new_params << ransack_abbreviation_for(ransack_search_object, ransack_name)
-        end
-      else
-        raise ArgumentError, "don't know how to interpret abbreviations for #{params}"
-      end
-      
-      new_params
-    end
-  end
-end
-
-ActionView::Base.send :include, RansackAbbreviator::ViewHelpers

data/spec/ransack_abbreviator/helper_spec.rb

@@ -1,90 +0,0 @@
-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