footable_rails 0.0.1

data/vendor/assets/javascripts/footable.memory.js

@@ -0,0 +1,429 @@
+/**
+ * Footable Memory 
+ *
+ * Version 1.1.0
+ *
+ * Requires browser support for localStorage. Fallback to cookies using
+ * jQuery Cookie (https://github.com/carhartl/jquery-cookie)
+ *
+ * Stores table state in a cookie and reloads state when page is refreshed.
+ *
+ * Supports common FooTable features:
+ * - Pagination
+ * - Sorting
+ * - Filtering
+ * - Expansion
+ *
+ * Written to be compatible with multiple FooTables per page and with
+ * JavaScript libraries like AngularJS and Ember that use hash based URLs.
+ *
+ * Disabled by default, to enable add the following section to the footable
+ * options:
+ *
+ *   $('#table').footable({
+ *     memory: {
+ *       enabled: true
+ *     }
+ *   });
+ *
+ * Based on FooTable Plugin Bookmarkable by Amy Farrell (https://github.com/akf)
+ *
+ * Created by Chris Laskey (https://github.com/chrislaskey)
+ */
+
+(function ($, w, undefined) {
+
+    if (w.footable === undefined || w.foobox === null) {
+        throw new Error('Please check and make sure footable.js is included in the page and is loaded prior to this script.');
+    }
+
+    var defaults = {
+        memory: {
+            enabled: false
+        }
+    };
+
+    var storage;
+
+    var storage_engines = {};
+
+    storage_engines.local_storage = (function($){
+
+        'use strict';
+
+        var path_page = function(){
+            return location.pathname;
+        };
+
+        var path_subpage = function(){
+            return location.hash || 'root';
+        };
+
+        var storage_key = function(index){
+            return path_page() + '/' + path_subpage() + '/index-' + index;
+        };
+
+        var get = function(index){
+            var key = storage_key(index),
+                as_string = localStorage.getItem(key);
+
+            return as_string ? JSON.parse(as_string) : {};
+        };
+
+        var set = function(index, item){
+            var key = storage_key(index),
+                as_string = JSON.stringify(item);
+
+            localStorage.setItem(key, as_string);
+        };
+
+        return {
+            get: function(index){
+                return get(index);
+            },
+            set: function(index, item){
+                set(index, item);
+            }
+        };
+
+    })($);
+
+    storage_engines.cookie = (function($){
+
+        'use strict';
+
+        /**
+         * Stores footable bookmarkable data in a cookie
+         *
+         * By default will store each page in its own cookie.
+         * Supports multiple FooTables per page.
+         * Supports JS frameworks that use hashmap URLs (AngularJS, Ember, etc).
+         *
+         * For example take an example application:
+         *
+         *     http://example.com/application-data (2 FooTables on this page)
+         *     http://example.com/application-data/#/details (1 FooTable on this page)
+         *     http://example.com/other-data (1 FooTable on this page)
+         *
+         * Would be stored like this:
+         *
+         *     cookie['/application-data'] = {
+         *         '/': {
+         *             1: {
+         *                 key1: value1,
+         *                 key2: value2
+         *             },
+         *             2: {
+         *                 key1: value1,
+         *                 key2: value2
+         *             }
+         *         },
+         *         '#/details': {
+         *             1: {
+         *                 key1: value1,
+         *                 key2: value2
+         *             }
+         *         }
+         *     };
+         *
+         *     cookie['/other-data'] = {
+         *         '/': {
+         *             1: {
+         *                 key1: value1,
+         *                 key2: value2
+         *             },
+         *         }
+         *     }
+         *
+         */
+
+        if( $.cookie ){
+            $.cookie.json = true;
+        }
+
+        var days_to_keep_data = 7;
+
+        var path_page = function(){
+            return location.pathname;
+        };
+
+        var path_subpage = function(){
+            return location.hash || '/';
+        };
+
+        var get_data = function(){
+            var page = path_page(),
+                data = $.cookie(page);
+
+            return data || {};
+        };
+
+        var get_table = function(index){
+            var subpage = path_subpage(),
+                data = get_data();
+
+            if( data[subpage] && data[subpage][index] ){
+                return data[subpage][index];
+            } else {
+                return {};
+            }
+        };
+
+        var set = function(index, item){
+            var page = path_page(),
+                subpage = path_subpage(),
+                data = get_data(),
+                options;
+
+            if( !data[subpage] ){
+                data[subpage] = {};
+            }
+
+            data[subpage][index] = item;
+
+            options = {
+                path: page,
+                expires: days_to_keep_data
+            };
+
+            $.cookie(page, data, options);
+        };
+
+        return {
+            get: function(index){
+                return get_table(index);
+            },
+            set: function(index, item){
+                set(index, item);
+            }
+        };
+
+    })($);
+
+    var set_storage_engine = (function(){
+        var test = 'footable-memory-plugin-storage-test';
+
+        try {
+            localStorage.setItem(test, test);
+            localStorage.removeItem(test);
+            storage = storage_engines.local_storage;
+        } catch(e) {
+            try {
+                $.cookie(test, test);
+                storage = storage_engines.cookie;
+            } catch(e) {
+                throw new Error('FooTable Memory requires either localStorage or cookie support via jQuery $.cookie plugin (https://github.com/carhartl/jquery-cookie)');
+            }
+        }
+    })($);
+
+    var state = (function($){
+
+        'use strict';
+
+        /**
+         * Gets and sets current table state
+         */
+
+        var vars = {};
+
+        var get = {};
+
+        var set = {};
+
+        set.vars = function(ft){
+            vars.ft = ft;
+            vars.table = $(ft.table);
+        };
+
+        get.descending = function(){
+            var descending = false;
+            $.each(vars.table.find('th'), function(index){
+                if( $(this).hasClass('footable-sorted-desc') ){
+                    descending = true;
+                }
+            });
+            return descending;
+        };
+
+        get.expanded = function(){
+            var indexes = [];
+            $.each(vars.ft.table.rows, function(index, value){
+                if( $(this).hasClass('footable-detail-show') ){
+                    indexes.push(index);
+                }
+            });
+            return indexes;
+        };
+
+        set.expanded = function(data){
+            if( data.expanded ){
+                $.each(data.expanded, function(index, value){
+                    // var row = $(vars.ft.table.rows[value]);
+                    // row.find('> td:first').trigger('footable_toggle_row');
+
+                    // Trying to execute the lines above, but the expanded row
+                    // shows raw AngularJS template (with {{ values }}) instead
+                    // of the fully rendered result.
+                    //
+                    // Best guess is some things happen after
+                    // 'footable_initialized' event and row expanding can not
+                    // occur until after those fire.
+                    //
+                    // A hack to get around this is to wait an interval before
+                    // executing the intended commands. Wrapped in an
+                    // immediately executing function to ensure ft is the
+                    // current value.
+
+                    (function(ft){
+                        setTimeout(function(){
+                            var row = $(ft.table.rows[value]);
+                            row.find('> td:first').trigger('footable_toggle_row');
+                        }, 150);
+                    })(vars.ft);
+                });
+            }
+        };
+
+        get.filter = function(){
+            return vars.table.data('filter') ? $(vars.table.data('filter')).val() : '';
+        };
+
+        set.filter = function(data){
+            if( data.filter ){
+                $(vars.table.data('filter'))
+                    .val(data.filter)
+                    .trigger('keyup');
+            }
+        };
+
+        get.page = function(){
+            return vars.ft.pageInfo && vars.ft.pageInfo.currentPage !== undefined ? vars.ft.pageInfo.currentPage : 0;
+        };
+
+        set.page = function(data){
+            if( data.page ){
+                vars.table.data('currentPage', data.page);
+                // Delay triggering table until sort is updated, since both effect
+                // pagination.
+            }
+        };
+
+        get.shown = function(){
+            return vars.table
+                .find('tbody')
+                .find('tr:not(.footable-row-detail)')
+                .filter(':visible').length;
+        };
+
+        get.sorted = function(){
+            if( vars.table.data('sorted') !== undefined ){
+                return vars.table.data('sorted');
+            } else {
+                return -1;
+            }
+        };
+
+        set.sorted = function(data){
+            if( data.sorted >= 0 ) {
+                // vars.table.data('footable-sort').doSort(data.sorted, !data.descending);
+                
+                // Trying to execute the line above, but only sort icon on the
+                // <th> element gets set. The rows themselves do not get sorted.
+                //
+                // Best guess is some things happen after 'footable_initialized' event
+                // and sorting can not occur until after those fire.
+                //
+                // A hack to get around this is to wait an interval before executing
+                // the intended commands. Wrapped in an immediately executing
+                // function to ensure ft is the current value.
+
+                (function(ft){
+                    setTimeout(function(){
+                        $(ft.table).data('footable-sort').doSort(data.sorted, !data.descending);
+                    }, 150);
+                })(vars.ft);
+            } else {
+                vars.table.trigger('footable_setup_paging');
+            }
+        };
+
+        get.total = function(){
+            return vars.table
+                .find('tbody')
+                .find('tr:not(.footable-row-detail, .footable-filtered)').length;
+        };
+
+        var get_state = function(){
+            return {
+                descending: get.descending(),
+                expanded: get.expanded(),
+                filter: get.filter(),
+                page: get.page(),
+                shown: get.shown(),
+                sorted: get.sorted(),
+                total: get.total()
+            };
+        };
+
+        var set_state = function(data){
+            set.filter(data);
+            set.page(data);
+            set.sorted(data);
+            set.expanded(data);
+        };
+
+        return {
+            get: function(ft){
+                set.vars(ft);
+                return get_state();
+            },
+            set: function(ft, data){
+                set.vars(ft);
+                return set_state(data);
+            }
+        };
+
+    })($);
+
+    var is_enabled = function(ft){
+        return ft.options.memory.enabled;
+    };
+
+    var update = function(ft, event) {
+        var index = ft.id,
+            data = state.get(ft);
+
+        storage.set(index, data);
+    };
+
+    var load = function(ft){
+        var index = ft.id,
+            data = storage.get(index);
+
+        state.set(ft, data);
+        ft.memory_plugin_loaded = true;
+    };
+
+    function Memory() {
+        var p = this;
+        p.name = 'Footable Memory';
+        p.init = function(ft) {
+            if (is_enabled(ft)) {
+                $(ft.table).bind({
+                    'footable_initialized': function(){
+                        load(ft);
+                    },
+                    'footable_page_filled footable_redrawn footable_filtered footable_sorted footable_row_expanded footable_row_collapsed': function(e) {
+                        if (ft.memory_plugin_loaded) {
+                            update(ft, e);
+                        }
+                    }
+                });
+            }
+        };
+    }
+
+    w.footable.plugins.register(Memory, defaults);
+
+})(jQuery, window);

