table_sortable 0.1.2

data/lib/table_sortable/column/filter.rb

@@ -0,0 +1,19 @@
+module TableSortable
+  class Column
+    class Filter
+      include TableSortable::Concerns::Proc
+
+      def initialize(*options)
+        super :filter, *options
+      end
+
+      def array_proc
+        -> (value, col=nil) { select{|record| value.downcase.in? col.value(record).to_s.downcase} }
+      end
+
+      def sql_proc
+        -> (value, col=nil) { where("? LIKE (?)", filter.to_s.underscore, "%#{value}%") }
+      end
+    end
+  end
+end

data/lib/table_sortable/column/sorter.rb

@@ -0,0 +1,20 @@
+module TableSortable
+  class Column
+    class Sorter
+      include TableSortable::Concerns::Proc
+
+      def initialize(*options)
+        super :sort, *options
+      end
+
+      def array_proc
+        -> (col=nil) { sort{ |a,b| col.value(a) <=> col.value(b) }}
+      end
+
+      def sql_proc
+        -> (col=nil) { order(sorter) }
+      end
+
+    end
+  end
+end

data/lib/table_sortable/column.rb

@@ -0,0 +1,30 @@
+module TableSortable
+  class Column
+
+    attr_reader :name, :label, :filter, :sorter, :template, :placeholder
+
+    def initialize(col_name, *options)
+
+      options = options.extract_options!
+      value = options[:value] || col_name
+      label = options[:label] || (options[:label] == false ? '' : col_name.to_s.titleize)
+      placeholder = options[:placeholder] || (options[:placeholder] == false ? false : label)
+      template = options[:template] || col_name
+
+      @name = col_name
+      @value = value.is_a?(Proc) ? value : -> (record) { record.send(value) }
+      @label = label
+      @placeholder = placeholder
+      @template = template
+      @filter = TableSortable::Column::Filter.new(options.merge(:column_name => @name) )
+      @sorter = TableSortable::Column::Sorter.new(options.merge(:column_name => @name) )
+
+    end
+
+    def value(record)
+      record.instance_eval(&@value) unless @value.nil?
+    end
+
+  end
+
+end

data/lib/table_sortable/columns.rb

@@ -0,0 +1,26 @@
+module TableSortable
+  class Columns
+
+    def initialize
+      @columns = []
+    end
+
+    def add(col_name, *options)
+      options = options.extract_options!
+      @columns << TableSortable::Column.new(col_name, options)
+    end
+
+    def sort_by(sort_key)
+      if sort_key
+        sort_key.map{|c| @columns.find{|col| (c.is_a?(String) ? (col.label == c) : col.name == c)}}
+      else
+        @columns
+      end
+    end
+
+    def sort(&sort_proc)
+      @columns.sort(&sort_proc)
+    end
+
+  end
+end

data/lib/table_sortable/concerns/proc.rb

@@ -0,0 +1,49 @@
+module TableSortable
+  module Concerns
+    module Proc
+      extend ActiveSupport::Concern
+
+      included do
+        attr_reader :proc, :method
+      end
+
+      def initialize(option_name, *options)
+        options = options.extract_options!
+        unless options[option_name] == false
+          filter = options[option_name] || options[:column_name]
+          @method = options["#{option_name.to_s}_method".to_sym] || :array
+          if filter.respond_to? :call
+            @proc = -> (records, col=nil) { instance_exec(records, &filter) }
+            @method = detect_method(@proc)
+          elsif !filter.nil?
+            case @method
+              when :array
+                @proc = array_proc
+              when :sql
+                @proc = sql_proc
+            end
+          end
+        end
+      end
+
+      def detect_method(proc)
+        method = [].instance_exec('', &proc) rescue :failed
+        method == :failed ? :sql : :array
+      end
+
+      def disabled?
+        method.nil?
+      end
+
+      def array_proc
+        raise NotImplementedError
+      end
+
+      def sql_proc
+        raise NotImplementedError
+      end
+
+    end
+  end
+end
+

data/lib/table_sortable/controller.rb

