s3_cors_fileupload 0.2.0 → 0.2.1

data/lib/generators/s3_cors_fileupload/install/templates/views/haml/index.html.haml

@@ -1,4 +1,4 @@
-= stylesheet_link_tag '//netdna.bootstrapcdn.com/twitter-bootstrap/2.3.1/css/bootstrap-combined.min.css'
+= stylesheet_link_tag '//netdna.bootstrapcdn.com/twitter-bootstrap/2.3.2/css/bootstrap-combined.min.css'
 
 %div{:style => 'padding: 10px;'}
   %h2 Upload file(s)

data/lib/s3_cors_fileupload/rails/form_helper.rb

@@ -51,39 +51,41 @@ module S3CorsFileupload
         <!-- The fileupload-buttonbar contains buttons to add/delete files and start/cancel the upload -->  
         <div class='row fileupload-buttonbar'>
           <div class='span7'>
-            <button class='btn btn-success fileinput-button'>
+            <span class='btn btn-success fileinput-button'>
               <i class='icon-plus icon-white'></i>
               <span>Add files...</span>
               ".html_safe +
               file_field_tag(:file, :multiple => true) + "
-            </button>
-            <button class='btn btn-primary start' type='submit'>
+            </span>
+            <button type='submit' class='btn btn-primary start'>
               <i class='icon-upload icon-white'></i>
               <span>Start upload</span>
             </button>
-            <button class='btn btn-warning cancel' type='reset'>
+            <button type='reset' class='btn btn-warning cancel'>
               <i class='icon-ban-circle icon-white'></i>
               <span>Cancel upload</span>
             </button>
-            <button class='btn btn-danger delete' type='button'>
+            <button type='button' class='btn btn-danger delete'>
               <i class='icon-trash icon-white'></i>
               <span>Delete</span>
             </button>
-            <input class='toggle' type='checkbox'></input>
+            <input type='checkbox' class='toggle'></input>
+            <!-- The loading indicator is shown during file processing -->
+	          <span class='fileupload-loading'></span>
           </div>
-          <div class='span5'>
+          <!-- The global progress information -->
+          <div class='span5 fileupload-progress fade'>
             <!-- The global progress bar -->
-            <div class='progress progress-success progress-striped active fade'>
-              <div class='bar' style='width: 0%'></div>
+            <div class='progress progress-success progress-striped active' role='progressbar' aria-valuemin='0' aria-valuemax='100'>
+              <div class='bar' style='width: 0%;'></div>
             </div>
+            <!-- The extended global progress information -->
+            <div class='progress-extended'>&nbsp;</div>
           </div>
         </div>
-        <!-- The loading indicator is shown during image processing -->
-        <div class='fileupload-loading'></div>
-        <br>
         <!-- The table listing the files available for upload/download -->
-        <table class='table table-striped' id='upload_files'>
-          <tbody class='files' data-target='#modal-gallery' data-toggle='modal-gallery'></tbody>
+        <table role='presentation' class='table table-striped' id='upload_files'>
+          <tbody class='files'></tbody>
         </table>".html_safe + (block ? capture(&block) : '')
       end
     end

data/lib/s3_cors_fileupload/version.rb

@@ -1,5 +1,5 @@
 module S3CorsFileupload
-  VERSION = '0.2.0'
-  JQUERY_FILEUPLOAD_VERSION = '5.26'
-  JQUERY_FILEUPLOAD_UI_VERSION = '7.4.1'
+  VERSION = '0.2.1'
+  JQUERY_FILEUPLOAD_VERSION = '5.32.0'
+  JQUERY_FILEUPLOAD_UI_VERSION = '8.5.0'
 end

data/vendor/assets/javascripts/s3_cors_fileupload/index.js

@@ -3,4 +3,7 @@
 //= require s3_cors_fileupload/vendor/load-image
 //= require s3_cors_fileupload/jquery.iframe-transport
 //= require s3_cors_fileupload/jquery.fileupload
