footable 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 53dd13769ac7560f0eddfdad7d7ea6a89a0617f4
+  data.tar.gz: 331fc1a4b2073604b3c521eab04cf6b4300e3f5a
+SHA512:
+  metadata.gz: 500677da9fcff6b14b2e4e8c94399f7bb45eafdc8384edd053286829fd5626470c42b0f61944450d112dbf7e2ec730b9f52bff83633ae94a4fbc9f3bd046ce67
+  data.tar.gz: 700794c559325250349655b0d001c4217ff56799c3054fabb2446a74d05b63abb569086948f2a04d4dc1334d3f583d1f5ce9966df5ffed5cdf14be90945190d1

data/.gitignore

@@ -0,0 +1,13 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+
+footable-0.1.0.gem

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.3.2
+before_install: gem install bundler -v 1.16.4

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at duwal.amar2006@gmail.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in footable.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 alizduwal
+
+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,181 @@
+# Footable
+
+![Footable](../master/footable.jpg)
+
+FooTable is a jQuery plugin that aims to make HTML tables on smaller devices look awesome - No matter how many columns of data you may have in them.
+
+# What Does It Do?
+
+FooTable transforms your HTML tables into expandable responsive tables. This is how it works:
+* It hides certain columns of data at different resolutions (we call these breakpoints).
+* Rows become expandable to show the data that was hidden.
+So simple! So all the data that is hidden can always be seen just by clicking the row.
+
+## Installation
+
+Footable depends on jQuery. Add this line to your application's Gemfile:
+
+```ruby
+gem 'jquery-rails'
+gem 'footable'
+```
+
+And then execute:
+
+```console
+$ bundle install
+```
+
+Require Footable Javascripts in app/assets/javascripts/application.js:
+
+```js
+//= require jquery
+//= require footable
+//= require footable.sortable
+```
+
+Import Footable styles in `app/assets/stylesheets/application.scss`:
+
+```scss
+@import "footable";
+@import "footable.sortable"
+```
+
+## Usage
+
+Example Usage:
+HTML
+```html
+<table class="footable">
+	<thead>
+		<tr>
+			<th data-class="expand" data-sort-initial="true"><span
+			title="table sorted by this column on load">Order ID</span></th>
+			<th data-hide="phone,tablet" data-sort-ignore="true">No. of items</th>
+			<th data-hide="phone,tablet" data-sort-ignore="true">Invoice</th>
+			<th data-hide="phone,tablet"><strong>Payment Method</strong></th>
+			<th data-hide="phone,tablet"><strong></strong></th>
+			<th data-hide="default"> Price</th>
+			<th data-hide="default" data-type="numeric"> Date</th>
+			<th data-hide="phone" data-type="numeric"> Status</th>
+		</tr>
+	</thead>
+	<tbody>
+		<tr>
+			<td>#028DE</td>
+			<td>5
+				<small>item(s)</small>
+			</td>
+			<td><a target="_blank">-</a></td>
+			<td>Bank Wire</td>
+			<td><a href="" class="btn btn-primary btn-sm">view status</a></td>
+			<td>$403</td>
+			<td data-value="78025368997">22 Jun 2019</td>
+			<td data-value="3"><span class="label label-success">Done</span></td>
+		</tr>
+		<tr>
+			<td>#045YU</td>
+			<td>2
+				<small>item(s)</small>
+			</td>
+			<td><a target="_blank">-</a></td>
+			<td>Bank Wire</td>
+			<td><a href="" class="btn btn-primary btn-sm">view status</a></td>
+			<td>$105</td>
+			<td data-value="-100297281571">28 Oct 2019</td>
+			<td data-value="1"><span class="label label-primary">Pending</span></td>
+		</tr>
+		<tr>
+			<td>#08UJL</td>
+			<td>6
+				<small>item(s)</small>
+			</td>
+			<td><a target="_blank">-</a></td>
+			<td><a target="_blank">PayPal</a></td>
+			<td><a href="" class="btn btn-primary btn-sm">view status</a></td>
+			<td><a target="_blank">$550 </a></td>
+			<td data-value="370961043292">3 Oct 2019</td>
+			<td data-value="2"><span class="label label-success">Done</span></td>
+		</tr>
+		<tr>
+			<td>#09ydo</td>
+			<td>1
+				<small>item(s)</small>
+			</td>
+			<td><a target="_blank">-</a></td>
+			<td>Paypal</td>
+			<td><a href="" class="btn btn-primary btn-sm">view status</a></td>
+			<td>$34</td>
+			<td data-value="-22133780420">19 Apr 2019</td>
+			<td data-value="1"><span class="label label-primary">Pending</span></td>
+		</tr>
+		<tr>
+			<td>#EC089</td>
+			<td>8
+				<small>item(s)</small>
+			</td>
+			<td><a target="_blank">-</a></td>
+			<td>MasterCard</td>
+			<td><a href="" class="btn btn-primary btn-sm">view status</a></td>
+			<td>$1108</td>
+			<td data-value="250833505574">13 Dec 2019</td>
+			<td data-value="3"><span class="label label-danger">Cancel</span></td>
+		</tr>
+		<tr>
+			<td>#OH746</td>
+			<td>4
+				<small>item(s)</small>
+			</td>
+			<td><a target="_blank">-</a></td>
+			<td>Bank Wire</td>
+			<td><a href="" class="btn btn-primary btn-sm">view status</a></td>
+			<td>$669</td>
+			<td data-value="694116650726">30 Dec 2019</td>
+			<td data-value="3"><span class="label label-danger">Cancel</span></td>
+		</tr>
+		<tr>
+			<td>#04628J</td>
+			<td>11
+				<small>item(s)</small>
+			</td>
+			<td><a target="_blank">-</a></td>
+			<td>Bank Wire</td>
+			<td><a href="" class="btn btn-primary btn-sm">view status</a></td>
+			<td>$400</td>
+			<td data-value="561440464855">17 Oct 2019</td>
+			<td data-value="2"><span class="label label-default">Disable</span></td>
+		</tr>
+		<tr>
+			<td>#046738</td>
+			<td>2
+				<small>item(s)</small>
+			</td>
+			<td><a target="_blank">-</a></td>
+			<td><a target="_blank">PayPal</a></td>
+			<td><a href="" class="btn btn-primary btn-sm">view status</a></td>
+			<td>$403</td>
+			<td data-value="437400551390">11 Nov 2019</td>
+			<td data-value="3"><span class="label label-danger">Cancel</span></td>
+		</tr>		
+	</tbody>
+</table>
+```
+
+Javascript
+```js
+$(function () {
+    $('.footable').footable();
+});
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/amarduwal/footable. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Footable project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/amarduwal/footable/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "footable"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/footable.gemspec

@@ -0,0 +1,38 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "footable/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "footable"
+  spec.version       = Footable::VERSION
+  spec.authors       = ["amarduwal"]
+  spec.email         = ["duwal.amar2006@gmail.com"]
+
+  spec.summary       = %q{FooTable - Awesome Responsive Tables.}
+  spec.description   = %q{FooTable - Awesome Responsive Tables. Where you can sort table through jquery.}
+  spec.homepage      = "https://github.com/amarduwal/footable"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata["allowed_push_host"] = "https://rubygems.org"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

data/lib/footable.rb

@@ -0,0 +1,5 @@
+require "footable/version"
+
+module Footable
+  class Engine < ::Rails::Engine; end
+end

data/lib/footable/version.rb

@@ -0,0 +1,3 @@
+module Footable
+  VERSION = "0.1.0"
+end

data/vendor/assets/javascripts/footable.js

@@ -0,0 +1,553 @@
+/*!
+ * FooTable - Awesome Responsive Tables
+ * Version : 0.5
+ * http://themergency.com/footable
+ *
+ * Requires jQuery - http://jquery.com/
+ *
+ * Copyright 2012 Steven Usher & Brad Vincent
+ * Released under the MIT license
+ * You are free to use FooTable in commercial projects as long as this copyright header is left intact.
+ *
+ * Date: 22 Apr 2013
+ */
+(function ($, w, undefined) {
+    w.footable = {
+        options: {
+            delay: 100, // The number of millseconds to wait before triggering the react event
+            breakpoints: { // The different screen resolution breakpoints
+                phone: 480,
+                tablet: 1024
+            },
+            parsers: {  // The default parser to parse the value out of a cell (values are used in building up row detail)
+                alpha: function (cell) {
+                    return $(cell).data('value') || $.trim($(cell).text());
+                }
+            },
+            calculateWidthAndHeightOverride: null,
+            toggleSelector: ' > tbody > tr:not(.footable-row-detail)', //the selector to show/hide the detail row
+            columnDataSelector: '> thead > tr:last-child > th, > thead > tr:last-child > td', //the selector used to find the column data in the thead
+            createDetail: function (element, data) {
+                /// <summary>This function is used by FooTable to generate the detail view seen when expanding a collapsed row.</summary>
+                /// <param name="element">This is the div that contains all the detail row information, anything could be added to it.</param>
+                /// <param name="data">
+                ///  This is an array of objects containing the cell information for the current row.
+                ///  These objects look like the below:
+                ///    obj = {
+                ///      'name': String, // The name of the column
+                ///      'value': Object, // The value parsed from the cell using the parsers. This could be a string, a number or whatever the parser outputs.
+                ///      'display': String, // This is the actual HTML from the cell, so if you have images etc you want moved this is the one to use and is the default value used.
+                ///      'group': String, // This is the identifier used in the data-group attribute of the column.
+                ///      'groupName': String // This is the actual name of the group the column belongs to.
+                ///    }
+                /// </param>
+
+                var groups = {'_none': {'name': null, 'data': []}};
+                for (var i = 0; i < data.length; i++) {
+                    var groupid = data[i].group;
+                    if (groupid != null) {
+                        if (!(groupid in groups))
+                            groups[groupid] = {'name': data[i].groupName, 'data': []};
+
+                        groups[groupid].data.push(data[i]);
+                    } else {
+                        groups._none.data.push(data[i]);
+                    }
+                }
+
+                for (var group in groups) {
+                    if (groups[group].data.length == 0) continue;
+                    if (group != '_none') element.append('<h4>' + groups[group].name + '</h4>');
+
+                    for (var j = 0; j < groups[group].data.length; j++) {
+                        var separator = (groups[group].data[j].name) ? ':' : '';
+                        element.append('<div><strong>' + groups[group].data[j].name + '</strong> ' + separator + ' ' + groups[group].data[j].display + '</div>');
+                    }
+                }
+            },
+            classes: {
+                loading: 'footable-loading',
+                loaded: 'footable-loaded',
+                sorted: 'footable-sorted',
+                descending: 'footable-sorted-desc',
+                indicator: 'footable-sort-indicator'
+            },
+            debug: false // Whether or not to log information to the console.
+        },
+
+        version: {
+            major: 0, minor: 5,
+            toString: function () {
+                return w.footable.version.major + '.' + w.footable.version.minor;
+            },
+            parse: function (str) {
+                version = /(\d+)\.?(\d+)?\.?(\d+)?/.exec(str);
+                return {
+                    major: parseInt(version[1]) || 0,
+                    minor: parseInt(version[2]) || 0,
+                    patch: parseInt(version[3]) || 0
+                };
+            }
+        },
+
+        plugins: {
+            _validate: function (plugin) {
+                ///<summary>Simple validation of the <paramref name="plugin"/> to make sure any members called by Foobox actually exist.</summary>
+                ///<param name="plugin">The object defining the plugin, this should implement a string property called "name" and a function called "init".</param>
+
+                if (typeof plugin['name'] !== 'string') {
+                    if (w.footable.options.debug == true) console.error('Validation failed, plugin does not implement a string property called "name".', plugin);
+                    return false;
+                }
+                if (!$.isFunction(plugin['init'])) {
+                    if (w.footable.options.debug == true) console.error('Validation failed, plugin "' + plugin['name'] + '" does not implement a function called "init".', plugin);
+                    return false;
+                }
+                if (w.footable.options.debug == true) console.log('Validation succeeded for plugin "' + plugin['name'] + '".', plugin);
+                return true;
+            },
+            registered: [], // An array containing all registered plugins.
+            register: function (plugin, options) {
+                ///<summary>Registers a <paramref name="plugin"/> and its default <paramref name="options"/> with Foobox.</summary>
+                ///<param name="plugin">The plugin that should implement a string property called "name" and a function called "init".</param>
+                ///<param name="options">The default options to merge with the Foobox's base options.</param>
+
+                if (w.footable.plugins._validate(plugin)) {
+                    w.footable.plugins.registered.push(plugin);
+                    if (options != undefined && typeof options === 'object') $.extend(true, w.footable.options, options);
+                    if (w.footable.options.debug == true) console.log('Plugin "' + plugin['name'] + '" has been registered with the Foobox.', plugin);
+                }
+            },
+            init: function (instance) {
+                ///<summary>Loops through all registered plugins and calls the "init" method supplying the current <paramref name="instance"/> of the Foobox as the first parameter.</summary>
+                ///<param name="instance">The current instance of the Foobox that the plugin is being initialized for.</param>
+
+                for (var i = 0; i < w.footable.plugins.registered.length; i++) {
+                    try {
+                        w.footable.plugins.registered[i]['init'](instance);
+                    } catch (err) {
+                        if (w.footable.options.debug == true) console.error(err);
+                    }
+                }
+            }
+        }
+    };
+
+    var instanceCount = 0;
+
+    $.fn.footable = function (options) {
+        ///<summary>The main constructor call to initialize the plugin using the supplied <paramref name="options"/>.</summary>
+        ///<param name="options">
+        ///<para>A JSON object containing user defined options for the plugin to use. Any options not supplied will have a default value assigned.</para>
+        ///<para>Check the documentation or the default options object above for more information on available options.</para>
+        ///</param>
+
+        options = options || {};
+        var o = $.extend(true, {}, w.footable.options, options); //merge user and default options
+        return this.each(function () {
+            instanceCount++;
+            this.footable = new Footable(this, o, instanceCount);
+        });
+    };
+
+    //helper for using timeouts
+    function Timer() {
+        ///<summary>Simple timer object created around a timeout.</summary>
+        var t = this;
+        t.id = null;
+        t.busy = false;
+        t.start = function (code, milliseconds) {
+            ///<summary>Starts the timer and waits the specified amount of <paramref name="milliseconds"/> before executing the supplied <paramref name="code"/>.</summary>
+            ///<param name="code">The code to execute once the timer runs out.</param>
+            ///<param name="milliseconds">The time in milliseconds to wait before executing the supplied <paramref name="code"/>.</param>
+
+            if (t.busy) {
+                return;
+            }
+            t.stop();
+            t.id = setTimeout(function () {
+                code();
+                t.id = null;
+                t.busy = false;
+            }, milliseconds);
+            t.busy = true;
+        };
+        t.stop = function () {
+            ///<summary>Stops the timer if its runnning and resets it back to its starting state.</summary>
+
+            if (t.id != null) {
+                clearTimeout(t.id);
+                t.id = null;
+                t.busy = false;
+            }
+        };
+    };
+
+    function Footable(t, o, id) {
+        ///<summary>Inits a new instance of the plugin.</summary>
+        ///<param name="t">The main table element to apply this plugin to.</param>
+        ///<param name="o">The options supplied to the plugin. Check the defaults object to see all available options.</param>
+        ///<param name="id">The id to assign to this instance of the plugin.</param>
+
+        var ft = this;
+        ft.id = id;
+        ft.table = t;
+        ft.options = o;
+        ft.breakpoints = [];
+        ft.breakpointNames = '';
+        ft.columns = {};
+
+        var opt = ft.options;
+        var cls = opt.classes;
+        var indexOffset = 0;
+
+        // This object simply houses all the timers used in the footable.
+        ft.timers = {
+            resize: new Timer(),
+            register: function (name) {
+                ft.timers[name] = new Timer();
+                return ft.timers[name];
+            }
+        };
+
+        w.footable.plugins.init(ft);
+
+        ft.init = function () {
+            var $window = $(w), $table = $(ft.table);
+
+            if ($table.hasClass(cls.loaded)) {
+                //already loaded FooTable for the table, so don't init again
+                ft.raise('footable_already_initialized');
+                return;
+            }
+
+            $table.addClass(cls.loading);
+
+            // Get the column data once for the life time of the plugin
+            $table.find(opt.columnDataSelector).each(function () {
+                var data = ft.getColumnData(this);
+                ft.columns[data.index] = data;
+
+                if (data.className != null) {
+                    var selector = '', first = true;
+                    $.each(data.matches, function (m, match) { //support for colspans
+                        if (!first) {
+                            selector += ', ';
+                        }
+                        selector += '> tbody > tr:not(.footable-row-detail) > td:nth-child(' + (parseInt(match) + 1) + ')';
+                        first = false;
+                    });
+                    //add the className to the cells specified by data-class="blah"
+                    $table.find(selector).not('.footable-cell-detail').addClass(data.className);
+                }
+            });
+
+            // Create a nice friendly array to work with out of the breakpoints object.
+            for (var name in opt.breakpoints) {
+                ft.breakpoints.push({'name': name, 'width': opt.breakpoints[name]});
+                ft.breakpointNames += (name + ' ');
+            }
+
+            // Sort the breakpoints so the smallest is checked first
+            ft.breakpoints.sort(function (a, b) {
+                return a['width'] - b['width'];
+            });
+
+            //bind the toggle selector click events
+            ft.bindToggleSelectors();
+
+            ft.raise('footable_initializing');
+
+            $table.bind('footable_initialized', function () {
+                //resize the footable onload
+                ft.resize();
+
+                //remove the loading class
+                $table.removeClass(cls.loading);
+
+                //hides all elements within the table that have the attribute data-hide="init"
+                //what does this do? LOL
+                $table.find('[data-init="hide"]').hide();
+                $table.find('[data-init="show"]').show();
+
+                //add the loaded class
+                $table.addClass(cls.loaded);
+            });
+
+            $table.bind('footable_resize', function () {
+                ft.resize();
+            });
+
+            $window
+                .bind('resize.footable', function () {
+                    ft.timers.resize.stop();
+                    ft.timers.resize.start(function () {
+                        ft.resize();
+                    }, opt.delay);
+                });
+
+            ft.raise('footable_initialized');
+        };
+
+        //moved this out into it's own function so that it can be called from other add-ons
+        ft.bindToggleSelectors = function () {
+            var $table = $(ft.table);
+            $table.find(opt.toggleSelector).unbind('click.footable').bind('click.footable', function (e) {
+                if ($table.is('.breakpoint') && $(e.target).is('td')) {
+                    var $row = $(this).is('tr') ? $(this) : $(this).parents('tr:first');
+                    ft.toggleDetail($row.get(0));
+                }
+            });
+        };
+
+        ft.parse = function (cell, column) {
+            var parser = opt.parsers[column.type] || opt.parsers.alpha;
+            return parser(cell);
+        };
+
+        ft.getColumnData = function (th) {
+            var $th = $(th), hide = $th.data('hide'), index = $th.index();
+            hide = hide || '';
+            hide = hide.split(',');
+            var data = {
+                'index': index,
+                'hide': {},
+                'type': $th.data('type') || 'alpha',
+                'name': $.trim($th.data('name') || $th.text()),
+                'ignore': $th.data('ignore') || false,
+                'className': $th.data('class') || null,
+                'matches': [],
+                'names': {},
+                'group': $th.data('group') || null,
+                'groupName': null
+            };
+
+            if (data.group != null) {
+                var $group = $(ft.table).find('> thead > tr.footable-group-row > th[data-group="' + data.group + '"], > thead > tr.footable-group-row > td[data-group="' + data.group + '"]').first();
+                data.groupName = ft.parse($group, {'type': 'alpha'});
+            }
+
+            var pcolspan = parseInt($th.prev().attr('colspan') || 0);
+            indexOffset += pcolspan > 1 ? pcolspan - 1 : 0;
+            var colspan = parseInt($th.attr('colspan') || 0), curindex = data.index + indexOffset;
+            if (colspan > 1) {
+                var names = $th.data('names');
+                names = names || '';
+                names = names.split(',');
+                for (var i = 0; i < colspan; i++) {
+                    data.matches.push(i + curindex);
+                    if (i < names.length) data.names[i + curindex] = names[i];
+                }
+            } else {
+                data.matches.push(curindex);
+            }
+
+            data.hide['default'] = ($th.data('hide') === "all") || ($.inArray('default', hide) >= 0);
+
+            for (var name in opt.breakpoints) {
+                data.hide[name] = ($th.data('hide') === "all") || ($.inArray(name, hide) >= 0);
+            }
+            var e = ft.raise('footable_column_data', {'column': {'data': data, 'th': th}});
+            return e.column.data;
+        };
+
+        ft.getViewportWidth = function () {
+            return window.innerWidth || (document.body ? document.body.offsetWidth : 0);
+        };
+
+        ft.getViewportHeight = function () {
+            return window.innerHeight || (document.body ? document.body.offsetHeight : 0);
+        };
+
+        ft.calculateWidthAndHeight = function ($table, info) {
+            if (jQuery.isFunction(opt.calculateWidthAndHeightOverride)) {
+                return opt.calculateWidthAndHeightOverride($table, info);
+            }
+            if (info.viewportWidth < info.width) info.width = info.viewportWidth;
+            if (info.viewportHeight < info.height) info.height = info.viewportHeight;
+
+            return info;
+        };
+
+        ft.hasBreakpointColumn = function (breakpoint) {
+            for (var c in ft.columns) {
+                if (ft.columns[c].hide[breakpoint]) {
+                    return true;
+                }
+            }
+            return false;
+        };
+
+        ft.resize = function () {
+            var $table = $(ft.table);
+            var info = {
+                'width': $table.width(),                  //the table width
+                'height': $table.height(),                //the table height
+                'viewportWidth': ft.getViewportWidth(),   //the width of the viewport
+                'viewportHeight': ft.getViewportHeight(), //the width of the viewport
+                'orientation': null
+            };
+            info.orientation = info.viewportWidth > info.viewportHeight ? 'landscape' : 'portrait';
+
+            info = ft.calculateWidthAndHeight($table, info);
+
+            var pinfo = $table.data('footable_info');
+            $table.data('footable_info', info);
+            ft.raise('footable_resizing', {'old': pinfo, 'info': info});
+
+            // This (if) statement is here purely to make sure events aren't raised twice as mobile safari seems to do
+            if (!pinfo || ((pinfo && pinfo.width && pinfo.width != info.width) || (pinfo && pinfo.height && pinfo.height != info.height))) {
+                var current = null, breakpoint;
+                for (var i = 0; i < ft.breakpoints.length; i++) {
+                    breakpoint = ft.breakpoints[i];
+                    if (breakpoint && breakpoint.width && info.width <= breakpoint.width) {
+                        current = breakpoint;
+                        break;
+                    }
+                }
+
+                var breakpointName = (current == null ? 'default' : current['name']);
+
+                var hasBreakpointFired = ft.hasBreakpointColumn(breakpointName);
+
+                $table
+                    .removeClass('default breakpoint').removeClass(ft.breakpointNames)
+                    .addClass(breakpointName + (hasBreakpointFired ? ' breakpoint' : ''))
+                    .find('> thead > tr:last-child > th')
+                    .each(function () {
+                        var data = ft.columns[$(this).index()], selector = '', first = true;
+                        $.each(data.matches, function (m, match) {
+                            if (!first) {
+                                selector += ', ';
+                            }
+                            var count = match + 1;
+                            selector += '> tbody > tr:not(.footable-row-detail) > td:nth-child(' + count + ')';
+                            selector += ', > tfoot > tr:not(.footable-row-detail) > td:nth-child(' + count + ')';
+                            selector += ', > colgroup > col:nth-child(' + count + ')';
+                            first = false;
+                        });
+
+                        selector += ', > thead > tr[data-group-row="true"] > th[data-group="' + data.group + '"]';
+                        var $column = $table.find(selector).add(this);
+                        if (data.hide[breakpointName] == false) $column.show();
+                        else $column.hide();
+
+                        if ($table.find('> thead > tr.footable-group-row').length == 1) {
+                            var $groupcols = $table.find('> thead > tr:last-child > th[data-group="' + data.group + '"]:visible, > thead > tr:last-child > th[data-group="' + data.group + '"]:visible'),
+                                $group = $table.find('> thead > tr.footable-group-row > th[data-group="' + data.group + '"], > thead > tr.footable-group-row > td[data-group="' + data.group + '"]'),
+                                groupspan = 0;
+
+                            $.each($groupcols, function () {
+                                groupspan += parseInt($(this).attr('colspan') || 1);
+                            });
+
+                            if (groupspan > 0) $group.attr('colspan', groupspan).show();
+                            else $group.hide();
+                        }
+                    })
+                    .end()
+                    .find('> tbody > tr.footable-detail-show').each(function () {
+                        ft.createOrUpdateDetailRow(this);
+                    });
+
+                $table.find('> tbody > tr.footable-detail-show:visible').each(function () {
+                    var $next = $(this).next();
+                    if ($next.hasClass('footable-row-detail')) {
+                        if (!hasBreakpointFired) $next.hide();
+                        else $next.show();
+                    }
+                });
+
+                // adding .footable-first-column and .footable-last-column to the first and last th and td of each row in order to allow
+                // for styling if the first or last column is hidden (which won't work using :first-child or :last-child)
+                $table.find('> thead > tr > th.footable-last-column, > tbody > tr > td.footable-last-column').removeClass('footable-last-column');
+                $table.find('> thead > tr > th.footable-first-column, > tbody > tr > td.footable-first-column').removeClass('footable-first-column');
+                $table.find('> thead > tr, > tbody > tr')
+                    .find('> th:visible:last, > td:visible:last')
+                    .addClass('footable-last-column')
+                    .end()
+                    .find('> th:visible:first, > td:visible:first')
+                    .addClass('footable-first-column');
+
+                ft.raise('footable_breakpoint_' + breakpointName, {'info': info});
+            }
+
+            ft.raise('footable_resized', {'old': pinfo, 'info': info});
+        };
+
+        ft.toggleDetail = function (actualRow) {
+            var $row = $(actualRow),
+                created = ft.createOrUpdateDetailRow($row.get(0)),
+                $next = $row.next();
+
+            if (!created && $next.is(':visible')) {
+                $row.removeClass('footable-detail-show');
+                //only hide the next row if it's a detail row
+                if ($next.hasClass('footable-row-detail')) $next.hide();
+            } else {
+                $row.addClass('footable-detail-show');
+                $next.show();
+            }
+        };
+
+        ft.getColumnFromTdIndex = function (index) {
+            /// <summary>Returns the correct column data for the supplied index taking into account colspans.</summary>
+            /// <param name="index">The index to retrieve the column data for.</param>
+            /// <returns type="json">A JSON object containing the column data for the supplied index.</returns>
+            var result = null;
+            for (var column in ft.columns) {
+                if ($.inArray(index, ft.columns[column].matches) >= 0) {
+                    result = ft.columns[column];
+                    break;
+                }
+            }
+            return result;
+        };
+
+        ft.createOrUpdateDetailRow = function (actualRow) {
+            var $row = $(actualRow), $next = $row.next(), $detail, values = [];
+            if ($row.is(':hidden')) return false; //if the row is hidden for some readon (perhaps filtered) then get out of here
+            ft.raise('footable_rowdetailupdated', {'row': $row, 'detail': $next});
+            $row.find('> td:hidden').each(function () {
+                var index = $(this).index(), column = ft.getColumnFromTdIndex(index), name = column.name;
+                if (column.ignore == true) return true;
+
+                if (index in column.names) name = column.names[index];
+                values.push({
+                    'name': name,
+                    'value': ft.parse(this, column),
+                    'display': $.trim($(this).html()),
+                    'group': column.group,
+                    'groupName': column.groupName
+                });
+                return true;
+            });
+            if (values.length == 0) return false; //return if we don't have any data to show
+            var colspan = $row.find('> td:visible').length;
+            var exists = $next.hasClass('footable-row-detail');
+            if (!exists) { // Create
+                $next = $('<tr class="footable-row-detail"><td class="footable-cell-detail"><div class="footable-row-detail-inner"></div></td></tr>');
+                $row.after($next);
+            }
+            $next.find('> td:first').attr('colspan', colspan);
+            $detail = $next.find('.footable-row-detail-inner').empty();
+            opt.createDetail($detail, values);
+            return !exists;
+        };
+
+        ft.raise = function (eventName, args) {
+            args = args || {};
+            var def = {'ft': ft};
+            $.extend(true, def, args);
+            var e = $.Event(eventName, def);
+            if (!e.ft) {
+                $.extend(true, e, def);
+            } //pre jQuery 1.6 which did not allow data to be passed to event object constructor
+            $(ft.table).trigger(e);
+            return e;
+        };
+
+        ft.init();
+        return ft;
+    };
+})(jQuery, window);