jquery-datatables 1.10.19.1 → 1.10.20

data/app/assets/javascripts/datatables/plugins/sorting/enum.js

@@ -0,0 +1,51 @@
+/**
+ * Sort data by a defined enumerated (enum) list. The options for the values in
+ * the enum are defined by passing the values in an array to the method
+ * `$.fn.dataTable.enum`. Type detection and sorting plug-ins for DataTables will
+ * automatically be generated and added to the table.
+ *
+ * For full details and instructions please see [this DataTables blog
+ * post](//datatables.net/blog/2016-06-16).
+ *
+ * @name enum
+ * @summary Dynamically create enum sorting options for a DataTable
+ * @author [SpryMedia Ltd](http://datatables.net)
+ *
+ *  @example
+ *    $.fn.dataTable.enum( [ 'High', 'Medium', 'Low' ] );
+ *
+ *    $('#example').DataTable();
+ */
+
+
+(function ($) {
+
+
+var unique = 0;
+var types = $.fn.dataTable.ext.type;
+
+// Using form $.fn.dataTable.enum breaks at least YuiCompressor since enum is
+// a reserved word in JavaScript
+$.fn.dataTable['enum'] = function ( arr ) {
+	var name = 'enum-'+(unique++);
+	var lookup = window.Map ? new Map() : {};
+
+	for ( var i=0, ien=arr.length ; i<ien ; i++ ) {
+		lookup[ arr[i] ] = i;
+	}
+
+	// Add type detection
+	types.detect.unshift( function ( d ) {
+		return lookup[ d ] !== undefined ?
+			name :
+			null;
+	} );
+
+	// Add sorting method
+	types.order[ name+'-pre' ] = function ( d ) {
+		return lookup[ d ];
+	};
+};
+
+
+})(jQuery);

data/app/assets/javascripts/datatables/plugins/type-detection/date-dd-MMM-yyyy.js

@@ -0,0 +1,63 @@
+/*
+ * Adds a new sorting option to dataTables called `date-dd-mmm-yyyy`. Also
+ * includes a type detection plug-in. Matches and sorts date strings in
+ * the format: `dd/mmm/yyyy`. For example:
+ * 
+ * * 02-FEB-1978
+ * * 17-MAY-2013
+ * * 31-JAN-2014
+ *
+ * Please note that this plug-in is **deprecated*. The
+ * [datetime](//datatables.net/blog/2014-12-18) plug-in provides enhanced
+ * functionality and flexibility.
+ *
+ *  @name Date (dd-mmm-yyyy)
+ *  @summary Sort dates in the format `dd-mmm-yyyy`
+ *  @author [Jeromy French](http://www.appliedinter.net/jeromy_works/)
+ *  @deprecated
+ *
+ *  @example
+ *    $('#example').dataTable( {
+ *       columnDefs: [
+ *         { type: 'date-dd-mmm-yyyy', targets: 0 }
+ *       ]
+ *    } );
+ */
+
+(function () {
+
+var customDateDDMMMYYYYToOrd = function (date) {
+	"use strict"; //let's avoid tom-foolery in this function
+	// Convert to a number YYYYMMDD which we can use to order
+	var dateParts = date.split(/-/);
+	return (dateParts[2] * 10000) + ($.inArray(dateParts[1].toUpperCase(), ["JAN", "FEB", "MAR", "APR", "MAY", "JUN", "JUL", "AUG", "SEP", "OCT", "NOV", "DEC"]) * 100) + (dateParts[0]*1);
+};
+
+// This will help DataTables magic detect the "dd-MMM-yyyy" format; Unshift
+// so that it's the first data type (so it takes priority over existing)
+jQuery.fn.dataTableExt.aTypes.unshift(
+	function (sData) {
+		"use strict"; //let's avoid tom-foolery in this function
+		if (/^([0-2]?\d|3[0-1])-(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)-\d{4}/i.test(sData)) {
+			return 'date-dd-mmm-yyyy';
+		}
+		return null;
+	}
+);
+
+// define the sorts
+jQuery.fn.dataTableExt.oSort['date-dd-mmm-yyyy-asc'] = function (a, b) {
+	"use strict"; //let's avoid tom-foolery in this function
+	var ordA = customDateDDMMMYYYYToOrd(a),
+		ordB = customDateDDMMMYYYYToOrd(b);
+	return (ordA < ordB) ? -1 : ((ordA > ordB) ? 1 : 0);
+};
+
+jQuery.fn.dataTableExt.oSort['date-dd-mmm-yyyy-desc'] = function (a, b) {
+	"use strict"; //let's avoid tom-foolery in this function
+	var ordA = customDateDDMMMYYYYToOrd(a),
+		ordB = customDateDDMMMYYYYToOrd(b);
+	return (ordA < ordB) ? 1 : ((ordA > ordB) ? -1 : 0);
+};
+
+})();

