jquery-dynatable-rails 0.3.1 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a70a9990943bbe77b4470160766681599a4ff486
-  data.tar.gz: f045ccf4e84129ddfe4da3393de47e8c02b99768
+  metadata.gz: b6e2fa52f5c8abbb77cada9fe2b076b82d071908
+  data.tar.gz: f8ef2f1d0139ade6d88e07c7f806c12d504c4b20
 SHA512:
-  metadata.gz: 4e2fad37ba5c03f940f62338392a6d825437469038141bd744faf28d1bee042c7eb302fa28bc55badc48f111343324802b8f6a2e40e0aea88a8430ccc27d655b
-  data.tar.gz: a65a16201b8ff5912dc2691cad6e11cb7a594e9a2c3d47730d881602905a603ab9d059acaeb7654c37b5058443679a951a69db67af18bced24d546d616365445
+  metadata.gz: e23d4686145ee95fa3ae64cbd1c41952b0554be2fca8c2e6f75febc6f873141181f1024f490f0b681fcac6974810d3110c022e1213c2c31a7ca552a9d60edaa9
+  data.tar.gz: 23fba218fb0113acfebc5192ef1dd0465210ba783b36e966d4541329d6ff9a9f770598d39a5c3e583e4b5ad62f6b0e6182cbedf69ac5932bc4c2eac22c4a6502

data/README.md

@@ -1,6 +1,10 @@
 # Jquery::Dynatable::Rails
 
