jquery-tablesorter-rails-utils 0.0.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 78cbade05c4684cc14f69a730fef1e7dd40ec1b1
-  data.tar.gz: dc91520ae73b330131ff2e2c8adf1f659f7e6b77
+SHA256:
+  metadata.gz: 6d98212066f5ac93fe21031a01671d3ff844b63839b916aa59bdbf83b6c93d9f
+  data.tar.gz: 1a54f4773bcae58fe0e44f3aecef78f79908a57d137e90edc7dd9d1a1efc5ac6
 SHA512:
-  metadata.gz: d813e7bcdae763cd440088a3d71d37164d9758f5f8f23d11c8dff9328f1811c6dbce53f28771bb592c43bc31748199b84a77e93658460ec2c29c1d51fc8af39c
-  data.tar.gz: f5eaae71f1dc5fe2e92ec1e2273108ba187dd0c481e8ad84bd5122998e26d17bd9d022358614546afb9b8b1a0fc4b95706d6a7acd8951e86a773a9ddfed5e467
+  metadata.gz: a0e372bf08248ffb06ae896fd9c8c182d1da90ed3c947fb5e0c2e9b09168910781926960beb29739d67f7a265e5eeb4f7ff4702d7b3da058058745b51c4b1a88
+  data.tar.gz: 8df400686e4d15a9cd0cd33ff70e5182c91aea9fd33e57a399b7470c92130f43ec50833aeccdf28daecc347bdeb011843b7721eed51ad44706fb537320e80036

data/CHANGELOG.md

@@ -1,3 +1,13 @@
 # Change Log
 
-## 0.1.0 (2016-09-30) (initial release)
+## 0.2.0 (2020-01-09)
+
+### Important Notice
+This version changes the whole interface of the gem. In case you used it, it will require changes.
+Also please note that the documentation wasn't changed yet.
+
+### Changed
+* Mostly everything.
+* Rails 6 support
+
+## 0.1.0 (2016-09-28) (initial release)

data/Gemfile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 source 'https://rubygems.org'
 
 # Specify your gem's dependencies in jquery-tablesorter-rails-utils.gemspec

data/README.md

@@ -1,5 +1,7 @@
 # Jquery::Tablesorter::Rails::Utils
 