data/app/assets/javascripts/datatables/plugins/type-detection/date-de.js

@@ -0,0 +1,125 @@
+/**
+ * This sorting plug-in for DataTables will correctly sort data in date time or date
+ * format typically used in Germany:
+ * date and time:`dd.mm.YYYY HH:mm`
+ * just date:`dd.mm.YYYY`.
+ *
+ * Please note that this plug-in is **deprecated*. The
+ * [datetime](//datatables.net/blog/2014-12-18) plug-in provides enhanced
+ * functionality and flexibility.
+ *
+ *  @name Date (dd.mm.YYYY) or date and time (dd.mm.YYYY HH:mm)
+ *  @summary Sort date / time in the format `dd.mm.YYYY HH:mm` or `dd.mm.YYYY`.
+ *  @author [Ronny Vedrilla](http://www.ambient-innovation.com)
+ *  @deprecated
+ *
+ *  @example
+ *    $('#example').dataTable( {
+ *       columnDefs: [
+ *         { type: 'de_datetime', targets: 0 },
+ *         { type: 'de_date', targets: 1 }
+ *       ]
+ *    } );
+ */
+
+ jQuery.extend( jQuery.fn.dataTableExt.oSort, {
+	"de_datetime-asc": function ( a, b ) {
+		var x, y;
+		if (jQuery.trim(a) !== '') {
+			var deDatea = jQuery.trim(a).split(' ');
+			var deTimea = deDatea[1].split(':');
+			var deDatea2 = deDatea[0].split('.');
+                        if(typeof deTimea[2] != 'undefined') {
+                            x = (deDatea2[2] + deDatea2[1] + deDatea2[0] + deTimea[0] + deTimea[1] + deTimea[2]) * 1;
+                        } else {
+                            x = (deDatea2[2] + deDatea2[1] + deDatea2[0] + deTimea[0] + deTimea[1]) * 1;
+                        }
+		} else {
+			x = -Infinity; // = l'an 1000 ...
+		}
+
+		if (jQuery.trim(b) !== '') {
+			var deDateb = jQuery.trim(b).split(' ');
+			var deTimeb = deDateb[1].split(':');
+			deDateb = deDateb[0].split('.');
+                        if(typeof deTimeb[2] != 'undefined') {
+                            y = (deDateb[2] + deDateb[1] + deDateb[0] + deTimeb[0] + deTimeb[1] + deTimeb[2]) * 1;
+                        } else {
+                            y = (deDateb[2] + deDateb[1] + deDateb[0] + deTimeb[0] + deTimeb[1]) * 1;
+                        }
+		} else {
+			y = -Infinity;
+		}
+		var z = ((x < y) ? -1 : ((x > y) ? 1 : 0));
+		return z;
+	},
+
+	"de_datetime-desc": function ( a, b ) {
+		var x, y;
+		if (jQuery.trim(a) !== '') {
+			var deDatea = jQuery.trim(a).split(' ');
+			var deTimea = deDatea[1].split(':');
+			var deDatea2 = deDatea[0].split('.');
+                        if(typeof deTimea[2] != 'undefined') {
+                            x = (deDatea2[2] + deDatea2[1] + deDatea2[0] + deTimea[0] + deTimea[1] + deTimea[2]) * 1;
+                        } else {
+                            x = (deDatea2[2] + deDatea2[1] + deDatea2[0] + deTimea[0] + deTimea[1]) * 1;
+                        }
+		} else {
+			x = Infinity;
+		}
+
+		if (jQuery.trim(b) !== '') {
+			var deDateb = jQuery.trim(b).split(' ');
+			var deTimeb = deDateb[1].split(':');
+			deDateb = deDateb[0].split('.');
+                        if(typeof deTimeb[2] != 'undefined') {
+                            y = (deDateb[2] + deDateb[1] + deDateb[0] + deTimeb[0] + deTimeb[1] + deTimeb[2]) * 1;
+                        } else {
+                            y = (deDateb[2] + deDateb[1] + deDateb[0] + deTimeb[0] + deTimeb[1]) * 1;
+                        }
+		} else {
+			y = -Infinity;
+		}
+		var z = ((x < y) ? 1 : ((x > y) ? -1 : 0));
+		return z;
+	},
+
+	"de_date-asc": function ( a, b ) {
+		var x, y;
+		if (jQuery.trim(a) !== '') {
+			var deDatea = jQuery.trim(a).split('.');
+			x = (deDatea[2] + deDatea[1] + deDatea[0]) * 1;
+		} else {
+			x = Infinity; // = l'an 1000 ...
+		}
+
+		if (jQuery.trim(b) !== '') {
+			var deDateb = jQuery.trim(b).split('.');
+			y = (deDateb[2] + deDateb[1] + deDateb[0]) * 1;
+		} else {
+			y = -Infinity;
+		}
+		var z = ((x < y) ? -1 : ((x > y) ? 1 : 0));
+		return z;
+	},
+
+	"de_date-desc": function ( a, b ) {
+		var x, y;
+		if (jQuery.trim(a) !== '') {
+			var deDatea = jQuery.trim(a).split('.');
+			x = (deDatea[2] + deDatea[1] + deDatea[0]) * 1;
+		} else {
+			x = -Infinity;
+		}
+
+		if (jQuery.trim(b) !== '') {
+			var deDateb = jQuery.trim(b).split('.');
+			y = (deDateb[2] + deDateb[1] + deDateb[0]) * 1;
+		} else {
+			y = Infinity;
+		}
+		var z = ((x < y) ? 1 : ((x > y) ? -1 : 0));
+		return z;
+	}
+} );