-TODO: Write a gem description
+This gem packages the jQuery [Dynatable](https://github.com/alfajango/jquery-dynatable)
+plugin for easy use with the Rails 3.1+ asset pipleine.
+
+Dynatable is a funner, semantic, interactive table plugin using jQuery,
+HTML5, and JSON. And it's not just for tables.
 
 ## Installation
 
@@ -18,11 +22,23 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+    /= require 'jquery.dynatable'
+
+
+## Thanks
+Thanks the authors for making the [Dynatable](https://github.com/alfajango/jquery-dynatable) plugin for jQuery:
+
+Steve Schwartz -
+[JangoSteve on Github](https://github.com/JangoSteve),
+[@jangosteve on Twitter](https://twitter.com/jangosteve)
+
+![Alfa Jango logo](https://s3.amazonaws.com/s3.alfajango.com/github-readmes/AlfaJango_Logo_Black_noname-tiny.png)
+[Alfa Jango Open Source](http://os.alfajango.com) -
+[@alfajango on Twitter](https://twitter.com/alfajango)
 
 ## Contributing
 
-1. Fork it ( http://github.com/<my-github-username>/jquery-dynatable-rails/fork )
+1. Fork it ( http://github.com/ricardodovalle/jquery-dynatable-rails/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`)

data/jquery-dynatable-rails.gemspec

@@ -20,8 +20,10 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency 'bundler', '~> 1.5'
-  spec.add_development_dependency 'rake', '~> 0'
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake'
+
+  spec.add_dependency 'jquery-rails'
+  spec.add_dependency "railties", ">= 3.2", "< 5.0"
 
-  spec.add_dependency 'jquery-rails', '~> 0'
 end

data/lib/jquery/dynatable/rails.rb

@@ -3,7 +3,8 @@ require "jquery/dynatable/rails/version"
 module Jquery
   module Dynatable
     module Rails
-      # Your code goes here...
+      class Engine < ::Rails::Engine
+      end
     end
   end
 end

data/lib/jquery/dynatable/rails/version.rb

@@ -1,7 +1,7 @@
 module Jquery
   module Dynatable
     module Rails
-      VERSION = "0.3.1"
+      VERSION = "0.3.2"
     end
   end
 end

data/vendor/assets/javascripts/jquery.dynatable.js

@@ -0,0 +1,1681 @@
+/*
+ * jQuery Dynatable plugin 0.3.1
+ *
+ * Copyright (c) 2014 Steve Schwartz (JangoSteve)
+ *
+ * Dual licensed under the AGPL and Proprietary licenses:
+ *   http://www.dynatable.com/license/
+ *
+ * Date: Tue Jan 02 2014
+ */
+//
+
+(function($) {
+  var defaults,
+      mergeSettings,
+      dt,
+      Model,
+      modelPrototypes = {
+        dom: Dom,
+        domColumns: DomColumns,
+        records: Records,
+        recordsCount: RecordsCount,
+        processingIndicator: ProcessingIndicator,
+        state: State,
+        sorts: Sorts,
+        sortsHeaders: SortsHeaders,
+        queries: Queries,
+        inputsSearch: InputsSearch,
+        paginationPage: PaginationPage,
+        paginationPerPage: PaginationPerPage,
+        paginationLinks: PaginationLinks
+      },
+      utility,
+      build,
+      processAll,
+      initModel,
+      defaultRowWriter,
+      defaultCellWriter,
+      defaultAttributeWriter,
+      defaultAttributeReader;
+
+  //-----------------------------------------------------------------
+  // Cached plugin global defaults
+  //-----------------------------------------------------------------
+
+  defaults = {
+    features: {
+      paginate: true,
+      sort: true,
+      pushState: true,
+      search: true,
+      recordCount: true,
+      perPageSelect: true
+    },
+    table: {
+      defaultColumnIdStyle: 'camelCase',
+      columns: null,
+      headRowSelector: 'thead tr', // or e.g. tr:first-child
+      bodyRowSelector: 'tbody tr',
+      headRowClass: null
+    },
+    inputs: {
+      queries: null,
+      sorts: null,
+      multisort: ['ctrlKey', 'shiftKey', 'metaKey'],
+      page: null,
+      queryEvent: 'blur change',
+      recordCountTarget: null,
+      recordCountPlacement: 'after',
+      paginationLinkTarget: null,
+      paginationLinkPlacement: 'after',
+      paginationClass: 'dynatable-pagination-links',
+      paginationLinkClass: 'dynatable-page-link',
+      paginationPrevClass: 'dynatable-page-prev',
+      paginationNextClass: 'dynatable-page-next',
+      paginationActiveClass: 'dynatable-active-page',
+      paginationDisabledClass: 'dynatable-disabled-page',
+      paginationPrev: 'Previous',
+      paginationNext: 'Next',
+      paginationGap: [1,2,2,1],
+      searchTarget: null,
+      searchPlacement: 'before',
+      perPageTarget: null,
+      perPagePlacement: 'before',
+      perPageText: 'Show: ',
+      recordCountText: 'Showing ',
+      processingText: 'Processing...'
+    },
+    dataset: {
+      ajax: false,
+      ajaxUrl: null,
+      ajaxCache: null,
+      ajaxOnLoad: false,
+      ajaxMethod: 'GET',
+      ajaxDataType: 'json',
+      totalRecordCount: null,
+      queries: {},
+      queryRecordCount: null,
+      page: null,
+      perPageDefault: 10,
+      perPageOptions: [10,20,50,100],
+      sorts: {},
+      sortsKeys: null,
+      sortTypes: {},
+      records: null
+    },
+    writers: {
+      _rowWriter: defaultRowWriter,
+      _cellWriter: defaultCellWriter,
+      _attributeWriter: defaultAttributeWriter
+    },
+    readers: {
+      _rowReader: null,
+      _attributeReader: defaultAttributeReader
+    },
+    params: {
+      dynatable: 'dynatable',
+      queries: 'queries',
+      sorts: 'sorts',
+      page: 'page',
+      perPage: 'perPage',
+      offset: 'offset',
+      records: 'records',
+      record: null,
+      queryRecordCount: 'queryRecordCount',
+      totalRecordCount: 'totalRecordCount'
+    }
+  };
+
+  //-----------------------------------------------------------------
+  // Each dynatable instance inherits from this,
+  // set properties specific to instance
+  //-----------------------------------------------------------------
+
+  dt = {
+    init: function(element, options) {
+      this.settings = mergeSettings(options);
+      this.element = element;
+      this.$element = $(element);
+
+      // All the setup that doesn't require element or options
+      build.call(this);
+
+      return this;
+    },
+
+    process: function(skipPushState) {
+      processAll.call(this, skipPushState);
+    }
+  };
+
+  //-----------------------------------------------------------------
+  // Cached plugin global functions
+  //-----------------------------------------------------------------
+
+  mergeSettings = function(options) {
+    var newOptions = $.extend(true, {}, defaults, options);
+
+    // TODO: figure out a better way to do this.
+    // Doing `extend(true)` causes any elements that are arrays
+    // to merge the default and options arrays instead of overriding the defaults.
+    if (options) {
+      if (options.inputs) {
+        if (options.inputs.multisort) {
+          newOptions.inputs.multisort = options.inputs.multisort;
+        }
+        if (options.inputs.paginationGap) {
+          newOptions.inputs.paginationGap = options.inputs.paginationGap;
+        }
+      }
+      if (options.dataset && options.dataset.perPageOptions) {
+        newOptions.dataset.perPageOptions = options.dataset.perPageOptions;
+      }
+    }
+
+    return newOptions;
+  };
+
+  build = function() {
+    this.$element.trigger('dynatable:preinit', this);
+
+    for (model in modelPrototypes) {
+      if (modelPrototypes.hasOwnProperty(model)) {
+        var modelInstance = this[model] = new modelPrototypes[model](this, this.settings);
+        if (modelInstance.initOnLoad()) {
+          modelInstance.init();
+        }
+      }
+    }
+
+    this.$element.trigger('dynatable:init', this);
+
+    if (!this.settings.dataset.ajax || (this.settings.dataset.ajax && this.settings.dataset.ajaxOnLoad) || this.settings.features.paginate) {
+      this.process();
+    }
+  };
+
+  processAll = function(skipPushState) {
+    var data = {};
+
+    this.$element.trigger('dynatable:beforeProcess', data);
+
+    if (!$.isEmptyObject(this.settings.dataset.queries)) { data[this.settings.params.queries] = this.settings.dataset.queries; }
+    // TODO: Wrap this in a try/rescue block to hide the processing indicator and indicate something went wrong if error
+    this.processingIndicator.show();
+
+    if (this.settings.features.sort && !$.isEmptyObject(this.settings.dataset.sorts)) { data[this.settings.params.sorts] = this.settings.dataset.sorts; }
+    if (this.settings.features.paginate && this.settings.dataset.page) {
+      var page = this.settings.dataset.page,
+          perPage = this.settings.dataset.perPage;
+      data[this.settings.params.page] = page;
+      data[this.settings.params.perPage] = perPage;
+      data[this.settings.params.offset] = (page - 1) * perPage;
+    }
+    if (this.settings.dataset.ajaxData) { $.extend(data, this.settings.dataset.ajaxData); }
+
+    // If ajax, sends query to ajaxUrl with queries and sorts serialized and appended in ajax data
+    // otherwise, executes queries and sorts on in-page data
+    if (this.settings.dataset.ajax) {
+      var _this = this;
+      var options = {
+        type: _this.settings.dataset.ajaxMethod,
+        dataType: _this.settings.dataset.ajaxDataType,
+        data: data,
+        error: function(xhr, error) {
+        },
+        success: function(response) {
+          _this.$element.trigger('dynatable:ajax:success', response);
+          // Merge ajax results and meta-data into dynatables cached data
+          _this.records.updateFromJson(response);
+          // update table with new records
+          _this.dom.update();
+
+          if (!skipPushState && _this.state.initOnLoad()) {
+            _this.state.push(data);
+          }
+        },
+        complete: function() {
+          _this.processingIndicator.hide();
+        }
+      };
+      // Do not pass url to `ajax` options if blank
+      if (this.settings.dataset.ajaxUrl) {
+        options.url = this.settings.dataset.ajaxUrl;
+
+      // If ajaxUrl is blank, then we're using the current page URL,
+      // we need to strip out any query, sort, or page data controlled by dynatable
+      // that may have been in URL when page loaded, so that it doesn't conflict with
+      // what's passed in with the data ajax parameter
+      } else {
+        options.url = utility.refreshQueryString(window.location.href, {}, this.settings);
+      }
+      if (this.settings.dataset.ajaxCache !== null) { options.cache = this.settings.dataset.ajaxCache; }
+
+      $.ajax(options);
+    } else {
+      this.records.resetOriginal();
+      this.queries.run();
+      if (this.settings.features.sort) {
+        this.records.sort();
+      }
+      if (this.settings.features.paginate) {
+        this.records.paginate();
+      }
+      this.dom.update();
+      this.processingIndicator.hide();
+
+      if (!skipPushState && this.state.initOnLoad()) {
+        this.state.push(data);
+      }
+    }
+    this.$element.trigger('dynatable:afterProcess', data);
+  };
+
+  function defaultRowWriter(rowIndex, record, columns, cellWriter) {
+    var tr = '';
+
+    // grab the record's attribute for each column
+    for (var i = 0, len = columns.length; i < len; i++) {
+      tr += cellWriter(columns[i], record);
+    }
+
+    return '<tr>' + tr + '</tr>';
+  };
+
+  function defaultCellWriter(column, record) {
+    var html = column.attributeWriter(record),
+        td = '<td';
+
+    if (column.hidden || column.textAlign) {
+      td += ' style="';
+
+      // keep cells for hidden column headers hidden
+      if (column.hidden) {
+        td += 'display: none;';
+      }
+
+      // keep cells aligned as their column headers are aligned
+      if (column.textAlign) {
+        td += 'text-align: ' + column.textAlign + ';';
+      }
+
+      td += '"';
+    }
+
+    return td + '>' + html + '</td>';
+  };
+
+  function defaultAttributeWriter(record) {
+    // `this` is the column object in settings.columns
+    // TODO: automatically convert common types, such as arrays and objects, to string
+    return record[this.id];
+  };
+
+  function defaultAttributeReader(cell, record) {
+    return $(cell).html();
+  };
+
+  //-----------------------------------------------------------------
+  // Dynatable object model prototype
+  // (all object models get these default functions)
+  //-----------------------------------------------------------------
+
+  Model = {
+    initOnLoad: function() {
+      return true;
+    },
+
+    init: function() {}
+  };
+
+  for (model in modelPrototypes) {
+    if (modelPrototypes.hasOwnProperty(model)) {
+      var modelPrototype = modelPrototypes[model];
+      modelPrototype.prototype = Model;
+    }
+  }
+
+  //-----------------------------------------------------------------
+  // Dynatable object models
+  //-----------------------------------------------------------------
+
+  function Dom(obj, settings) {
+    var _this = this;
+
+    // update table contents with new records array
+    // from query (whether ajax or not)
+    this.update = function() {
+      var rows = '',
+          columns = settings.table.columns,
+          rowWriter = settings.writers._rowWriter,
+          cellWriter = settings.writers._cellWriter;
+
+      obj.$element.trigger('dynatable:beforeUpdate', rows);
+
+      // loop through records
+      for (var i = 0, len = settings.dataset.records.length; i < len; i++) {
+        var record = settings.dataset.records[i],
+            tr = rowWriter(i, record, columns, cellWriter);
+        rows += tr;
+      }
+
+      // Appended dynatable interactive elements
+      if (settings.features.recordCount) {
+        $('#dynatable-record-count-' + obj.element.id).replaceWith(obj.recordsCount.create());
+      }
+      if (settings.features.paginate) {
+        $('#dynatable-pagination-links-' + obj.element.id).replaceWith(obj.paginationLinks.create());
+        if (settings.features.perPageSelect) {
+          $('#dynatable-per-page-' + obj.element.id).val(parseInt(settings.dataset.perPage));
+        }
+      }
+
+      // Sort headers functionality
+      if (settings.features.sort && columns) {
+        obj.sortsHeaders.removeAllArrows();
+        for (var i = 0, len = columns.length; i < len; i++) {
+          var column = columns[i],
+              sortedByColumn = utility.allMatch(settings.dataset.sorts, column.sorts, function(sorts, sort) { return sort in sorts; }),
+              value = settings.dataset.sorts[column.sorts[0]];
+
+          if (sortedByColumn) {
+            obj.$element.find('[data-dynatable-column="' + column.id + '"]').find('.dynatable-sort-header').each(function(){
+              if (value == 1) {
+                obj.sortsHeaders.appendArrowUp($(this));
+              } else {
+                obj.sortsHeaders.appendArrowDown($(this));
+              }
+            });
+          }
+        }
+      }
+
+      // Query search functionality
+      if (settings.inputs.queries || settings.features.search) {
+        var allQueries = settings.inputs.queries || $();
+        if (settings.features.search) {
+          allQueries = allQueries.add('#dynatable-query-search-' + obj.element.id);
+        }
+
+        allQueries.each(function() {
+          var $this = $(this),
+              q = settings.dataset.queries[$this.data('dynatable-query')];
+          $this.val(q || '');
+        });
+      }
+
+      obj.$element.find(settings.table.bodyRowSelector).remove();
+      obj.$element.append(rows);
+
+      obj.$element.trigger('dynatable:afterUpdate', rows);
+    };
+  };
+
+  function DomColumns(obj, settings) {
+    var _this = this;
+
+    this.initOnLoad = function() {
+      return obj.$element.is('table');
+    };
+
+    this.init = function() {
+      settings.table.columns = [];
+      this.getFromTable();
+    };
+
+    // initialize table[columns] array
+    this.getFromTable = function() {
+      var $columns = obj.$element.find(settings.table.headRowSelector).children('th,td');
+      if ($columns.length) {
+        $columns.each(function(index){
+          _this.add($(this), index, true);
+        });
+      } else {
+        return $.error("Couldn't find any columns headers in '" + settings.table.headRowSelector + " th,td'. If your header row is different, specify the selector in the table: headRowSelector option.");
+      }
+    };
+
+    this.add = function($column, position, skipAppend, skipUpdate) {
+      var columns = settings.table.columns,
+          label = $column.text(),
+          id = $column.data('dynatable-column') || utility.normalizeText(label, settings.table.defaultColumnIdStyle),
+          dataSorts = $column.data('dynatable-sorts'),
+          sorts = dataSorts ? $.map(dataSorts.split(','), function(text) { return $.trim(text); }) : [id];
+
+      // If the column id is blank, generate an id for it
+      if ( !id ) {
+        this.generate($column);
+        id = $column.data('dynatable-column');
+      }
+      // Add column data to plugin instance
+      columns.splice(position, 0, {
+        index: position,
+        label: label,
+        id: id,
+        attributeWriter: settings.writers[id] || settings.writers._attributeWriter,
+        attributeReader: settings.readers[id] || settings.readers._attributeReader,
+        sorts: sorts,
+        hidden: $column.css('display') === 'none',
+        textAlign: $column.css('text-align')
+      });
+
+      // Modify header cell
+      $column
+        .attr('data-dynatable-column', id)
+        .addClass('dynatable-head');
+      if (settings.table.headRowClass) { $column.addClass(settings.table.headRowClass); }
+
+      // Append column header to table
+      if (!skipAppend) {
+        var domPosition = position + 1,
+            $sibling = obj.$element.find(settings.table.headRowSelector)
+              .children('th:nth-child(' + domPosition + '),td:nth-child(' + domPosition + ')').first(),
+            columnsAfter = columns.slice(position + 1, columns.length);
+
+        if ($sibling.length) {
+          $sibling.before($column);
+        // sibling column doesn't yet exist (maybe this is the last column in the header row)
+        } else {
+          obj.$element.find(settings.table.headRowSelector).append($column);
+        }
+
+        obj.sortsHeaders.attachOne($column.get());
+
+        // increment the index of all columns after this one that was just inserted
+        if (columnsAfter.length) {
+          for (var i = 0, len = columnsAfter.length; i < len; i++) {
+            columnsAfter[i].index += 1;
+          }
+        }
+
+        if (!skipUpdate) {
+          obj.dom.update();
+        }
+      }
+
+      return dt;
+    };
+
+    this.remove = function(columnIndexOrId) {
+      var columns = settings.table.columns,
+          length = columns.length;
+
+      if (typeof(columnIndexOrId) === "number") {
+        var column = columns[columnIndexOrId];
+        this.removeFromTable(column.id);
+        this.removeFromArray(columnIndexOrId);
+      } else {
+        // Traverse columns array in reverse order so that subsequent indices
+        // don't get messed up when we delete an item from the array in an iteration
+        for (var i = columns.length - 1; i >= 0; i--) {
+          var column = columns[i];
+
+          if (column.id === columnIndexOrId) {
+            this.removeFromTable(columnIndexOrId);
+            this.removeFromArray(i);
+          }
+        }
+      }
+
+      obj.dom.update();
+    };
+
+    this.removeFromTable = function(columnId) {
+      obj.$element.find(settings.table.headRowSelector).children('[data-dynatable-column="' + columnId + '"]').first()
+        .remove();
+    };
+
+    this.removeFromArray = function(index) {
+      var columns = settings.table.columns,
+          adjustColumns;
+      columns.splice(index, 1);
+      adjustColumns = columns.slice(index, columns.length);
+      for (var i = 0, len = adjustColumns.length; i < len; i++) {
+        adjustColumns[i].index -= 1;
+      }
+    };
+
+    this.generate = function($cell) {
+      var cell = $cell === undefined ? $('<th></th>') : $cell;
+      return this.attachGeneratedAttributes(cell);
+    };
+
+    this.attachGeneratedAttributes = function($cell) {
+      // Use increment to create unique column name that is the same each time the page is reloaded,
+      // in order to avoid errors with mismatched attribute names when loading cached `dataset.records` array
+      var increment = obj.$element.find(settings.table.headRowSelector).children('th[data-dynatable-generated]').length;
+      return $cell
+        .attr('data-dynatable-column', 'dynatable-generated-' + increment) //+ utility.randomHash(),
+        .attr('data-dynatable-no-sort', 'true')
+        .attr('data-dynatable-generated', increment);
+    };
+  };
+
+  function Records(obj, settings) {
+    var _this = this;
+
+    this.initOnLoad = function() {
+      return !settings.dataset.ajax;
+    };
+
+    this.init = function() {
+      if (settings.dataset.records === null) {
+        settings.dataset.records = this.getFromTable();
+
+        if (!settings.dataset.queryRecordCount) {
+          settings.dataset.queryRecordCount = this.count();
+        }
+
+        if (!settings.dataset.totalRecordCount){
+          settings.dataset.totalRecordCount = settings.dataset.queryRecordCount;
+        }
+      }
+
+      // Create cache of original full recordset (unpaginated and unqueried)
+      settings.dataset.originalRecords = $.extend(true, [], settings.dataset.records);
+    };
+
+    // merge ajax response json with cached data including
+    // meta-data and records
+    this.updateFromJson = function(data) {
+      var records;
+      if (settings.params.records === "_root") {
+        records = data;
+      } else if (settings.params.records in data) {
+        records = data[settings.params.records];
+      }
+      if (settings.params.record) {
+        var len = records.length - 1;
+        for (var i = 0; i < len; i++) {
+          records[i] = records[i][settings.params.record];
+        }
+      }
+      if (settings.params.queryRecordCount in data) {
+        settings.dataset.queryRecordCount = data[settings.params.queryRecordCount];
+      }
+      if (settings.params.totalRecordCount in data) {
+        settings.dataset.totalRecordCount = data[settings.params.totalRecordCount];
+      }
+      settings.dataset.records = records;
+    };
+
+    // For really advanced sorting,
+    // see http://james.padolsey.com/javascript/sorting-elements-with-jquery/
+    this.sort = function() {
+      var sort = [].sort,
+          sorts = settings.dataset.sorts,
+          sortsKeys = settings.dataset.sortsKeys,
+          sortTypes = settings.dataset.sortTypes;
+
+      var sortFunction = function(a, b) {
+        var comparison;
+        if ($.isEmptyObject(sorts)) {
+          comparison = obj.sorts.functions['originalPlacement'](a, b);
+        } else {
+          for (var i = 0, len = sortsKeys.length; i < len; i++) {
+            var attr = sortsKeys[i],
+                direction = sorts[attr],
+                sortType = sortTypes[attr] || obj.sorts.guessType(a, b, attr);
+            comparison = obj.sorts.functions[sortType](a, b, attr, direction);
+            // Don't need to sort any further unless this sort is a tie between a and b,
+            // so break the for loop unless tied
+            if (comparison !== 0) { break; }
+          }
+        }
+        return comparison;
+      }
+
+      return sort.call(settings.dataset.records, sortFunction);
+    };
+
+    this.paginate = function() {
+      var bounds = this.pageBounds(),
+          first = bounds[0], last = bounds[1];
+      settings.dataset.records = settings.dataset.records.slice(first, last);
+    };
+
+    this.resetOriginal = function() {
+      settings.dataset.records = settings.dataset.originalRecords || [];
+    };
+
+    this.pageBounds = function() {
+      var page = settings.dataset.page || 1,
+          first = (page - 1) * settings.dataset.perPage,
+          last = Math.min(first + settings.dataset.perPage, settings.dataset.queryRecordCount);
+      return [first,last];
+    };
+
+    // get initial recordset to populate table
+    // if ajax, call ajaxUrl
+    // otherwise, initialize from in-table records
+    this.getFromTable = function() {
+      var records = [],
+          columns = settings.table.columns,
+          tableRecords = obj.$element.find(settings.table.bodyRowSelector);
+
+      tableRecords.each(function(index){
+        var record = {};
+        record['dynatable-original-index'] = index;
+        $(this).find('th,td').each(function(index) {
+          if (columns[index] === undefined) {
+            // Header cell didn't exist for this column, so let's generate and append
+            // a new header cell with a randomly generated name (so we can store and
+            // retrieve the contents of this column for each record)
+            obj.domColumns.add(obj.domColumns.generate(), columns.length, false, true); // don't skipAppend, do skipUpdate
+          }
+          var value = columns[index].attributeReader(this, record),
+              attr = columns[index].id;
+
+          // If value from table is HTML, let's get and cache the text equivalent for
+          // the default string sorting, since it rarely makes sense for sort headers
+          // to sort based on HTML tags.
+          if (typeof(value) === "string" && value.match(/\s*\<.+\>/)) {
+            if (! record['dynatable-sortable-text']) {
+              record['dynatable-sortable-text'] = {};
+            }
+            record['dynatable-sortable-text'][attr] = $.trim($('<div></div>').html(value).text());
+          }
+
+          record[attr] = value;
+        });
+        // Allow configuration function which alters record based on attributes of
+        // table row (e.g. from html5 data- attributes)
+        if (typeof(settings.readers._rowReader) === "function") {
+          settings.readers._rowReader(index, this, record);
+        }
+        records.push(record);
+      });
+      return records; // 1st row is header
+    };
+
+    // count records from table
+    this.count = function() {
+      return settings.dataset.records.length;
+    };
+  };
+
+  function RecordsCount(obj, settings) {
+    this.initOnLoad = function() {
+      return settings.features.recordCount;
+    };
+
+    this.init = function() {
+      this.attach();
+    };
+
+    this.create = function() {
+      var recordsShown = obj.records.count(),
+          recordsQueryCount = settings.dataset.queryRecordCount,
+          recordsTotal = settings.dataset.totalRecordCount,
+          text = settings.inputs.recordCountText,
+          collection_name = settings.params.records;
+
+      if (recordsShown < recordsQueryCount && settings.features.paginate) {
+        var bounds = obj.records.pageBounds();
+        text += "<span class='dynatable-record-bounds'>" + (bounds[0] + 1) + " to " + bounds[1] + "</span> of ";
+      } else if (recordsShown === recordsQueryCount && settings.features.paginate) {
+        text += recordsShown + " of ";
+      }
+      text += recordsQueryCount + " " + collection_name;
+      if (recordsQueryCount < recordsTotal) {
+        text += " (filtered from " + recordsTotal + " total records)";
+      }
+
+      return $('<span></span>', {
+                id: 'dynatable-record-count-' + obj.element.id,
+                'class': 'dynatable-record-count',
+                html: text
+              });
+    };
+
+    this.attach = function() {
+      var $target = settings.inputs.recordCountTarget ? $(settings.inputs.recordCountTarget) : obj.$element;
+      $target[settings.inputs.recordCountPlacement](this.create());
+    };
+  };
+
+  function ProcessingIndicator(obj, settings) {
+    this.init = function() {
+      this.attach();
+    };
+
+    this.create = function() {
+      var $processing = $('<div></div>', {
+            html: '<span>' + settings.inputs.processingText + '</span>',
+            id: 'dynatable-processing-' + obj.element.id,
+            'class': 'dynatable-processing',
+            style: 'position: absolute; display: none;'
+          });
+
+      return $processing;
+    };
+
+    this.position = function() {
+      var $processing = $('#dynatable-processing-' + obj.element.id),
+          $span = $processing.children('span'),
+          spanHeight = $span.outerHeight(),
+          spanWidth = $span.outerWidth(),
+          $covered = obj.$element,
+          offset = $covered.offset(),
+          height = $covered.outerHeight(), width = $covered.outerWidth();
+
+      $processing
+        .offset({left: offset.left, top: offset.top})
+        .width(width)
+        .height(height)
+      $span
+        .offset({left: offset.left + ( (width - spanWidth) / 2 ), top: offset.top + ( (height - spanHeight) / 2 )});
+
+      return $processing;
+    };
+
+    this.attach = function() {
+      obj.$element.before(this.create());
+    };
+
+    this.show = function() {
+      $('#dynatable-processing-' + obj.element.id).show();
+      this.position();
+    };
+
+    this.hide = function() {
+      $('#dynatable-processing-' + obj.element.id).hide();
+    };
+  };
+
+  function State(obj, settings) {
+    this.initOnLoad = function() {
+      // Check if pushState option is true, and if browser supports it
+      return settings.features.pushState && history.pushState;
+    };
+
+    this.init = function() {
+      window.onpopstate = function(event) {
+        if (event.state && event.state.dynatable) {
+          obj.state.pop(event);
+        }
+      }
+    };
+
+    this.push = function(data) {
+      var urlString = window.location.search,
+          urlOptions,
+          path,
+          params,
+          hash,
+          newParams,
+          cacheStr,
+          cache,
+          // replaceState on initial load, then pushState after that
+          firstPush = !(window.history.state && window.history.state.dynatable),
+          pushFunction = firstPush ? 'replaceState' : 'pushState';
+
+      if (urlString && /^\?/.test(urlString)) { urlString = urlString.substring(1); }
+      $.extend(urlOptions, data);
+
+      params = utility.refreshQueryString(urlString, data, settings);
+      if (params) { params = '?' + params; }
+      hash = window.location.hash;
+      path = window.location.pathname;
+
+      obj.$element.trigger('dynatable:push', data);
+
+      cache = { dynatable: { dataset: settings.dataset } };
+      if (!firstPush) { cache.dynatable.scrollTop = $(window).scrollTop(); }
+      cacheStr = JSON.stringify(cache);
+
+      // Mozilla has a 640k char limit on what can be stored in pushState.
+      // See "limit" in https://developer.mozilla.org/en/DOM/Manipulating_the_browser_history#The_pushState().C2.A0method
+      // and "dataStr.length" in http://wine.git.sourceforge.net/git/gitweb.cgi?p=wine/wine-gecko;a=patch;h=43a11bdddc5fc1ff102278a120be66a7b90afe28
+      //
+      // Likewise, other browsers may have varying (undocumented) limits.
+      // Also, Firefox's limit can be changed in about:config as browser.history.maxStateObjectSize
+      // Since we don't know what the actual limit will be in any given situation, we'll just try caching and rescue
+      // any exceptions by retrying pushState without caching the records.
+      //
+      // I have absolutely no idea why perPageOptions suddenly becomes an array-like object instead of an array,
+      // but just recently, this started throwing an error if I don't convert it:
+      // 'Uncaught Error: DATA_CLONE_ERR: DOM Exception 25'
+      cache.dynatable.dataset.perPageOptions = $.makeArray(cache.dynatable.dataset.perPageOptions);
+
+      try {
+        window.history[pushFunction](cache, "Dynatable state", path + params + hash);
+      } catch(error) {
+        // Make cached records = null, so that `pop` will rerun process to retrieve records
+        cache.dynatable.dataset.records = null;
+        window.history[pushFunction](cache, "Dynatable state", path + params + hash);
+      }
+    };
+
+    this.pop = function(event) {
+      var data = event.state.dynatable;
+      settings.dataset = data.dataset;
+
+      if (data.scrollTop) { $(window).scrollTop(data.scrollTop); }
+
+      // If dataset.records is cached from pushState
+      if ( data.dataset.records ) {
+        obj.dom.update();
+      } else {
+        obj.process(true);
+      }
+    };
+  };
+
+  function Sorts(obj, settings) {
+    this.initOnLoad = function() {
+      return settings.features.sort;
+    };
+
+    this.init = function() {
+      var sortsUrl = window.location.search.match(new RegExp(settings.params.sorts + '[^&=]*=[^&]*', 'g'));
+      settings.dataset.sorts = sortsUrl ? utility.deserialize(sortsUrl)[settings.params.sorts] : {};
+      settings.dataset.sortsKeys = sortsUrl ? utility.keysFromObject(settings.dataset.sorts) : [];
+    };
+
+    this.add = function(attr, direction) {
+      var sortsKeys = settings.dataset.sortsKeys,
+          index = $.inArray(attr, sortsKeys);
+      settings.dataset.sorts[attr] = direction;
+      if (index === -1) { sortsKeys.push(attr); }
+      return dt;
+    };
+
+    this.remove = function(attr) {
+      var sortsKeys = settings.dataset.sortsKeys,
+          index = $.inArray(attr, sortsKeys);
+      delete settings.dataset.sorts[attr];
+      if (index !== -1) { sortsKeys.splice(index, 1); }
+      return dt;
+    };
+
+    this.clear = function() {
+      settings.dataset.sorts = {};
+      settings.dataset.sortsKeys.length = 0;
+    };
+
+    // Try to intelligently guess which sort function to use
+    // based on the type of attribute values.
+    // Consider using something more robust than `typeof` (http://javascriptweblog.wordpress.com/2011/08/08/fixing-the-javascript-typeof-operator/)
+    this.guessType = function(a, b, attr) {
+      var types = {
+            string: 'string',
+            number: 'number',
+            'boolean': 'number',
+            object: 'number' // dates and null values are also objects, this works...
+          },
+          attrType = a[attr] ? typeof(a[attr]) : typeof(b[attr]),
+          type = types[attrType] || 'number';
+      return type;
+    };
+
+    // Built-in sort functions
+    // (the most common use-cases I could think of)
+    this.functions = {
+      number: function(a, b, attr, direction) {
+        return a[attr] === b[attr] ? 0 : (direction > 0 ? a[attr] - b[attr] : b[attr] - a[attr]);
+      },
+      string: function(a, b, attr, direction) {
+        var aAttr = (a['dynatable-sortable-text'] && a['dynatable-sortable-text'][attr]) ? a['dynatable-sortable-text'][attr] : a[attr],
+            bAttr = (b['dynatable-sortable-text'] && b['dynatable-sortable-text'][attr]) ? b['dynatable-sortable-text'][attr] : b[attr],
+            comparison;
+        aAttr = aAttr.toLowerCase();
+        bAttr = bAttr.toLowerCase();
+        comparison = aAttr === bAttr ? 0 : (direction > 0 ? aAttr > bAttr : bAttr > aAttr);
+        // force false boolean value to -1, true to 1, and tie to 0
+        return comparison === false ? -1 : (comparison - 0);
+      },
+      originalPlacement: function(a, b) {
+        return a['dynatable-original-index'] - b['dynatable-original-index'];
+      }
+    };
+  };
+
+  // turn table headers into links which add sort to sorts array
+  function SortsHeaders(obj, settings) {
+    var _this = this;
+
+    this.initOnLoad = function() {
+      return settings.features.sort;
+    };
+
+    this.init = function() {
+      this.attach();
+    };
+
+    this.create = function(cell) {
+      var $cell = $(cell),
+          $link = $('<a></a>', {
+            'class': 'dynatable-sort-header',
+            href: '#',
+            html: $cell.html()
+          }),
+          id = $cell.data('dynatable-column'),
+          column = utility.findObjectInArray(settings.table.columns, {id: id});
+
+      $link.bind('click', function(e) {
+        _this.toggleSort(e, $link, column);
+        obj.process();
+
+        e.preventDefault();
+      });
+
+      if (this.sortedByColumn($link, column)) {
+        if (this.sortedByColumnValue(column) == 1) {
+          this.appendArrowUp($link);
+        } else {
+          this.appendArrowDown($link);
+        }
+      }
+
+      return $link;
+    };
+
+    this.removeAll = function() {
+      obj.$element.find(settings.table.headRowSelector).children('th,td').each(function(){
+        _this.removeAllArrows();
+        _this.removeOne(this);
+      });
+    };
+
+    this.removeOne = function(cell) {
+      var $cell = $(cell),
+          $link = $cell.find('.dynatable-sort-header');
+      if ($link.length) {
+        var html = $link.html();
+        $link.remove();
+        $cell.html($cell.html() + html);
+      }
+    };
+
+    this.attach = function() {
+      obj.$element.find(settings.table.headRowSelector).children('th,td').each(function(){
+        _this.attachOne(this);
+      });
+    };
+
+    this.attachOne = function(cell) {
+      var $cell = $(cell);
+      if (!$cell.data('dynatable-no-sort')) {
+        $cell.html(this.create(cell));
+      }
+    };
+
+    this.appendArrowUp = function($link) {
+      this.removeArrow($link);
+      $link.append("<span class='dynatable-arrow'> &#9650;</span>");
+    };
+
+    this.appendArrowDown = function($link) {
+      this.removeArrow($link);
+      $link.append("<span class='dynatable-arrow'> &#9660;</span>");
+    };
+
+    this.removeArrow = function($link) {
+      // Not sure why `parent()` is needed, the arrow should be inside the link from `append()` above
+      $link.find('.dynatable-arrow').remove();
+    };
+
+    this.removeAllArrows = function() {
+      obj.$element.find('.dynatable-arrow').remove();
+    };
+
+    this.toggleSort = function(e, $link, column) {
+      var sortedByColumn = this.sortedByColumn($link, column),
+          value = this.sortedByColumnValue(column);
+      // Clear existing sorts unless this is a multisort event
+      if (!settings.inputs.multisort || !utility.anyMatch(e, settings.inputs.multisort, function(evt, key) { return e[key]; })) {
+        this.removeAllArrows();
+        obj.sorts.clear();
+      }
+
+      // If sorts for this column are already set
+      if (sortedByColumn) {
+        // If ascending, then make descending
+        if (value == 1) {
+          for (var i = 0, len = column.sorts.length; i < len; i++) {
+            obj.sorts.add(column.sorts[i], -1);
+          }
+          this.appendArrowDown($link);
+        // If descending, remove sort
+        } else {
+          for (var i = 0, len = column.sorts.length; i < len; i++) {
+            obj.sorts.remove(column.sorts[i]);
+          }
+          this.removeArrow($link);
+        }
+      // Otherwise, if not already set, set to ascending
+      } else {
+        for (var i = 0, len = column.sorts.length; i < len; i++) {
+          obj.sorts.add(column.sorts[i], 1);
+        }
+        this.appendArrowUp($link);
+      }
+    };
+
+    this.sortedByColumn = function($link, column) {
+      return utility.allMatch(settings.dataset.sorts, column.sorts, function(sorts, sort) { return sort in sorts; });
+    };
+
+    this.sortedByColumnValue = function(column) {
+      return settings.dataset.sorts[column.sorts[0]];
+    };
+  };
+
+  function Queries(obj, settings) {
+    var _this = this;
+
+    this.initOnLoad = function() {
+      return settings.inputs.queries || settings.features.search;
+    };
+
+    this.init = function() {
+      var queriesUrl = window.location.search.match(new RegExp(settings.params.queries + '[^&=]*=[^&]*', 'g'));
+
+      settings.dataset.queries = queriesUrl ? utility.deserialize(queriesUrl)[settings.params.queries] : {};
+      if (settings.dataset.queries === "") { settings.dataset.queries = {}; }
+
+      if (settings.inputs.queries) {
+        this.setupInputs();
+      }
+    };
+
+    this.add = function(name, value) {
+      // reset to first page since query will change records
+      if (settings.features.paginate) {
+        settings.dataset.page = 1;
+      }
+      settings.dataset.queries[name] = value;
+      return dt;
+    };
+
+    this.remove = function(name) {
+      delete settings.dataset.queries[name];
+      return dt;
+    };
+
+    this.run = function() {
+      for (query in settings.dataset.queries) {
+        if (settings.dataset.queries.hasOwnProperty(query)) {
+          var value = settings.dataset.queries[query];
+          if (_this.functions[query] === undefined) {
+            // Try to lazily evaluate query from column names if not explicitly defined
+            var queryColumn = utility.findObjectInArray(settings.table.columns, {id: query});
+            if (queryColumn) {
+              _this.functions[query] = function(record, queryValue) {
+                return record[query] == queryValue;
+              };
+            } else {
+              $.error("Query named '" + query + "' called, but not defined in queries.functions");
+              continue; // to skip to next query
+            }
+          }
+          // collect all records that return true for query
+          settings.dataset.records = $.map(settings.dataset.records, function(record) {
+            return _this.functions[query](record, value) ? record : null;
+          });
+        }
+      }
+      settings.dataset.queryRecordCount = obj.records.count();
+    };
+
+    // Shortcut for performing simple query from built-in search
+    this.runSearch = function(q) {
+      var origQueries = $.extend({}, settings.dataset.queries);
+      if (q) {
+        this.add('search', q);
+      } else {
+        this.remove('search');
+      }
+      if (!utility.objectsEqual(settings.dataset.queries, origQueries)) {
+        obj.process();
+      }
+    };
+
+    this.setupInputs = function() {
+      settings.inputs.queries.each(function() {
+        var $this = $(this),
+            event = $this.data('dynatable-query-event') || settings.inputs.queryEvent,
+            query = $this.data('dynatable-query') || $this.attr('name') || this.id,
+            queryFunction = function(e) {
+              var q = $(this).val();
+              if (q === "") { q = undefined; }
+              if (q === settings.dataset.queries[query]) { return false; }
+              if (q) {
+                _this.add(query, q);
+              } else {
+                _this.remove(query);
+              }
+              obj.process();
+              e.preventDefault();
+            };
+
+        $this
+          .attr('data-dynatable-query', query)
+          .bind(event, queryFunction)
+          .bind('keypress', function(e) {
+            if (e.which == 13) {
+              queryFunction.call(this, e);
+            }
+          });
+
+        if (settings.dataset.queries[query]) { $this.val(decodeURIComponent(settings.dataset.queries[query])); }
+      });
+    };
+
+    // Query functions for in-page querying
+    // each function should take a record and a value as input
+    // and output true of false as to whether the record is a match or not
+    this.functions = {
+      search: function(record, queryValue) {
+        var contains = false;
+        // Loop through each attribute of record
+        for (attr in record) {
+          if (record.hasOwnProperty(attr)) {
+            var attrValue = record[attr];
+            if (typeof(attrValue) === "string" && attrValue.toLowerCase().indexOf(queryValue.toLowerCase()) !== -1) {
+              contains = true;
+              // Don't need to keep searching attributes once found
+              break;
+            } else {
+              continue;
+            }
+          }
+        }
+        return contains;
+      }
+    };
+  };
+
+  function InputsSearch(obj, settings) {
+    var _this = this;
+
+    this.initOnLoad = function() {
+      return settings.features.search;
+    };
+
+    this.init = function() {
+      this.attach();
+    };
+
+    this.create = function() {
+      var $search = $('<input />', {
+            type: 'search',
+            id: 'dynatable-query-search-' + obj.element.id,
+            'data-dynatable-query': 'search',
+            value: settings.dataset.queries.search
+          }),
+          $searchSpan = $('<span></span>', {
+            id: 'dynatable-search-' + obj.element.id,
+            'class': 'dynatable-search',
+            text: 'Search: '
+          }).append($search);
+
+      $search
+        .bind(settings.inputs.queryEvent, function() {
+          obj.queries.runSearch($(this).val());
+        })
+        .bind('keypress', function(e) {
+          if (e.which == 13) {
+            obj.queries.runSearch($(this).val());
+            e.preventDefault();
+          }
+        });
+      return $searchSpan;
+    };
+
+    this.attach = function() {
+      var $target = settings.inputs.searchTarget ? $(settings.inputs.searchTarget) : obj.$element;
+      $target[settings.inputs.searchPlacement](this.create());
+    };
+  };
+
+  // provide a public function for selecting page
+  function PaginationPage(obj, settings) {
+    this.initOnLoad = function() {
+      return settings.features.paginate;
+    };
+
+    this.init = function() {
+      var pageUrl = window.location.search.match(new RegExp(settings.params.page + '=([^&]*)'));
+      // If page is present in URL parameters and pushState is enabled
+      // (meaning that it'd be possible for dynatable to have put the
+      // page parameter in the URL)
+      if (pageUrl && settings.features.pushState) {
+        this.set(pageUrl[1]);
+      } else {
+        this.set(1);
+      }
+    };
+
+    this.set = function(page) {
+      settings.dataset.page = parseInt(page, 10);
+    }
+  };
+
+  function PaginationPerPage(obj, settings) {
+    var _this = this;
+
+    this.initOnLoad = function() {
+      return settings.features.paginate;
+    };
+
+    this.init = function() {
+      var perPageUrl = window.location.search.match(new RegExp(settings.params.perPage + '=([^&]*)'));
+
+      // If perPage is present in URL parameters and pushState is enabled
+      // (meaning that it'd be possible for dynatable to have put the
+      // perPage parameter in the URL)
+      if (perPageUrl && settings.features.pushState) {
+        // Don't reset page to 1 on init, since it might override page
+        // set on init from URL
+        this.set(perPageUrl[1], true);
+      } else {
+        this.set(settings.dataset.perPageDefault, true);
+      }
+
+      if (settings.features.perPageSelect) {
+        this.attach();
+      }
+    };
+
+    this.create = function() {
+      var $select = $('<select>', {
+            id: 'dynatable-per-page-' + obj.element.id,
+            'class': 'dynatable-per-page-select'
+          });
+
+      for (var i = 0, len = settings.dataset.perPageOptions.length; i < len; i++) {
+        var number = settings.dataset.perPageOptions[i],
+            selected = settings.dataset.perPage == number ? 'selected="selected"' : '';
+        $select.append('<option value="' + number + '" ' + selected + '>' + number + '</option>');
+      }
+
+      $select.bind('change', function(e) {
+        _this.set($(this).val());
+        obj.process();
+      });
+
+      return $('<span />', {
+        'class': 'dynatable-per-page'
+      }).append("<span class='dynatable-per-page-label'>" + settings.inputs.perPageText + "</span>").append($select);
+    };
+
+    this.attach = function() {
+      var $target = settings.inputs.perPageTarget ? $(settings.inputs.perPageTarget) : obj.$element;
+      $target[settings.inputs.perPagePlacement](this.create());
+    };
+
+    this.set = function(number, skipResetPage) {
+      if (!skipResetPage) { obj.paginationPage.set(1); }
+      settings.dataset.perPage = parseInt(number);
+    };
+  };
+
+  // pagination links which update dataset.page attribute
+  function PaginationLinks(obj, settings) {
+    var _this = this;
+
+    this.initOnLoad = function() {
+      return settings.features.paginate;
+    };
+
+    this.init = function() {
+      this.attach();
+    };
+
+    this.create = function() {
+      var pageLinks = '<ul id="' + 'dynatable-pagination-links-' + obj.element.id + '" class="' + settings.inputs.paginationClass + '">',
+          pageLinkClass = settings.inputs.paginationLinkClass,
+          activePageClass = settings.inputs.paginationActiveClass,
+          disabledPageClass = settings.inputs.paginationDisabledClass,
+          pages = Math.ceil(settings.dataset.queryRecordCount / settings.dataset.perPage),
+          page = settings.dataset.page,
+          breaks = [
+            settings.inputs.paginationGap[0],
+            settings.dataset.page - settings.inputs.paginationGap[1],
+            settings.dataset.page + settings.inputs.paginationGap[2],
+            (pages + 1) - settings.inputs.paginationGap[3]
+          ];
+
+      pageLinks += '<li><span>Pages: </span></li>';
+
+      for (var i = 1; i <= pages; i++) {
+        if ( (i > breaks[0] && i < breaks[1]) || (i > breaks[2] && i < breaks[3])) {
+          // skip to next iteration in loop
+          continue;
+        } else {
+          var li = obj.paginationLinks.buildLink(i, i, pageLinkClass, page == i, activePageClass),
+              breakIndex,
+              nextBreak;
+
+          // If i is not between one of the following
+          // (1 + (settings.paginationGap[0]))
+          // (page - settings.paginationGap[1])
+          // (page + settings.paginationGap[2])
+          // (pages - settings.paginationGap[3])
+          breakIndex = $.inArray(i, breaks);
+          nextBreak = breaks[breakIndex + 1];
+          if (breakIndex > 0 && i !== 1 && nextBreak && nextBreak > (i + 1)) {
+            var ellip = '<li><span class="dynatable-page-break">&hellip;</span></li>';
+            li = breakIndex < 2 ? ellip + li : li + ellip;
+          }
+
+          if (settings.inputs.paginationPrev && i === 1) {
+            var prevLi = obj.paginationLinks.buildLink(page - 1, settings.inputs.paginationPrev, pageLinkClass + ' ' + settings.inputs.paginationPrevClass, page === 1, disabledPageClass);
+            li = prevLi + li;
+          }
+          if (settings.inputs.paginationNext && i === pages) {
+            var nextLi = obj.paginationLinks.buildLink(page + 1, settings.inputs.paginationNext, pageLinkClass + ' ' + settings.inputs.paginationNextClass, page === pages, disabledPageClass);
+            li += nextLi;
+          }
+
+          pageLinks += li;
+        }
+      }
+
+      pageLinks += '</ul>';
+
+      // only bind page handler to non-active and non-disabled page links
+      var selector = '#dynatable-pagination-links-' + obj.element.id + ' a.' + pageLinkClass + ':not(.' + activePageClass + ',.' + disabledPageClass + ')';
+      // kill any existing delegated-bindings so they don't stack up
+      $(document).undelegate(selector, 'click.dynatable');
+      $(document).delegate(selector, 'click.dynatable', function(e) {
+        $this = $(this);
+        $this.closest(settings.inputs.paginationClass).find('.' + activePageClass).removeClass(activePageClass);
+        $this.addClass(activePageClass);
+
+        obj.paginationPage.set($this.data('dynatable-page'));
+        obj.process();
+        e.preventDefault();
+      });
+
+      return pageLinks;
+    };
+
+    this.buildLink = function(page, label, linkClass, conditional, conditionalClass) {
+      var link = '<a data-dynatable-page=' + page + ' class="' + linkClass,
+          li = '<li';
+
+      if (conditional) {
+        link += ' ' + conditionalClass;
+        li += ' class="' + conditionalClass + '"';
+      }
+
+      link += '">' + label + '</a>';
+      li += '>' + link + '</li>';
+
+      return li;
+    };
+
+    this.attach = function() {
+      // append page links *after* delegate-event-binding so it doesn't need to
+      // find and select all page links to bind event
+      var $target = settings.inputs.paginationLinkTarget ? $(settings.inputs.paginationLinkTarget) : obj.$element;
+      $target[settings.inputs.paginationLinkPlacement](obj.paginationLinks.create());
+    };
+  };
+
+  utility = dt.utility = {
+    normalizeText: function(text, style) {
+      text = this.textTransform[style](text);
+      return text;
+    },
+    textTransform: {
+      trimDash: function(text) {
+        return text.replace(/^\s+|\s+$/g, "").replace(/\s+/g, "-");
+      },
+      camelCase: function(text) {
+        text = this.trimDash(text);
+        return text
+          .replace(/(\-[a-zA-Z])/g, function($1){return $1.toUpperCase().replace('-','');})
+          .replace(/([A-Z])([A-Z]+)/g, function($1,$2,$3){return $2 + $3.toLowerCase();})
+          .replace(/^[A-Z]/, function($1){return $1.toLowerCase();});
+      },
+      dashed: function(text) {
+        text = this.trimDash(text);
+        return this.lowercase(text);
+      },
+      underscore: function(text) {
+        text = this.trimDash(text);
+        return this.lowercase(text.replace(/(-)/g, '_'));
+      },
+      lowercase: function(text) {
+        return text.replace(/([A-Z])/g, function($1){return $1.toLowerCase();});
+      }
+    },
+    // Deserialize params in URL to object
+    // see http://stackoverflow.com/questions/1131630/javascript-jquery-param-inverse-function/3401265#3401265
+    deserialize: function(query) {
+      if (!query) return {};
+      // modified to accept an array of partial URL strings
+      if (typeof(query) === "object") { query = query.join('&'); }
+
+      var hash = {},
+          vars = query.split("&");
+
+      for (var i = 0; i < vars.length; i++) {
+        var pair = vars[i].split("="),
+            k = decodeURIComponent(pair[0]),
+            v, m;
+
+        if (!pair[1]) { continue };
+        v = decodeURIComponent(pair[1].replace(/\+/g, ' '));
+
+        // modified to parse multi-level parameters (e.g. "hi[there][dude]=whatsup" => hi: {there: {dude: "whatsup"}})
+        while (m = k.match(/([^&=]+)\[([^&=]+)\]$/)) {
+          var origV = v;
+          k = m[1];
+          v = {};
+
+          // If nested param ends in '][', then the regex above erroneously included half of a trailing '[]',
+          // which indicates the end-value is part of an array
+          if (m[2].substr(m[2].length-2) == '][') { // must use substr for IE to understand it
+            v[m[2].substr(0,m[2].length-2)] = [origV];
+          } else {
+            v[m[2]] = origV;
+          }
+        }
+
+        // If it is the first entry with this name
+        if (typeof hash[k] === "undefined") {
+          if (k.substr(k.length-2) != '[]') { // not end with []. cannot use negative index as IE doesn't understand it
+            hash[k] = v;
+          } else {
+            hash[k] = [v];
+          }
+        // If subsequent entry with this name and not array
+        } else if (typeof hash[k] === "string") {
+          hash[k] = v;  // replace it
+        // modified to add support for objects
+        } else if (typeof hash[k] === "object") {
+          hash[k] = $.extend({}, hash[k], v);
+        // If subsequent entry with this name and is array
+        } else {
+          hash[k].push(v);
+        }
+      }
+      return hash;
+    },
+    refreshQueryString: function(urlString, data, settings) {
+      var _this = this,
+          queryString = urlString.split('?'),
+          path = queryString.shift(),
+          urlOptions;
+
+      urlOptions = this.deserialize(urlString);
+
+      // Loop through each dynatable param and update the URL with it
+      for (attr in settings.params) {
+        if (settings.params.hasOwnProperty(attr)) {
+          var label = settings.params[attr];
+          // Skip over parameters matching attributes for disabled features (i.e. leave them untouched),
+          // because if the feature is turned off, then parameter name is a coincidence and it's unrelated to dynatable.
+          if (
+            (!settings.features.sort && attr == "sorts") ||
+              (!settings.features.paginate && _this.anyMatch(attr, ["page", "perPage", "offset"], function(attr, param) { return attr == param; }))
+          ) {
+            continue;
+          }
+
+          // Delete page and offset from url params if on page 1 (default)
+          if ((attr === "page" || attr === "offset") && data["page"] === 1) {
+            if (urlOptions[label]) {
+              delete urlOptions[label];
+            }
+            continue;
+          }
+
+          // Delete perPage from url params if default perPage value
+          if (attr === "perPage" && data[label] == settings.dataset.perPageDefault) {
+            if (urlOptions[label]) {
+              delete urlOptions[label];
+            }
+            continue;
+          }
+
+          // For queries, we're going to handle each possible query parameter individually here instead of
+          // handling the entire queries object below, since we need to make sure that this is a query controlled by dynatable.
+          if (attr == "queries" && data[label]) {
+            var queries = settings.inputs.queries || [],
+                inputQueries = $.makeArray(queries.map(function() { return $(this).attr('name') }));
+
+            if (settings.features.search) { inputQueries.push('search'); }
+
+            for (var i = 0, len = inputQueries.length; i < len; i++) {
+              var attr = inputQueries[i];
+              if (data[label][attr]) {
+                if (typeof urlOptions[label] === 'undefined') { urlOptions[label] = {}; }
+                urlOptions[label][attr] = data[label][attr];
+              } else {
+                delete urlOptions[label][attr];
+              }
+            }
+            continue;
+          }
+
+          // If we haven't returned true by now, then we actually want to update the parameter in the URL
+          if (data[label]) {
+            urlOptions[label] = data[label];
+          } else {
+            delete urlOptions[label];
+          }
+        }
+      }
+      return decodeURI($.param(urlOptions));
+    },
+    // Get array of keys from object
+    // see http://stackoverflow.com/questions/208016/how-to-list-the-properties-of-a-javascript-object/208020#208020
+    keysFromObject: function(obj){
+      var keys = [];
+      for (var key in obj){
+        keys.push(key);
+      }
+      return keys;
+    },
+    // Find an object in an array of objects by attributes.
+    // E.g. find object with {id: 'hi', name: 'there'} in an array of objects
+    findObjectInArray: function(array, objectAttr) {
+      var _this = this,
+          foundObject;
+      for (var i = 0, len = array.length; i < len; i++) {
+        var item = array[i];
+        // For each object in array, test to make sure all attributes in objectAttr match
+        if (_this.allMatch(item, objectAttr, function(item, key, value) { return item[key] == value; })) {
+          foundObject = item;
+          break;
+        }
+      }
+      return foundObject;
+    },
+    // Return true if supplied test function passes for ALL items in an array
+    allMatch: function(item, arrayOrObject, test) {
+      // start off with true result by default
+      var match = true,
+          isArray = $.isArray(arrayOrObject);
+      // Loop through all items in array
+      $.each(arrayOrObject, function(key, value) {
+        var result = isArray ? test(item, value) : test(item, key, value);
+        // If a single item tests false, go ahead and break the array by returning false
+        // and return false as result,
+        // otherwise, continue with next iteration in loop
+        // (if we make it through all iterations without overriding match with false,
+        // then we can return the true result we started with by default)
+        if (!result) { return match = false; }
+      });
+      return match;
+    },
+    // Return true if supplied test function passes for ANY items in an array
+    anyMatch: function(item, arrayOrObject, test) {
+      var match = false,
+          isArray = $.isArray(arrayOrObject);
+
+      $.each(arrayOrObject, function(key, value) {
+        var result = isArray ? test(item, value) : test(item, key, value);
+        if (result) {
+          // As soon as a match is found, set match to true, and return false to stop the `$.each` loop
+          match = true;
+          return false;
+        }
+      });
+      return match;
+    },
+    // Return true if two objects are equal
+    // (i.e. have the same attributes and attribute values)
+    objectsEqual: function(a, b) {
+      for (attr in a) {
+        if (a.hasOwnProperty(attr)) {
+          if (!b.hasOwnProperty(attr) || a[attr] !== b[attr]) {
+            return false;
+          }
+        }
+      }
+      for (attr in b) {
+        if (b.hasOwnProperty(attr) && !a.hasOwnProperty(attr)) {
+          return false;
+        }
+      }
+      return true;
+    },
+    // Taken from http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/105074#105074
+    randomHash: function() {
+      return (((1+Math.random())*0x10000)|0).toString(16).substring(1);
+    }
+  };
+
+  //-----------------------------------------------------------------
+  // Build the dynatable plugin
+  //-----------------------------------------------------------------
+
+  // Object.create support test, and fallback for browsers without it
+  if ( typeof Object.create !== "function" ) {
+    Object.create = function (o) {
+      function F() {}
+      F.prototype = o;
+      return new F();
+    };
+  }
+
+  //-----------------------------------------------------------------
+  // Global dynatable plugin setting defaults
+  //-----------------------------------------------------------------
+
+  $.dynatableSetup = function(options) {
+    defaults = mergeSettings(options);
+  };
+
+  // Create dynatable plugin based on a defined object
+  $.dynatable = function( object ) {
+    $.fn['dynatable'] = function( options ) {
+      return this.each(function() {
+        if ( ! $.data( this, 'dynatable' ) ) {
+          $.data( this, 'dynatable', Object.create(object).init(this, options) );
+        }
+      });
+    };
+  };
+
+  $.dynatable(dt);
+
+})(jQuery);