-//= require s3_cors_fileupload/jquery.fileupload-ui
+//= require s3_cors_fileupload/jquery.fileupload-process
+//= require s3_cors_fileupload/jquery.fileupload-image
+//= require s3_cors_fileupload/jquery.fileupload-validate
+//= require s3_cors_fileupload/jquery.fileupload-ui

data/vendor/assets/javascripts/s3_cors_fileupload/jquery.fileupload-image.js

@@ -0,0 +1,213 @@
+/*
+ * jQuery File Upload Image Preview & Resize Plugin 1.0
+ * https://github.com/blueimp/jQuery-File-Upload
+ *
+ * Copyright 2013, Sebastian Tschan
+ * https://blueimp.net
+ *
+ * Licensed under the MIT license:
+ * http://www.opensource.org/licenses/MIT
+ */
+
+/*jslint nomen: true, unparam: true, regexp: true */
+/*global define, window */
+
+(function (factory) {
+    'use strict';
+    if (typeof define === 'function' && define.amd) {
+        // Register as an anonymous AMD module:
+        define([
+            'jquery',
+            'load-image',
+            'canvas-to-blob',
+            './jquery.fileupload-process'
+        ], factory);
+    } else {
+        // Browser globals:
+        factory(
+            window.jQuery,
+            window.loadImage
+        );
+    }
+}(function ($, loadImage) {
+    'use strict';
+
+    // Prepend to the default processQueue:
+    $.blueimp.fileupload.prototype.options.processQueue.unshift(
+        {
+            action: 'loadImage',
+            // Always trigger this action,
+            // even if the previous action was rejected: 
+            always: true,
+            fileTypes: '@loadImageFileTypes',
+            maxFileSize: '@loadImageMaxFileSize',
+            noRevoke: '@loadImageNoRevoke',
+            disabled: '@disableImageLoad'
+        },
+        {
+            action: 'resizeImage',
+            maxWidth: '@imageMaxWidth',
+            maxHeight: '@imageMaxHeight',
+            minWidth: '@imageMinWidth',
+            minHeight: '@imageMinHeight',
+            crop: '@imageCrop',
+            disabled: '@disableImageResize'
+        },
+        {
+            action: 'saveImage',
+            disabled: '@disableImageResize'
+        },
+        {
+            action: 'resizeImage',
+            maxWidth: '@previewMaxWidth',
+            maxHeight: '@previewMaxHeight',
+            minWidth: '@previewMinWidth',
+            minHeight: '@previewMinHeight',
+            crop: '@previewCrop',
+            canvas: '@previewAsCanvas',
+            disabled: '@disableImagePreview'
+        },
+        {
+            action: 'setImage',
+            name: '@imagePreviewName',
+            disabled: '@disableImagePreview'
+        }
+    );
+
+    // The File Upload Resize plugin extends the fileupload widget
+    // with image resize functionality:
+    $.widget('blueimp.fileupload', $.blueimp.fileupload, {
+
+        options: {
+            // The regular expression for the types of images to load:
+            // matched against the file type:
+            loadImageFileTypes: /^image\/(gif|jpeg|png)$/,
+            // The maximum file size of images to load:
+            loadImageMaxFileSize: 5000000, // 5MB
+            // The maximum width of resized images:
+            imageMaxWidth: 1920,
+            // The maximum height of resized images:
+            imageMaxHeight: 1080,
+            // Define if resized images should be cropped or only scaled:
+            imageCrop: false,
+            // Disable the resize image functionality by default:
+            disableImageResize: true,
+            // The maximum width of the preview images:
+            previewMaxWidth: 80,
+            // The maximum height of the preview images:
+            previewMaxHeight: 80,
+            // Define if preview images should be cropped or only scaled:
+            previewCrop: false,
+            // Define if preview images should be resized as canvas elements:
+            previewAsCanvas: true
+        },
+
+        processActions: {
+
+            // Loads the image given via data.files and data.index
+            // as img element if the browser supports canvas.
+            // Accepts the options fileTypes (regular expression)
+            // and maxFileSize (integer) to limit the files to load:
+            loadImage: function (data, options) {
+                if (options.disabled) {
+                    return data;
+                }
+                var that = this,
+                    file = data.files[data.index],
+                    dfd = $.Deferred();
+                if (($.type(options.maxFileSize) === 'number' &&
+                            file.size > options.maxFileSize) ||
+                        (options.fileTypes &&
+                            !options.fileTypes.test(file.type)) ||
+                        !loadImage(
+                            file,
+                            function (img) {
+                                if (!img.src) {
+                                    return dfd.rejectWith(that, [data]);
+                                }
+                                data.img = img;
+                                dfd.resolveWith(that, [data]);
+                            },
+                            options
+                        )) {
+                    dfd.rejectWith(that, [data]);
+                }
+                return dfd.promise();
+            },
+
+            // Resizes the image given as data.canvas or data.img
+            // and updates data.canvas or data.img with the resized image.
+            // Accepts the options maxWidth, maxHeight, minWidth,
+            // minHeight, canvas and crop:
+            resizeImage: function (data, options) {
+                options = $.extend({canvas: true}, options);
+                var img = (options.canvas && data.canvas) || data.img,
+                    canvas;
+                if (img && !options.disabled) {
+                    canvas = loadImage.scale(img, options);
+                    if (canvas && (canvas.width !== img.width ||
+                            canvas.height !== img.height)) {
+                        data[canvas.getContext ? 'canvas' : 'img'] = canvas;
+                    }
+                }
+                return data;
+            },
+
+            // Saves the processed image given as data.canvas
+            // inplace at data.index of data.files:
+            saveImage: function (data, options) {
+                if (!data.canvas || options.disabled) {
+                    return data;
+                }
+                var that = this,
+                    file = data.files[data.index],
+                    name = file.name,
+                    dfd = $.Deferred(),
+                    callback = function (blob) {
+                        if (!blob.name) {
+                            if (file.type === blob.type) {
+                                blob.name = file.name;
+                            } else if (file.name) {
+                                blob.name = file.name.replace(
+                                    /\..+$/,
+                                    '.' + blob.type.substr(6)
+                                );
+                            }
+                        }
+                        // Store the created blob at the position
+                        // of the original file in the files list:
+                        data.files[data.index] = blob;
+                        dfd.resolveWith(that, [data]);
+                    };
+                // Use canvas.mozGetAsFile directly, to retain the filename, as
+                // Gecko doesn't support the filename option for FormData.append:
+                if (data.canvas.mozGetAsFile) {
+                    callback(data.canvas.mozGetAsFile(
+                        (/^image\/(jpeg|png)$/.test(file.type) && name) ||
+                            ((name && name.replace(/\..+$/, '')) ||
+                                'blob') + '.png',
+                        file.type
+                    ));
+                } else if (data.canvas.toBlob) {
+                    data.canvas.toBlob(callback, file.type);
+                } else {
+                    return data;
+                }
+                return dfd.promise();
+            },
+
+            // Sets the resized version of the image as a property of the
+            // file object, must be called after "saveImage":
+            setImage: function (data, options) {
+                var img = data.canvas || data.img;
+                if (img && !options.disabled) {
+                    data.files[data.index][options.name || 'preview'] = img;
+                }
+                return data;
+            }
+
+        }
+
+    });
+
+}));

