grid_table 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3822148a7134b0523bad25bba7d31440a68497e9
+  data.tar.gz: 9e3b2dbc9d8dc3d316b3995060f4865c26b6b620
+SHA512:
+  metadata.gz: b8afb20b6c8d00007a29b256659e4ae15c80c0f3e41f8e29f4daaa7fb450e9a3357583625b4b11220d508d829c9ee979173c06380fd962e6ee053b66acd07b21
+  data.tar.gz: b8b6495fb43c7d7aade3d6c2ff881af9af47f0c8de603dcb36e7c738fce7b9e438e6a028574539833d242e7a5b94f7e2d378c9b107a7da2cdb2f3298ae2564da

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in gridtable.gemspec
+gemspec
+
+gem 'activerecord', require: "active_record"

data/LICENSE.txt

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Jon Principe
+
+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,124 @@
+# GridTable
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'grid_table'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install grid_table
+
+## Usage
+
+1. Mark up your table in the index.html.haml with the GridTable HTML 5 attributes
+```
+  %table.grid-table{data: {url: users_path}}
+    %thead
+      %tr
+        %th.small-5{data: { field: 'email', sort: 'true', filter: 'true', default_sort: 'asc' }} Email
+        %th{data: { field: 'first_name', sort: 'true', filter: 'true' }} First Name
+        %th{data: { field: 'last_name', sort: 'true', filter: 'true' }} Last Name
+        %th{data: { field: 'customer_name', sort: 'true', filter: 'true' }} Customer
+        %th{data: { field: 'created_at', sort: 'true', filter: 'false' }} Created
+        %th
+      %tr.filters
+        %th
+          %input{data: {field: 'email'}}
+        %th
+          %input{data: {field: 'first_name'}}
+        %th
+          %input{data: {field: 'last_name'}}
+        %th
+          %input{data: {field: 'customer_name'}}
+        %th
+        %th
+    %tbody
+      %tr.no-results.hide
+        %td
+          %h4 No Results Found
+        %td
+        %td
+        %td
+        %td
+        %td
+    %tcaption
+      .grid-pager
+        %ul.pagination
+          %li
+            %button#first
+              First
+          %li
+            %button#previous
+              Back
+          %li#pagedisplay
+          %li
+            %button#next
+              Next
+          %li
+            %button#last
+              Last
+          .pagination
+            Results per page:
+            #pagesize
+```
+2. Create a partial for each row of the table.  By default the partial name is ```_row.html.haml```
+```html
+%tr
+     %td= user.email
+     %td= user.first_name
+     %td= user.last_name
+     %td= user.customer.name
+     %td= l(user.created_at.to_date)
+     %td
+```
+3. Define the fields and how they are accessed in the ActiveRecord Model
+```ruby
+class User < ActiveRecord::Base
+     extend GridTable::Model
+
+     belongs_to :customer
+
+     grid_table_control :email
+     grid_table_control :first_name
+     grid_table_control :last_name
+     grid_table_control :created_at
+     grid_table_control :customer_name,
+                         source: :customer,
+                         source_column: 'name'
+end
+```
+4. Setup the controller handle the HTML response and the JS response that does the lookup of the data
+```ruby
+class UsersController < ApplicationController
+      def index
+        respond_to do |format|
+          format.html {}
+          format.js { grid_table_for(Users.all, index_params) }
+        end
+      end
+
+      private
+
+      def index_params
+        params.permit [].concat(User.grid_table_strong_params)
+      end
+end
+```
+
+TODO: Fill out details about options available other than defaults
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/gridtable/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/grid_table.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'grid_table/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "grid_table"
+  spec.version       = GridTable::VERSION
+  spec.authors       = ["Jon Principe", "Mike Raimondi"]
+  spec.email         = ["jp@adharmonics.com"]
+  spec.summary       = %q{Utility for powerful HTML Tables}
+  spec.description   = %q{Library to help manage powerful HTML Tables through the Model, View and Controller.}
+  spec.homepage      = "http://github.com/jprincipe/grid_table"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+end

data/lib/grid_table/control.rb

