ransack_abbreviator 0.0.1

data/.gitignore

@@ -0,0 +1,7 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.rspec
+config/*
+bin/*

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+## v0.0.1
+
+* initial release

data/Gemfile

@@ -0,0 +1,31 @@
+source "http://rubygems.org"
+gemspec
+
+gem 'rake'
+
+rails = ENV['RAILS'] || '3-2-stable'
+
+gem 'arel', '3.0.2'
+
+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) 2013 Jamie Davidson
+
+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,7 @@
+ransack-abbreviator
+===================
+
+
+## To Do
+* Support abbreviation of 'ransacker' attributes
+* Extend the 'attribute_select' form helper to support returning attributes as their abbreviations

data/Rakefile

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

data/lib/ransack_abbreviator/abbreviators/decoder.rb

@@ -0,0 +1,80 @@
+module RansackAbbreviator
+  module Abbreviators
+    module Decoder
+      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
+        decoded_str = ""
+        if possible_assoc_abbr 
+          decoded_str, parent_of_attribute = decode_assoc_abbr(possible_assoc_abbr)
+        end
+
+        if attr_name = decode_column_abbr(possible_attr_abbr, parent_of_attribute)
+          decoded_str << attr_name
+        else
+          decoded_str << possible_attr_abbr
+        end
+      
+        decoded_str
+      end
+    
+      def decode_assoc_abbr(possible_assoc_abbr)
+        # possible_assoc_abbr can be a chain of abbreviated associations, so decode them all and reconstruct into
+        # the format expected by Ransack
+        decoded_str = ""
+        segments = possible_assoc_abbr.split(/_/)
+        association_parts = []
+        klass = self.klass
+      
+        while segments.size > 0 && association_parts << segments.shift
+          assoc_to_test = association_parts.join('_')
+          if 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_"
+            association_parts.clear
+          elsif assoc_name = klass.ransackable_assoc_name_for(assoc_to_test)
+            assoc = klass.reflect_on_all_associations.find{|a| a.name.to_s == assoc_name}
+            decoded_str << "#{assoc_name}_"
+            unless assoc.options[:polymorphic]
+              # Get the model for this association, as the next association/attribute will be related to it
+              klass = assoc.klass 
+              association_parts.clear
+            end
+          end
+        end
+
+        decoded_str = "#{possible_assoc_abbr}_" if decoded_str.blank?
+        [decoded_str, klass]
+      end
+    
+      def decode_column_abbr(possible_attr_abbr, klass=@klass)
+        klass.ransackable_column_name_for(possible_attr_abbr)
+      end
+      
+      private
+    
+      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)
+          class_type = RansackAbbreviator.assoc_name_for(match.captures.first).camelize
+        end
+        [assoc_name, class_type]
+      end
+      
+      def extract_possible_assoc_and_attribute_abbr(s)
+        possible_assoc = possible_attr_name = nil
+        if s.include?(".")
+          parts = s.split(".")
+          possible_assoc = parts[0]
+          possible_attr_name = parts[1]
+        else
+          possible_attr_name = s
+        end
+      
+        [possible_assoc, possible_attr_name]
+      end
+    end
+  end
+end

data/lib/ransack_abbreviator/abbreviators/encoder.rb

@@ -0,0 +1,49 @@
+module RansackAbbreviator
+  module Abbreviators
+    module Encoder
+      def encode_ransack_str(str)
+        encoded_str = ""
+        associations, attr_name = self.get_associations_and_attribute(str)
+        parent_of_attribute = self.klass
+        
+        if attr_name
+          unless associations.blank?
+            encoded_associations, parent_of_attribute = self.encode_associations(associations, str)
+            encoded_str = "#{encoded_associations}."
+          end
+          encoded_str << self.encode_attribute(attr_name, parent_of_attribute)
+        else
+          encoded_str = str
+        end
+        
+        encoded_str
+      end
+      
+      def encode_associations(associations, ransack_name)
+        klass = self.klass
+        encoded_str = ""
+        
+        associations.each_with_index do |assoc, i|
+          encoded_str << "_" unless i == 0
+          encoded_str << klass.ransackable_assoc_abbr_for(assoc.name.to_s)
+          if assoc.options[:polymorphic] && (match = ransack_name.match(/_of_([^_]+?)_type.*$/))
+            # Polymorphic belongs_to format detected
+            # Lookup the association abbreviation out of all association abbreviations, as the value 
+            # can be the name of any model (e.g. PersonItem...which is why we underscore)
+            klass_name = match.captures.first
+            encoded_str << "_of_#{RansackAbbreviator.assoc_abbreviation_for(klass_name.underscore)}_type"
+            klass = Kernel.const_get(klass_name)
+          else
+            klass = assoc.klass
+          end
+        end
+        
+        [encoded_str, klass]
+      end
+      
+      def encode_attribute(attr_name, parent=@klass)
+        parent.ransackable_column_abbr_for(attr_name)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+module RansackAbbreviator
+  module Adapters
+    module ActiveRecord
+      module Base
+
+        def self.extended(base)
+          base.class_eval do
+            class_attribute :_ransack_column_abbreviations, :_ransack_assoc_abbreviations
+          end
+        end
+        
+        def ransack_abbreviate_column(column_name, column_abbr)
+          ransack_abbreviate_column!(column_name, column_abbr) rescue {}
+        end
+        
+        def ransack_abbreviate_column!(column_name, column_abbr)
+          raise ActiveModel::MissingAttributeError, "missing attribute: #{column_name}" unless column_names.include?(column_name) 
+          raise "column #{self.ransackable_column_abbreviations.key(column_abbr)} has abbreviaiton #{column_abbr}" if self.ransackable_column_abbreviations.has_value?(column_abbr)
+          self._ransack_column_abbreviations[column_name] = column_abbr
+        end
+        
+        def ransack_abbreviate_assoc(assoc_name, assoc_abbr)
+          ransack_abbreviate_assoc!(assoc_name, assoc_abbr) rescue {}
+        end
+        
+        def ransack_abbreviate_assoc!(assoc_name, assoc_abbr)
+          raise ActiveModel::MissingAttributeError, "missing association: #{assoc_name}" unless reflect_on_all_associations.map{|a| a.name.to_s}.include?(assoc_name) 
+          raise "association #{self.ransackable_assoc_abbreviations.key(assoc_abbr)} has abbreviaiton #{assoc_abbr}" if self.ransackable_assoc_abbreviations.has_value?(assoc_abbr)
+          self._ransack_assoc_abbreviations[assoc_name] = assoc_abbr
+        end
+        
+        def ransackable_column_abbreviations
+          self._ransack_column_abbreviations ||= RansackAbbreviator.column_abbreviations.select{ |key, val| column_names.include?(key) }
+        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) }
+        end
+        
+        def ransackable_column_name_for(possible_abbr)
+          possible_abbr = possible_abbr.to_s
+          column_names.include?(possible_abbr) ? possible_abbr : self.ransackable_column_abbreviations.key(possible_abbr)
+        end
+        
+        def ransackable_column_abbr_for(column_name)
+          column_name = column_name.to_s
+          self.ransackable_column_abbreviations.has_key?(column_name) ? self.ransackable_column_abbreviations[column_name] : column_name
+        end
+        
+        def ransackable_assoc_name_for(possible_abbr)
+          possible_abbr = possible_abbr.to_s
+          reflect_on_all_associations.map{|a| a.name.to_s}.include?(possible_abbr) ? possible_abbr : self.ransackable_assoc_abbreviations.key(possible_abbr)
+        end
+        
+        def ransackable_assoc_abbr_for(assoc)
+          assoc = assoc.to_s
+          self.ransackable_assoc_abbreviations.has_key?(assoc) ? self.ransackable_assoc_abbreviations[assoc] : assoc
+        end
+      end
+    end
+  end
+end

data/lib/ransack_abbreviator/adapters/active_record.rb

@@ -0,0 +1,3 @@
+require 'active_record'
+require 'ransack_abbreviator/adapters/active_record/base'
+ActiveRecord::Base.extend RansackAbbreviator::Adapters::ActiveRecord::Base

data/lib/ransack_abbreviator/configuration.rb

@@ -0,0 +1,32 @@
+require "pathname"
+
+module RansackAbbreviator
+  module Configuration
+    mattr_accessor :column_abbreviations, :assoc_abbreviations
+    self.column_abbreviations = self.assoc_abbreviations = {}
+    
+    def configure
+      yield self
+    end
+    
+    def column_abbreviation_for(column)
+      self.column_abbreviations.has_key?(column) ? self.column_abbreviations[column] : column
+    end
+    
+    def column_name_for(column_abbr)
+      self.column_abbreviations.has_value?(column_abbr) ? self.column_abbreviations.key(column_abbr) : column_abbr
+    end
+    
+    def assoc_abbreviation_for(assoc)
+      self.assoc_abbreviations.has_key?(assoc) ? self.assoc_abbreviations[assoc] : assoc
+    end
+    
+    def assoc_name_for(assoc_abbr)
+      self.assoc_abbreviations.has_value?(assoc_abbr) ? self.assoc_abbreviations.key(assoc_abbr) : assoc_abbr
+    end
+    
+    def config_dir
+      defined?(Rails) ? Rails.root.join("config") : Pathname.new("config")
+    end
+  end
+end

data/lib/ransack_abbreviator/constants.rb

@@ -0,0 +1,5 @@
+module RansackAbbreviator
+  module Constants
+    RESERVED_KEYWORDS = %w(or and of type)
+  end
+end

data/lib/ransack_abbreviator/ransack_extensions/context.rb

@@ -0,0 +1,34 @@
+require 'ransack_abbreviator/abbreviators/decoder'
+require 'ransack_abbreviator/abbreviators/encoder'
+
+module Ransack
+  class Context
+    include RansackAbbreviator::Abbreviators::Decoder
+    include RansackAbbreviator::Abbreviators::Encoder
+    
+    def get_associations_and_attribute(str, klass = @klass, associations = [])
+      attr_name = nil
+      if ransackable_attribute?(str, klass)
+        attr_name = str
+      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)
+            attr_name = remainder.join('_')
+            associations, attr_name = get_associations_and_attribute(attr_name, poly_class || found_assoc.klass, associations << found_assoc)
+          end
+        end
+      end
+
+      [associations, attr_name]
+    end
+    
+    private
+    
+    def polymorphic_association_specified?(str)
+      str && str.match(/_of_([^_]+?)_type$/)
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Ransack
+  module Nodes
+    class Condition
+      alias_method :ransack_condition_build, :build
+      
+      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)
+        end
+        params[:a] = decoded_attr_names
+        ransack_condition_build(params)
+      end
+    end
+  end
+end

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

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

data/lib/ransack_abbreviator/ransack_extensions/search.rb

@@ -0,0 +1,30 @@
+module Ransack
+  class Search
+    alias_method :ransack_search_build, :build
+    
+    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
+      end
+
+      ransack_search_build(new_params)
+    end
+  end
+end

data/lib/ransack_abbreviator/version.rb

@@ -0,0 +1,3 @@
+module RansackAbbreviator
+  VERSION = "0.0.1"
+end

data/lib/ransack_abbreviator/view_helpers.rb

@@ -0,0 +1,39 @@
+module RansackAbbreviator
+  module ViewHelpers
+    def ransack_abbreviation_for(ransack_search_object, ransack_name)
+      str = ransack_name.is_a?(Symbol) ? ransack_name.to_s : ransack_name.dup
+      pred = Ransack::Predicate.detect_and_strip_from_string!(str)
+      conjunctions = str.split("_").select{|s| s == "and" || s == "or" }
+      abbr_str = ""
+      str.split(/_and_|_or_/).each do |s|
+        abbr_str << ransack_search_object.context.encode_ransack_str(s)
+        abbr_str << "_#{conjunctions.shift}_" if !conjunctions.blank?
+      end
+      
+      pred ? "#{abbr_str}_#{pred}" : abbr_str
+    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