jquery-datatables-rails 3.3.0 → 3.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (24) hide show
  1. checksums.yaml +4 -4
  2. data/app/assets/javascripts/dataTables/bootstrap/3/jquery.dataTables.bootstrap.js +64 -29
  3. data/app/assets/javascripts/dataTables/extras/dataTables.autoFill.js +806 -648
  4. data/app/assets/javascripts/dataTables/extras/dataTables.buttons.js +1607 -0
  5. data/app/assets/javascripts/dataTables/extras/dataTables.colReorder.js +220 -267
  6. data/app/assets/javascripts/dataTables/extras/dataTables.fixedColumns.js +164 -69
  7. data/app/assets/javascripts/dataTables/extras/dataTables.fixedHeader.js +469 -870
  8. data/app/assets/javascripts/dataTables/extras/dataTables.keyTable.js +636 -972
  9. data/app/assets/javascripts/dataTables/extras/dataTables.responsive.js +472 -187
  10. data/app/assets/javascripts/dataTables/extras/dataTables.rowReorder.js +619 -0
  11. data/app/assets/javascripts/dataTables/extras/dataTables.scroller.js +146 -111
  12. data/app/assets/javascripts/dataTables/extras/dataTables.select.js +1038 -0
  13. data/app/assets/javascripts/dataTables/jquery.dataTables.api.fnGetColumnData.js +0 -0
  14. data/app/assets/javascripts/dataTables/jquery.dataTables.api.fnReloadAjax.js +0 -0
  15. data/app/assets/javascripts/dataTables/jquery.dataTables.foundation.js +37 -61
  16. data/app/assets/javascripts/dataTables/jquery.dataTables.js +720 -387
  17. data/app/assets/javascripts/dataTables/jquery.dataTables.sorting.ipAddress.js +44 -0
  18. data/app/assets/javascripts/dataTables/jquery.dataTables.sorting.numbersHtml.js +0 -0
  19. data/app/assets/javascripts/dataTables/jquery.dataTables.typeDetection.numbersHtml.js +0 -0
  20. data/app/assets/stylesheets/dataTables/jquery.dataTables.scss +34 -66
  21. data/app/assets/stylesheets/dataTables/src/demo_table.css +1 -1
  22. data/app/assets/stylesheets/dataTables/src/demo_table_jui.css.scss +4 -4
  23. data/lib/jquery/datatables/rails/version.rb +1 -1
  24. metadata +24 -19