@@ -0,0 +1,131 @@
+class GridTable::Control
+  include ActiveModel::Model
+
+  attr_writer :model, :attribute, :source, :source_class, :source_column, :filter, :polymorphic
+
+  def filter(param_filter_value, records)
+    unless @filter == false
+      arel_query = nil
+      strategy_map = {
+        exact_match: ->(col) { col.eq(param_filter_value) },
+        prefix:      ->(col) { col.matches("#{param_filter_value}%") },
+        suffix:      ->(col) { col.matches("%#{param_filter_value}") },
+        fuzzy:       ->(col) { col.matches("%#{param_filter_value}%") },
+        array:       ->(col) { "#{column.to_s} @> ARRAY[#{[param_filter_value].flatten.join(',')}]" }
+      }
+
+      polymorphic_models.each_with_index do |klass, i|
+        # TODO implement array filtering
+        if i == 0
+          arel_query = strategy_map[strategy].call(klass.arel_table[column])
+        else
+          arel_query = arel_query.or(strategy_map[strategy].call(klass.arel_table[column]))
+        end
+      end
+
+      arel_query ||= strategy_map[strategy].call(source_table[column])
+      prepared_records(records).where(arel_query)
+    end
+  end
+
+  def sort(param_sort_order, records)
+    sort_order = %w[asc, desc].include?(param_sort_order) ? param_sort_order : 'asc'
+
+    if @polymorphic
+      models = polymorphic_models
+      if models.present?
+        prepared_records(records).select("\"#{@model.to_s.tableize}\".*, #{polymorphic_select_sql(models)} AS #{active_source}")
+                                 .order("#{active_source} #{sort_order}")
+      else
+        records
+      end
+    else
+      prepared_records(records).order("#{table_with_column} #{sort_order}")
+    end
+  end
+
+  def url_param
+    @attribute
+  end
+
+  private
+
+  def prepared_records(records)
+    if @polymorphic
+      polymorphic_models.each do |klass|
+        records = records.joins("LEFT OUTER JOIN #{klass.table_name} ON #{model_fk}_id = #{klass.table_name}.id AND #{model_fk}_type = '#{klass}'")
+      end
+      records
+    else
+      joined_control? ? records.includes(active_source).references(active_source) : records
+    end
+  end
+
+  def column
+    @source_column || @attribute
+  end
+
+  def active_source
+    @source || @model
+  end
+
+  def joined_control?
+    @model != active_source
+  end
+
+  def strategy
+    @filter || :fuzzy
+  end
+
+  def source_table
+    klass = Object.const_get(@source_class || active_source.to_s.classify)
+    klass.arel_table
+  end
+
+  def table_with_column
+    "#{source_table.name}.#{column}"
+  end
+
+  def model_fk
+    "#{@model.to_s.tableize}.#{@source}"
+  end
+
+  def polymorphic_select_sql(models)
+    sql = ''
+
+    models.each_with_index do |klass, i|
+      if models.length == 1
+        sql = "#{klass.table_name}.#{column}"
+      elsif i == 0
+        sql << "(CASE WHEN #{klass.table_name}.#{column} IS NOT NULL THEN #{klass.table_name}.#{column}"
+      elsif i == models.length - 1
+        sql << " ELSE #{klass.table_name}.#{column} END)"
+      else
+        sql << " ELSIF #{klass.table_name}.#{column} IS NOT NULL THEN #{klass.table_name}.#{column}"
+      end
+    end
+
+    sql
+  end
+
+  def polymorphic_models
+    return [] unless @polymorphic
+
+    if @polymorphic_models.blank?
+      col = (active_source.to_s + '_type').to_sym
+      @polymorphic_models = Object.const_get(@model.to_s.classify)
+                                  .select(col)
+                                  .uniq
+                                  .where.not(col => nil)
+                                  .pluck(col).map { |klass| Object.const_get(klass) }
+    end
+
+    @polymorphic_models
+  end
+
+  class << self
+    def find_by_param(param, controls)
+      controls.detect { |control| control.url_param == param.try(:to_sym) }
+    end
+  end
+end

