jquery-datatables 1.10.12 → 1.10.13

data/app/assets/javascripts/datatables/plugins/api/average.js

@@ -0,0 +1,32 @@
+/**
+ * It can sometimes be useful to get the average of data in an API result set,
+ * be it from a column, or a collection of cells. This method provides exactly
+ * that ability.
+ *
+ *  @name average()
+ *  @summary Average the values in a data set.
+ *  @author [Allan Jardine](http://sprymedia.co.uk)
+ *  @requires DataTables 1.10+
+ *
+ * @returns {Number} Calculated average
+ *
+ *  @example
+ *    // Average a column
+ *    var table = $('#example').DataTable();
+ *    table.column( 3 ).data().average();
+ *
+ *  @example
+ *    // Average two cells
+ *    var table = $('#example').DataTable();
+ *    table.cells( 0, [3,4] ).data().average();
+ */
+
+jQuery.fn.dataTable.Api.register( 'average()', function () {
+    var data = this.flatten();
+    var sum = data.reduce( function ( a, b ) {
+        return (a*1) + (b*1); // cast values in-case they are strings
+    }, 0 );
+ 
+    return sum / data.length;
+} );
+

data/app/assets/javascripts/datatables/plugins/api/sum.js

@@ -0,0 +1,51 @@
+/**
+ * Fairly simply, this plug-in will take the data from an API result set
+ * and sum it, returning the summed value. The data can come from any data
+ * source, including column data, cells or rows.
+ *
+ * Note that it will attempt to 'deformat' any string based data that is passed
+ * into it - i.e. it will strip any non-numeric characters in order to make a
+ * best effort attempt to sum all data types. This can be useful when working
+ * with formatting numbers such as currency. However the trade-off is that no
+ * error is thrown if non-numeric data is passed in. You should be aware of this
+ * in case unexpected values are returned - likely the input data is not what is
+ * expected.
+ *
+ *  @name sum()
+ *  @summary Sum the values in a data set.
+ *  @author [Allan Jardine](http://sprymedia.co.uk)
+ *  @requires DataTables 1.10+
+ *
+ *  @returns {Number} Summed value
+ *
+ *  @example
+ *    // Simply get the sum of a column
+ *    var table = $('#example').DataTable();
+ *    table.column( 3 ).data().sum();
+ *
+ *  @example
+ *    // Insert the sum of a column into the columns footer, for the visible
+ *    // data on each draw
+ *    $('#example').DataTable( {
+ *      drawCallback: function () {
+ *        var api = this.api();
+ *        $( api.table().footer() ).html(
+ *          api.column( 4, {page:'current'} ).data().sum()
+ *        );
+ *      }
+ *    } );
+ */
+
+jQuery.fn.dataTable.Api.register( 'sum()', function ( ) {
+	return this.flatten().reduce( function ( a, b ) {
+		if ( typeof a === 'string' ) {
+			a = a.replace(/[^\d.-]/g, '') * 1;
+		}
+		if ( typeof b === 'string' ) {
+			b = b.replace(/[^\d.-]/g, '') * 1;
+		}
+
+		return a + b;
+	}, 0 );
+} );
+

data/app/assets/javascripts/datatables/plugins/pagination/input.js