data/vendor/assets/javascripts/s3_cors_fileupload/jquery.fileupload-process.js

@@ -0,0 +1,164 @@
+/*
+ * jQuery File Upload Processing Plugin 1.2.2
+ * https://github.com/blueimp/jQuery-File-Upload
+ *
+ * Copyright 2012, Sebastian Tschan
+ * https://blueimp.net
+ *
+ * Licensed under the MIT license:
+ * http://www.opensource.org/licenses/MIT
+ */
+
+/*jslint nomen: true, unparam: true */
+/*global define, window */
+
+(function (factory) {
+    'use strict';
+    if (typeof define === 'function' && define.amd) {
+        // Register as an anonymous AMD module:
+        define([
+            'jquery',
+            './jquery.fileupload'
+        ], factory);
+    } else {
+        // Browser globals:
+        factory(
+            window.jQuery
+        );
+    }
+}(function ($) {
+    'use strict';
+
+    var originalAdd = $.blueimp.fileupload.prototype.options.add;
+
+    // The File Upload Processing plugin extends the fileupload widget
+    // with file processing functionality:
+    $.widget('blueimp.fileupload', $.blueimp.fileupload, {
+
+        options: {
+            // The list of processing actions:
+            processQueue: [
+                /*
+                {
+                    action: 'log',
+                    type: 'debug'
+                }
+                */
+            ],
+            add: function (e, data) {
+                var $this = $(this);
+                data.process(function () {
+                    return $this.fileupload('process', data);
+                });
+                originalAdd.call(this, e, data);
+            }
+        },
+
+        processActions: {
+            /*
+            log: function (data, options) {
+                console[options.type](
+                    'Processing "' + data.files[data.index].name + '"'
+                );
+            }
+            */
+        },
+
+        _processFile: function (data) {
+            var that = this,
+                dfd = $.Deferred().resolveWith(that, [data]),
+                chain = dfd.promise();
+            this._trigger('process', null, data);
+            $.each(data.processQueue, function (i, settings) {
+                var func = function (data) {
+                    return that.processActions[settings.action].call(
+                        that,
+                        data,
+                        settings
+                    );
+                };
+                chain = chain.pipe(func, settings.always && func);
+            });
+            chain
+                .done(function () {
+                    that._trigger('processdone', null, data);
+                    that._trigger('processalways', null, data);
+                })
+                .fail(function () {
+                    that._trigger('processfail', null, data);
+                    that._trigger('processalways', null, data);
+                });
+            return chain;
+        },
+
+        // Replaces the settings of each processQueue item that
+        // are strings starting with an "@", using the remaining
+        // substring as key for the option map,
+        // e.g. "@autoUpload" is replaced with options.autoUpload:
+        _transformProcessQueue: function (options) {
+            var processQueue = [];
+            $.each(options.processQueue, function () {
+                var settings = {},
+                    action = this.action,
+                    prefix = this.prefix === true ? action : this.prefix;
+                $.each(this, function (key, value) {
+                    if ($.type(value) === 'string' &&
+                            value.charAt(0) === '@') {
+                        settings[key] = options[
+                            value.slice(1) || (prefix ? prefix +
+                                key.charAt(0).toUpperCase() + key.slice(1) : key)
+                        ];
+                    } else {
+                        settings[key] = value;
+                    }
+
+                });
+                processQueue.push(settings);
+            });
+            options.processQueue = processQueue;
+        },
+
+        // Returns the number of files currently in the processsing queue:
+        processing: function () {
+            return this._processing;
+        },
+
+        // Processes the files given as files property of the data parameter,
+        // returns a Promise object that allows to bind callbacks:
+        process: function (data) {
+            var that = this,
+                options = $.extend({}, this.options, data);
+            if (options.processQueue && options.processQueue.length) {
+                this._transformProcessQueue(options);
+                if (this._processing === 0) {
+                    this._trigger('processstart');
+                }
+                $.each(data.files, function (index) {
+                    var opts = index ? $.extend({}, options) : options,
+                        func = function () {
+                            return that._processFile(opts);
+                        };
+                    opts.index = index;
+                    that._processing += 1;
+                    that._processingQueue = that._processingQueue.pipe(func, func)
+                        .always(function () {
+                            that._processing -= 1;
+                            if (that._processing === 0) {
+                                that._trigger('processstop');
+                            }
+                        });
+                });
+            }
+            return this._processingQueue;
+        },
+
+        _create: function () {
+            this._super();
+            this._processing = 0;
+            this._processingQueue = $.Deferred().resolveWith(this)
+                .promise();
+        }
+
+    });
+
+}));