data/lib/grid_table/controller.rb

@@ -0,0 +1,35 @@
+module GridTable
+  module Controller
+    def grid_table_for(resource, params, options = {})
+      grid_table = resource.grid_table
+      grid_table.populate!(resource, params)
+
+      if block_given?
+        yield grid_table.records, grid_table.total_rows
+      else
+        rows = []
+
+        local = options[:local].try(:to_sym) || grid_table.records.klass.name.demodulize.underscore.to_sym
+        grid_table.records.each do |record|
+          rows << (render_to_string partial: (options[:partial] || 'row'), locals: { local => record })
+        end
+
+        render json: { total_rows: grid_table.total_rows, rows: rows }
+      end
+    end
+
+    def grid_table_export_for(resource, params, options = {})
+      grid_table = resource.grid_table
+      params[:skip_paging] ||= true
+      grid_table.populate!(resource, params)
+
+      if block_given?
+        yield grid_table.records
+      else
+        csv = grid_table.records.klass.to_csv(grid_table.records)
+
+        send_data csv, filename: "#{grid_table.records.klass.name.demodulize.underscore}.csv"
+      end
+    end
+  end
+end

data/lib/grid_table/model.rb

@@ -0,0 +1,14 @@
+module GridTable
+  module Model
+    attr_accessor :grid_table
+
+    def grid_table_control(attribute, options = {})
+      self.grid_table ||= GridTable::Table.new
+      self.grid_table.add_control(self, attribute, options)
+    end
+
+    def grid_table_strong_params
+      self.grid_table.strong_params
+    end
+  end
+end

data/lib/grid_table/table.rb

@@ -0,0 +1,72 @@
+class GridTable::Table
+  attr_reader :records, :total_rows
+
+  def initialize
+    @controls = []
+  end
+
+  def add_control(model, attribute, options)
+    @controls << GridTable::Control.new(
+      {
+        model: model.name.underscore.to_sym,
+        attribute: attribute,
+        source: options[:source],
+        source_class: options[:source_class],
+        source_column: options[:source_column],
+        filter: options[:filter],
+        polymorphic: options[:polymorphic]
+      })
+  end
+
+  def populate!(resource, params)
+    @params   = params
+    @records  = resource
+
+    filter!
+    sort!
+    @total_rows = @records.size
+    page! unless params[:skip_paging]
+
+    @records
+  end
+
+  def strong_params
+    @controls.inject(common_strong_params) do |all_params, control|
+      all_params << control.url_param
+    end
+  end
+
+  private
+
+  def common_strong_params
+    [:page, :page_size, :sort, :sort_order]
+  end
+
+  def page
+    (@params[:page] || 0).to_i
+  end
+
+  def page_size
+    (@params[:page_size] || 10).to_i
+  end
+
+  def filter!
+    @params.each do |attribute, attribute_value|
+      control = GridTable::Control.find_by_param(attribute, @controls)
+      @records = control.filter(attribute_value, @records) if control.present?
+    end
+  end
+
+  def sort!
+    control = GridTable::Control.find_by_param(@params[:sort], @controls)
+
+    if control.present?
+      @records = control.sort(@params[:sort_order], records)
+    end
+  end
+
+  def page!
+    @records = @records.offset(page * page_size).limit(page_size)
+  end
+
+end

data/lib/grid_table/version.rb

@@ -0,0 +1,3 @@
+module GridTable
+  VERSION = "1.0.0"
+end

data/lib/grid_table.rb

@@ -0,0 +1,10 @@
+require "grid_table/version"
+require "grid_table/control"
+require "grid_table/table"
+require "grid_table/controller"
+require "grid_table/model"
+
+module GridTable
+  class Engine < ::Rails::Engine
+  end
+end

data/vendor/assets/javascripts/gridtable.js

