acts_as_data_table 0.0.1 → 0.0.2

data/app/helpers/acts_as_data_table_helper.rb

@@ -147,8 +147,8 @@ module ActsAsDataTableHelper
     if block_given?
       yield sortable
     else
-      renderer = renderer_class.constantize.new(sortable, self)
-      renderer.to_html
+      renderer = renderer_class.is_a?(Class) ? renderer_class : renderer_class.constantize
+      renderer.new(sortable, self).to_html
     end
   end
 

data/config/locales/acts_as_data_table.en.yml

@@ -9,3 +9,4 @@ en:
         general_error:  "The scope filter could not be applied successfully"
         invalid_date:   "%{arg_name} ('%{arg_value}') is not a valid date"
         invalid_record: "The filter argument '%{arg_name}' did not match any valid record in the system."
+        blank:          "The argument '%{arg_name}' has to be given."

data/lib/acts_as_data_table.rb

@@ -16,6 +16,7 @@ require 'acts_as_data_table/scope_filters/form_helper'
 #Sortable Column Renderers
 require 'acts_as_data_table/sortable_columns/renderers/default'
 require 'acts_as_data_table/sortable_columns/renderers/bootstrap2'
+require 'acts_as_data_table/sortable_columns/renderers/bootstrap3'
 
 module ActsAsDataTable
 end

data/lib/acts_as_data_table/scope_filters/validator.rb

@@ -97,7 +97,7 @@ module Acts
               elsif @model.respond_to?(proc)
                 result = @model.send(proc, @args)
               else
-                raise ArgumentError.new "The method '#{@proc}' was set up as scope filter validation method in model '#{@model.name}', but doesn't exist."
+                raise ArgumentError.new "The method '#{proc}' was set up as validation method for the scope '#{@scope}' in group '#{@group}' of model '#{@model.name}', but doesn't exist."
               end
             when NilClass
               result = true

data/lib/acts_as_data_table/sortable_columns/renderers/bootstrap3.rb

@@ -0,0 +1,17 @@
+module Acts
+  module DataTable
+    module SortableColumns
+      module Renderers
+        class Bootstrap3 < Default
+          def direction_indicator
+            if @sortable.direction == 'ASC'
+              @action_view.content_tag(:i, nil, :class => 'glyphicon glyphicon-sort-by-attributes')
+            else
+              @action_view.content_tag(:i, nil, :class => 'glyphicon glyphicon-sort-by-attributes-alt')
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/acts_as_data_table/version.rb

@@ -1,3 +1,3 @@
 module ActsAsDataTable
-  VERSION = '0.0.1'
+  VERSION = '0.0.2'
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: acts_as_data_table
 version: !ruby/object:Gem::Version 
-  hash: 29
+  hash: 27
   prerelease: 
   segments: 
   - 0
   - 0
-  - 1
-  version: 0.0.1
+  - 2
+  version: 0.0.2
 platform: ruby
 authors: 
 - Stefan Exner
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2015-04-30 00:00:00 Z
+date: 2015-05-01 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: bundler
@@ -90,16 +90,14 @@ files:
 - lib/acts_as_data_table/scope_filters/active_record.rb
 - lib/acts_as_data_table/scope_filters/form_helper.rb
 - lib/acts_as_data_table/scope_filters/validator.rb
-- lib/acts_as_data_table/session_helper.rb
 - lib/acts_as_data_table/shared/action_controller.rb
 - lib/acts_as_data_table/shared/session.rb
 - lib/acts_as_data_table/sortable_columns/action_controller.rb
 - lib/acts_as_data_table/sortable_columns/active_record.rb
 - lib/acts_as_data_table/sortable_columns/renderers/bootstrap2.rb
+- lib/acts_as_data_table/sortable_columns/renderers/bootstrap3.rb
 - lib/acts_as_data_table/sortable_columns/renderers/default.rb
 - lib/acts_as_data_table/version.rb
-- lib/acts_as_data_table_helper.rb.bak
-- lib/named_scope_filters.rb
 - lib/tasks/acts_as_data_table.rake
 - rails/init.rb
 - test/acts_as_searchable_test.rb