@@ -0,0 +1,93 @@
+module TableSortable
+  module Controller
+
+    extend ActiveSupport::Concern
+
+    included do
+      helper_method :columns
+      prepend_before_action :initialize_table_sortable
+    end
+
+    module ClassMethods
+      def define_columns(*args)
+        options = args.extract_options!
+        column_offset = options[:offset] || 0
+        columns   = args
+        before_action(options) do
+          columns.each do |column|
+            define_column column
+          end
+          self.column_offset = column_offset
+        end
+      end
+
+      def define_column(*args)
+        before_action do
+          define_column *args
+        end
+      end
+    end
+
+    def define_column(col_name, *options)
+      options = options.extract_options!
+      @columns.add(col_name, options)
+    end
+
+    private
+
+    def filter_and_sort(scope)
+      cols = @columns.sort_by(display_order)
+
+      page = params[:page]
+      page_size = params[:pagesize]
+      sort_by_col_data = params[SCOL] ? params[SCOL].keys.first : column_offset
+      sort_order = params[SCOL] ? params[SCOL].values.first : SORT_ASC
+
+      sort_column = cols.at(sort_by_col_data.to_i - column_offset)
+      sort_proc = ->(records) { records.instance_exec(sort_column, &sort_column.sorter.proc)}
+      ordered_sort_proc = ->(records) {sort_order == SORT_ASC ? sort_proc.call(records) : sort_proc.call(records).reverse}
+
+      filters = [->(records) { ordered_sort_proc.call(records) }]
+
+      # a filter exists
+      if params[FCOL]
+        @columns.sort_by(filter_order.reverse).each_with_index do |col, i|
+          column_index = cols.index(col) + column_offset
+          filter_value = params[FCOL][column_index.to_s]
+          filters << ->(records){ filter_value.nil? ? filters[i].call(records) : filters[i].call(records.instance_exec(filter_value, col, &col.filter.proc)) }
+        end
+      end
+      scope = filters.last.call(scope)
+      if page
+        scope = Kaminari.paginate_array(scope)
+        scope = scope.page(page.to_i + 1).per(page_size)
+      end
+      scope
+    end
+
+    def initialize_table_sortable
+
+      @columns ||= TableSortable::Columns.new
+      self.column_offset = 0
+
+    end
+
+    def columns(record = nil)
+      @columns.sort_by(display_order)
+    end
+
+    def filter_order
+      @filter_order || @columns.sort{ |a,b| a.filter.method && b.filter.method ? b.filter.method <=> a.filter.method : a.filter.method ? 1 : -1 }.compact.map{|col| col.name}
+    end
+
+    def sort_order
+      @sort_order || @columns.sort{ |a,b| a.sorter.method && b.sorter.method ? b.sorter.method <=> a.sorter.method : a.filter.method ? 1 : -1 }.compact.map{|col| col.name}
+    end
+
+    public
+
+    attr_writer :filter_order, :sort_order
+    attr_accessor :display_order, :column_offset
+
+  end
+end

data/lib/table_sortable/version.rb

@@ -0,0 +1,3 @@
+module TableSortable
+  VERSION = "0.1.2"
+end

data/lib/table_sortable.rb

@@ -0,0 +1,25 @@
+require 'rails/engine'
+require 'active_support/concern'
+require 'action_controller'
+
+module TableSortable
+
+  FCOL = 'fcol'
+  SCOL = 'scol'
+  SORT_ASC = '0'
+  SORT_DESC = '1'
+
+  class Engine < Rails::Engine; end
+
+end
+
+
+class TableSortableError < StandardError; end
+
+require 'table_sortable/concerns/proc'
+require 'table_sortable/column/sorter'
+require 'table_sortable/column/filter'
+require 'table_sortable/column'
+require 'table_sortable/columns'
+require 'table_sortable/version'
+require 'table_sortable/controller'

data/spec/concerns/proc_class_spec.rb

@@ -0,0 +1,13 @@
+shared_examples_for 'proc_class' do |parameter_name|
+  include_context 'shared stuff'
+
+  let(:dummy_class) { described_class.new(parameter_name => ->(x) {x}) }
+
+  it 'includes TableSortable::Concerns::Proc' do
+    expect(described_class.included_modules).to include TableSortable::Concerns::Proc
+  end
+  it 'defines array_proc and sql_proc that return a proc' do
+    expect(dummy_class.array_proc).to respond_to :call
+    expect(dummy_class.sql_proc).to respond_to :call
+  end
+end

data/spec/controllers/test_controller_spec.rb

@@ -0,0 +1,17 @@
+module Test
+  class Controller < ActionController::Base
+
+    include TableSortable::Controller
+
+    def index
+    end
+  end
+end
+
+describe Test::Controller, type: :controller do
+
+  let(:controller) { Test::Controller.new }
+
+  it { has_before_filters(:initialize_table_sortable) }
+
+end

