ransack_abbreviator 0.0.2 → 0.0.3

data/lib/ransack_abbreviator/abbreviators/decoder.rb

@@ -1,9 +1,36 @@
 module RansackAbbreviator
   module Abbreviators
-    module Decoder
+    class Decoder
+      attr_reader :context
+      
+      def initialize(context)
+        @context = context
+      end
+      
+      def decode_parameter(param)
+        str = param.dup
+        pred = Ransack::Predicate.detect_and_strip_from_string!(str)
+        decoded_param = nil
+        case str
+        when /^(g|c|m|groupings|conditions|combinator)=?$/
+          decoded_param = param
+        else
+          conjunctions = str.split("_").select{|s| s == "and" || s == "or" }
+          decoded_param = ""
+          str.split(/_and_|_or_/).each do |possible_abbr|
+            decoded_str = self.context.decode_possible_abbr(possible_abbr)
+            decoded_param << (!decoded_str.blank? ? decoded_str : possible_abbr)
+            decoded_param << "_#{conjunctions.shift}_" if !conjunctions.blank?
+          end
+        end
+        
+        decoded_param << "_#{pred}" if pred
+        decoded_param
+      end
+      
       def decode_possible_abbr(possible_abbr)
         possible_assoc_abbr, possible_attr_abbr = extract_possible_assoc_and_attribute_abbr(possible_abbr)
-        parent_of_attribute = self.klass
+        parent_of_attribute = @context.klass
         decoded_str = ""
         if possible_assoc_abbr 
           decoded_str, parent_of_attribute = decode_assoc_abbr(possible_assoc_abbr)
@@ -24,11 +51,11 @@ module RansackAbbreviator
         decoded_str = ""
         segments = possible_assoc_abbr.split(/_/)
         association_parts = []
-        klass = self.klass
+        klass = @context.klass
       
         while segments.size > 0 && association_parts << segments.shift
           assoc_to_test = association_parts.join('_')
-          if polymorphic_association_specified?(assoc_to_test)
+          if Ransack::Context.polymorphic_association_specified?(assoc_to_test)
             assoc_name, class_type = get_polymorphic_assoc_and_class_type(assoc_to_test)
             klass = Kernel.const_get(class_type)
             decoded_str << "of_#{class_type}_type_"
@@ -48,7 +75,7 @@ module RansackAbbreviator
         [decoded_str, klass]
       end
     
-      def decode_column_abbr(possible_attr_abbr, klass=@klass)
+      def decode_column_abbr(possible_attr_abbr, klass=@context.klass)
         klass.ransackable_column_name_for(possible_attr_abbr)
       end
       
@@ -57,7 +84,7 @@ module RansackAbbreviator
       def get_polymorphic_assoc_and_class_type(possible_assoc_abbr)
         assoc_name = class_type = nil
         if (match = possible_assoc_abbr.match(/_of_([^_]+?)_type$/))
-          assoc_name = self.klass.ransackable_assoc_name_for(match.pre_match)
+          assoc_name = @context.klass.ransackable_assoc_name_for(match.pre_match)
           class_type = RansackAbbreviator.assoc_name_for(match.captures.first).camelize
         end
         [assoc_name, class_type]

data/lib/ransack_abbreviator/abbreviators/encoder.rb

@@ -1,17 +1,23 @@
 module RansackAbbreviator
   module Abbreviators
-    module Encoder
+    class Encoder
+      attr_reader :context
+      
+      def initialize(context)
+        @context = context
+      end
+      
       def encode_ransack_str(str)
         encoded_str = ""
-        associations, attr_name = self.get_associations_and_attribute(str)
-        parent_of_attribute = self.klass
+        associations, attr_name = @context.get_associations_and_attribute(str)
+        parent_of_attribute = @context.klass
         
         if attr_name
           unless associations.blank?
-            encoded_associations, parent_of_attribute = self.encode_associations(associations, str)
+            encoded_associations, parent_of_attribute = encode_associations(associations, str)
             encoded_str = "#{encoded_associations}."
           end