@@ -0,0 +1,619 @@
1
+ /*! RowReorder 1.1.0
2
+ * 2015 SpryMedia Ltd - datatables.net/license
3
+ */
4
+
5
+ /**
6
+ * @summary RowReorder
7
+ * @description Row reordering extension for DataTables
8
+ * @version 1.1.0
9
+ * @file dataTables.rowReorder.js
10
+ * @author SpryMedia Ltd (www.sprymedia.co.uk)
11
+ * @contact www.sprymedia.co.uk/contact
12
+ * @copyright Copyright 2015 SpryMedia Ltd.
13
+ *
14
+ * This source file is free software, available under the following license:
15
+ * MIT license - http://datatables.net/license/mit
16
+ *
17
+ * This source file is distributed in the hope that it will be useful, but
18
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
19
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the license files for details.
20
+ *
21
+ * For details please refer to: http://www.datatables.net
22
+ */
23
+
24
+ (function( factory ){
25
+ if ( typeof define === 'function' && define.amd ) {
26
+ // AMD
27
+ define( ['jquery', 'datatables.net'], function ( $ ) {
28
+ return factory( $, window, document );
29
+ } );
30
+ }
31
+ else if ( typeof exports === 'object' ) {
32
+ // CommonJS
33
+ module.exports = function (root, $) {
34
+ if ( ! root ) {
35
+ root = window;
36
+ }
37
+
38
+ if ( ! $ || ! $.fn.dataTable ) {
39
+ $ = require('datatables.net')(root, $).$;
40
+ }
41
+
42
+ return factory( $, root, root.document );
43
+ };
44
+ }
45
+ else {
46
+ // Browser
47
+ factory( jQuery, window, document );
48
+ }
49
+ }(function( $, window, document, undefined ) {
50
+ 'use strict';
51
+ var DataTable = $.fn.dataTable;
52
+
53
+
54
+ /**
55
+ * RowReorder provides the ability in DataTables to click and drag rows to
56
+ * reorder them. When a row is dropped the data for the rows effected will be
57
+ * updated to reflect the change. Normally this data point should also be the
58
+ * column being sorted upon in the DataTable but this does not need to be the
59
+ * case. RowReorder implements a "data swap" method - so the rows being
60
+ * reordered take the value of the data point from the row that used to occupy
61
+ * the row's new position.
62
+ *
63
+ * Initialisation is done by either:
64
+ *
65
+ * * `rowReorder` parameter in the DataTable initialisation object
66
+ * * `new $.fn.dataTable.RowReorder( table, opts )` after DataTables
67
+ * initialisation.
68
+ *
69
+ * @class
70
+ * @param {object} settings DataTables settings object for the host table
71
+ * @param {object} [opts] Configuration options
72
+ * @requires jQuery 1.7+
73
+ * @requires DataTables 1.10.7+
74
+ */
75
+ var RowReorder = function ( dt, opts ) {
76
+ // Sanity check that we are using DataTables 1.10 or newer
77
+ if ( ! DataTable.versionCheck || ! DataTable.versionCheck( '1.10.8' ) ) {
78
+ throw 'DataTables RowReorder requires DataTables 1.10.8 or newer';
79
+ }
80
+
81
+ // User and defaults configuration object
82
+ this.c = $.extend( true, {},
83
+ DataTable.defaults.rowReorder,
84
+ RowReorder.defaults,
85
+ opts
86
+ );
87
+
88
+ // Internal settings
89
+ this.s = {
90
+ /** @type {integer} Scroll body top cache */
91
+ bodyTop: null,
92
+
93
+ /** @type {DataTable.Api} DataTables' API instance */
94
+ dt: new DataTable.Api( dt ),
95
+
96
+ /** @type {function} Data fetch function */
97
+ getDataFn: DataTable.ext.oApi._fnGetObjectDataFn( this.c.dataSrc ),
98
+
99
+ /** @type {array} Pixel positions for row insertion calculation */
100
+ middles: null,
101
+
102
+ /** @type {function} Data set function */
103
+ setDataFn: DataTable.ext.oApi._fnSetObjectDataFn( this.c.dataSrc ),
104
+
105
+ /** @type {Object} Mouse down information */
106
+ start: {
107
+ top: 0,
108
+ left: 0,
109
+ offsetTop: 0,
110
+ offsetLeft: 0,
111
+ nodes: []
112
+ },
113
+
114
+ /** @type {integer} Window height cached value */
115
+ windowHeight: 0
116
+ };
117
+
118
+ // DOM items
119
+ this.dom = {
120
+ /** @type {jQuery} Cloned row being moved around */
121
+ clone: null
122
+ };
123
+
124
+ // Check if row reorder has already been initialised on this table
125
+ var settings = this.s.dt.settings()[0];
126
+ var exisiting = settings.rowreorder;
127
+ if ( exisiting ) {
128
+ return exisiting;
129
+ }
130
+
131
+ settings.rowreorder = this;
132
+ this._constructor();
133
+ };
134
+
135
+
136
+ $.extend( RowReorder.prototype, {
137
+ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
138
+ * Constructor
139
+ */
140
+
141
+ /**
142
+ * Initialise the RowReorder instance
143
+ *
144
+ * @private
145
+ */
146
+ _constructor: function ()
147
+ {
148
+ var that = this;
149
+ var dt = this.s.dt;
150
+ var table = $( dt.table().node() );
151
+
152
+ // Need to be able to calculate the row positions relative to the table
153
+ if ( table.css('position') === 'static' ) {
154
+ table.css( 'position', 'relative' );
155
+ }
156
+
157
+ // listen for mouse down on the target column - we have to implement
158
+ // this rather than using HTML5 drag and drop as drag and drop doesn't
159
+ // appear to work on table rows at this time. Also mobile browsers are
160
+ // not supported.
161
+ // Use `table().container()` rather than just the table node for IE8 -
162
+ // otherwise it only works once...
163
+ $(dt.table().container()).on( 'mousedown.rowReorder touchstart.rowReorder', this.c.selector, function (e) {
164
+ var tr = $(this).closest('tr');
165
+
166
+ // Double check that it is a DataTable row
167
+ if ( dt.row( tr ).any() ) {
168
+ that._mouseDown( e, tr );
169
+ return false;
170
+ }
171
+ } );
172
+
173
+ dt.on( 'destroy.rowReorder', function () {
174
+ $(dt.table().container()).off( '.rowReorder' );
175
+ dt.off( '.rowReorder' );
176
+ } );
177
+ },
178
+
179
+
180
+ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
181
+ * Private methods
182
+ */
183
+
184
+ /**
185
+ * Cache the measurements that RowReorder needs in the mouse move handler
186
+ * to attempt to speed things up, rather than reading from the DOM.
187
+ *
188
+ * @private
189
+ */
190
+ _cachePositions: function ()
191
+ {
192
+ var dt = this.s.dt;
193
+
194
+ // Frustratingly, if we add `position:relative` to the tbody, the
195
+ // position is still relatively to the parent. So we need to adjust
196
+ // for that
197
+ var headerHeight = $( dt.table().node() ).find('thead').outerHeight();
198
+
199
+ // Need to pass the nodes through jQuery to get them in document order,
200
+ // not what DataTables thinks it is, since we have been altering the
201
+ // order
202
+ var nodes = $.unique( dt.rows( { page: 'current' } ).nodes().toArray() );
203
+ var tops = $.map( nodes, function ( node, i ) {
204
+ return $(node).position().top - headerHeight;
205
+ } );
206
+
207
+ var middles = $.map( tops, function ( top, i ) {
208
+ return tops.length < i-1 ?
209
+ (top + tops[i+1]) / 2 :
210
+ (top + top + $( dt.row( ':last-child' ).node() ).outerHeight() ) / 2;
211
+ } );
212
+
213
+ this.s.middles = middles;
214
+ this.s.bodyTop = $( dt.table().body() ).offset().top;
215
+ this.s.windowHeight = $(window).height();
216
+ },
217
+
218
+
219
+ /**
220
+ * Clone a row so it can be floated around the screen
221
+ *
222
+ * @param {jQuery} target Node to be cloned
223
+ * @private
224
+ */
225
+ _clone: function ( target )
226
+ {
227
+ var dt = this.s.dt;
228
+ var clone = $( dt.table().node().cloneNode(false) )
229
+ .addClass( 'dt-rowReorder-float' )
230
+ .append('<tbody/>')
231
+ .append( target.clone( false ) );
232
+
233
+ // Match the table and column widths - read all sizes before setting
234
+ // to reduce reflows
235
+ var tableWidth = target.outerWidth();
236
+ var tableHeight = target.outerHeight();
237
+ var sizes = target.children().map( function () {
238
+ return $(this).width();
239
+ } );
240
+
241
+ clone
242
+ .width( tableWidth )
243
+ .height( tableHeight )
244
+ .find('tr').children().each( function (i) {
245
+ this.style.width = sizes[i]+'px';
246
+ } );
247
+
248
+ // Insert into the document to have it floating around
249
+ clone.appendTo( 'body' );
250
+
251
+ this.dom.clone = clone;
252
+ },
253
+
254
+
255
+ /**
256
+ * Update the cloned item's position in the document
257
+ *
258
+ * @param {object} e Event giving the mouse's position
259
+ * @private
260
+ */
261
+ _clonePosition: function ( e )
262
+ {
263
+ var start = this.s.start;
264
+ var topDiff = this._eventToPage( e, 'Y' ) - start.top;
265
+ var leftDiff = this._eventToPage( e, 'X' ) - start.left;
266
+ var snap = this.c.snapX;
267
+ var left;
268
+
269
+ if ( snap === true ) {
270
+ left = start.offsetLeft;
271
+ }
272
+ else if ( typeof snap === 'number' ) {
273
+ left = start.offsetLeft + snap;
274
+ }
275
+ else {
276
+ left = leftDiff + start.offsetLeft;
277
+ }
278
+
279
+ this.dom.clone.css( {
280
+ top: topDiff + start.offsetTop,
281
+ left: left
282
+ } );
283
+ },
284
+
285
+
286
+ /**
287
+ * Emit an event on the DataTable for listeners
288
+ *
289
+ * @param {string} name Event name
290
+ * @param {array} args Event arguments
291
+ * @private
292
+ */
293
+ _emitEvent: function ( name, args )
294
+ {
295
+ this.s.dt.iterator( 'table', function ( ctx, i ) {
296
+ $(ctx.nTable).triggerHandler( name+'.dt', args );
297
+ } );
298
+ },
299
+
300
+
301
+ /**
302
+ * Get pageX/Y position from an event, regardless of if it is a mouse or
303
+ * touch event.
304
+ *
305
+ * @param {object} e Event
306
+ * @param {string} pos X or Y (must be a capital)
307
+ * @private
308
+ */
309
+ _eventToPage: function ( e, pos )
310
+ {
311
+ if ( e.type.indexOf( 'touch' ) !== -1 ) {
312
+ return e.originalEvent.touches[0][ 'page'+pos ];
313
+ }
314
+
315
+ return e[ 'page'+pos ];
316
+ },
317
+
318
+
319
+ /**
320
+ * Mouse down event handler. Read initial positions and add event handlers
321
+ * for the move.
322
+ *
323
+ * @param {object} e Mouse event
324
+ * @param {jQuery} target TR element that is to be moved
325
+ * @private
326
+ */
327
+ _mouseDown: function ( e, target )
328
+ {
329
+ var that = this;
330
+ var dt = this.s.dt;
331
+ var start = this.s.start;
332
+
333
+ var offset = target.offset();
334
+ start.top = this._eventToPage( e, 'Y' );
335
+ start.left = this._eventToPage( e, 'X' );
336
+ start.offsetTop = offset.top;
337
+ start.offsetLeft = offset.left;
338
+ start.nodes = $.unique( dt.rows( { page: 'current' } ).nodes().toArray() );
339
+
340
+ this._cachePositions();
341
+ this._clone( target );
342
+ this._clonePosition( e );
343
+
344
+ this.dom.target = target;
345
+ target.addClass( 'dt-rowReorder-moving' );
346
+
347
+ $( document )
348
+ .on( 'mouseup.rowReorder touchend.rowReorder', function (e) {
349
+ that._mouseUp(e);
350
+ } )
351
+ .on( 'mousemove.rowReorder touchmove.rowReorder', function (e) {
352
+ that._mouseMove(e);
353
+ } );
354
+
355
+ // Check if window is x-scrolling - if not, disable it for the duration
356
+ // of the drag
357
+ if ( $(window).width() === $(document).width() ) {
358
+ $(document.body).addClass( 'dt-rowReorder-noOverflow' );
359
+ }
360
+ },
361
+
362
+
363
+ /**
364
+ * Mouse move event handler - move the cloned row and shuffle the table's
365
+ * rows if required.
366
+ *
367
+ * @param {object} e Mouse event
368
+ * @private
369
+ */
370
+ _mouseMove: function ( e )
371
+ {
372
+ this._clonePosition( e );
373
+
374
+ // Transform the mouse position into a position in the table's body
375
+ var bodyY = this._eventToPage( e, 'Y' ) - this.s.bodyTop;
376
+ var middles = this.s.middles;
377
+ var insertPoint = null;
378
+ var dt = this.s.dt;
379
+ var body = dt.table().body();
380
+
381
+ // Determine where the row should be inserted based on the mouse
382
+ // position
383
+ for ( var i=0, ien=middles.length ; i<ien ; i++ ) {
384
+ if ( bodyY < middles[i] ) {
385
+ insertPoint = i;
386
+ break;
387
+ }
388
+ }
389
+
390
+ if ( insertPoint === null ) {
391
+ insertPoint = middles.length;
392
+ }
393
+
394
+ // Perform the DOM shuffle if it has changed from last time
395
+ if ( this.s.lastInsert === null || this.s.lastInsert !== insertPoint ) {
396
+ if ( insertPoint === 0 ) {
397
+ this.dom.target.prependTo( body );
398
+ }
399
+ else {
400
+ var nodes = $.unique( dt.rows( { page: 'current' } ).nodes().toArray() );
401
+
402
+ if ( insertPoint > this.s.lastInsert ) {
403
+ this.dom.target.before( nodes[ insertPoint-1 ] );
404
+ }
405
+ else {
406
+ this.dom.target.after( nodes[ insertPoint ] );
407
+ }
408
+ }
409
+
410
+ this._cachePositions();
411
+
412
+ this.s.lastInsert = insertPoint;
413
+ }
414
+
415
+ // scroll window up and down when reaching the edges
416
+ var windowY = this._eventToPage( e, 'Y' ) - document.body.scrollTop;
417
+ var scrollInterval = this.s.scrollInterval;
418
+
419
+ if ( windowY < 65 ) {
420
+ if ( ! scrollInterval ) {
421
+ this.s.scrollInterval = setInterval( function () {
422
+ document.body.scrollTop -= 5;
423
+ }, 15 );
424
+ }
425
+ }
426
+ else if ( this.s.windowHeight - windowY < 65 ) {
427
+ if ( ! scrollInterval ) {
428
+ this.s.scrollInterval = setInterval( function () {
429
+ document.body.scrollTop += 5;
430
+ }, 15 );
431
+ }
432
+ }
433
+ else {
434
+ clearInterval( scrollInterval );
435
+ this.s.scrollInterval = null;
436
+ }
437
+ },
438
+
439
+
440
+ /**
441
+ * Mouse up event handler - release the event handlers and perform the
442
+ * table updates
443
+ *
444
+ * @param {object} e Mouse event
445
+ * @private
446
+ */
447
+ _mouseUp: function ( e )
448
+ {
449
+ var dt = this.s.dt;
450
+ var i, ien;
451
+ var dataSrc = this.c.dataSrc;
452
+
453
+ this.dom.clone.remove();
454
+ this.dom.clone = null;
455
+
456
+ this.dom.target.removeClass( 'dt-rowReorder-moving' );
457
+ //this.dom.target = null;
458
+
459
+ $(document).off( '.rowReorder' );
460
+ $(document.body).removeClass( 'dt-rowReorder-noOverflow' );
461
+
462
+ clearInterval( this.s.scrollInterval );
463
+ this.s.scrollInterval = null;
464
+
465
+ // Calculate the difference
466
+ var startNodes = this.s.start.nodes;
467
+ var endNodes = $.unique( dt.rows( { page: 'current' } ).nodes().toArray() );
468
+ var idDiff = {};
469
+ var fullDiff = [];
470
+ var diffNodes = [];
471
+ var getDataFn = this.s.getDataFn;
472
+ var setDataFn = this.s.setDataFn;
473
+
474
+ for ( i=0, ien=startNodes.length ; i<ien ; i++ ) {
475
+ if ( startNodes[i] !== endNodes[i] ) {
476
+ var id = dt.row( endNodes[i] ).id();
477
+ var endRowData = dt.row( endNodes[i] ).data();
478
+ var startRowData = dt.row( startNodes[i] ).data();
479
+
480
+ if ( id ) {
481
+ idDiff[ id ] = getDataFn( startRowData );
482
+ }
483
+
484
+ fullDiff.push( {
485
+ node: endNodes[i],
486
+ oldData: getDataFn( endRowData ),
487
+ newData: getDataFn( startRowData ),
488
+ newPosition: i,
489
+ oldPosition: $.inArray( endNodes[i], startNodes )
490
+ } );
491
+
492
+ diffNodes.push( endNodes[i] );
493
+ }
494
+ }
495
+
496
+ // Emit event
497
+ this._emitEvent( 'row-reorder', [ fullDiff, {
498
+ dataSrc: dataSrc,
499
+ nodes: diffNodes,
500
+ values: idDiff,
501
+ triggerRow: dt.row( this.dom.target )
502
+ } ] );
503
+
504
+ // Editor interface
505
+ if ( this.c.editor ) {
506
+ this.c.editor
507
+ .edit( diffNodes, false, {
508
+ submit: 'changed'
509
+ } )
510
+ .multiSet( dataSrc, idDiff )
511
+ .submit();
512
+ }
513
+
514
+ // Do update if required
515
+ if ( this.c.update ) {
516
+ for ( i=0, ien=fullDiff.length ; i<ien ; i++ ) {
517
+ var row = dt.row( fullDiff[i].node );
518
+ var rowData = row.data();
519
+
520
+ setDataFn( rowData, fullDiff[i].newData );
521
+
522
+ // Invalidate the cell that has the same data source as the dataSrc
523
+ dt.columns().every( function () {
524
+ if ( this.dataSrc() === dataSrc ) {
525
+ dt.cell( fullDiff[i].node, this.index() ).invalidate( 'data' );
526
+ }
527
+ } );
528
+ }
529
+
530
+ dt.draw( false );
531
+ }
532
+ }
533
+ } );
534
+
535
+
536
+
537
+ /**
538
+ * RowReorder default settings for initialisation
539
+ *
540
+ * @namespace
541
+ * @name RowReorder.defaults
542
+ * @static
543
+ */
544
+ RowReorder.defaults = {
545
+ /**
546
+ * Data point in the host row's data source object for where to get and set
547
+ * the data to reorder. This will normally also be the sorting column.
548
+ *
549
+ * @type {Number}
550
+ */
551
+ dataSrc: 0,
552
+
553
+ /**
554
+ * Editor instance that will be used to perform the update
555
+ *
556
+ * @type {DataTable.Editor}
557
+ */
558
+ editor: null,
559
+
560
+ /**
561
+ * Drag handle selector. This defines the element that when dragged will
562
+ * reorder a row.
563
+ *
564
+ * @type {String}
565
+ */
566
+ selector: 'td:first-child',
567
+
568
+ /**
569
+ * Optionally lock the dragged row's x-position. This can be `true` to
570
+ * fix the position match the host table's, `false` to allow free movement
571
+ * of the row, or a number to define an offset from the host table.
572
+ *
573
+ * @type {Boolean|number}
574
+ */
575
+ snapX: false,
576
+
577
+ /**
578
+ * Update the table's data on drop
579
+ *
580
+ * @type {Boolean}
581
+ */
582
+ update: true
583
+ };
584
+
585
+
586
+ /**
587
+ * Version information
588
+ *
589
+ * @name RowReorder.version
590
+ * @static
591
+ */
592
+ RowReorder.version = '1.1.0';
593
+
594
+
595
+ $.fn.dataTable.RowReorder = RowReorder;
596
+ $.fn.DataTable.RowReorder = RowReorder;
597
+
598
+ // Attach a listener to the document which listens for DataTables initialisation
599
+ // events so we can automatically initialise
600
+ $(document).on( 'init.dt.dtr', function (e, settings, json) {
601
+ if ( e.namespace !== 'dt' ) {
602
+ return;
603
+ }
604
+
605
+ var init = settings.oInit.rowReorder;
606
+ var defaults = DataTable.defaults.rowReorder;
607
+
608
+ if ( init || defaults ) {
609
+ var opts = $.extend( {}, init, defaults );
610
+
611
+ if ( init !== false ) {
612
+ new RowReorder( settings, opts );
613
+ }
614
+ }
615
+ } );
616
+
617
+
618
+ return RowReorder;
619
+ }));