jquery.fileupload-rails 1.0.0.alpha → 1.0.0.beta

data/demo/public/robots.txt

@@ -0,0 +1,5 @@
+# See http://www.robotstxt.org/wc/norobots.html for documentation on how to use the robots.txt file
+#
+# To ban all spiders from the entire site uncomment the next two lines:
+# User-Agent: *
+# Disallow: /

data/demo/script/rails

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# This command will automatically be run when you run "rails" with Rails 3 gems installed from the root of your application.
+
+APP_PATH = File.expand_path('../../config/application',  __FILE__)
+require File.expand_path('../../config/boot',  __FILE__)
+require 'rails/commands'

data/demo/test/performance/browsing_test.rb

@@ -0,0 +1,12 @@
+require 'test_helper'
+require 'rails/performance_test_help'
+
+class BrowsingTest < ActionDispatch::PerformanceTest
+  # Refer to the documentation for all available options
+  # self.profile_options = { :runs => 5, :metrics => [:wall_time, :memory]
+  #                          :output => 'tmp/performance', :formats => [:flat] }
+
+  def test_homepage
+    get '/'
+  end
+end

data/demo/test/test_helper.rb

@@ -0,0 +1,13 @@
+ENV["RAILS_ENV"] = "test"
+require File.expand_path('../../config/environment', __FILE__)
+require 'rails/test_help'
+
+class ActiveSupport::TestCase
+  # Setup all fixtures in test/fixtures/*.(yml|csv) for all tests in alphabetical order.
+  #
+  # Note: You'll currently still have to declare fixtures explicitly in integration tests
+  # -- they do not yet inherit this setting
+  fixtures :all
+
+  # Add more helper methods to be used by all tests here...
+end

data/lib/jquery.fileupload-rails.rb

@@ -1,11 +1,10 @@
 require "jquery.fileupload-rails/version"
+require "jquery-ui-rails"
 
 module JqueryFileUpload
   module Rails
-    if defined?(::Rails) and ::Rails.version >= "3.1"
-			class Rails::Engine < ::Rails::Engine
-				# this class enables the asset pipeline
-			end
+		class Rails::Engine < ::Rails::Engine
+      paths['vendor/assets'] << 'vendor/legacy_assets'
 		end
   end
 end

data/lib/jquery.fileupload-rails/version.rb

@@ -1,5 +1,5 @@
 module JqueryFileUpload
   module Rails
-    VERSION = "1.0.0.alpha"
+    VERSION = "1.0.0.beta"
   end
 end

data/vendor/assets/javascripts/jquery.fileupload.js