data/lib/acts_as_data_table/session_helper.rb

@@ -1,193 +0,0 @@
-module Stex
-  module Acts
-    module DataTable
-      class SessionHelper
-        def initialize(session, controller_path, action, model_name)
-          @session         = session
-          @controller_path = controller_path
-          @action          = action
-          @model           = model_name.to_s.classify.constantize
-        end
-
-        def controller_path
-          @controller_path
-        end
-
-        def action_name
-          @action
-        end
-
-        def model
-          @model
-        end
-
-        #----------------------------------------------------------------
-        #                           Filters
-        #----------------------------------------------------------------
-
-        # Adds a filter for a specific view
-        # If a filter for this group is already set, the new filter
-        # will override the existing one.
-        #--------------------------------------------------------------
-        def add_filter(group, scope, args)
-          controller_key = action_key(controller_path, action_name)
-          @session[:scope_filters] ||= {}
-          @session[:scope_filters][controller_key] ||= {}
-
-          args = hash_keys_to_strings(args) if args
-
-          @session[:scope_filters][controller_key][group.to_s] = {scope.to_s => args}
-        end
-
-        # Removes an active filter. As only one filter per group can
-        # be active at a time, we can simply delete the whole group.
-        # If all filters are deleted, we can also remove the namespaces
-        # in the session
-        #--------------------------------------------------------------
-        def remove_filter(group)
-          controller_key = action_key(controller_path, action_name)
-          return unless @session[:scope_filters][controller_key]
-          @session[:scope_filters][controller_key].delete(group.to_s)
-          @session[:scope_filters].delete(controller_key) if @session[:scope_filters][controller_key].empty?
-          @session.delete(:scope_filters) if @session[:scope_filters].empty?
-        end
-
-        # Removes all filters from the given controller + action
-        #--------------------------------------------------------------
-        def remove_all_filters
-          @session[:scope_filters].delete(action_key(controller_path, action_name))
-        end
-
-        # Returns all active filters for the given controller and action
-        #--------------------------------------------------------------
-        def active_filters
-          return {} unless @session[:scope_filters]
-          @session[:scope_filters][action_key(controller_path, action_name)] || {}
-        end
-
-        # Checks if the given filter is currently active
-        #--------------------------------------------------------------
-        def active_filter?(group, scope, args)
-          active = active_filters
-          args = hash_keys_to_strings(args) if args
-
-          active.any? &&
-              active[group.to_s] &&
-              active[group.to_s].has_key?(scope.to_s) &&
-              (active[group.to_s][scope.to_s].to_a - args.to_a).empty? #sometimes the session hash contains {:raise => true}, whereever it comes from...
-        end
-
-        #----------------------------------------------------------------
-        #                         Column Sorting
-        #----------------------------------------------------------------
-
-        # Replaces all current sorting columns with the new one
-        #--------------------------------------------------------------
-        def replace_sorting_column(model_name, column_name)
-          args = generate_sorting_arguments(model_name, column_name)
-          return unless args[:model].column_names.include?(column_name.to_s)
-
-          @session[:column_sorting] ||= {}
-          @session[:column_sorting][args[:key]] = [[args[:column], 'ASC']]
-        end
-
-        # Adds a new sorting column to the current controller and action
-        #--------------------------------------------------------------
-        def add_or_toggle_sorting_column(model_name, column_name)
-          args = generate_sorting_arguments(model_name, column_name)
-
-          return unless args[:model].column_names.include?(column_name.to_s)
-
-          @session[:column_sorting] ||= {}
-          @session[:column_sorting][args[:key]] ||= []
-
-          existing_entry = @session[:column_sorting][args[:key]].assoc(args[:column])
-
-          #Toggle the direction
-          if existing_entry
-            idx = @session[:column_sorting][args[:key]].index(existing_entry)
-
-            direction = existing_entry.last == 'ASC' ? 'DESC' : 'ASC'
-
-            @session[:column_sorting][args[:key]].delete(existing_entry)
-
-            @session[:column_sorting][args[:key]].insert(idx, [args[:column], direction])
-          else
-            #Simply append the new column to the sorting list
-            @session[:column_sorting][args[:key]] << [args[:column], 'ASC']
-          end
-        end
-
-        # Removes a sorting column from current controller and action
-        #--------------------------------------------------------------
-        def remove_sorting_column(model_name, column_name)
-          args = generate_sorting_arguments(model_name, column_name)
-          return if @session[:column_sorting].nil? || @session[:column_sorting].empty?
-          return unless @session[:column_sorting].has_key?(args[:key])
-
-          existing_entry = @session[:column_sorting][args[:key]].assoc(args[:column])
-          @session[:column_sorting][args[:key]].delete(existing_entry) if existing_entry
-
-          #Remove the controller namespace from the session if it's empty
-          @session[:column_sorting].delete(args[:key]) if @session[:column_sorting][args[:key]].empty?
-        end
-
-        # Returns all sorting columns as a string
-        #--------------------------------------------------------------
-        def sorting_columns_string
-          controller_key = action_key(controller_path, action_name)
-          return nil if @session[:column_sorting].nil? || @session[:column_sorting].empty?
-          return nil unless @session[:column_sorting].has_key?(controller_key)
-
-          @session[:column_sorting][controller_key].map {|column_and_direction| column_and_direction.join(' ')}.join(', ')
-        end
-
-        # Returns the current sorting direction for a given column
-        # or nil if this column is currently not active.
-        #--------------------------------------------------------------
-        def sorting_direction(model_name, column_name)
-          args = generate_sorting_arguments(model_name, column_name)
-
-          return nil if @session[:column_sorting].nil? || @session[:column_sorting].empty?
-          return nil unless @session[:column_sorting].has_key?(args[:key])
-          entry = @session[:column_sorting][args[:key]].assoc(args[:column])
-          entry ? entry.last : nil
-        end
-
-        # loads the sorting defaults for the current action
-        # Parameters==
-        #   defaults:: [['users.last_name', 'ASC'], ['users.first_name', 'ASC']]
-        #--------------------------------------------------------------
-        def load_sorting_defaults(defaults = [])
-          return if defaults.empty?
-          controller_key = action_key(controller_path, action_name)
-          @session[:column_sorting] = {}
-          @session[:column_sorting][controller_key] = defaults
-        end
-
-        private
-
-        def generate_sorting_arguments(model_name, column_name)
-          model = model_name.to_s.classify.constantize
-          {
-              :model  => model,
-              :key    => action_key(controller_path, action_name),
-              :column => "#{model.table_name}.#{column_name}"
-          }
-        end
-
-        def action_key(controller, action)
-          [controller.gsub("/", "_"), action].join('_')
-        end
-
-        def hash_keys_to_strings(hash)
-          new_hash = {}
-          hash.each do |key, value|
-            new_hash[key.to_s] = value
-          end
-          new_hash
-        end
-      end
-    end
-  end
-end