@@ -0,0 +1,482 @@
+var GridTable;
+
+$(function() {
+  $('[data-grid-table-sort]').on('change', function() {
+    var gridtable;
+    gridtable = GridTableFactory.get($(this));
+    return gridtable.refresh((function(_this) {
+      return function() {
+        var $checked, n, url;
+        n = _this.name;
+        gridtable = GridTableFactory.get(_this);
+        url = gridtable.getUrl();
+        gridtable.setFilter(n, null, {
+          skip_load: true
+        });
+        if (_this.type === 'checkbox') {
+          $checked = $(':checkbox[name="' + n + '"]:checked');
+          if ($checked.length > 0) {
+            url += '?' + ($checked.map(function() {
+              return "" + n + "=" + this.value;
+            }).toArray().join('&'));
+          }
+          return gridtable.setUrl(url);
+        } else {
+          return gridtable.setUrl(updateQueryString(n, _this.value, url));
+        }
+      };
+    })(this));
+  });
+  return $('.grid-table').each(function() {
+    var $table;
+    $table = $(this);
+    return GridTableFactory.createGridTable($table).loadGridTable($table);
+  });
+});
+
+window.GridTableFactory = (function() {
+  function GridTableFactory() {}
+
+  GridTableFactory.gridTableList = [];
+
+  GridTableFactory.defaultGridTableId = 'default-grid-table';
+
+  GridTableFactory.get = function(obj) {
+    var $gt, id;
+    if (typeof obj === 'object') {
+      id = $(obj).data('grid-table-id');
+    } else {
+      id = obj;
+    }
+    return $gt = this.gridTableList[id || this.defaultGridTableId];
+  };
+
+  GridTableFactory.createGridTable = function(table, params) {
+    var $table, existing_table, gridTable;
+    if ((existing_table = this.get(table)) != null) {
+      throw new Error(existing_table);
+    }
+    $table = $(table);
+    gridTable = new GridTable(params);
+    $table.on('ajax:success', 'a, button', function() {
+      gridTable = GridTableFactory.get($table);
+      return gridTable.refresh();
+    });
+    this.gridTableList[$table.data('grid-table-id') || this.defaultGridTableId] = gridTable;
+    return gridTable;
+  };
+
+  return GridTableFactory;
+
+})();
+
+GridTable = (function() {
+  var GridTableParams, sortIcons;
+
+  sortIcons = {
+    "default": 'fi-sort',
+    asc: 'fi-sort-down',
+    desc: 'fi-sort-up'
+  };
+
+  GridTable.prototype.gridTableParams = null;
+
+  GridTable.prototype.gridTableDOM = null;
+
+  GridTable.prototype.loadDataCompleteCallback = null;
+
+  GridTable.prototype.loadDataStartCallback = null;
+
+  GridTable.prototype.loadDataErrorCallback = null;
+
+  function GridTable(params) {
+    this.gridTableParams = new GridTableParams(params);
+  }
+
+  GridTable.prototype.loadGridTable = function(table, params) {
+    if (params == null) {
+      params = {};
+    }
+    this.gridTableDOM = $(table);
+    this.gridTableParams.setId(this.gridTableDOM.data('grid-table-id'));
+    if (this.gridTableDOM.attr('data-page-size')) {
+      this.gridTableParams.setPageSize(this.gridTableDOM.data('page-size'));
+    }
+    this.gridTableParams.setUrl(this.gridTableDOM.data('url'));
+    this.gridTableDOM.find('thead th[data-sort="true"], .thead [data-sort="true"]').each((function(_this) {
+      return function(index, column) {
+        var $column;
+        $column = $(column);
+        $column.append(" <i class='" + sortIcons['default'] + "'></i>");
+        if ($column.data('default-sort')) {
+          _this.setSort($column.data('field'), $column.data('default-sort'));
+        }
+        return $column.on('click', function(event) {
+          _this.gridTableParams.setSort($(event.currentTarget).data('field'), null);
+          return _this.loadData();
+        });
+      };
+    })(this));
+    this.gridTableDOM.find('select.row-filter').each((function(_this) {
+      return function(index, filter) {
+        return $(filter).on("change", function(event) {
+          _this.gridTableParams.setFilter($(filter).data('field'), $(filter).val());
+          return _this.loadData();
+        });
+      };
+    })(this));
+    this.gridTableDOM.find('input.row-filter').each((function(_this) {
+      return function(index, filter) {
+        var timeout;
+        _this.gridTableParams.setFilter($(filter).data('field'), $(filter).val());
+        timeout = null;
+        return $(filter).on("propertychange keyup input paste", function(event) {
+          clearTimeout(timeout);
+          return timeout = setTimeout((function() {
+            _this.gridTableParams.setFilter($(filter).data('field'), $(filter).val());
+            return _this.loadData();
+          }), 500);
+        });
+      };
+    })(this));
+    this.gridTableDOM.find('.grid-pager #pagesize').each((function(_this) {
+      return function(index, elem) {
+        var pageSizeSelect, size, _i, _len, _ref;
+        pageSizeSelect = '<select id="page-size-select">';
+        _ref = _this.gridTableParams.pageSizeOptions;
+        for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+          size = _ref[_i];
+          if (size === _this.gridTableParams.pageSize) {
+            pageSizeSelect += "<option selected value=\"" + size + "\">" + size + "</option>";
+          } else {
+            pageSizeSelect += "<option value=\"" + size + "\">" + size + "</option>";
+          }
+        }
+        pageSizeSelect += '</select>';
+        $(elem).append(pageSizeSelect);
+        return $(elem).find('#page-size-select').on("change", function(event) {
+          return _this.setPageSize($(event.currentTarget).val());
+        });
+      };
+    })(this));
+    this.loadData(params);
+    return $('.export[data-grid-table-id="' + this.gridTableParams.id + '"]').on('click', (function(_this) {
+      return function(event) {
+        return _this.exportData();
+      };
+    })(this));
+  };
+
+  GridTable.prototype.refresh = function(callback) {
+    if (typeof callback === "function") {
+      callback(callback);
+    }
+    return this.loadData();
+  };
+
+  GridTable.prototype.setId = function(id) {
+    return this.gridTableParams.setId(id);
+  };
+
+  GridTable.prototype.setUrl = function(url) {
+    return this.gridTableParams.setUrl(url);
+  };
+
+  GridTable.prototype.getUrl = function() {
+    return this.gridTableParams.url;
+  };
+
+  GridTable.prototype.setFilter = function(key, value, options) {
+    if (options == null) {
+      options = {};
+    }
+    this.gridTableParams.setFilter(key, value);
+    if (this.gridTableDOM !== null && !options.skip_load) {
+      return this.loadData();
+    }
+  };
+
+  GridTable.prototype.setSort = function(column, direction) {
+    this.gridTableParams.setSort(column, direction);
+    if (this.gridTableDOM !== null) {
+      return this.loadData();
+    }
+  };
+
+  GridTable.prototype.loadDataStart = function(callback) {
+    return this.loadDataStartCallback = callback;
+  };
+
+  GridTable.prototype.loadDataComplete = function(callback) {
+    return this.loadDataCompleteCallback = callback;
+  };
+
+  GridTable.prototype.loadDataError = function(callback) {
+    return this.loadDataErrorCallback = callback;
+  };
+
+  GridTable.prototype.buildUrl = function(baseUrl) {
+    return this.gridTableParams.buildUrl(baseUrl, true);
+  };
+
+  GridTable.prototype.setPage = function(page) {
+    this.gridTableParams.page = page;
+    return this.loadData();
+  };
+
+  GridTable.prototype.setPageSize = function(size) {
+    this.gridTableParams.pageSize = size;
+    this.gridTableParams.page = 0;
+    return this.loadData();
+  };
+
+  GridTable.prototype.loadData = function(params) {
+    if (params == null) {
+      params = {};
+    }
+    if (params.globalAjax == null) {
+      params.globalAjax = true;
+    }
+    if (typeof this.loadDataStartCallback === "function") {
+      this.loadDataStartCallback();
+    }
+    return $.ajax(this.gridTableParams.buildUrl(this.gridTableParams.url), {
+      type: 'GET',
+      global: params.globalAjax,
+      dataType: 'json',
+      error: (function(_this) {
+        return function(jqXHR, textStatus, errorThrown) {
+          if (typeof _this.loadDataErrorCallback === "function") {
+            return _this.loadDataErrorCallback();
+          }
+        };
+      })(this),
+      success: (function(_this) {
+        return function(data, textStatus, jqXHR) {
+          var row, _i, _len, _ref;
+          _this.gridTableDOM.find('tbody, .tbody').children().not('.no-results').remove();
+          _this.gridTableDOM.find('.no-results').addClass('hide');
+          if (data.totals) {
+            _this.gridTableDOM.find('thead tr.totals, .thead tr.totals, .thead .tr.totals').html(data.totals);
+          }
+          if (data.rows.length === 0) {
+            _this.gridTableDOM.find('.no-results').removeClass('hide');
+          } else {
+            _ref = data.rows;
+            for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+              row = _ref[_i];
+              _this.gridTableDOM.find('tbody, .tbody').append(row);
+            }
+          }
+          _this.updateSortDisplay();
+          _this.updatePagerDisplay(data.total_rows);
+          if (typeof _this.loadDataCompleteCallback === "function") {
+            return _this.loadDataCompleteCallback();
+          }
+        };
+      })(this)
+    });
+  };
+
+  GridTable.prototype.exportData = function() {
+    var baseUrl, url;
+    url = this.gridTableParams.url.split('?');
+    if (url.length === 1) {
+      baseUrl = url[0] + '.csv';
+    } else {
+      baseUrl = url[0] + '.csv?' + url[1];
+    }
+    return window.open(this.gridTableParams.buildUrl(baseUrl));
+  };
+
+  GridTable.prototype.updatePagerDisplay = function(total_rows) {
+    var back_enabled, display, first, forward_enabled, last, last_page, next, pager, previous;
+    pager = this.gridTableDOM.find('.grid-pager');
+    first = $(pager).find('#first');
+    previous = $(pager).find('#previous');
+    next = $(pager).find('#next');
+    last = $(pager).find('#last');
+    display = $(pager).find('#pagedisplay');
+    $(first).off('click');
+    $(previous).off('click');
+    $(next).off('click');
+    $(last).off('click');
+    last_page = Math.floor(total_rows / this.gridTableParams.pageSize);
+    if (total_rows % this.gridTableParams.pageSize === 0) {
+      last_page -= 1;
+    }
+    back_enabled = this.gridTableParams.page > 0;
+    forward_enabled = this.gridTableParams.page < last_page;
+    if (back_enabled) {
+      $(first).removeClass('disabled');
+      $(first).on('click', (function(_this) {
+        return function(event) {
+          event.preventDefault();
+          return _this.setPage(0);
+        };
+      })(this));
+      $(previous).removeClass('disabled');
+      $(previous).on('click', (function(_this) {
+        return function(event) {
+          event.preventDefault();
+          return _this.setPage(_this.gridTableParams.page - 1);
+        };
+      })(this));
+    } else {
+      $(first).addClass('disabled');
+      $(previous).addClass('disabled');
+    }
+    if (forward_enabled) {
+      $(next).removeClass('disabled');
+      $(next).on('click', (function(_this) {
+        return function(event) {
+          event.preventDefault();
+          return _this.setPage(_this.gridTableParams.page + 1);
+        };
+      })(this));
+      $(last).removeClass('disabled');
+      $(last).on('click', (function(_this) {
+        return function(event) {
+          event.preventDefault();
+          return _this.setPage(last_page);
+        };
+      })(this));
+    } else {
+      $(next).addClass('disabled');
+      $(last).addClass('disabled');
+    }
+    return display.text("" + (this.gridTableParams.page + 1) + " of " + (last_page + 1) + " (" + total_rows + ")");
+  };
+
+  GridTable.prototype.updateSortDisplay = function() {
+    var field, sortOrder;
+    field = this.gridTableParams.sortCol;
+    sortOrder = this.gridTableParams.sortOrder;
+    return this.gridTableDOM.find('thead th[data-sort="true"], .thead [data-sort="true"]').each((function(_this) {
+      return function(i, c) {
+        var value;
+        value = $(c).data('field');
+        if (value === field) {
+          switch (sortOrder) {
+            case 'asc':
+              $(c).addClass('sorting');
+              return $(c).find('i').attr('class', sortIcons['asc']);
+            case 'desc':
+              $(c).addClass('sorting');
+              return $(c).find('i').attr('class', sortIcons['desc']);
+            default:
+              $(c).removeClass('sorting');
+              return $(c).find('i').attr('class', sortIcons['default']);
+          }
+        } else {
+          $(c).removeClass('sorting');
+          return $(c).find('i').attr('class', sortIcons['default']);
+        }
+      };
+    })(this));
+  };
+
+  GridTableParams = (function() {
+    GridTableParams.prototype.id = null;
+
+    GridTableParams.prototype.url = null;
+
+    GridTableParams.prototype.sortCol = '';
+
+    GridTableParams.prototype.sortOrder = '';
+
+    GridTableParams.prototype.filter = {};
+
+    GridTableParams.prototype.page = 0;
+
+    GridTableParams.prototype.pageSize = 10;
+
+    GridTableParams.prototype.pageSizeOptions = [5, 10, 25, 50, 100, 200];
+
+    function GridTableParams(params) {
+      if ((params != null)) {
+        if ('sortCol' in params) {
+          this.sortCol = params['sortCol'];
+        }
+        if ('sortOrder' in params) {
+          this.sortOrder = params['sortOrder'];
+        }
+        if ('filter' in params) {
+          this.filter = params['filter'];
+        }
+        if ('page' in params) {
+          this.page = params['page'];
+        }
+        if ('pageSize' in params) {
+          this.pageSize = params['pageSize'];
+        }
+        if ('id' in params) {
+          this.id = params['id'];
+        }
+        if ('url' in params) {
+          this.url = params['url'];
+        }
+      }
+    }
+
+    GridTableParams.prototype.setId = function(id) {
+      return this.id = id;
+    };
+
+    GridTableParams.prototype.setUrl = function(url) {
+      return this.url = url;
+    };
+
+    GridTableParams.prototype.setPageSize = function(pageSize) {
+      return this.pageSize = pageSize;
+    };
+
+    GridTableParams.prototype.setSort = function(column, direction) {
+      var order;
+      this.page = 0;
+      if (this.sortCol === column) {
+        order = this.sortOrder === 'asc' ? 'desc' : 'asc';
+      } else {
+        order = 'asc';
+      }
+      this.sortOrder = direction || order;
+      return this.sortCol = column;
+    };
+
+    GridTableParams.prototype.setFilter = function(column, value) {
+      this.page = 0;
+      if (value === null || value.trim().length === 0) {
+        return delete this.filter[column];
+      } else {
+        return this.filter[column] = value;
+      }
+    };
+
+    GridTableParams.prototype.buildUrl = function(baseUrl, skip_paging) {
+      var k, url, v, _ref;
+      if (skip_paging == null) {
+        skip_paging = false;
+      }
+      url = baseUrl;
+      url += /\?/.test(url) ? '&' : '?';
+      if (!skip_paging) {
+        url += 'page=' + this.page;
+        url += "&page_size=" + this.pageSize;
+        url += "&sort=" + this.sortCol;
+        url += "&sort_order=" + this.sortOrder;
+      }
+      _ref = this.filter;
+      for (k in _ref) {
+        v = _ref[k];
+        url += '&' + k + '=' + v;
+      }
+      return url;
+    };
+
+    return GridTableParams;
+
+  })();
+
+  return GridTable;
+
+})();

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification
+name: grid_table
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Jon Principe
+- Mike Raimondi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Library to help manage powerful HTML Tables through the Model, View and
+  Controller.
+email:
+- jp@adharmonics.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- grid_table.gemspec
+- lib/grid_table.rb
+- lib/grid_table/control.rb
+- lib/grid_table/controller.rb
+- lib/grid_table/model.rb
+- lib/grid_table/table.rb
+- lib/grid_table/version.rb
+- vendor/assets/javascripts/gridtable.js
+homepage: http://github.com/jprincipe/grid_table
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: Utility for powerful HTML Tables
+test_files: []