data/app/assets/javascripts/datatables/plugins/type-detection/date-eu.js

@@ -0,0 +1,64 @@
+/**
+ * Similar to the Date (dd/mm/YY) data sorting plug-in, this plug-in offers 
+ * additional  flexibility with support for spaces between the values and
+ * either . or / notation for the separators.
+ *
+ * Please note that this plug-in is **deprecated*. The
+ * [datetime](//datatables.net/blog/2014-12-18) plug-in provides enhanced
+ * functionality and flexibility.
+ *
+ *  @name Date (dd . mm[ . YYYY]) 
+ *  @summary Sort dates in the format `dd/mm/YY[YY]` (with optional spaces)
+ *  @author [Robert Sedovšek](http://galjot.si/)
+ *  @deprecated
+ *
+ *  @example
+ *    $('#example').dataTable( {
+ *       columnDefs: [
+ *         { type: 'date-eu', targets: 0 }
+ *       ]
+ *    } );
+ */
+
+jQuery.extend( jQuery.fn.dataTableExt.oSort, {
+	"date-eu-pre": function ( date ) {
+		date = date.replace(" ", "");
+		
+		if ( ! date ) {
+			return 0;
+		}
+
+		var year;
+		var eu_date = date.split(/[\.\-\/]/);
+
+		/*year (optional)*/
+		if ( eu_date[2] ) {
+			year = eu_date[2];
+		}
+		else {
+			year = 0;
+		}
+
+		/*month*/
+		var month = eu_date[1];
+		if ( month.length == 1 ) {
+			month = 0+month;
+		}
+
+		/*day*/
+		var day = eu_date[0];
+		if ( day.length == 1 ) {
+			day = 0+day;
+		}
+
+		return (year + month + day) * 1;
+	},
+
+	"date-eu-asc": function ( a, b ) {
+		return ((a < b) ? -1 : ((a > b) ? 1 : 0));
+	},
+
+	"date-eu-desc": function ( a, b ) {
+		return ((a < b) ? 1 : ((a > b) ? -1 : 0));
+	}
+} );