-          encoded_str << self.encode_attribute(attr_name, parent_of_attribute)
+          encoded_str << encode_attribute(attr_name, parent_of_attribute)
         else
           encoded_str = str
         end
@@ -20,7 +26,7 @@ module RansackAbbreviator
       end
       
       def encode_associations(associations, ransack_name)
-        klass = self.klass
+        klass = @context.klass
         encoded_str = ""
         
         associations.each_with_index do |assoc, i|
@@ -41,7 +47,7 @@ module RansackAbbreviator
         [encoded_str, klass]
       end
       
-      def encode_attribute(attr_name, parent=@klass)
+      def encode_attribute(attr_name, parent=@context.klass)
         parent.ransackable_column_abbr_for(attr_name)
       end
     end

data/lib/ransack_abbreviator/adapters/active_record/base.rb

@@ -34,8 +34,10 @@ module RansackAbbreviator
         end
         
         def ransackable_assoc_abbreviations
-          associations = reflect_on_all_associations.map{|a| a.name.to_s}
-          self._ransack_assoc_abbreviations ||= RansackAbbreviator.assoc_abbreviations.select{ |key, val| associations.include?(key) }
+          self._ransack_assoc_abbreviations ||= begin 
+            associations = reflect_on_all_associations.map{|a| a.name.to_s}
+            RansackAbbreviator.assoc_abbreviations.select{ |key, val| associations.include?(key) }
+          end
         end
         
         def ransackable_column_name_for(possible_abbr)

data/lib/ransack_abbreviator/ransack_extensions/context.rb

@@ -3,8 +3,12 @@ require 'ransack_abbreviator/abbreviators/encoder'
 
 module Ransack
   class Context
-    include RansackAbbreviator::Abbreviators::Decoder
-    include RansackAbbreviator::Abbreviators::Encoder
+    attr_reader :decoder, :encoder
+    alias_method :full_ransackable_attribute?, :ransackable_attribute?
+    alias_method :full_ransackable_association?, :ransackable_association?
+    
+    delegate :encode_ransack_str, to: :encoder
+    delegate :decode_parameter, :decode_possible_abbr, to: :decoder
     
     def get_associations_and_attribute(str, klass = @klass, associations = [])
       attr_name = nil
@@ -25,9 +29,31 @@ module Ransack
       [associations, attr_name]
     end
     
-    private
+    def decoder
+      @decoder ||= RansackAbbreviator::Abbreviators::Decoder.new(self)
+    end
+    
+    def encoder
+      @encoder ||= RansackAbbreviator::Abbreviators::Encoder.new(self)
+    end
+    
+    def ransackable_attribute?(str, klass)
+      full_ransackable_attribute?(str, klass) || ransackable_attribute_abbreviation?(str, klass)
+    end
+    
+    def ransackable_association?(str, klass)
+      full_ransackable_association?(str, klass) || ransackable_assoc_abbreviation?(str, klass)
+    end
+    
+    def ransackable_attribute_abbreviation?(str, klass)
+      klass.ransackable_column_abbreviations.has_value?(str)
+    end
+    
+    def ransackable_assoc_abbreviation?(str, klass)
+      klass.ransackable_assoc_abbreviations.has_value?(str)
+    end
     
-    def polymorphic_association_specified?(str)
+    def self.polymorphic_association_specified?(str)
       str && str.match(/_of_([^_]+?)_type$/)
     end
   end

data/lib/ransack_abbreviator/ransack_extensions/nodes/condition.rb

@@ -6,8 +6,7 @@ module Ransack
       def build(params)
         decoded_attr_names = []
         params[:a].each do |possible_abbr|
-          decoded_str = @context.decode_possible_abbr(possible_abbr)
-          decoded_attr_names << (!decoded_str.blank? ? decoded_str : possible_abbr)
+          decoded_attr_names << @context.decode_parameter(possible_abbr)
         end
         params[:a] = decoded_attr_names
         ransack_condition_build(params)

data/lib/ransack_abbreviator/ransack_extensions/search.rb

