jquery-datatables 1.10.19.1 → 1.10.20

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

@@ -0,0 +1,86 @@
+/*
+ * Adds a new sorting option to dataTables called `datetime-us`.
+ * 
+ * Also included is a type detection plug-in. Matches and sorts date / time
+ * strings in the format: `(m)m/(d)d/(yy)yy (h)h/m(m) (am|pm)`. For example:
+ *
+ * * 1/1/13 1:4 pm
+ * * 01/01/2013 01:04 PM
+ * * 1/1/2013 1:04 Pm
+ *
+ * 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 / time - US
+ *  @summary Sort date / time in the format `m/d/yy h:m am|pm`
+ *  @author [Kevin Gravier](http://mrkmg.com/)
+ *  @deprecated
+ *
+ *  @example
+ *    $('#example').dataTable( {
+ *       columnDefs: [
+ *         { type: 'datetime-us', targets: 0 }
+ *       ]
+ *    } );
+*/
+jQuery.extend(jQuery.fn.dataTableExt.oSort, {
+    "datetime-us-pre": function (a) {
+        var b = a.match(/(\d{1,2})\/(\d{1,2})\/(\d{2,4}) (\d{1,2}):(\d{1,2}) (am|pm|AM|PM|Am|Pm)/),
+            month = b[1],
+            day = b[2],
+            year = b[3],
+            hour = b[4],
+            min = b[5],
+            ap = b[6].toLowerCase();
+
+        if (hour == '12') {
+            hour = '0';
+            if (ap == 'pm') {
+                hour = parseInt(hour, 10) + 12;
+            }
+
+            if (year.length == 2) {
+                if (parseInt(year, 10) < 70) {
+                    year = '20' + year;
+                }
+                else {
+                    year = '19' + year;
+                }
+            }
+            if (month.length == 1) {
+                month = '0' + month;
+            }
+            if (day.length == 1) {
+                day = '0' + day;
+            }
+            if (hour.length == 1) {
+                hour = '0' + hour;
+            }
+            if (min.length == 1) {
+                min = '0' + min;
+            }
+
+            var tt = year + month + day + hour + min;
+            return tt;
+        }
+    },
+
+    "datetime-us-asc": function (a, b) {
+            return a - b;
+    },
+
+    "datetime-us-desc": function (a, b) {
+        return b - a;
+    }
+});
+
+jQuery.fn.dataTableExt.aTypes.unshift(
+    function (sData) {
+        if (sData !== null && sData.match(/\d{1,2}\/\d{1,2}\/\d{2,4} \d{1,2}:\d{1,2} (am|pm|AM|PM|Am|Pm)/)) {
+
+            return 'datetime-us';
+        }
+        return null;
+    }
+);

data/app/assets/javascripts/datatables/plugins/type-detection/file-size.js

@@ -1,20 +1,44 @@
 /**
- * Detect file size type columns automatically. Commonly used for computer
- * file sizes, this can allow sorting to take the order of magnitude indicated
- * by the label (GB etc) into account.
+ * When dealing with computer file sizes, it is common to append a post fix
+ * such as B, KB, MB or GB to a string in order to easily denote the order of
+ * magnitude of the file size. This plug-in allows sorting to take these
+ * indicates of size into account.
+ *
+ * A counterpart type detection plug-in is also available.
  *
  *  @name File size
- *  @summary Detect abbreviated file size data (8MB, 4KB, 3B, etc)
+ *  @summary Sort abbreviated file sizes correctly (8MB, 4KB, etc)
  *  @author Allan Jardine - datatables.net
+ *
+ *  @example
+ *    $('#example').DataTable( {
+ *       columnDefs: [
+ *         { type: 'file-size', targets: 0 }
+ *       ]
+ *    } );
  */
 