data/app/assets/javascripts/datatables/plugins/type-detection/date-euro.js

@@ -0,0 +1,48 @@
+/**
+ * This plug-in will provide date sorting for the "dd/mm/YYYY hh:ii:ss" 
+ * formatting, which is common in France and other European countries. It can 
+ * also be quickly adapted for other formatting as required. Furthermore, this 
+ * date sorting plug-in allows for empty values in the column.
+ *
+ * Please note that this plug-in is **deprecated*. The
+ * [datetime](//datatables.net/blog/2014-12-18) plug-in provides enhanced
+ * functionality and flexibility.
+ *
+ *  @name Date (dd/mm/YYYY hh:ii:ss) 
+ *  @summary Sort date / time in the format `dd/mm/YYYY hh:ii:ss`
+ *  @author [Ronan Guilloux](http://coolforest.net/)
+ *  @deprecated
+ *
+ *  @example
+ *    $('#example').dataTable( {
+ *       columnDefs: [
+ *         { type: 'date-euro', targets: 0 }
+ *       ]
+ *    } );
+ */
+
+ jQuery.extend( jQuery.fn.dataTableExt.oSort, {
+    "date-euro-pre": function ( a ) {
+        var x;
+
+        if ( $.trim(a) !== '' ) {
+            var frDatea = $.trim(a).split(' ');
+            var frTimea = (undefined != frDatea[1]) ? frDatea[1].split(':') : [00,00,00];
+            var frDatea2 = frDatea[0].split('/');
+            x = (frDatea2[2] + frDatea2[1] + frDatea2[0] + frTimea[0] + frTimea[1] + ((undefined != frTimea[2]) ? frTimea[2] : 0)) * 1;
+        }
+        else {
+            x = Infinity;
+        }
+
+        return x;
+    },
+
+    "date-euro-asc": function ( a, b ) {
+        return a - b;
+    },
+
+    "date-euro-desc": function ( a, b ) {
+        return b - a;
+    }
+} );

data/app/assets/javascripts/datatables/plugins/type-detection/date-uk.js

@@ -1,19 +1,42 @@
 /**
- * Automatically detect British (`dd/mm/yyyy`) date types. Goes with the UK 
- * date sorting plug-in.
+ * DataTables internal date sorting replies on `Date.parse()` which is part of 
+ * the Javascript language, but you may wish to sort on dates which is doesn't 
+ * recognise. The following is a plug-in for sorting dates in the format 
+ * `dd/mm/yy`.
+ * 
+ * An automatic type detection plug-in is available for this sorting plug-in.
  *
- *  @name Date (`dd/mm/yyyy`)
- *  @summary Detect data which is in the date format `dd/mm/yyyy`
+ * Please note that this plug-in is **deprecated*. The
+ * [datetime](//datatables.net/blog/2014-12-18) plug-in provides enhanced
+ * functionality and flexibility.
+ *
+ *  @name Date (dd/mm/YY)
+ *  @summary Sort dates in the format `dd/mm/YY`
  *  @author Andy McMaster
+ *  @deprecated
+ *
+ *  @example
+ *    $('#example').dataTable( {
+ *       columnDefs: [
+ *         { type: 'date-uk', targets: 0 }
+ *       ]
+ *    } );
  */
 