@@ -0,0 +1,224 @@
+/**
+ * Sometimes for quick navigation, it can be useful to allow an end user to
+ * enter which page they wish to jump to manually. This paging control uses a
+ * text input box to accept new paging numbers (arrow keys are also allowed
+ * for), and four standard navigation buttons are also presented to the end
+ * user.
+ *
+ *  @name Navigation with text input
+ *  @summary Shows an input element into which the user can type a page number
+ *  @author [Allan Jardine](http://sprymedia.co.uk)
+ *  @author [Gordey Doronin](http://github.com/GDoronin)
+ *
+ *  @example
+ *    $(document).ready(function() {
+ *        $('#example').dataTable( {
+ *            "pagingType": "input"
+ *        } );
+ *    } );
+ */
+
+(function ($) {
+	function calcDisableClasses(oSettings) {
+		var start = oSettings._iDisplayStart;
+		var length = oSettings._iDisplayLength;
+		var visibleRecords = oSettings.fnRecordsDisplay();
+		var all = length === -1;
+
+		// Gordey Doronin: Re-used this code from main jQuery.dataTables source code. To be consistent.
+		var page = all ? 0 : Math.ceil(start / length);
+		var pages = all ? 1 : Math.ceil(visibleRecords / length);
+
+		var disableFirstPrevClass = (page > 0 ? '' : oSettings.oClasses.sPageButtonDisabled);
+		var disableNextLastClass = (page < pages - 1 ? '' : oSettings.oClasses.sPageButtonDisabled);
+
+		return {
+			'first': disableFirstPrevClass,
+			'previous': disableFirstPrevClass,
+			'next': disableNextLastClass,
+			'last': disableNextLastClass
+		};
+	}
+
+	function calcCurrentPage(oSettings) {
+		return Math.ceil(oSettings._iDisplayStart / oSettings._iDisplayLength) + 1;
+	}
+
+	function calcPages(oSettings) {
+		return Math.ceil(oSettings.fnRecordsDisplay() / oSettings._iDisplayLength);
+	}
+
+	var firstClassName = 'first';
+	var previousClassName = 'previous';
+	var nextClassName = 'next';
+	var lastClassName = 'last';
+
+	var paginateClassName = 'paginate';
+	var paginateOfClassName = 'paginate_of';
+	var paginatePageClassName = 'paginate_page';
+	var paginateInputClassName = 'paginate_input';
+
+	$.fn.dataTableExt.oPagination.input = {
+		'fnInit': function (oSettings, nPaging, fnCallbackDraw) {
+			var nFirst = document.createElement('span');
+			var nPrevious = document.createElement('span');
+			var nNext = document.createElement('span');
+			var nLast = document.createElement('span');
+			var nInput = document.createElement('input');
+			var nPage = document.createElement('span');
+			var nOf = document.createElement('span');
+
+			var language = oSettings.oLanguage.oPaginate;
+			var classes = oSettings.oClasses;
+
+			nFirst.innerHTML = language.sFirst;
+			nPrevious.innerHTML = language.sPrevious;
+			nNext.innerHTML = language.sNext;
+			nLast.innerHTML = language.sLast;
+
+			nFirst.className = firstClassName + ' ' + classes.sPageButton;
+			nPrevious.className = previousClassName + ' ' + classes.sPageButton;
+			nNext.className = nextClassName + ' ' + classes.sPageButton;
+			nLast.className = lastClassName + ' ' + classes.sPageButton;
+
+			nOf.className = paginateOfClassName;
+			nPage.className = paginatePageClassName;
+			nInput.className = paginateInputClassName;
+
+			if (oSettings.sTableId !== '') {
+				nPaging.setAttribute('id', oSettings.sTableId + '_' + paginateClassName);
+				nFirst.setAttribute('id', oSettings.sTableId + '_' + firstClassName);
+				nPrevious.setAttribute('id', oSettings.sTableId + '_' + previousClassName);
+				nNext.setAttribute('id', oSettings.sTableId + '_' + nextClassName);
+				nLast.setAttribute('id', oSettings.sTableId + '_' + lastClassName);
+			}
+
+			nInput.type = 'text';
+			nPage.innerHTML = 'Page ';
+
+			nPaging.appendChild(nFirst);
+			nPaging.appendChild(nPrevious);
+			nPaging.appendChild(nPage);
+			nPaging.appendChild(nInput);
+			nPaging.appendChild(nOf);
+			nPaging.appendChild(nNext);
+			nPaging.appendChild(nLast);
+
+			$(nFirst).click(function() {
+				var iCurrentPage = calcCurrentPage(oSettings);
+				if (iCurrentPage !== 1) {
+					oSettings.oApi._fnPageChange(oSettings, 'first');
+					fnCallbackDraw(oSettings);
+				}
+			});
+
+			$(nPrevious).click(function() {
+				var iCurrentPage = calcCurrentPage(oSettings);
+				if (iCurrentPage !== 1) {
+					oSettings.oApi._fnPageChange(oSettings, 'previous');
+					fnCallbackDraw(oSettings);
+				}
+			});
+
+			$(nNext).click(function() {
+				var iCurrentPage = calcCurrentPage(oSettings);
+				if (iCurrentPage !== calcPages(oSettings)) {
+					oSettings.oApi._fnPageChange(oSettings, 'next');
+					fnCallbackDraw(oSettings);
+				}
+			});
+
+			$(nLast).click(function() {
+				var iCurrentPage = calcCurrentPage(oSettings);
+				if (iCurrentPage !== calcPages(oSettings)) {
+					oSettings.oApi._fnPageChange(oSettings, 'last');
+					fnCallbackDraw(oSettings);
+				}
+			});
+
+			$(nInput).keyup(function (e) {
+				// 38 = up arrow, 39 = right arrow
+				if (e.which === 38 || e.which === 39) {
+					this.value++;
+				}
+				// 37 = left arrow, 40 = down arrow
+				else if ((e.which === 37 || e.which === 40) && this.value > 1) {
+					this.value--;
+				}
+
+				if (this.value === '' || this.value.match(/[^0-9]/)) {
+					/* Nothing entered or non-numeric character */
+					this.value = this.value.replace(/[^\d]/g, ''); // don't even allow anything but digits
+					return;
+				}
+
+				var iNewStart = oSettings._iDisplayLength * (this.value - 1);
+				if (iNewStart < 0) {
+					iNewStart = 0;
+				}
+				if (iNewStart >= oSettings.fnRecordsDisplay()) {
+					iNewStart = (Math.ceil((oSettings.fnRecordsDisplay()) / oSettings._iDisplayLength) - 1) * oSettings._iDisplayLength;
+				}
+
+				oSettings._iDisplayStart = iNewStart;
+				fnCallbackDraw(oSettings);
+			});
+
+			// Take the brutal approach to cancelling text selection.
+			$('span', nPaging).bind('mousedown', function () { return false; });
+			$('span', nPaging).bind('selectstart', function() { return false; });
+
+			// If we can't page anyway, might as well not show it.
+			var iPages = calcPages(oSettings);
+			if (iPages <= 1) {
+				$(nPaging).hide();
+			}
+		},
+
+		'fnUpdate': function (oSettings) {
+			if (!oSettings.aanFeatures.p) {
+				return;
+			}
+
+			var iPages = calcPages(oSettings);
+			var iCurrentPage = calcCurrentPage(oSettings);
+
+			var an = oSettings.aanFeatures.p;
+			if (iPages <= 1) // hide paging when we can't page
+			{
+				$(an).hide();
+				return;
+			}
+
+			var disableClasses = calcDisableClasses(oSettings);
+
+			$(an).show();
+
+			// Enable/Disable `first` button.
+			$(an).children('.' + firstClassName)
+				.removeClass(oSettings.oClasses.sPageButtonDisabled)
+				.addClass(disableClasses[firstClassName]);
+
+			// Enable/Disable `prev` button.
+			$(an).children('.' + previousClassName)
+				.removeClass(oSettings.oClasses.sPageButtonDisabled)
+				.addClass(disableClasses[previousClassName]);
+
+			// Enable/Disable `next` button.
+			$(an).children('.' + nextClassName)
+				.removeClass(oSettings.oClasses.sPageButtonDisabled)
+				.addClass(disableClasses[nextClassName]);
+
+			// Enable/Disable `last` button.
+			$(an).children('.' + lastClassName)
+				.removeClass(oSettings.oClasses.sPageButtonDisabled)
+				.addClass(disableClasses[lastClassName]);
+
+			// Paginate of N pages text
+			$(an).children('.' + paginateOfClassName).html(' of ' + iPages);
+
+			// Current page numer input value
+			$(an).children('.' + paginateInputClassName).val(iCurrentPage);
+		}
+	};
+})(jQuery);