@@ -2,7 +2,7 @@
 //= require jquery.iframe-transport
 
 /*
- * jQuery File Upload Plugin 5.17.2
+ * jQuery File Upload Plugin 5.17.6
  * https://github.com/blueimp/jQuery-File-Upload
  *
  * Copyright 2010, Sebastian Tschan
@@ -506,9 +506,7 @@
                 fs = file.size,
                 ub = options.uploadedBytes = options.uploadedBytes || 0,
                 mcs = options.maxChunkSize || fs,
-                // Use the Blob methods with the slice implementation
-                // according to the W3C Blob API specification:
-                slice = file.webkitSlice || file.mozSlice || file.slice,
+                slice = file.slice || file.webkitSlice || file.mozSlice,
                 upload,
                 n,
                 jqXHR,
@@ -521,7 +519,7 @@
                 return true;
             }
             if (ub >= fs) {
-                file.error = 'uploadedBytes';
+                file.error = 'Uploaded bytes exceed file size';
                 return this._getXHRPromise(
                     false,
                     options.context,
@@ -809,10 +807,16 @@
                 dirReader;
             path = path || '';
             if (entry.isFile) {
-                entry.file(function (file) {
-                    file.relativePath = path;
-                    dfd.resolve(file);
-                }, errorHandler);
+                if (entry._file) {
+                    // Workaround for Chrome bug #149735
+                    entry._file.relativePath = path;
+                    dfd.resolve(entry._file);
+                } else {
+                    entry.file(function (file) {
+                        file.relativePath = path;
+                        dfd.resolve(file);
+                    }, errorHandler);
+                }
             } else if (entry.isDirectory) {
                 dirReader = entry.createReader();
                 dirReader.readEntries(function (entries) {
@@ -853,8 +857,12 @@
                     items[0].getAsEntry)) {
                 return this._handleFileTreeEntries(
                     $.map(items, function (item) {
+                        var entry;
                         if (item.webkitGetAsEntry) {
-                            return item.webkitGetAsEntry();
+                            entry = item.webkitGetAsEntry();
+                            // Workaround for Chrome bug #149735:
+                            entry._file = item.getAsFile();
+                            return entry;
                         }
                         return item.getAsEntry();
                     })

data/vendor/legacy_assets/javascripts/jquery.fileupload-fp.js

@@ -0,0 +1,219 @@
+/*
+ * jQuery File Upload File Processing Plugin 1.0
+ * 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, regexp: true */
+/*global define, window, document */
+
+(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'
+        ], factory);
+    } else {
+        // Browser globals:
+        factory(
+            window.jQuery,
+            window.loadImage
+        );
+    }
+}(function ($, loadImage) {
+    'use strict';
+
+    // The File Upload IP version extends the basic fileupload widget
+    // with file processing functionality:
+    $.widget('blueimpFP.fileupload', $.blueimp.fileupload, {
+
+        options: {
+            // The list of file processing actions:
+            process: [
+            /*
+                {
+                    action: 'load',
+                    fileTypes: /^image\/(gif|jpeg|png)$/,
+                    maxFileSize: 20000000 // 20MB
+                },
+                {
+                    action: 'resize',
+                    maxWidth: 1920,
+                    maxHeight: 1200,
+                    minWidth: 800,
+                    minHeight: 600
+                },
+                {
+                    action: 'save'
+                }
+            */
+            ],
+
+            // 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) {
+                $(this).fileupload('process', data).done(function () {
+                    data.submit();
+                });
+            }
+        },
+
+        processActions: {
+            // Loads the image given via data.files and data.index
+            // as canvas element.
+            // Accepts the options fileTypes (regular expression)
+            // and maxFileSize (integer) to limit the files to load:
+            load: function (data, options) {
+                var that = this,
+                    file = data.files[data.index],
+                    dfd = $.Deferred();
+                if (window.HTMLCanvasElement &&
+                        window.HTMLCanvasElement.prototype.toBlob &&
+                        ($.type(options.maxFileSize) !== 'number' ||
+                            file.size < options.maxFileSize) &&
+                        (!options.fileTypes ||
+                            options.fileTypes.test(file.type))) {
+                    loadImage(
+                        file,
+                        function (canvas) {
+                            data.canvas = canvas;
+                            dfd.resolveWith(that, [data]);
+                        },
+                        {canvas: true}
+                    );
+                } else {
+                    dfd.rejectWith(that, [data]);
+                }
+                return dfd.promise();
+            },
+            // Resizes the image given as data.canvas and updates
+            // data.canvas with the resized image.
+            // Accepts the options maxWidth, maxHeight, minWidth and
+            // minHeight to scale the given image:
+            resize: function (data, options) {
+                if (data.canvas) {
+                    var canvas = loadImage.scale(data.canvas, options);
+                    if (canvas.width !== data.canvas.width ||
+                            canvas.height !== data.canvas.height) {
+                        data.canvas = canvas;
+                        data.processed = true;
+                    }
+                }
+                return data;
+            },
+            // Saves the processed image given as data.canvas
+            // inplace at data.index of data.files:
+            save: function (data, options) {
+                // Do nothing if no processing has happened:
+                if (!data.canvas || !data.processed) {
+                    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 {
+                    data.canvas.toBlob(callback, file.type);
+                }
+                return dfd.promise();
+            }
+        },
+
+        // Resizes the file at the given index and stores the created blob at
+        // the original position of the files list, returns a Promise object:
+        _processFile: function (files, index, options) {
+            var that = this,
+                dfd = $.Deferred().resolveWith(that, [{
+                    files: files,
+                    index: index
+                }]),
+                chain = dfd.promise();
+            that._processing += 1;
+            $.each(options.process, function (i, settings) {
+                chain = chain.pipe(function (data) {
+                    return that.processActions[settings.action]
+                        .call(this, data, settings);
+                });
+            });
+            chain.always(function () {
+                that._processing -= 1;
+                if (that._processing === 0) {
+                    that.element
+                        .removeClass('fileupload-processing');
+                }
+            });
+            if (that._processing === 1) {
+                that.element.addClass('fileupload-processing');
+            }
+            return chain;
+        },
+
+        // Processes the files given as files property of the data parameter,
+        // returns a Promise object that allows to bind a done handler, which
+        // will be invoked after processing all files (inplace) is done:
+        process: function (data) {
+            var that = this,
+                options = $.extend({}, this.options, data);
+            if (options.process && options.process.length &&
+                    this._isXHRUpload(options)) {
+                $.each(data.files, function (index, file) {
+                    that._processingQueue = that._processingQueue.pipe(
+                        function () {
+                            var dfd = $.Deferred();
+                            that._processFile(data.files, index, options)
+                                .always(function () {
+                                    dfd.resolveWith(that);
+                                });
+                            return dfd.promise();
+                        }
+                    );
+                });
+            }
+            return this._processingQueue;
+        },
+
+        _create: function () {
+            $.blueimp.fileupload.prototype._create.call(this);
+            this._processing = 0;
+            this._processingQueue = $.Deferred().resolveWith(this)
+                .promise();
+        }
+
+    });
+
+}));