-jQuery.fn.dataTable.ext.type.detect.unshift( function ( data ) {
-	if ( typeof data !== 'string' ) {
-		return null;
-	}
+jQuery.fn.dataTable.ext.type.order['file-size-pre'] = function (data) {
+	var matches = data.match(/^(\d+(?:\.\d+)?)\s*([a-z]+)/i);
+	var multipliers = {
+		b: 1,
+		bytes: 1,
+		kb: 1000,
+		kib: 1024,
+		mb: 1000000,
+		mib: 1048576,
+		gb: 1000000000,
+		gib: 1073741824,
+		tb: 1000000000000,
+		tib: 1099511627776,
+		pb: 1000000000000000,
+		pib: 1125899906842624
+	};
 
-	var matches = data.match( /^(\d+(?:\.\d+)?)\s*([a-z]+)/i );
-	var units = ['b', 'kb', 'mb', 'gb', 'tb', 'pb'];
-	var is_file_size = ( matches && jQuery.inArray(matches[2].toLowerCase(), units) !== -1 );
-	return is_file_size ? 'file-size' : null;
-} );
+	if (matches) {
+		var multiplier = multipliers[matches[2].toLowerCase()];
+		return parseFloat(matches[1]) * multiplier;
+	} else {
+		return -1;
+	};
+};

data/app/assets/javascripts/datatables/plugins/type-detection/ip-address.js

@@ -1,18 +1,120 @@
 /**
- * Automatically detect IP addresses in dot notation. Goes perfectly with the
- * IP address sorting function.
+ * Sorts a column containing IP addresses (IPv4 and IPv6) or IPv4 address and port delimited by ':' in typical dot
+ * notation / colon. This can be most useful when using DataTables for a
+ * networking application, and reporting information containing IP address.
  *
- *  @name IP address detection
- *  @summary Detect data which is in IP address notation
+ *  @name IP addresses 
+ *  @summary Sort IP addresses numerically
+ *  @author Dominique Fournier
  *  @author Brad Wasson
+ *  @author Peter Vilhan
+ *
+ *  @example
+ *    $('#example').dataTable( {
+ *       columnDefs: [
+ *         { type: 'ip-address', targets: 0 }
+ *       ]
+ *    } );
  */
 