data/spec/lib/table_sortable/column/filter_spec.rb

@@ -0,0 +1,3 @@
+describe TableSortable::Column::Filter do
+  it_behaves_like 'proc_class', :filter
+end

data/spec/lib/table_sortable/column/sorter_spec.rb

@@ -0,0 +1,3 @@
+describe TableSortable::Column::Sorter do
+  it_behaves_like 'proc_class', :sort
+end

data/spec/lib/table_sortable/concerns/proc_spec.rb

@@ -0,0 +1,82 @@
+describe TableSortable::Concerns::Proc do
+  include_context 'shared stuff'
+
+  let :proc_class do
+    Class.new do
+      include TableSortable::Concerns::Proc
+
+      def array_proc
+        -> (x) {x * 2}
+      end
+
+      def sql_proc
+        -> (x) {x * 3}
+      end
+    end
+  end
+
+  let :dummy_proc do
+    proc_class.new(:proc, proc: dummy_col)
+  end
+
+  context 'on initialization' do
+    context 'given a proc' do
+      it 'should keep it' do
+        example_proc = -> (x) { x * 100 }
+        proc = proc_class.new(:proc, proc: example_proc )
+        expect(5.instance_eval(&proc.proc)).to eq 500
+      end
+      context 'it is an sql proc' do
+        it 'should detect it as sql' do
+          proc = proc_class.new(:proc, proc: -> (value) { where(name: value) } )
+          expect(proc.method).to eq :sql
+        end
+      end
+      context 'it is an array proc' do
+        it 'should detect it as array' do
+          proc = proc_class.new(:proc, proc: -> (value) { select{|record| record.name == value} } )
+          expect(proc.method).to eq :array
+        end
+      end
+    end
+    context 'given no proc' do
+      it 'should use array proc' do
+        expect(dummy_proc.method).to eq :array
+      end
+      context '_method: option' do
+        context 'not provided' do
+          it 'should replace it with array_proc' do
+            expect(5.instance_eval(&dummy_proc.proc)).to eq 5.instance_eval(&dummy_proc.array_proc)
+          end
+        end
+        context '== :sql' do
+          it 'should replace it with sql_proc' do
+            dummy_proc = proc_class.new(:proc, column_name: :proc, proc_method: :sql)
+            expect(5.instance_eval(&dummy_proc.proc)).to eq 5.instance_eval(&dummy_proc.sql_proc)
+          end
+        end
+        context '== :array' do
+          it 'should replace it with sql_proc' do
+            dummy_proc = proc_class.new(:proc, column_name: :proc, proc_method: :array)
+            expect(5.instance_eval(&dummy_proc.proc)).to eq 5.instance_eval(&dummy_proc.array_proc)
+          end
+        end
+      end
+    end
+  end
+
+  context 'detect method' do
+    context 'given a proc containing an sql method' do
+      it 'should detect it as sql' do
+        proc_to_detect = -> (filter_value) { where(name: filter_value) }
+        expect(dummy_proc.detect_method(proc_to_detect)).to eq :sql
+      end
+    end
+    context 'given a proc containing an array method' do
+      it 'should detect it as array' do
+        proc_to_detect = -> (filter_value) { select{|record| record.name == filter_value} }
+        expect(dummy_proc.detect_method(proc_to_detect)).to eq :array
+      end
+    end
+  end
+end

data/spec/lib/table_sortable/controller_spec.rb