+[![Gem Version](https://badge.fury.io/rb/jquery-tablesorter-rails-utils.svg)](https://badge.fury.io/rb/jquery-tablesorter-rails-utils)
+
 Helpful (hopefully! ;-) ) additions for jQuery tablesorter (only support for [Mottie's fork] targeted) when working with rails.
 
 While still in early development - which might bring breaking changes with new releases - it is meant to provide helpful utilities for jquery-tablesorter in rails. At the current state of development it only supports a mechanism to help to work with Ajax based tables.
@@ -26,7 +28,9 @@ Or install it yourself as:
 
     $ gem install jquery-tablesorter-rails-utils
 
-## Usage
+## Usage (Attention: OUTDATED!)
+
+!!! The following information might not fully apply to version 0.2.0 !!!
 
 ### Module: Ajax
 

data/Rakefile

@@ -1,2 +1,4 @@
-require "bundler/gem_tasks"
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
 task default: :spec

data/jquery-tablesorter-rails-utils.gemspec

@@ -1,5 +1,6 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'jquery-tablesorter/rails-utils/version'
 
@@ -14,18 +15,19 @@ Gem::Specification.new do |spec|
   spec.homepage      = 'https://github.com/themilkman/jquery-tablesorter-rails-utils'
   spec.license       = 'MIT'
 
-  spec.required_ruby_version = '>= 1.9.3'
 
-  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+  spec.required_ruby_version = '>= 2.4.0'
+
+  spec.files = `git ls-files -z`.split("\x0").reject do |f|
     f.match(%r{^(test|spec|features)/})
   end
 
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'activerecord',  '>= 4.0', '< 6.0'
-  spec.add_dependency 'activesupport', '>= 4.0', '< 6.0'
-  spec.add_dependency 'actionview',    '>= 4.0', '< 6.0'
   spec.add_dependency 'pg'
+  spec.add_dependency 'actionview',    '>= 5.0', '< 7.0'
+  spec.add_dependency 'activerecord',  '>= 5.0', '< 7.0'
+  spec.add_dependency 'activesupport', '>= 5.0', '< 7.0'
 
   spec.add_development_dependency 'bundler', '~> 1.13'
   spec.add_development_dependency 'rake',    '~> 10.0'

data/lib/jquery-tablesorter-rails-utils.rb

@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 require 'jquery-tablesorter/rails-utils/version'
 require 'jquery-tablesorter/rails-utils/ajax'

data/lib/jquery-tablesorter/rails-utils/ajax.rb

@@ -1,20 +1,6 @@
-# Adds mechanisms to work with Ajax based tables and tablesorter.
-# Current limitions (extract ;-P):
-# * It does not support sorting by multiple columns.
-# * Currently only PostgreSQL is supported
-#
-# Usage:
-# Includet this module in your controller and call methods in your query-action,
-# where the results can be used to build the response.
-#
-# Further ToDos/plans/ideas/dreams:
-# * There might be a possibility to pass a block for each column-operation such
-#   as filtering or sorting and allow more dynamic work. This might happen before or better
-#   instead the standard processing. (partly done with the filter_mapping filter-parameter)
-# * Maybe it'd be possible to allow multi-column sorting somehow.
-# * In some cases it could make sense not to cast all columns to strings/varchars. So, an optionally passed
-#   type for a column might get evaluated/used in a different manner. (done for DateTime)
+# frozen_string_literal: true
 
+# Adds mechanisms to work with Ajax based tables and tablesorter.
 module JqueryTablesorter
   module RailsUtils
     module Ajax

data/lib/jquery-tablesorter/rails-utils/ajax/action_controller.rb

@@ -1,39 +1,52 @@
+# frozen_string_literal: true
+
 # Controller concern to help with ajax jquery tablesorter requests.
 # It handles sorting and filtering.
-
+# Current limitions (extract ;-P):
+# * It does not support sorting by multiple columns.
+#
+# Usage:
+# Include module in controller and call methods in query-action,
+# where the results can be used to build the response.
+#
+# Further ToDos/plans/ideas/dreams:
+# * Also, there might be a possibility to pass a block for each column-operation such
+#   as filtering or sorting and allow more dynamic work. This might happen before or better
+#   instead the standard processing.
+# * Maybe it'd be possible to allow multi-column sorting somehow.
+# * In some cases it could make sense not to cast all columns to strings/varchars. So, an optionally passed
+#   type for a column might get evaluated/used in a different manner.
+# * Evaluate if the position of a column should be passed to the columns (in other words:  useful?!)
 module JqueryTablesorter
   module RailsUtils
     module Ajax
       module ActionController
         extend ActiveSupport::Concern
 
-
         # A generalized method to handle tablesorter queries. It's meant to be used in the corresponding
         # Controller action. Params:
         # clazz:              The model's primary class
         # base_query:         If there are any relevant joins or so -> pass the AR relation here
         # partial (optional): path to the partial to be rendered
-        def create_query_html_response(base_query, partial: 'row')
-          resp_data         = ts_ajax_handler.query_data(base_query)
+        def create_query_html_response(base_query, partial: 'row', locals: {})
+          resp_data        = ts_ajax_handler.query_data(base_query)
+          records          = resp_data.delete(:records)
+          resp_data[:data] = render_response_html(records, partial: partial, locals: locals)
 
-          records           = resp_data.delete(:records)
-          resp_data[:data]  = render_response_html(records, partial: partial)
-
-          return resp_data
+          resp_data
         end
 
         private
 
         # Render the html rows for the given records and an optional named partial.
         # Returns HTML string or nil
-        def render_response_html(records, partial: 'row' )
-          output = render_to_string partial: partial, locals: { records: records }
+        def render_response_html(records, partial: 'row', locals: {} )
+          output = render_to_string(partial: partial, locals: { records: records }.merge(locals))
 
-          unless records.any? # if the query had 0 results, it will return a string which has let jquery crash
-            output = nil
-          end
+          # if the query has no results, it will return a string which causes jquery to crash
+          output = nil unless records.any?
 
-          return output
+          output
         end
 
         def ts_ajax_handler
@@ -41,11 +54,12 @@ module JqueryTablesorter
         end
 
         def tablesorter_params
-          params.permit(:page, :size, :controller, :action, :query, :sort, :filter,
-            { sort:           params[:sort].try(:keys) },
-            { filter:         params[:filter].try(:keys) })
+          params.permit(
+            :page, :size, :controller, :action, :query, :sort, :filter,
+            { sort:   params[:sort].try(:keys) },
+            { filter: params[:filter].try(:keys) }
+          )
         end
-
       end
     end
   end

data/lib/jquery-tablesorter/rails-utils/ajax/filter.rb

@@ -1,60 +1,61 @@
+# frozen_string_literal: true
+
 module JqueryTablesorter
   module RailsUtils
     module Ajax
-      # Represents a table sorting Filter. In most cases this is also a column
-      # in your table, but might als be a global/external filter.
+      # Represents a table sorting Filter.
       class Filter
-        # Name of the column in the DB. Used for queries, but may also be :all for glob. filters.
-        attr_accessor :column_name
-        # Class of the base model.
-        attr_accessor :model
-        # If you need to join, this is your relation table
-        attr_accessor :join_rel
-        # An external table column to be used with join.
-        attr_accessor :external_column
-        # If a having clase is required, pass it here. This will change the controll flow on
-        # filter-/sorting.
-        attr_accessor :having_clause
-        # Optional data type of the column. This might be used to make queries more flexible.
-        # For examaple, if DateTime is passed, it will strip away milliseconds from query.
-        attr_accessor :data_type
-        # Optional boolean filter if the given filter is a global filter or not.
-        attr_accessor :global_filter
-        # Optional index requested by tablesorter, needed for glob. filters.
-        attr_accessor :position
-        # Optional block to modify the real input of filters to match UI (e.g. Input: 'Iceland' =>  DB: 'is')
-        # This block has to return an array which will be used for an IN-Query. Thus, the current implementation
-        # depends on an 1:1 match.
-        attr_accessor :filter_mapping
-
-        def initialize(column_name, model_clazz, opts = {})
-          @column_name     = column_name
-          @model           = model_clazz
-          @position        = opts[:position]
-          @join_rel        = opts[:join_rel]
-          @external_column = opts[:external_column]
-          @having_clause   = opts[:having_clause]
-          @data_type       = opts[:data_type]
-          @global_filter   = opts[:global_filter]
-          @filter_mapping  = opts[:filter_mapping]
-        end
-
-        def global_filter?
-          @global_filter || false
-        end
-
-        def name
-          self.column_name
-        end
-
-        def model_class
-          self.model
-        end
-
-        def external?
-          external_column.present?
+        attr_reader :position, :options
+
+        def initialize(position, options = {})
+          @position = position || (options[:global] ? 999 : nil)
+          @options  = options
+        end
+
+        # dummy filter that will does nothing
+        def noop?
+          !!@options[:noop]
+        end
+
+        # filter that is only applied on global filtering
+        def global?
+          @options[:global] || false
+        end
+
+        # data type of column for special handling
+        def data_type
+          @options[:data_type].presence
+        end
+
+        # model class that has the specified column
+        def klass
+          @options[:class].presence
         end
 
+        # column that should be filtered on
+        def column
+          @options[:column].presence
+        end
+
+        # proc for filtering/mapping values
+        def values
+          @options[:values].presence
+        end
+
+        # proc for custom query modifications
+        def query
+          @options[:query].presence
+        end
+
+        # proc for custom column sorter
+        def sorter_query
+          @options[:sorter_query].presence
+        end
+
+        # string with sql having condition
+        def having
+          @options[:having].presence
+        end
       end
     end
   end

data/lib/jquery-tablesorter/rails-utils/ajax/handler.rb

@@ -1,19 +1,22 @@
+# frozen_string_literal: true
+
 module JqueryTablesorter
   module RailsUtils
     module Ajax
       # Class used by ActionController concern. Encapsulates query logic.
       # For further documentation see ajax-module.
       class Handler
-
         def initialize(tablesorter_params)
           @ts_params = tablesorter_params
         end
 
         # Define the table structure
-        def create_filter_info(column_name, model_clazz, filter_opts = {})
-          filter = Filter.new(column_name, model_clazz, filter_opts)
+        def create_filter_info(position, options = {})
+          filter = Filter.new(position, options)
+
           ajax_filters << filter
-          return filter
+
+          filter
         end
 
         # Load data for the given tablesorter params in a controller action
@@ -24,40 +27,40 @@ module JqueryTablesorter
         # filtered_rows: How many records are left after filtering
         # records:       An collection with the resulting records
         def query_data(base_query)
-          @query      = base_query
-
-          result      = Hash.new
+          query  = base_query
+          result = Hash.new
 
           # Filters
-          @query = apply_filters(@query, tablesorter_params)
+          query = apply_filters(query, tablesorter_params)
 
           # Calculate row counts
-          rec_counts             = record_counts(base_query, @query)
+          rec_counts             = record_counts(base_query, query)
           result[:filtered_rows] = rec_counts[:filtered_rows]
           result[:total_rows]    = rec_counts[:total_rows]
 
           # Handle paging afterwards
-          @query = handle_pagination(@query, tablesorter_params, result)
+          query = handle_pagination(query, tablesorter_params, result)
 
           # Sorting
-          @query = apply_sorting(@query, tablesorter_params)
+          query = apply_sorting(query, tablesorter_params)
 
-          result[:records] = @query
+          result[:records] = query
 
-          return result
+          result
         end
 
+        private
+
         # Calulate count of all and filtered records
         # Params:
         # model_query:    The base query of the current selection
         # filtered_query: The filtered query (relation with applied tablesorter filters)
         def record_counts(model_query, filtered_query)
-          counts              = Hash.new
-          total               = model_query.distinct.count(:id)
+          counts = Hash.new
+          total  = model_query.distinct.count(:id)
 
-          if total.is_a?(Hash) # Handle results of joined queries. This feels a little bit hacky.
-            total = total.keys.length
-          end
+          # Handle results of joined queries. This feels a little bit hacky.
+          total = total.keys.length if total.is_a?(Hash)
 
           counts[:total_rows] = total
 
@@ -65,183 +68,148 @@ module JqueryTablesorter
             # Count again if additional filters were applied (fires a query)
             cnt = filtered_query.count("#{model_query.table_name}.id")
 
-            if cnt.is_a?(Hash) # Handle results of having-queries. This feels a little bit hacky.
-              cnt = cnt.keys.length
-            end
+            # Handle results of having-queries. This feels a little bit hacky.
+            cnt = cnt.keys.length if cnt.is_a?(Hash)
+
             counts[:filtered_rows] = cnt
           else
             counts[:filtered_rows] = total # There wasn't any reduction.
           end
 
-          return counts
+          counts
         end
 
+        # add filter query to sql
+        def apply_filter(query, filter, value)
+          return [query] if query.blank? || filter.blank? || value.blank?
+          return [query] if filter.noop?
 
-        # let every special case be handled within that block.
-        # block should remove the values from the params parameter to allow regular processing.
-        def apply_filters(record_relation, filter_params)
-          splat_global_filter(filter_params)
-          record_relation = apply_global_filters(record_relation, filter_params)
+          klass  = filter.klass || query.klass
+          column = filter.column
+          value  = filter.values.call(value) if filter.values.present?
 
-          # iterate over all filter inputs
-          (filter_params[:filter] || {}).each do |filter_index, filter_value|
-            sel_col = ajax_filters[filter_index.to_i]
-            next if sel_col.blank?
-
-            clazz           = sel_col.model
-            selected_column = sel_col.name
-
-            if sel_col.external? # query an external model
-              ext_query       = "LOWER(#{sel_col.join_rel}.#{sel_col.external_column}::varchar) LIKE LOWER(?)"
-              record_relation = record_relation.where(ext_query, "%#{filter_value}%")
-
-            elsif sel_col.having_clause
-              clause          = sel_col.having_clause
-              record_relation = record_relation.having("LOWER((#{clause})::varchar) LIKE ?", "%#{filter_value}%")
-
-            elsif sel_col.filter_mapping # there were modifications on the query
-              target_col      = "#{clazz.table_name}.#{selected_column}"
-              values          = sel_col.filter_mapping.call(filter_value)
-              # Maybe we could use an SIMILAR TO query for this.
-              record_relation = record_relation.where("LOWER(#{target_col}::varchar) IN (?)", values )
-
-            else # directly on current model
-              target_col = "#{clazz.table_name}.#{selected_column}"
-              if sel_col.data_type == DateTime
-                target_col = "date_trunc('minute', #{target_col})"
+          queries = []
+
+          if column.present?
+            target_column = "#{klass.table_name}.#{column}"
+
+            if filter.data_type == DateTime
+              target_column = "date_trunc('second', #{target_column})"
+            end
+
+            vals  = Array(value)
+            value = []
+            q     = []
+
+            vals.each do |val|
+              if klass.columns_hash[column.to_s] && klass.columns_hash[column.to_s].type == :integer && !(val.to_s.strip =~ /\A\d+\Z/)
+                q << '0 = 1'
+              else
+                q     << "LOWER(#{target_column}::varchar) LIKE LOWER(?)"
+                value << "%#{val}%"
               end
-              record_relation = record_relation.where("LOWER(#{target_col}::varchar) LIKE LOWER(?)", "%#{filter_value}%" )
             end
 
+            queries << "(#{q.join(' OR ')})" if q.any?
+          elsif filter.query.present?
+            query, query_list, value_list = filter.query.call(query, value)
+            queries = Array(query_list)
+            value   = Array(value_list)
+          elsif filter.having.present?
+            query = query.having("LOWER((#{filter.having})::varchar) LIKE ?", "%#{Array(value).first}%")
           end
 
-          return record_relation
+          [query, queries, value]
         end
 
-        # Sort the passed relation by the tablesorter-sorting.
-        def apply_sorting(record_relation, sort_params)
-          (sort_params[:sort] || {}).each do |sort_index, order|
-            order   = (order.to_i % 2 == 0) ? :asc : :desc
-            sel_col = ajax_filters[sort_index.to_i]
+        # apply global filter value for all column filters
+        def apply_global_filters(query, filter_params)
+          value = filter_params[:filter][999.to_s] rescue nil
 
-            if sel_col.external?
-              order_query     = [sel_col.join_rel, sel_col.external_column].compact.join('.')
-              record_relation = record_relation.order("#{order_query} #{order}")
+          return query if value.blank?
 
-            elsif sel_col.having_clause
-              # If there is a having_clause, use the column name w/o tablename
-              record_relation = record_relation.order("#{sel_col.name} #{order} NULLS LAST")
+          queries = []
+          values  = []
 
-            else
-              order_query     = [sel_col.model.table_name, sel_col.name].compact.join('.')
-              record_relation = record_relation.order("#{order_query} #{order} NULLS LAST")
-            end
+          # iterate over all filter inputs
+          ajax_filters.each do |filter|
+            next if filter.blank?
+            next if filter.having.present?
+
+            query, q, v = apply_filter(query, filter, value)
 
+            next if q.blank?
+
+            queries += Array(q)
+            values  += Array(v) unless v.nil?
           end
 
-          return record_relation
+          query.where(queries.join(' OR '), *values)
         end
 
-        # Paginiation/the amount of visible rows in the table (per page)
-        def handle_pagination(query, ts_params, result)
-          # Tablesorter submits row count or simply 'all'. If user requests more rows
-          # than available do nothing.
-          return query if ( (ts_params[:size] == 'all') || (ts_params[:size].to_i >= result[:total_rows]) )
+        # apply individual column filters
+        def apply_filters(query, filter_params)
+          query = apply_global_filters(query, filter_params)
 
-          query = query
-                      .limit(ts_params[:size].to_i)
-                      .offset(ts_params[:size].to_i * ts_params[:page].to_i)
+          queries = []
+          values  = []
 
-          return query
-        end
+          # iterate over all filter inputs
+          (filter_params[:filter] || {}).each do |idx, value|
+            ajax_filters.select { |f| f.position == idx.to_i }.each do |filter|
+              next if filter.blank?
+              next if filter.global?
 
-        # Array with all currently configured Filter-Objects
-        def ajax_filters
-          @_ajax_table_filters ||= []
-        end
+              query, q, v = apply_filter(query, filter, value)
 
-        private
+              next if q.blank?
 
-        def tablesorter_params
-          @ts_params
+              queries += Array(q)
+              values  += Array(v) unless v.nil?
+            end
+          end
+
+          query.where(queries.join(' AND '), *values)
         end
 
-        # Iterate over all columns with the (previous in *splat_global_filter* initialized)
-        # global filter value
-        def apply_global_filters(record_relation, filter_params)
-          # TODO Wouldn't it be smarter to make query an array and join it by ' OR '?
-          query         = ''
-          filter_values = []
-
-          (filter_params[:global_filter] || {}).each do |filter_index, filter_value|
-            sel_col = ajax_filters[filter_index.to_i]
-            next if sel_col.blank?
-
-            clazz           = sel_col.model
-            selected_column = sel_col.name
-            table_name      = clazz.table_name
-
-            if sel_col.external? # Query an external model
-              query         << "LOWER(#{sel_col.join_rel}.#{sel_col.external_column}::varchar) LIKE LOWER(?) OR "
-              filter_values << "%#{filter_value}%"
-
-            elsif sel_col.filter_mapping # there were modifications on the query
-              target_col     = "#{clazz.table_name}.#{selected_column}"
-              values         = sel_col.filter_mapping.call(filter_value)
-              # Maybe we could use an SIMILAR TO query for this.
-              query         << "LOWER(#{target_col}::varchar) IN (?) OR "
-              filter_values << values
-
-            elsif sel_col.having_clause
-              # Having clauses will create an extra query to select IDs of base-table records
-              # an add them into the main query as IN <ids>.
-              # If there is a having_clause, use the column name only w/o tablename.
-              clause        = "LOWER(#{sel_col.having_clause}::varchar) LIKE LOWER(?)"
-              filter_values << record_relation.having(clause, "%#{filter_value}%")
-                                              .pluck(:id)
-              query         << "#{table_name}.id IN (?) OR "
+        # Sort the passed relation by the tablesorter-sorting.
+        def apply_sorting(query, sort_params)
+          (sort_params[:sort] || {}).each do |idx, order|
+            order  = (order.to_i % 2 == 0) ? :asc : :desc
+            filter = ajax_filters.find { |f| f.position == idx.to_i }
 
-            else
-              target_col = "#{table_name}.#{selected_column}"
+            next if filter.blank?
 
-              if sel_col.data_type == DateTime # Special handling for Dates -> strip away millisecs
-                target_col = "date_trunc('second', #{target_col})"
-              end
+            klass  = filter.klass || query.klass
+            column = filter.column
 
-              query         << "LOWER(#{target_col}::varchar) LIKE LOWER(?) OR "
-              filter_values << "%#{filter_value}%"
+            if filter.sorter_query.present?
+              query = filter.sorter_query.call(query, order)
+            else
+              query  = query.reorder("#{klass.table_name}.#{column} #{order} NULLS LAST")
             end
           end
 
-          query = query.chomp(' OR ') # remove the last OR
+          query
+        end
 
-          return record_relation.where(query, *filter_values)
+        # Paginiation/the amount of visible rows in the table (per page)
+        def handle_pagination(query, ts_params, result)
+          # Tablesorter submits row count or simply 'all'. If user requests more rows
+          # than available do nothing.
+          return query if (ts_params[:size] == 'all') || (ts_params[:size].to_i >= result[:total_rows])
 
+          query.limit(ts_params[:size].to_i).offset(ts_params[:size].to_i * ts_params[:page].to_i)
         end
 
-        # If any global filter value (the user input) is found (which currently is asumed to the last),
-        # take this input and add it to a global_filter subkey with the corresponding index of each
-        # not global-filter column. Thus, later the may be used to check all coulmns for the given
-        # input.
-        def splat_global_filter(filter_params)
-          # Global filter params is assumed to be at the last index
-          global_filter = ajax_filters.find { |c| c.global_filter? }
-          return unless global_filter
-
-          global_filter_value = filter_params.dig(:filter, global_filter.position.to_s)
-          return if global_filter_value.nil?
-
-          filter_params[:global_filter] ||= {}
-          ajax_filters.each_with_index do |col, idx|
-            next if (col.nil? || col.global_filter?)
-            # Add search query for each (non-global) value
-            filter_params[:global_filter][idx.to_s] = global_filter_value
-          end
-
-          # Remove the global filter from the params
-          filter_params[:filter].delete(global_filter.position.to_s)
+        # Array with all currently configured Filter-Objects
+        def ajax_filters
+          @_ajax_table_filters ||= []
         end
 
+        def tablesorter_params
+          @ts_params
+        end
       end
     end
   end

data/lib/jquery-tablesorter/rails-utils/version.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module JqueryTablesorter
   module RailsUtils
     MAJOR = 0
-    MINOR = 0
-    TINY  = 1
+    MINOR = 2
+    TINY  = 0
 
     VERSION = [MAJOR, MINOR, TINY].compact.join('.')
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jquery-tablesorter-rails-utils
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Erik-B. Ernst
@@ -9,82 +9,82 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-30 00:00:00.000000000 Z
+date: 2020-01-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: activerecord
+  name: pg
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.0'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.0'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: activesupport
+  name: actionview
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '5.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '7.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '5.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '7.0'
 - !ruby/object:Gem::Dependency
-  name: actionview
+  name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '5.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '7.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '5.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '7.0'
 - !ruby/object:Gem::Dependency
-  name: pg
+  name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '5.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '5.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -144,15 +144,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.9.3
+      version: 2.4.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Some helpers to work with jQuery tablesorter and Ruby on Rails