-jQuery.fn.dataTableExt.aTypes.unshift(
-	function ( sData )
-	{
-		if (/^\d{1,3}[\.]\d{1,3}[\.]\d{1,3}[\.]\d{1,3}$/.test(sData)) {
-			return 'ip-address';
+
+jQuery.extend(jQuery.fn.dataTableExt.oSort, {
+	"ip-address-pre": function (a) {
+		var i, item;
+		var m, n, t;
+		var x, xa;
+
+		if (!a) {
+			return 0
+		}
+
+		a = a.replace(/<[\s\S]*?>/g, "");
+		//IPv4:Port
+		t = a.split(":");
+		if (t.length == 2) {
+			m = t[0].split(".");
+		}
+		else {
+			m = a.split(".");
+		}
+		n = a.split(":");
+		x = "";
+		xa = "";
+
+		if (m.length == 4) {
+			// IPV4
+			for (i = 0; i < m.length; i++) {
+				item = m[i];
+
+				if (item.length == 1) {
+					x += "00" + item;
+				}
+				else if (item.length == 2) {
+					x += "0" + item;
+				}
+				else {
+					x += item;
+				}
+			}
 		}
-		return null;
+		else if (n.length > 0) {
+			// IPV6
+			var count = 0;
+			for (i = 0; i < n.length; i++) {
+				item = n[i];
+
+				if (i > 0) {
+					xa += ":";
+				}
+
+				if (item.length === 0) {
+					count += 0;
+				}
+				else if (item.length == 1) {
+					xa += "000" + item;
+					count += 4;
+				}
+				else if (item.length == 2) {
+					xa += "00" + item;
+					count += 4;
+				}
+				else if (item.length == 3) {
+					xa += "0" + item;
+					count += 4;
+				}
+				else {
+					xa += item;
+					count += 4;
+				}
+			}
+
+			// Padding the ::
+			n = xa.split(":");
+			var paddDone = 0;
+
+			for (i = 0; i < n.length; i++) {
+				item = n[i];
+
+				if (item.length === 0 && paddDone === 0) {
+					for (var padding = 0; padding < (32 - count); padding++) {
+						x += "0";
+						paddDone = 1;
+					}
+				}
+				else {
+					x += item;
+				}
+			}
+		}
+
+		return x;
+	},
+
+	"ip-address-asc": function (a, b) {
+		return ((a < b) ? -1 : ((a > b) ? 1 : 0));
+	},
+
+	"ip-address-desc": function (a, b) {
+		return ((a < b) ? 1 : ((a > b) ? -1 : 0));
 	}
-);
+});

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

@@ -0,0 +1,63 @@
+/**
+ * 
+ * This plug in will sort only on the number value that is included anywhere in a Regex.
+ * This is useful for sorting data which requires some extra context to be included in the table.
+ *
+ *  @name numString
+ *  @summary Sorting for number value that is included anywhere in a regex.
+ *  @author [Sandy Galloway](http://datatables.net)
+ *
+ * 
+ *  @example
+ * //This example shows a mixture of text and number values, with the number at the start of the expression.
+ * //It is using regex and start and end of expression tags.
+ * //It will match "5 examples completed." for example. 
+ * $(document).ready( function(){
+ *      $.fn.dataTable.numString(/^\d+ examples? completed.$/);
+ *      var table = $('#example').DataTable();
+ * })
+ * 
+ * @example
+ *  //This example shows a mixture of text and number values, with the number at the end of the expression.
+ * //It is using regex and start and end of expression tags.
+ * //It will match "Examples left: 67" for example. 
+ *  $(document).ready( function(){
+ *      $.fn.dataTable.numString(/^Examples? left: \d+$/);
+ *      var table = $('#example').DataTable();
+ * })
+ * 
+ * @example
+ * //This example shows a mixture of text and number values, with the number in the middle of the expression.
+ * //It is using regex and no start and end of expression tags.
+ * //It will match "Only 1 left." for example. 
+ *  $(document).ready(function(){
+ *      $.fn.dataTable.numString(/Only \d+ left./);
+ *      var table = $('example').DataTable();
+ * })
+ * 
+    */
+$.fn.dataTable.numString = function(format) {
+    //This is the type detection plug in
+    $.fn.dataTable.ext.type.detect.unshift(function(data) {
+      if (typeof data !== "string") {
+        return null;
+      }
+  
+      if (data.match(format)) {
+        return "numString-" + format.source;
+      }
+  
+      return null;
+    });
+    
+    //This is the ordering plug in
+    $.fn.dataTable.ext.type.order[
+      "numString-" + format.source + "-pre"
+    ] = function(data) {
+      var num = data.replace(/\D/g, "");
+  
+      return num * 1;
+    };
+    // end plug-in
+  };
+  

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

@@ -0,0 +1,34 @@
+/**
+ * Sort numeric data which has a percent sign with it.
+ *
+ * DataTables 1.10+ has percentage data type detection and sorting abilities
+ * built-in. As such this plug-in is marked as deprecated, but might be useful
+ * when working with old versions of DataTables.
+ * 
+ *  @name Percentage
+ *  @summary Sort numeric data with a postfixed percentage symbol
+ *  @deprecated
+ *  @author [Jonathan Romley](http://jonathanromley.org/)
+ *
+ *  @example
+ *    $('#example').dataTable( {
+ *       columnDefs: [
+ *         { type: 'percent', targets: 0 }
+ *       ]
+ *    } );
+ */
+
+jQuery.extend( jQuery.fn.dataTableExt.oSort, {
+	"percent-pre": function ( a ) {
+		var x = (a == "-") ? 0 : a.replace( /%/, "" );
+		return parseFloat( x );
+	},
+
+	"percent-asc": function ( a, b ) {
+		return ((a < b) ? -1 : ((a > b) ? 1 : 0));
+	},
+
+	"percent-desc": function ( a, b ) {
+		return ((a < b) ? 1 : ((a > b) ? -1 : 0));
+	}
+} );

data/app/assets/javascripts/datatables/plugins/type-detection/time-elapsed-dhms.js

@@ -0,0 +1,42 @@
+/**
+ * Created by caochenghua on 2016/12/22.
+ */
+
+/**
+ * When dealing with time elapsed, it is common to append a post fix
+ * such as d(day), h(hour), m(minute) or s(second) to a string in order to easily denote the brief duration
+ * of the time span from now. This plug-in allows sorting to take these
+ * indicates of size into account.
+ *
+ * A counterpart type detection plug-in is also available.
+ *
+ *  @name Time span
+ *  @summary Sort abbreviated time span correctly (2d 3h, 2h 8m, 3m 8s, 30s, etc)
+ *  @author Allan Jardine - datatables.net
+ *
+ *  @example
+ *    $('#example').DataTable( {
+ *       columnDefs: [
+ *         { type: 'time-elapsed-dhms', targets: 0 }
+ *       ]
+ *    } );
+ */
+
+
+jQuery.fn.dataTable.ext.type.order['time-elapsed-dhms-pre'] = function(data) {
+
+    var matches = data.match(/^(\d+(?:\.\d+)?)\s*([a-z]+)/i);
+    var multipliers = {
+        s: 1,
+        m: 60,
+        h: 3600,
+        d: 86400
+    };
+
+    if (matches) {
+        var multiplier = multipliers[matches[2].toLowerCase()];
+        return parseFloat(matches[1]) * multiplier;
+    } else {
+        return -1;
+    };
+};

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

@@ -0,0 +1,56 @@
+/**
+ * This plug-in provides the ability to sort columns that contains time
+ * information in the most common formats used. It will automatically detect
+ * those date types.
+ *
+ * Please note that this plug-in is **deprecated*. The
+ * [datetime](//datatables.net/blog/2014-12-18) plug-in provides enhanced
+ * functionality and flexibility.
+ *
+ *  @name Time (dd/mm/YY)
+ *  @summary Sort Times in the formats: `hh:mm, hh:mm:ss, hh:mm tt, hh:mm:ss tt`
+ *    e.g. '22:50, 22:50:40, 10:50 pm, 10:50:40 pm' 
+ *    am and pm are not case sensitive. white space is not compulsory
+ *  @author David Stoneham
+ *  @deprecated
+ *
+ *  @example
+ *    $('#example').dataTable( {
+ *       columnDefs: [
+ *         { type: 'time-uni', targets: 0 }
+ *       ]
+ *    } );
+ */
+
+jQuery.extend(jQuery.fn.dataTableExt.oSort, {
+    "time-uni-pre": function (a) {
+        var uniTime;
+
+        if (a.toLowerCase().indexOf("am") > -1 || (a.toLowerCase().indexOf("pm") > -1 && Number(a.split(":")[0]) === 12)) {
+            uniTime = a.toLowerCase().split("pm")[0].split("am")[0];
+            while (uniTime.indexOf(":") > -1) {
+                uniTime = uniTime.replace(":", "");
+            }
+        } else if (a.toLowerCase().indexOf("pm") > -1 || (a.toLowerCase().indexOf("am") > -1 && Number(a.split(":")[0]) === 12)) {
+            uniTime = Number(a.split(":")[0]) + 12;
+            var leftTime = a.toLowerCase().split("pm")[0].split("am")[0].split(":");
+            for (var i = 1; i < leftTime.length; i++) {
+                uniTime = uniTime + leftTime[i].trim().toString();
+            }
+        } else {
+            uniTime = a.replace(":", "");
+            while (uniTime.indexOf(":") > -1) {
+                uniTime = uniTime.replace(":", "");
+            }
+        }
+        return Number(uniTime);
+    },
+
+    "time-uni-asc": function (a, b) {
+        return ((a < b) ? -1 : ((a > b) ? 1 : 0));
+    },
+
+    "time-uni-desc": function (a, b) {
+        return ((a < b) ? 1 : ((a > b) ? -1 : 0));
+    }
+});