data/lib/acts_as_data_table_helper.rb.bak

@@ -1,165 +0,0 @@
-module ActsAsDataTableHelper
-
-  def scope_filter_link(group, filter, options = {})
-
-  end
-#
-#   #----------------------------------------------------------------
-#   #                          Filters
-#   #----------------------------------------------------------------
-#
-#   # Generates a link to to add or remove a certain filter to the
-#   # current controller/action.
-#   # Parameters:
-#   # +group+::            The group name the filter belongs to
-#   #
-#   # ===Options
-#   #   +:filter+::        The filter name to be applied
-#   #   +:caption+::       The link caption, defaults to a localization
-#   #   +:remove+::        If set to +true+, the filter will be removed instead of (re-)added
-#   #   +:args+::          Args to be used when applying the filter
-#   #   +:auto_remove+::   If set to true, a click on an active filter will remove it again.
-#   #
-#   #   All other options will be used as html_options for the resulting link
-#   #--------------------------------------------------------------
-#   def scope_filter_link(group, options = {})
-#     filter_name     = options.delete(:filter)
-#     caption         = options.delete(:caption) || t("activerecord.scopes.#{searchable_session.model.table_name}.#{filter_name}")
-#     args            = options.delete(:args)
-#     surrounding_tag = options.delete(:surrounding)
-#     auto_remove     = options.delete(:auto_remove) && searchable_session.active_filter?(group, filter_name, args)
-#     remove          = options.delete(:remove)
-#
-#     if remove || auto_remove
-#       url = {:scope_filters => {:remove => group}}
-#     else
-#       url = {:scope_filters => {:group => group, :name => filter_name, :args => args}}
-#     end
-#
-#     classes = options[:class].try(:split, ' ') || []
-#     classes << 'active' if searchable_session.active_filter?(group, filter_name, args)
-#     options[:class] = classes.join(' ')
-#     link = link_to_remote caption, :url => url, :method => :get, :html => options
-#     surrounding_tag ? content_tag(surrounding_tag, link, :class => options[:class]) : link
-#   end
-#
-#   # Generates the URL to remove all filters from the current action
-#   #--------------------------------------------------------------
-#   def remove_all_scope_filters_url
-#     {:scope_filters => {:remove_all => true}}
-#   end
-#
-#   # Generates the URL to be used as form action to add a new filter
-#   #--------------------------------------------------------------
-#   def scope_filter_form_url(group, filter_name)
-#     {:scope_filters => {:group => group, :name => filter_name}}
-#   end
-#
-#   # Generates the form element name for filter args inside
-#   # a form
-#   #--------------------------------------------------------------
-#   def scope_filter_field_name(arg_name)
-#     "scope_filters[args][#{arg_name}]"
-#   end
-#
-#   # Generates a form field id for the given scope and arg
-#   #--------------------------------------------------------------
-#   def scope_filter_field_id(scope, arg_name)
-#     [scope, arg_name].join('_')
-#   end
-#
-#   # Builds the caption for an active filter
-#   #--------------------------------------------------------------
-#   def scope_filter_caption(active_filter)
-#     searchable_session.model.scope_caption(active_filter[:filter], active_filter[:args])
-#   end
-#
-#   # Returns the arguments for a currently active filter or nil
-#   # if the given filter is currently not active.
-#   #-------------------------------------------------------------
-#   def scope_filter_arg(filter_name, arg_name)
-#     @filter_args ||= {}
-#     @filter_args[filter_name.to_s] ||= {}
-#
-#     unless @filter_args[filter_name.to_s].has_key? arg_name.to_s
-#       filter = active_scope_filters.select{|f| f[:filter].to_s == filter_name.to_s}.first
-#       if filter
-#         @filter_args[filter_name.to_s] = filter[:args]
-#       else
-#         #If the filter is currently not active, cache the argument anyway with nil
-#         @filter_args[filter_name.to_s] ||= {}
-#         @filter_args[filter_name.to_s][arg_name.to_s] = nil
-#       end
-#     end
-#
-#     @filter_args[filter_name.to_s][arg_name.to_s]
-#   end
-#
-#   # Returns all active filters in a format which is easier to
-#   # process than the original hash structure. Each element of the
-#   # returned array contains the following properties:
-#   #
-#   # +:delete_url+:: A url hash which contains the necessary parameters to
-#   #                 remove the current filter from the active list
-#   #
-#   # +:group+::      The filter group this filter is in (in case you want to
-#   #                 user the +filter_link+ helper method)
-#   #
-#   # +:filter+::     The filter name
-#   #
-#   # +:args+::       The arguments the filter was applied to (for display reasons)
-#   #--------------------------------------------------------------
-#   def active_scope_filters
-#     return @active_filters if @active_filters
-#
-#     @active_filters = []
-#     searchable_session.active_filters.each do |group, filters|
-#       filters.each do |filter, args|
-#         @active_filters << {:delete_url => {:scope_filters => {:remove => group}},
-#                             :group      => group,
-#                             :filter     => filter,
-#                             :args       => HashWithIndifferentAccess.new(args)}
-#       end
-#     end
-#     @active_filters
-#   end
-#
-#   # Returns the active scope filter for a given filter group
-#   # If you hand in a block, the filter will be available inside
-#   # If there is no active filter for the given group,
-#   # the block is not executed.
-#   #--------------------------------------------------------------
-#   def active_scope_filter(group, &proc)
-#     filter = active_scope_filters.select {|sf| sf[:group].to_s == group.to_s}.first
-#     if block_given?
-#       yield filter if filter
-#     else
-#       filter
-#     end
-#   end
-#
-#   #----------------------------------------------------------------
-#   #                        Sorting Columns
-#   #----------------------------------------------------------------
-#
-#   def sortable_column(model_name, column_name, caption = nil, &proc)
-#     sortable = Struct.new(:caption, :direction, :active, :url_replace, :url_add_toggle, :url_remove).new
-#
-#     sortable.direction      = searchable_session.sorting_direction(model_name, column_name)
-#     sortable.active         = sortable.direction.present?
-#
-#     sortable.url_replace    = {:sorting_columns => {:replace => true, :model_name => model_name, :column_name => column_name}}
-#     sortable.url_add_toggle = {:sorting_columns => {:add     => true, :model_name => model_name, :column_name => column_name}}
-#     sortable.url_remove     = {:sorting_columns => {:remove  => true, :model_name => model_name, :column_name => column_name}}
-#     sortable.caption        = caption
-#
-#
-#     #If a block is given, we let the user handle the content of the table
-#     #header himself. Otherwise, we'll generate the default links.
-#     if block_given?
-#       yield sortable
-#     else
-#       render :partial => 'shared/sortable_column', :object => sortable
-#     end
-#   end
-end