data/app/assets/javascripts/datatables/plugins/search/alphabetSearch.js

@@ -0,0 +1,368 @@
+/*! AlphabetSearch for DataTables v1.1.2
+ * 2014 SpryMedia Ltd - datatables.net/license
+ * Gyrocode - MIT License
+ */
+
+/**
+ * @summary     AlphabetSearch
+ * @description Show an set of alphabet buttons alongside a table providing
+ *     search input options
+ * @version     1.1.1
+ * @file        dataTables.alphabetSearch.js
+ * @author      SpryMedia Ltd (www.sprymedia.co.uk)
+ * @contact     www.sprymedia.co.uk/contact
+ * @copyright   Copyright 2014 SpryMedia Ltd.
+ * @author      Gyrocode (www.gyrocode.com)
+ * @contact     www.gyrocode.com/contacts
+ * @copyright   Copyright (c) Gyrocode
+ *
+ * License      MIT - http://datatables.net/license/mit
+ *
+ * For more detailed information please see:
+ *     http://www.gyrocode.com/articles/jquery-datatables-alphabetical-search
+ */
+(function(){
+
+
+// Search function
+$.fn.dataTable.Api.register( 'alphabetSearch()', function ( searchTerm ) {
+	this.iterator( 'table', function ( context ) {
+		context.alphabetSearch.letter = searchTerm;
+	} );
+
+	return this;
+} );
+
+// Recalculate the alphabet display for updated data
+$.fn.dataTable.Api.register( 'alphabetSearch.recalc()', function ( searchTerm ) {
+	this.iterator( 'table', function ( context ) {
+		draw(
+			new $.fn.dataTable.Api( context ),
+			$('div.alphabet', this.table().container()),
+			context
+		);
+	} );
+
+	return this;
+} );
+
+
+// Search plug-in
+$.fn.dataTable.ext.search.push( function ( context, searchData ) {
+	// Ensure that there is a search applied to this table before running it
+	if ( ! context.alphabetSearch.letterSearch ) {
+		return true;
+	}
+
+	var letter = searchData[context.alphabetSearch.column]
+		.toString()
+		.replace(/<.*?>/g, '')
+		.charAt(0).toUpperCase();
+
+
+	if(context.alphabetSearch.letterSearch !== '#'){
+		if ( letter === context.alphabetSearch.letterSearch ) {
+			return true;
+		}
+	} else {
+		if(/\d/.test(letter)){
+			return true;
+		}
+	}
+
+	return false;
+} );
+
+
+// Order plug-in
+//
+// NOTES: If sorting by alphabetized column
+// there would be two calls to this method
+$.fn.dataTable.ext.order['alphabetSearch'] = function  ( context, col )
+{
+	var order_col    = this.api().order()[0][0];
+	var order_method = this.api().order()[0][1];
+
+	// If sorting by column other than the one being alphabetized
+	if(order_col !== context.alphabetSearch.column){
+		context.alphabetSearch.pass = 0;
+	}
+
+	var data = this.api().column( col, { order: 'index' } ).data().map( function (value, index) {
+		// If sorting by alphabetized column
+		return (order_col === context.alphabetSearch.column)
+			? (
+				// If first pass
+				( !context.alphabetSearch.pass )
+					// Ignore
+					?
+						''
+					// Otherwise, if it's a second pass
+					:
+						(
+							// If method is ascending sort
+							( order_method === 'asc' )
+								// Return first letter
+								? value.charAt(0)
+								: String.fromCharCode(65535 - value.charCodeAt(0))
+						)
+			)
+			// Otherwise, if sorting by column other than the one being alphabetized,
+			// return first letter
+			: value.charAt(0);
+
+	} );
+
+	// If sorting by alphabetized column
+	if(order_col === context.alphabetSearch.column){
+		// If pass is not defined, set it to 0
+		if(!context.alphabetSearchPass){ context.alphabetSearch.pass = 0; }
+		// Increment pass counter and reset it to 0 if it's a second pass
+		context.alphabetSearch.pass = (context.alphabetSearch.pass + 1) % 2;
+	}
+
+	return data;
+};
+
+
+// Private support methods
+function bin ( data ) {
+	var letter, bins = {};
+
+	for ( var i=0, ien=data.length ; i<ien ; i++ ) {
+		letter = data[i]
+			.toString()
+			.replace(/<.*?>/g, '')
+			.charAt(0).toUpperCase();
+
+		if(/\d/.test(letter)){ letter = '#'; }
+
+		if ( bins[letter] ) {
+			bins[letter]++;
+		}
+		else {
+			bins[letter] = 1;
+		}
+	}
+
+	return bins;
+}
+
+function draw ( table, alphabet, context )
+{
+	alphabet.empty();
+	alphabet.append( context.oLanguage.alphabetSearch.infoDisplay + ': ' );
+
+	var columnData = table.column(context.alphabetSearch.column, { search: 'applied' } ).data();
+	var bins = bin( columnData );
+
+	$('<span class="alphabet-clear' + ((!context.alphabetSearch.letter) ? ' active' : '') + '"/>')
+		.data( 'letter', '' )
+		.data( 'match-count', columnData.length )
+		.html( context.oLanguage.alphabetSearch.infoAll )
+		.appendTo( alphabet );
+
+	for ( var i=0 ; i<context.oLanguage.alphabetSearch.alphabet.length ; i++ ) {
+		var letter = context.oLanguage.alphabetSearch.alphabet[i];
+
+		$('<span/>')
+			.data( 'letter', letter )
+			.data( 'match-count', bins[letter] || 0 )
+			.addClass(
+				(! bins[letter] ? 'empty' : '')
+				+ ((context.alphabetSearch.letter === letter) ? ' active' : '')
+			)
+			.html(
+				(letter === '#') ? '0-9' : letter
+			)
+			.appendTo( alphabet );
+	}
+
+	$('<div class="alphabet_info"></div>')
+		.appendTo( alphabet );
+
+
+	// Perform second rendering
+	// needed to filter search results by letter
+	// NOTE: Future optimization is needed to avoid rendering twice
+	// when no search is performed
+
+	// If letter is selected
+	if(context.alphabetSearch.letter){
+		// Apply filtering by letter
+		context.alphabetSearch.letterSearch = context.alphabetSearch.letter;
+
+		// Redraw table
+		table.draw();
+
+		// Remove filtering by letter
+		context.alphabetSearch.letterSearch = '';
+	}
+
+	// Handle search event here only once
+	// when alphabet panel has been drawn
+	// because we are performing two-step rendering
+	// that could trigger search hanlder when not needed
+	table.one('search', function (e, context) {
+		var api = new $.fn.dataTable.Api( context );
+
+		// Redraw alphabet panel
+		api.alphabetSearch.recalc();
+	});
+}
+
+
+$.fn.dataTable.AlphabetSearch = function ( context ) {
+	var table = new $.fn.dataTable.Api( context );
+	var alphabet = $('<div class="alphabet"/>');
+
+	// Language
+	context.oLanguage.alphabetSearch =
+		$.extend(
+			{
+				'alphabet': '#ABCDEFGHIJKLMNOPQRSTUVWXYZ',
+				'infoDisplay': 'Display',
+				'infoAll': 'All'
+			},
+			((context.oLanguage.alphabetSearch)
+				? context.oLanguage.alphabetSearch
+				: {}
+			)
+		);
+	// Convert alphabet to uppercase
+	context.oLanguage.alphabetSearch.alphabet.toUpperCase();
+
+	context.alphabetSearch =
+		$.extend(
+			{
+				column: 0
+			},
+			$.isPlainObject(context.oInit.alphabetSearch) ? context.oInit.alphabetSearch : {},
+			{
+				letter: '',
+				letterSearch: '',
+				pass: 0
+			}
+		);
+
+	// Set required "orderDataType" ("sSortDataType") for a column
+	if(context.alphabetSearch.column >= 0 && context.alphabetSearch.column < context.aoColumns.length){
+		context.aoColumns[context.alphabetSearch.column].sSortDataType = 'alphabetSearch';
+	}
+
+	// Add column containing names to a list of columns
+	// where ordering will be always applied to the table
+	if( context.hasOwnProperty('aaSortingFixed')
+		 && typeof context.aaSortingFixed === 'object' )
+	{
+		if( $.isArray(context.aaSortingFixed) ){
+			if( context.aaSortingFixed.length && !$.isArray( context.aaSortingFixed[0] ) ) {
+				// 1D array
+				context.aaSortingFixed = [[context.alphabetSearch.column, 'asc'], context.aaSortingFixed];
+
+			} else {
+				// 2D array
+				context.aaSortingFixed.unshift([context.alphabetSearch.column, 'asc']);
+			}
+		} else {
+			if( !context.aaSortingFixed.hasOwnProperty('pre') ){
+				context.aaSortingFixed.pre = [];
+			}
+
+			if( context.aaSortingFixed.pre.length && !$.isArray( context.aaSortingFixed.pre[0] ) ) {
+				// 1D array
+				context.aaSortingFixed.pre = [[context.alphabetSearch.column, 'asc'], context.aaSortingFixed.pre];
+
+			} else {
+				// 2D array
+				context.aaSortingFixed.pre.unshift([context.alphabetSearch.column, 'asc']);
+			}
+		}
+
+	} else {
+		context.aaSortingFixed = [context.alphabetSearch.column, 'asc'];
+	}
+
+
+	draw( table, alphabet, context );
+
+
+	// Trigger a search
+	alphabet.on( 'click', 'span', function () {
+		alphabet.find( '.active' ).removeClass( 'active' );
+		$(this).addClass( 'active' );
+
+		table
+			.alphabetSearch( $(this).data('letter') )
+			.draw();
+	} );
+
+	// Mouse events to show helper information
+	alphabet
+		.on( 'mouseenter', 'span', function () {
+			alphabet
+				.find('div.alphabet_info')
+				.css( {
+					opacity: 1,
+					left: $(this).position().left,
+					width: $(this).width()
+				} )
+				.html( $(this).data('match-count') );
+		} )
+		.on( 'mouseleave', 'span', function () {
+			alphabet
+				.find('div.alphabet_info')
+				.css('opacity', 0);
+		} );
+
+	table.on('draw', function (e, context) {
+		var api = new $.fn.dataTable.Api( context );
+
+		// Total number of column nodes
+		var col_total = api.columns().nodes().length;
+
+		var rows = api.rows({ page: 'current' }).nodes();
+		var group_last = null;
+
+		api.column(context.alphabetSearch.column, { page: 'current' }).data().each(function (name, index){
+			var group = name.charAt(0).toUpperCase();
+
+			if (group_last !== group) {
+				$(rows).eq(index).before(
+					'<tr class="alphabet_group"><td colspan="' + col_total + '">' + group + '</td></tr>'
+				);
+
+				group_last = group;
+			}
+		});
+
+		// If there are no rows found and letter is selected
+		if(!rows.length && context.alphabetSearch){
+			var letter = (context.alphabetSearch.letter === '#') ? '0-9' : context.alphabetSearch.letter;
+
+			$(api.table().body()).prepend(
+				'<tr class="alphabet_group"><td colspan="' + col_total + '">' + letter + '</td></tr>'
+			);
+		}
+	});
+
+	// API method to get the alphabet container node
+	this.node = function () {
+		return alphabet;
+	};
+};
+
+$.fn.DataTable.AlphabetSearch = $.fn.dataTable.AlphabetSearch;
+
+
+// Register a search plug-in
+$.fn.dataTable.ext.feature.push( {
+	fnInit: function ( settings ) {
+		var search = new $.fn.dataTable.AlphabetSearch( settings );
+		return search.node();
+	},
+	cFeature: 'A'
+} );
+
+
+}());