data/vendor/legacy_assets/javascripts/jquery.fileupload-ip.js

@@ -0,0 +1,160 @@
+/*
+ * jQuery File Upload Image Processing Plugin 1.0.6
+ * 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, regexp: true */
+/*global define, window, document */
+
+(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'
+        ], factory);
+    } else {
+        // Browser globals:
+        factory(
+            window.jQuery,
+            window.loadImage,
+            window.canvasToBlob
+        );
+    }
+}(function ($, loadImage, canvasToBlob) {
+    'use strict';
+
+    // The File Upload IP version extends the basic fileupload widget
+    // with image processing functionality:
+    $.widget('blueimpIP.fileupload', $.blueimp.fileupload, {
+
+        options: {
+            // The regular expression to define which image files are to be
+            // resized, given that the browser supports the operation:
+            resizeSourceFileTypes: /^image\/(gif|jpeg|png)$/,
+            // The maximum file size of images that are to be resized:
+            resizeSourceMaxFileSize: 20000000, // 20MB
+            // The maximum width of the resized images:
+            resizeMaxWidth: undefined,
+            // The maximum height of the resized images:
+            resizeMaxHeight: undefined,
+            // The minimum width of the resized images:
+            resizeMinWidth: undefined,
+            // The minimum height of the resized images:
+            resizeMinHeight: undefined,
+
+            // 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) {
+                $(this).fileupload('resize', data).done(function () {
+                    data.submit();
+                });
+            }
+        },
+
+        // Resizes the image file at the given index and stores the created blob
+        // at the original position of the files list, returns a Promise object:
+        _resizeImage: function (files, index, options) {
+            var that = this,
+                file = files[index],
+                deferred = $.Deferred(),
+                canvas,
+                blob;
+            options = options || this.options;
+            loadImage(
+                file,
+                function (img) {
+                    var width = img.width,
+                        height = img.height;
+                    canvas = loadImage.scale(img, {
+                        maxWidth: options.resizeMaxWidth,
+                        maxHeight: options.resizeMaxHeight,
+                        minWidth: options.resizeMinWidth,
+                        minHeight: options.resizeMinHeight,
+                        canvas: true
+                    });
+                    if (width !== canvas.width || height !== canvas.height) {
+                        canvasToBlob(canvas, 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)
+                                    );
+                                }
+                            }
+                            files[index] = blob;
+                            deferred.resolveWith(that);
+                        }, file);
+                    } else {
+                        deferred.resolveWith(that);
+                    }
+                }
+            );
+            return deferred.promise();
+        },
+
+        // Resizes the images given as files property of the data parameter,
+        // returns a Promise object that allows to bind a done handler, which
+        // will be invoked after processing all images is done:
+        resize: function (data) {
+            var that = this,
+                options = $.extend({}, this.options, data),
+                resizeAll = $.type(options.resizeSourceMaxFileSize) !== 'number',
+                isXHRUpload = this._isXHRUpload(options);
+            $.each(data.files, function (index, file) {
+                if (isXHRUpload && that._resizeSupport &&
+                        (options.resizeMaxWidth || options.resizeMaxHeight ||
+                            options.resizeMinWidth || options.resizeMinHeight) &&
+                        (resizeAll || file.size < options.resizeSourceMaxFileSize) &&
+                        options.resizeSourceFileTypes.test(file.type)) {
+                    that._processing += 1;
+                    if (that._processing === 1) {
+                        that.element.addClass('fileupload-processing');
+                    }
+                    that._processingQueue = that._processingQueue.pipe(function () {
+                        var deferred = $.Deferred();
+                        that._resizeImage(
+                            data.files,
+                            index,
+                            options
+                        ).done(function () {
+                            that._processing -= 1;
+                            if (that._processing === 0) {
+                                that.element
+                                    .removeClass('fileupload-processing');
+                            }
+                            deferred.resolveWith(that);
+                        });
+                        return deferred.promise();
+                    });
+                }
+            });
+            return this._processingQueue;
+        },
+
+        _create: function () {
+            $.blueimp.fileupload.prototype._create.call(this);
+            this._processing = 0;
+            this._processingQueue = $.Deferred().resolveWith(this).promise();
+            this._resizeSupport = canvasToBlob && canvasToBlob(
+                document.createElement('canvas'),
+                $.noop
+            );
+        }
+
+    });
+
+}));