data/lib/named_scope_filters.rb

@@ -1,273 +0,0 @@
-module Stex
-  module Acts
-    module DataTable
-      module NamedScopeFilters
-        module ActiveRecord
-          def self.included(base)
-            base.send :extend, ClassMethods
-          end
-
-          module ClassMethods
-            # Generates methods to automatically combine named scopes
-            # based on the given input
-            # Arguments are all named scopes you'd like to include into
-            # The parameter includes all filters which may be used by the automatic
-            # data filtering later.
-            # {:group_name => [scope1, scope2, [scope_with_arguments, arg1, arg2], scope4]}
-            #--------------------------------------------------------------
-            def has_named_scope_filters(filter_groups = {})
-              if filter_groups.empty? #No groups given, no filters created
-                throw 'is_named_scope_filterable needs arguments to run.'
-              end
-
-              #Convert filters
-              filter_groups.each do |group_name, filters|
-                filters = Array(filters)
-                filters.map! {|f| Array(f)}
-
-                #Check if all given named scopes actually exist
-                filters.each do |ns|
-                  scope_name = ns.first
-                  logger.warn "The scope '#{scope_name}' in group '#{group_name}' does not exist." unless scopes.has_key?(scope_name)
-                end
-              end
-
-              #Create a method to test if a given filter is valid
-              define_singleton_method 'named_scope_filter?' do |group, name, args|
-                filter_groups[group] && filter_groups[group].assoc(name).present?
-              end
-
-              #Generate a method to actually apply the various filters to the current
-              #model.
-              define_singleton_method(:apply_scope_filters) do |scope_filter_groups|
-                result = self
-                scope_filter_groups.each do |group_name, scope_filters|
-                  set_scopes = filter_groups[group_name.to_sym]
-                  scope_filters.each do |filter, args|
-                    set_filter = set_scopes.assoc(filter.to_sym)
-                    arg_names  = set_filter.drop(1)
-                    scope_args = arg_names.map {|a| args[a.to_s]}
-                    result = result.send(set_filter.first, *scope_args)
-                  end
-                end
-                result
-              end
-
-              #Generate a method to label applied filters.
-              #This method only does default labelling and will most likely be
-              #overridden in the actual model
-              define_singleton_method(:scope_caption) do |scope_name, args|
-                options = {:scope => "activerecord.scopes.#{table_name}", :default => scope_name}
-                symbol_args = {}
-                args.each do |k,v|
-                  symbol_args[k.to_sym] = v
-                end
-                I18n.t(scope_name, options.merge(symbol_args))
-              end
-            end
-
-            #def is_named_scope_sortable(*args)
-            #  options = args.pop if args.last.is_a?(Hash)
-            #  processed_args = args.map {|a| generate_sortable_columns_and_includes(a)}.flatten
-            #
-            #  column_names = []
-            #  unfiltered_includes = []
-            #
-            #  processed_args.each do |arg|
-            #    column_names += arg[:columns]
-            #    unfiltered_includes += arg[:includes]
-            #  end
-            #
-            #  #TODO: filter longer include chains, have to get a real example first.
-            #
-            #
-            #  1
-            #end
-
-
-            ## Processes arguments for the sortable generator
-            ## Returns column names and necessary includes
-            ##--------------------------------------------------------------
-            #def generate_sortable_columns_and_includes(arg, model = self)
-            #  columns  = []
-            #  includes = []
-            #  #Associations from the current model
-            #  if arg.is_a?(Hash)
-            #    arg.each do |association_name, columns_and_associations|
-            #      association_endpoint = Stex::Acts::Searchable::DataHolder.graph.associations_for(model)[association_name.to_s]
-            #      Array(columns_and_associations).each do |new_arg|
-            #        processed_arg = generate_sortable_columns_and_includes(new_arg, association_endpoint)
-            #        columns += processed_arg[:columns]
-            #        if processed_arg[:includes].any?
-            #          includes << {association_name => processed_arg[:includes]}
-            #        else
-            #          includes << association_name if processed_arg[:columns].any?
-            #        end
-            #      end
-            #    end
-            #  else
-            #    columns << "#{model.table_name}.#{arg}" if model.column_names.include?(arg.to_s)
-            #  end
-            #
-            #  {:columns => columns, :includes => includes}
-            #end
-          end
-        end
-
-        module ActionController
-          def self.included(base)
-            base.send :extend, ClassMethods
-          end
-
-          module ClassMethods
-            # Generates the necessary controller methods to add and remove filters
-            # Expects the model name and a list of methods the filters will be used for
-            # Important: Do not use the model constant (e.g. User), it might break
-            # your database setup.
-            #
-            # == Examples
-            # scope_filters :user, :index
-            #--------------------------------------------------------------
-            def scope_filters(model_name, *args)
-              helper_method :searchable_session
-
-              before_filter :add_scope_filter, :only => args
-              before_filter :remove_scope_filter, :only => args
-              before_filter :remove_all_scope_filters, :only => args
-              before_filter :load_active_scope_filters, :only => args
-
-              helper :acts_as_data_table
-
-              # Adds a filter to the current data table. Works with the
-              # named scope filterable plugin.
-              # Expects the following params to be set:
-              #  :scope_filters =>
-              #   :group -- The group the named scope belongs to
-              #   :name  -- The named scope name inside the group
-              #   :args  -- Array of arguments to be passed to the named scope
-              # If any of these params (except filter_args which is optional)
-              # is not set, the filter will not be added.
-              #--------------------------------------------------------------
-              define_method(:add_scope_filter) do
-                return if params[:scope_filters].blank?
-                return if [:group, :name].any? { |p| params[:scope_filters][p].blank? }
-
-                group = params[:scope_filters][:group].to_sym
-                name  = params[:scope_filters][:name].to_sym
-                args  = params[:scope_filters][:args]
-                args  = nil if args.blank? #No empty string here
-
-                model = model_name.to_s.classify.constantize
-
-                #If the given filter is not valid, do not add it to the filters list
-                return unless model.named_scope_filter?(group, name, args)
-                searchable_session.add_filter(group, name, args)
-              end
-
-              # Removes a filter from the current data table.
-              # Expects the following params to be set:
-              # :scope_filters =>
-              #   :group -- The group the named scope belongs to
-              #   :remove => true
-              #--------------------------------------------------------------
-              define_method(:remove_scope_filter) do
-                return if params[:scope_filters].blank?
-                return if params[:scope_filters][:remove].blank?
-                searchable_session.remove_filter(params[:scope_filters][:remove])
-              end
-
-              # Removes all filters from the current controller and action
-              #--------------------------------------------------------------
-              define_method(:remove_all_scope_filters) do
-                return if params[:scope_filters].blank?
-                return if params[:scope_filters][:remove_all].blank?
-                searchable_session.remove_all_filters
-              end
-
-              # Session Helper instance accessor
-              #--------------------------------------------------------------
-              define_method(:searchable_session) do
-                @searchable_session = Stex::Acts::DataTable::SessionHelper.new(session, controller_path, action_name, model_name)
-              end
-
-              # Loads the active filters into an instance variable, just in case
-              # that naming changes later
-              #--------------------------------------------------------------
-              define_method(:load_active_scope_filters) do
-                @loaded_scope_filters = searchable_session.active_filters
-              end
-
-              #Make the helper methods private so rails does not handle them as actions
-              private :add_scope_filter, :remove_scope_filter, :searchable_session, :load_active_scope_filters
-            end
-
-            # Adds methods for automatic column sorting to the controller
-            # Parameters:
-            # actions_and_defaults:: Hash of actions which will be used to
-            #         display sortable content and their initial sorting
-            #         columns.
-            #
-            # == Example
-            #   column_sorting :index => [['users.last_name', 'ASC'], ['users.first_name', 'ASC']]
-            #--------------------------------------------------------------
-            def column_sorting(actions_and_defaults = {})
-
-              before_filter :add_or_toggle_sorting_column, :only => actions_and_defaults.keys
-              before_filter :replace_sorting_column, :only => actions_and_defaults.keys
-              before_filter :remove_sorting_column, :only => actions_and_defaults.keys
-              before_filter :load_sorting_columns, :only => actions_and_defaults.keys
-
-              param_namespace = :sorting_columns
-
-              # Adds a sorting column to the current sorting columns or
-              # toggles its direction if it is already part of the
-              # active sorting.
-              #
-              # Parameters
-              #   :sorting_columns => {
-              #     :model_name  => 'sale',
-              #     :column_name => 'reference'
-              #   }
-              #--------------------------------------------------------------
-              define_method(:add_or_toggle_sorting_column) do
-                return if params[param_namespace].blank?
-                return if [:add, :model_name, :column_name].select {|p| params[param_namespace][p].blank?}.any?
-                searchable_session.add_or_toggle_sorting_column(params[param_namespace][:model_name], params[param_namespace][:column_name])
-              end
-
-              # Replaces all current sorting columsn with the given one
-              #--------------------------------------------------------------
-              define_method(:replace_sorting_column) do
-                return if params[param_namespace].blank?
-                return if [:replace, :model_name, :column_name].select {|p| params[param_namespace][p].blank?}.any?
-                searchable_session.replace_sorting_column(params[param_namespace][:model_name], params[param_namespace][:column_name])
-              end
-
-              # Removes a column from the current sorting columns
-              #--------------------------------------------------------------
-              define_method(:remove_sorting_column) do
-                return if params[param_namespace].blank?
-                return if [:remove, :model_name, :column_name].select {|p| params[param_namespace][p].blank?}.any?
-                searchable_session.remove_sorting_column(params[param_namespace][:model_name], params[param_namespace][:column_name])
-              end
-
-              # Loads the current sorting string into an instance variable
-              #--------------------------------------------------------------
-              define_method(:load_sorting_columns) do
-                @current_sorting_string = searchable_session.sorting_columns_string
-
-                #If there is no user-set sorting, load the default sorting into the session.
-                if @current_sorting_string.blank?
-                  searchable_session.load_sorting_defaults(actions_and_defaults[action_name.to_sym])
-                end
-
-                @current_sorting_string = searchable_session.sorting_columns_string
-              end
-
-            end
-          end
-        end
-      end
-    end
-  end
-end