@@ -1,27 +1,23 @@
 module Ransack
   class Search
     alias_method :ransack_search_build, :build
+    alias_method :ransack_method_missing, :method_missing
+    
+    def method_missing(method_id, *args)
+      method_name = method_id.to_s
+      writer = method_name.sub!(/\=$/, '')
+      # Decode abbreviation (if it is indeed an abbreviation) so Ransack is happy
+      decoded_param = self.context.decode_parameter(method_name)
+      decoded_str = writer ? "#{decoded_param}=" : decoded_param
+      ransack_method_missing(decoded_str.to_sym, *args)
+    end
     
     def build(params)
       # Loop through each of the params and test if any contain abbreviations. If so, convert them to the normal Ransack language
       new_params = {}
       collapse_multiparameter_attributes!(params.with_indifferent_access).each do |key, value|
-        pred = Predicate.detect_from_string(key)
-        str = base.strip_predicate_and_index_from_param_string(key)
-        if base.special_condition?(str)
-          # Maintain the param as-is
-          new_params[key] = value
-        else
-          conjunctions = str.split("_").select{|s| s == "and" || s == "or" }
-          full_str = ""
-          str.split(/_and_|_or_/).each do |possible_abbr|
-            decoded_str = self.context.decode_possible_abbr(possible_abbr)
-            full_str << (!decoded_str.blank? ? decoded_str : possible_abbr)
-            full_str << "_#{conjunctions.shift}_" if !conjunctions.blank?
-          end
-          full_str << "_#{pred}" if pred
-          new_params[full_str] = value
-        end
+        decoded_param = self.context.decode_parameter(key)
+        new_params[decoded_param] = value
       end
 
       ransack_search_build(new_params)

data/lib/ransack_abbreviator/version.rb

@@ -1,3 +1,3 @@
 module RansackAbbreviator
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/lib/ransack_abbreviator.rb

@@ -21,7 +21,6 @@ RansackAbbreviator.configure do |config|
 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'

data/spec/ransack_abbreviator/search_spec.rb

@@ -375,5 +375,30 @@ module Ransack # We're testing Ransack's Search wih abbreviations
         search.result.where_values.first.to_sql.should eq abbr_search.result.where_values.first.to_sql
       end
     end
+    
+    describe '#method_missing' do
+      before do
+        @search = Search.new(Person)
+      end
+      
+      it 'support abbreviations' do
+        abbr_search = ransack_abbreviation_for(@search, :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)
+        @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)
+        note_search.send "#{abbr_search}=", 'Ernie'
+        note_search.notable_of_Person_type_name_eq.should eq 'Ernie'
+      end
+      
+      it 'raises NoMethodError when sent an invalid attribute/abreviation' do
+        expect {@search.i_am_garbage}.to raise_error NoMethodError
+      end
+    end
   end
 end

metadata

@@ -2,7 +2,7 @@
 name: ransack_abbreviator
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors: 
 - Jamie Davidson
@@ -104,7 +104,6 @@ files:
 - lib/ransack_abbreviator/constants.rb
 - lib/ransack_abbreviator/ransack_extensions/context.rb
 - lib/ransack_abbreviator/ransack_extensions/nodes/condition.rb
-- lib/ransack_abbreviator/ransack_extensions/nodes/grouping.rb
 - lib/ransack_abbreviator/ransack_extensions/search.rb
 - lib/ransack_abbreviator/version.rb
 - lib/ransack_abbreviator/view_helpers.rb

data/lib/ransack_abbreviator/ransack_extensions/nodes/grouping.rb

@@ -1,18 +0,0 @@
-module Ransack
-  module Nodes
-    class Grouping < Node
-      def strip_predicate_and_index_from_param_string(param_string)
-        strip_predicate_and_index(param_string)
-      end
-      
-      def special_condition?(str)
-        case str
-        when /^(g|c|m|groupings|conditions|combinator)=?$/
-          true
-        else
-          false
-        end
-      end
-    end
-  end
-end