glebtv-rails-uploader 0.4.1 → 0.5.0

data/spec/uploader_spec.rb

@@ -8,7 +8,7 @@ describe Uploader do
   it "should generate random string" do
     value = Uploader.guid
     value.should_not be_blank
-    value.size.should == 10
+    value.size.should == 20
   end
   
   it "should find all precompile assets" do

data/vendor/assets/javascripts/uploader/jquery.fileupload-fp.js

@@ -1,5 +1,5 @@
 /*
- * jQuery File Upload File Processing Plugin 1.2.1
+ * jQuery File Upload File Processing Plugin 1.2.3
  * https://github.com/blueimp/jQuery-File-Upload
  *
  * Copyright 2012, Sebastian Tschan
@@ -62,9 +62,13 @@
             // fileupload widget (via file input selection, drag & drop or add
             // API call). See the basic file upload widget for more information:
             add: function (e, data) {
-                $(this).fileupload('process', data).done(function () {
-                    data.submit();
-                });
+                if (data.autoUpload || (data.autoUpload !== false &&
+                        ($(this).data('blueimp-fileupload') ||
+                        $(this).data('fileupload')).options.autoUpload)) {
+                    $(this).fileupload('process', data).done(function () {
+                        data.submit();
+                    });
+                }
             }
         },
 

data/{app → vendor}/assets/javascripts/uploader/jquery.fileupload-ui.js

@@ -1,5 +1,5 @@
 /*
- * jQuery File Upload User Interface Plugin 8.2.1
+ * jQuery File Upload User Interface Plugin 7.4.4
  * https://github.com/blueimp/jQuery-File-Upload
  *
  * Copyright 2010, Sebastian Tschan
@@ -19,25 +19,20 @@
         define([
             'jquery',
             'tmpl',
-            './jquery.fileupload-resize',
-            './jquery.fileupload-validate'
+            'load-image',
+            './jquery.fileupload-fp'
         ], factory);
     } else {
         // Browser globals:
         factory(
             window.jQuery,
-            window.tmpl
+            window.tmpl,
+            window.loadImage
         );
     }
 }(function ($, tmpl, loadImage) {
     'use strict';
 
-    $.blueimp.fileupload.prototype._specialOptions.push(
-        'filesContainer',
-        'uploadTemplateId',
-        'downloadTemplateId'
-    );
-
     // The UI version extends the file upload widget
     // and adds complete user interface interaction:
     $.widget('blueimp.fileupload', $.blueimp.fileupload, {
@@ -47,6 +42,29 @@
             // as the user clicks on the start buttons. To enable automatic
             // uploads, set the following option to true:
             autoUpload: false,
+            // The following option limits the number of files that are
+            // allowed to be uploaded using this widget:
+            maxNumberOfFiles: undefined,
+            // The maximum allowed file size:
+            maxFileSize: undefined,
+            // The minimum allowed file size:
+            minFileSize: undefined,
+            // The regular expression for allowed file types, matches
+            // against either file type or file name:
+            acceptFileTypes:  /.+$/i,
+            // The regular expression to define for which files a preview
+            // image is shown, matched against the file type:
+            previewSourceFileTypes: /^image\/(gif|jpeg|png)$/,
+            // The maximum file size of images that are to be displayed as preview:
+            previewSourceMaxFileSize: 5000000, // 5MB
+            // The maximum width of the preview images:
+            previewMaxWidth: 80,
+            // The maximum height of the preview images:
+            previewMaxHeight: 80,
+            // By default, preview images are displayed as canvas elements
+            // if supported by the browser. Set the following option to false
+            // to always display preview images as img elements:
+            previewAsCanvas: true,
             // The ID of the upload template:
             uploadTemplateId: 'template-upload',
             // The ID of the download template:
@@ -61,43 +79,29 @@
             // option of the $.ajax upload requests:
             dataType: 'json',
 
-            // Function returning the current number of files,
-            // used by the maxNumberOfFiles validation:
-            getNumberOfFiles: function () {
-                return this.filesContainer.children().length;
-            },
-
-            // Callback to retrieve the list of files from the server response:
-            getFilesFromResponse: function (data) {
-                if (data.result && $.isArray(data.result.files)) {
-                    return data.result.files;
-                }
-                return [];
-            },
-
             // The add callback is invoked as soon as files are added to the fileupload
             // widget (via file input selection, drag & drop or add API call).
             // See the basic file upload widget for more information:
             add: function (e, data) {
-                var $this = $(this),
-                    that = $this.data('blueimp-fileupload') ||
-                        $this.data('fileupload'),
+                var that = $(this).data('blueimp-fileupload') ||
+                        $(this).data('fileupload'),
                     options = that.options,
                     files = data.files;
-                data.process(function () {
-                    return $this.fileupload('process', data);
-                }).always(function () {
+                $(this).fileupload('process', data).done(function () {
+                    that._adjustMaxNumberOfFiles(-files.length);
+                    data.maxNumberOfFilesAdjusted = true;
+                    data.files.valid = data.isValidated = that._validate(files);
                     data.context = that._renderUpload(files).data('data', data);
-                    that._renderPreviews(data);
                     options.filesContainer[
                         options.prependFiles ? 'prepend' : 'append'
                     ](data.context);
+                    that._renderPreviews(data);
                     that._forceReflow(data.context);
                     that._transition(data.context).done(
                         function () {
                             if ((that._trigger('added', e, data) !== false) &&
                                     (options.autoUpload || data.autoUpload) &&
-                                    data.autoUpload !== false && !data.files.error) {
+                                    data.autoUpload !== false && data.isValidated) {
                                 data.submit();
                             }
                         }
@@ -108,6 +112,15 @@
             send: function (e, data) {
                 var that = $(this).data('blueimp-fileupload') ||
                         $(this).data('fileupload');
+                if (!data.isValidated) {
+                    if (!data.maxNumberOfFilesAdjusted) {
+                        that._adjustMaxNumberOfFiles(-data.files.length);
+                        data.maxNumberOfFilesAdjusted = true;
+                    }
+                    if (!that._validate(data.files)) {
+                        return false;
+                    }
+                }
                 if (data.context && data.dataType &&
                         data.dataType.substr(0, 6) === 'iframe') {
                     // Iframe Transport does not support progress events.
@@ -129,9 +142,7 @@
             done: function (e, data) {
                 var that = $(this).data('blueimp-fileupload') ||
                         $(this).data('fileupload'),
-                    getFilesFromResponse = data.getFilesFromResponse ||
-                        that.options.getFilesFromResponse,
-                    files = getFilesFromResponse(data),
+                    files = that._getFilesFromResponse(data),
                     template,
                     deferred;
                 if (data.context) {
@@ -139,6 +150,9 @@
                         var file = files[index] ||
                                 {error: 'Empty file upload result'},
                             deferred = that._addFinishedDeferreds();
+                        if (file.error) {
+                            that._adjustMaxNumberOfFiles(1);
+                        }
                         that._transition($(this)).done(
                             function () {
                                 var node = $(this);
@@ -157,6 +171,17 @@
                         );
                     });
                 } else {
+                    if (files.length) {
+                        $.each(files, function (index, file) {
+                            if (data.maxNumberOfFilesAdjusted && file.error) {
+                                that._adjustMaxNumberOfFiles(1);
+                            } else if (!data.maxNumberOfFilesAdjusted &&
+                                    !file.error) {
+                                that._adjustMaxNumberOfFiles(-1);
+                            }
+                        });
+                        data.maxNumberOfFilesAdjusted = true;
+                    }
                     template = that._renderDownload(files)
                         .appendTo(that.options.filesContainer);
                     that._forceReflow(template);
@@ -177,6 +202,9 @@
                         $(this).data('fileupload'),
                     template,
                     deferred;
+                if (data.maxNumberOfFilesAdjusted) {
+                    that._adjustMaxNumberOfFiles(data.files.length);
+                }
                 if (data.context) {
                     data.context.each(function (index) {
                         if (data.errorThrown !== 'abort') {
@@ -295,12 +323,6 @@
                     }
                 );
             },
-            processstart: function () {
-                $(this).addClass('fileupload-processing');
-            },
-            processstop: function () {
-                $(this).removeClass('fileupload-processing');
-            },
             // Callback for file deletion:
             destroy: function (e, data) {
                 var that = $(this).data('blueimp-fileupload') ||
@@ -310,6 +332,7 @@
                         that._transition(data.context).done(
                             function () {
                                 $(this).remove();
+                                that._adjustMaxNumberOfFiles(1);
                                 that._trigger('destroyed', e, data);
                             }
                         );
@@ -334,6 +357,13 @@
             return this._finishedUploads;
         },
 
+        _getFilesFromResponse: function (data) {
+            if (data.result && $.isArray(data.result.files)) {
+                return data.result.files;
+            }
+            return [];
+        },
+
         // Link handler, that allows to download files
         // by drag & drop of the links to the desktop:
         _enableDragToDesktop: function () {
@@ -347,10 +377,21 @@
                         'DownloadURL',
                         [type, name, url].join(':')
                     );
-                } catch (ignore) {}
+                } catch (err) {}
             });
         },
 
+        _adjustMaxNumberOfFiles: function (operand) {
+            if (typeof this.options.maxNumberOfFiles === 'number') {
+                this.options.maxNumberOfFiles += operand;
+                if (this.options.maxNumberOfFiles < 1) {
+                    this._disableFileInputButton();
+                } else {
+                    this._enableFileInputButton();
+                }
+            }
+        },
+
         _formatFileSize: function (bytes) {
             if (typeof bytes !== 'number') {
                 return '';
@@ -406,6 +447,46 @@
                 this._formatFileSize(data.total);
         },
 
+        _hasError: function (file) {
+            if (file.error) {
+                return file.error;
+            }
+            // The number of added files is subtracted from
+            // maxNumberOfFiles before validation, so we check if
+            // maxNumberOfFiles is below 0 (instead of below 1):
+            if (this.options.maxNumberOfFiles < 0) {
+                return 'Maximum number of files exceeded';
+            }
+            // Files are accepted if either the file type or the file name
+            // matches against the acceptFileTypes regular expression, as
+            // only browsers with support for the File API report the type:
+            if (!(this.options.acceptFileTypes.test(file.type) ||
+                    this.options.acceptFileTypes.test(file.name))) {
+                return 'Filetype not allowed';
+            }
+            if (this.options.maxFileSize &&
+                    file.size > this.options.maxFileSize) {
+                return 'File is too big';
+            }
+            if (typeof file.size === 'number' &&
+                    file.size < this.options.minFileSize) {
+                return 'File is too small';
+            }
+            return null;
+        },
+
+        _validate: function (files) {
+            var that = this,
+                valid = !!files.length;
+            $.each(files, function (index, file) {
+                file.error = that._hasError(file);
+                if (file.error) {
+                    valid = false;
+                }
+            });
+            return valid;
+        },
+
         _renderTemplate: function (func, files) {
             if (!func) {
                 return $();
@@ -421,10 +502,63 @@
             return $(this.options.templatesContainer).html(result).children();
         },
 
+        _renderPreview: function (file, node) {
+            var that = this,
+                options = this.options,
+                dfd = $.Deferred();
+            return ((loadImage && loadImage(
+                file,
+                function (img) {
+                    node.append(img);
+                    that._forceReflow(node);
+                    that._transition(node).done(function () {
+                        dfd.resolveWith(node);
+                    });
+                    if (!$.contains(that.document[0].body, node[0])) {
+                        // If the element is not part of the DOM,
+                        // transition events are not triggered,
+                        // so we have to resolve manually:
+                        dfd.resolveWith(node);
+                    }
+                    node.on('remove', function () {
+                        // If the element is removed before the
+                        // transition finishes, transition events are
+                        // not triggered, resolve manually:
+                        dfd.resolveWith(node);
+                    });
+                },
+                {
+                    maxWidth: options.previewMaxWidth,
+                    maxHeight: options.previewMaxHeight,
+                    canvas: options.previewAsCanvas
+                }
+            )) || dfd.resolveWith(node)) && dfd;
+        },
+
         _renderPreviews: function (data) {
-            data.context.find('.preview').each(function (index, elm) {
-                $(elm).append(data.files[index].preview);
+            var that = this,
+                options = this.options;
+            data.context.find('.preview span').each(function (index, element) {
+                var file = data.files[index];
+                if (options.previewSourceFileTypes.test(file.type) &&
+                        ($.type(options.previewSourceMaxFileSize) !== 'number' ||
+                        file.size < options.previewSourceMaxFileSize)) {
+                    that._processingQueue = that._processingQueue.pipe(function () {
+                        var dfd = $.Deferred(),
+                            ev = $.Event('previewdone', {
+                                target: element
+                            });
+                        that._renderPreview(file, $(element)).done(
+                            function () {
+                                that._trigger(ev.type, ev, data);
+                                dfd.resolveWith(that);
+                            }
+                        );
+                        return dfd.promise();
+                    });
+                }
             });
+            return this._processingQueue;
         },
 
         _renderUpload: function (files) {
@@ -435,6 +569,7 @@
         },
 
         _renderDownload: function (files) {
+            console.log(files);
             return this._renderTemplate(
                 this.options.downloadTemplate,
                 files
@@ -597,14 +732,54 @@
             }
         },
 
+        _stringToRegExp: function (str) {
+            var parts = str.split('/'),
+                modifiers = parts.pop();
+            parts.shift();
+            return new RegExp(parts.join('/'), modifiers);
+        },
+
+        _initRegExpOptions: function () {
+            var options = this.options;
+            if ($.type(options.acceptFileTypes) === 'string') {
+                options.acceptFileTypes = this._stringToRegExp(
+                    options.acceptFileTypes
+                );
+            }
+            if ($.type(options.previewSourceFileTypes) === 'string') {
+                options.previewSourceFileTypes = this._stringToRegExp(
+                    options.previewSourceFileTypes
+                );
+            }
+        },
+
         _initSpecialOptions: function () {
             this._super();
             this._initFilesContainer();
             this._initTemplates();
+            this._initRegExpOptions();
+        },
+
+        _setOption: function (key, value) {
+            this._super(key, value);
+            if (key === 'maxNumberOfFiles') {
+                this._adjustMaxNumberOfFiles(0);
+            }
         },
 
         _create: function () {
             this._super();
+            this._refreshOptionsList.push(
+                'filesContainer',
+                'uploadTemplateId',
+                'downloadTemplateId'
+            );
+            if (!this._processingQueue) {
+                this._processingQueue = $.Deferred().resolveWith(this).promise();
+                this.process = function () {
+                    return this._processingQueue;
+                };
+            }
             this._resetFinishedDeferreds();
         },