@@ -0,0 +1,51 @@
+describe TableSortable::Controller do
+
+  let :controller do
+    controller = ActionController::Base.new
+    controller.class.include TableSortable::Controller
+    controller.instance_eval('initialize_table_sortable')
+    controller
+  end
+  let :populated_controller do
+    controller.send(:define_column,
+                    :column_with_sql_procs_a,
+                    filter: -> (value) { where(column: value)},
+                    sort: -> { order(:column)})
+    controller.send(:define_column,
+                    :column_with_array_procs,
+                    filter: -> (value) { select{|record| record == value}},
+                    sort: -> (col) { sort{ |a,b| col.value(a) <=> col.value(b) }})
+    controller.send(:define_column,
+                    :column_with_sql_procs_b,
+                    filter: -> (value) { where(last_name: value)},
+                    sort: -> { order(:column)})
+    controller
+  end
+
+  context 'initialization' do
+    it 'creates a columns collection' do
+      expect(controller.instance_eval('@columns')).to be_a TableSortable::Columns
+    end
+  end
+
+  context 'define_column' do
+    it 'adds a new column at the end of the collection' do
+      controller.send(:define_column, :name)
+      controller.send(:define_column, :another_name)
+      expect(controller.send(:columns).first.name).to eq :name
+      expect(controller.send(:columns).last.name).to eq :another_name
+    end
+  end
+
+  context 'filter_order' do
+    it 'orders sql filters before array filters' do
+      expect(populated_controller.send(:filter_order)).to eq [:column_with_sql_procs_a, :column_with_sql_procs_b, :column_with_array_procs]
+    end
+  end
+
+  context 'sort_order' do
+    it 'orders sql filters before array filters' do
+      expect(populated_controller.send(:sort_order)).to eq [:column_with_sql_procs_a, :column_with_sql_procs_b, :column_with_array_procs]
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,109 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+
+require 'table_sortable'
+require 'support/controller_macros'
+require 'support/matchers/have_filters'
+require 'support/shared_stuff'
+
+RSpec.configure do |config|
+
+  config.include ControllerMacros, type: :controller
+
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # This option will default to `:apply_to_host_groups` in RSpec 4 (and will
+  # have no way to turn it off -- the option exists only for backwards
+  # compatibility in RSpec 3). It causes shared context metadata to be
+  # inherited by the metadata hash of host groups and examples, rather than
+  # triggering implicit auto-inclusion in groups with matching metadata.
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # This allows you to limit a spec run to individual examples or groups
+  # you care about by tagging them with `:focus` metadata. When nothing
+  # is tagged with `:focus`, all examples get run. RSpec also provides
+  # aliases for `it`, `describe`, and `context` that include `:focus`
+  # metadata: `fit`, `fdescribe` and `fcontext`, respectively.
+  config.filter_run_when_matching :focus
+
+  # Allows RSpec to persist some state between runs in order to support
+  # the `--only-failures` and `--next-failure` CLI options. We recommend
+  # you configure your source control system to ignore this file.
+  config.example_status_persistence_file_path = "spec/examples.txt"
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
+  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = "doc"
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end

data/spec/support/controller_macros.rb

@@ -0,0 +1,7 @@
+# spec/support/controller_macros.rb
+
+module ControllerMacros
+  def has_before_filters *names
+    expect(controller).to have_filters(:before, *names)
+  end
+end

data/spec/support/matchers/have_filters.rb

@@ -0,0 +1,6 @@
+RSpec::Matchers.define :have_filters do |kind, *names|
+  match do |controller|
+    filters = controller._process_action_callbacks.select{ |f| f.kind == kind }.map(&:filter)
+    names.all?{ |name| filters.include?(name) }
+  end
+end

data/spec/support/shared_stuff.rb

@@ -0,0 +1,22 @@
+RSpec.configure do |rspec|
+  # This config option will be enabled by default on RSpec 4,
+  # but for reasons of backwards compatibility, you have to
+  # set it on RSpec 3.
+  #
+  # It causes the host group and examples to inherit metadata
+  # from the shared context.
+  rspec.shared_context_metadata_behavior = :apply_to_host_groups
+end
+
+RSpec.shared_context "shared stuff", :shared_context => :metadata do
+
+  let :dummy_col do
+    TableSortable::Column.new(:dummy_col)
+  end
+
+end
+
+
+RSpec.configure do |rspec|
+  rspec.include_context "shared stuff", :include_shared => true
+end

data/table_sortable.gemspec

@@ -0,0 +1,37 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "table_sortable/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "table_sortable"
+  spec.version       = TableSortable::VERSION
+  spec.authors       = ["Oded Davidov"]
+  spec.email         = ["davidovoded@gmail.com"]
+
+  spec.summary       = 'Use jquery-tablesorter.js with server side filtering, pagination and sorting'
+  spec.description   = 'Use jquery-tablesorter.js with server side filtering, pagination and sorting'
+  # spec.homepage      = "TODO: Put your gem's website or public repo URL here."
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    # spec.metadata["allowed_push_host"] = "localhost"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.test_files    = `git ls-files -- spec/*`.split("\n")
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.15"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.4"
+  spec.add_dependency "kaminari", '~> 0.17.0'
+  spec.add_dependency "rails", '~> 5.1', '>= 5.1.1'
+end