-jQuery.fn.dataTableExt.aTypes.unshift(
-	function ( sData )
-	{
-		if (sData !== null && sData.match(/^(0[1-9]|[12][0-9]|3[01])\/(0[1-9]|1[012])\/(19|20|21)\d\d$/))
-		{
-			return 'date-uk';
+jQuery.extend(jQuery.fn.dataTableExt.oSort, {
+	"date-uk-pre": function (a) {
+		if (a == null || a == "") {
+			return 0;
 		}
-		return null;
+		var ukDatea = a.split('/');
+		return (ukDatea[2] + ukDatea[1] + ukDatea[0]) * 1;
+	},
+
+	"date-uk-asc": function (a, b) {
+		return ((a < b) ? -1 : ((a > b) ? 1 : 0));
+	},
+
+	"date-uk-desc": function (a, b) {
+		return ((a < b) ? 1 : ((a > b) ? -1 : 0));
 	}
-);
+});

data/app/assets/javascripts/datatables/plugins/type-detection/datetime-moment.js

@@ -0,0 +1,74 @@
+/**
+ * This plug-in for DataTables represents the ultimate option in extensibility
+ * for sorting date / time strings correctly. It uses
+ * [Moment.js](http://momentjs.com) to create automatic type detection and
+ * sorting plug-ins for DataTables based on a given format. This way, DataTables
+ * will automatically detect your temporal information and sort it correctly.
+ *
+ * For usage instructions, please see the DataTables blog
+ * post that [introduces it](//datatables.net/blog/2014-12-18).
+ *
+ * @name Ultimate Date / Time sorting
+ * @summary Sort date and time in any format using Moment.js
+ * @author [Allan Jardine](//datatables.net)
+ * @depends DataTables 1.10+, Moment.js 1.7+
+ *
+ * @example
+ *    $.fn.dataTable.moment( 'HH:mm MMM D, YY' );
+ *    $.fn.dataTable.moment( 'dddd, MMMM Do, YYYY' );
+ *
+ *    $('#example').DataTable();
+ */
+
+(function (factory) {
+	if (typeof define === "function" && define.amd) {
+		define(["jquery", "moment", "datatables.net"], factory);
+	} else {
+		factory(jQuery, moment);
+	}
+}(function ($, moment) {
+
+$.fn.dataTable.moment = function ( format, locale, reverseEmpties ) {
+	var types = $.fn.dataTable.ext.type;
+
+	// Add type detection
+	types.detect.unshift( function ( d ) {
+		if ( d ) {
+			// Strip HTML tags and newline characters if possible
+			if ( d.replace ) {
+				d = d.replace(/(<.*?>)|(\r?\n|\r)/g, '');
+			}
+
+			// Strip out surrounding white space
+			d = $.trim( d );
+		}
+
+		// Null and empty values are acceptable
+		if ( d === '' || d === null ) {
+			return 'moment-'+format;
+		}
+
+		return moment( d, format, locale, true ).isValid() ?
+			'moment-'+format :
+			null;
+	} );
+
+	// Add sorting method - use an integer for the sorting
+	types.order[ 'moment-'+format+'-pre' ] = function ( d ) {
+		if ( d ) {
+			// Strip HTML tags and newline characters if possible
+			if ( d.replace ) {
+				d = d.replace(/(<.*?>)|(\r?\n|\r)/g, '');
+			}
+
+			// Strip out surrounding white space
+			d = $.trim( d );
+		}
+		
+		return !moment(d, format, locale, true).isValid() ?
+			(reverseEmpties ? -Infinity : Infinity) :
+			parseInt( moment( d, format, locale, true ).format( 'x' ), 10 );
+	};
+};
+
+}));