data/vendor/assets/javascripts/footable.paginate.js

@@ -0,0 +1,242 @@
+(function ($, w, undefined) {
+	if (w.footable === undefined || w.footable === null)
+		throw new Error('Please check and make sure footable.js is included in the page and is loaded prior to this script.');
+
+	var defaults = {
+		paginate: true,
+		pageSize: 10,
+		pageNavigation: '.pagination',
+		firstText: '«',
+		previousText: '‹',
+		nextText: '›',
+		lastText: '»',
+		limitNavigation: 0,
+		limitPreviousText: '...',
+		limitNextText: '...'
+	};
+
+	function pageInfo(ft) {
+		var $table = $(ft.table), data = $table.data();
+		this.pageNavigation = data.pageNavigation || ft.options.pageNavigation;
+		this.pageSize = data.pageSize || ft.options.pageSize;
+		this.firstText = data.firstText || ft.options.firstText;
+		this.previousText = data.previousText || ft.options.previousText;
+		this.nextText = data.nextText || ft.options.nextText;
+		this.lastText = data.lastText || ft.options.lastText;
+		this.limitNavigation = parseInt(data.limitNavigation || ft.options.limitNavigation || defaults.limitNavigation, 10);
+		this.limitPreviousText = data.limitPreviousText || ft.options.limitPreviousText;
+		this.limitNextText = data.limitNextText || ft.options.limitNextText;
+		this.limit = this.limitNavigation > 0;
+		this.currentPage = data.currentPage || 0;
+		this.pages = [];
+		this.control = false;
+	}
+
+	function Paginate() {
+		var p = this;
+		p.name = 'Footable Paginate';
+
+		p.init = function (ft) {
+			if (ft.options.paginate === true) {
+				if ($(ft.table).data('page') === false) return;
+				p.footable = ft;
+				$(ft.table)
+					.unbind('.paging')
+					.bind({
+						'footable_initialized.paging footable_row_removed.paging footable_redrawn.paging footable_sorted.paging footable_filtered.paging': function () {
+							p.setupPaging();
+						}
+					})
+					//save the filter object onto the table so we can access it later
+					.data('footable-paging', p);
+			}
+		};
+
+		p.setupPaging = function () {
+			var ft = p.footable,
+				$tbody = $(ft.table).find('> tbody');
+
+			ft.pageInfo = new pageInfo(ft);
+
+			p.createPages(ft, $tbody);
+			p.createNavigation(ft, $tbody);
+			p.fillPage(ft, $tbody, ft.pageInfo.currentPage);
+		};
+
+		p.createPages = function (ft, tbody) {
+			var pages = 1;
+			var info = ft.pageInfo;
+			var pageCount = pages * info.pageSize;
+			var page = [];
+			var lastPage = [];
+			info.pages = [];
+			var rows = tbody.find('> tr:not(.footable-filtered,.footable-row-detail)');
+			rows.each(function (i, row) {
+				page.push(row);
+				if (i === pageCount - 1) {
+					info.pages.push(page);
+					pages++;
+					pageCount = pages * info.pageSize;
+					page = [];
+				} else if (i >= rows.length - (rows.length % info.pageSize)) {
+					lastPage.push(row);
+				}
+			});
+			if (lastPage.length > 0) info.pages.push(lastPage);
+			if (info.currentPage >= info.pages.length) info.currentPage = info.pages.length - 1;
+			if (info.currentPage < 0) info.currentPage = 0;
+			if (info.pages.length === 1) {
+				//we only have a single page
+				$(ft.table).addClass('no-paging');
+			} else {
+				$(ft.table).removeClass('no-paging');
+			}
+		};
+
+		p.createNavigation = function (ft, tbody) {
+			var $nav = $(ft.table).find(ft.pageInfo.pageNavigation);
+			//if we cannot find the navigation control within the table, then try find it outside
+			if ($nav.length === 0) {
+				$nav = $(ft.pageInfo.pageNavigation);
+				//if the navigation control is inside another table, then get out
+				if ($nav.parents('table:first').length > 0 && $nav.parents('table:first') !== $(ft.table)) return;
+				//if we found more than one navigation control, write error to console
+				if ($nav.length > 1 && ft.options.debug === true) console.error('More than one pagination control was found!');
+			}
+			//if we still cannot find the control, then don't do anything
+			if ($nav.length === 0) return;
+			//if the nav is not a UL, then find or create a UL
+			if (!$nav.is('ul')) {
+				if ($nav.find('ul:first').length === 0) {
+					$nav.append('<ul />');
+				}
+				$nav = $nav.find('ul');
+			}
+			$nav.find('li').remove();
+			var info = ft.pageInfo;
+			info.control = $nav;
+			if (info.pages.length > 0) {
+				$nav.append('<li class="footable-page-arrow"><a data-page="first" href="#first">' + ft.pageInfo.firstText + '</a>');
+				$nav.append('<li class="footable-page-arrow"><a data-page="prev" href="#prev">' + ft.pageInfo.previousText + '</a></li>');
+				if (info.limit){
+					$nav.append('<li class="footable-page-arrow"><a data-page="limit-prev" href="#limit-prev">' + ft.pageInfo.limitPreviousText + '</a></li>');
+				}
+				if (!info.limit){
+					$.each(info.pages, function (i, page) {
+						if (page.length > 0) {
+							$nav.append('<li class="footable-page"><a data-page="' + i + '" href="#">' + (i + 1) + '</a></li>');
+						}
+					});
+				}
+				if (info.limit){
+					$nav.append('<li class="footable-page-arrow"><a data-page="limit-next" href="#limit-next">' + ft.pageInfo.limitNextText + '</a></li>');
+					p.createLimited($nav, info, 0);
+				}
+				$nav.append('<li class="footable-page-arrow"><a data-page="next" href="#next">' + ft.pageInfo.nextText + '</a></li>');
+				$nav.append('<li class="footable-page-arrow"><a data-page="last" href="#last">' + ft.pageInfo.lastText + '</a></li>');
+			}
+			$nav.off('click', 'a[data-page]').on('click', 'a[data-page]', function (e) {
+				e.preventDefault();
+				var page = $(this).data('page');
+				var newPage = info.currentPage;
+				if (page === 'first') {
+					newPage = 0;
+				} else if (page === 'prev') {
+					if (newPage > 0) newPage--;
+				} else if (page === 'next') {
+					if (newPage < info.pages.length - 1) newPage++;
+				} else if (page === 'last') {
+					newPage = info.pages.length - 1;
+				} else if (page === 'limit-prev') {
+					newPage = -1;
+					var first = $nav.find('.footable-page:first a').data('page');
+					p.createLimited($nav, info, first - info.limitNavigation);
+					p.setPagingClasses($nav, info.currentPage, info.pages.length);
+				} else if (page === 'limit-next') {
+					newPage = -1;
+					var last = $nav.find('.footable-page:last a').data('page');
+					p.createLimited($nav, info, last + 1);
+					p.setPagingClasses($nav, info.currentPage, info.pages.length);
+				} else {
+					newPage = page;
+				}
+				if (newPage >= 0){
+					if (info.limit && info.currentPage != newPage){
+						var start = newPage;
+						while (start % info.limitNavigation !== 0){ start -= 1; }
+						p.createLimited($nav, info, start);
+					}
+					p.paginate(ft, newPage);
+				}
+			});
+			p.setPagingClasses($nav, info.currentPage, info.pages.length);
+		};
+
+		p.createLimited = function(nav, info, start){
+			start = start || 0;
+			nav.find('li.footable-page').remove();
+			var i, page,
+				$prev = nav.find('li.footable-page-arrow > a[data-page="limit-prev"]').parent(),
+				$next = nav.find('li.footable-page-arrow > a[data-page="limit-next"]').parent();
+			for (i = info.pages.length - 1; i >=0 ; i--){
+				page = info.pages[i];
+				if (i >= start && i < start + info.limitNavigation && page.length > 0) {
+					$prev.after('<li class="footable-page"><a data-page="' + i + '" href="#">' + (i + 1) + '</a></li>');
+				}
+			}
+			if (start === 0){ $prev.hide(); }
+			else { $prev.show(); }
+			if (start + info.limitNavigation >= info.pages.length){ $next.hide(); }
+			else { $next.show(); }
+		};
+
+		p.paginate = function (ft, newPage) {
+			var info = ft.pageInfo;
+			if (info.currentPage !== newPage) {
+				var $tbody = $(ft.table).find('> tbody');
+
+				//raise a pre-pagin event so that we can cancel the paging if needed
+				var event = ft.raise('footable_paging', { page: newPage, size: info.pageSize });
+				if (event && event.result === false) return;
+
+				p.fillPage(ft, $tbody, newPage);
+				info.control.find('li').removeClass('active disabled');
+				p.setPagingClasses(info.control, info.currentPage, info.pages.length);
+			}
+		};
+
+		p.setPagingClasses = function (nav, currentPage, pageCount) {
+			nav.find('li.footable-page > a[data-page=' + currentPage + ']').parent().addClass('active');
+			if (currentPage >= pageCount - 1) {
+				nav.find('li.footable-page-arrow > a[data-page="next"]').parent().addClass('disabled');
+				nav.find('li.footable-page-arrow > a[data-page="last"]').parent().addClass('disabled');
+			}
+			if (currentPage < 1) {
+				nav.find('li.footable-page-arrow > a[data-page="first"]').parent().addClass('disabled');
+				nav.find('li.footable-page-arrow > a[data-page="prev"]').parent().addClass('disabled');
+			}
+		};
+
+		p.fillPage = function (ft, tbody, pageNumber) {
+			ft.pageInfo.currentPage = pageNumber;
+			$(ft.table).data('currentPage', pageNumber);
+			tbody.find('> tr').hide();
+			$(ft.pageInfo.pages[pageNumber]).each(function () {
+				p.showRow(this, ft);
+			});
+			ft.raise('footable_page_filled');
+		};
+
+		p.showRow = function (row, ft) {
+			var $row = $(row), $next = $row.next(), $table = $(ft.table);
+			if ($table.hasClass('breakpoint') && $row.hasClass('footable-detail-show') && $next.hasClass('footable-row-detail')) {
+				$row.add($next).show();
+				ft.createOrUpdateDetailRow(row);
+			}
+			else $row.show();
+		};
+	}
+
+	w.footable.plugins.register(Paginate, defaults);
+
+})(jQuery, window);