Added missing dependencies

Author: shinzui

vendor/assets/javascripts/jquery-fileupload/index.js

@@ -1,4 +1,7 @@
 //=require jquery-fileupload/vendor/jquery.ui.widget
+//=require jquery-fileupload/vendor/load-image
+//=require jquery-fileupload/vendor/canvas-to-blob
+//=require jquery-fileupload/vendor/tmpl
 //=require jquery-fileupload/jquery.iframe-transport
 //=require jquery-fileupload/jquery.fileupload
 //=require jquery-fileupload/jquery.fileupload-ip

vendor/assets/javascripts/jquery-fileupload/vendor/canvas-to-blob.js

@@ -0,0 +1,85 @@
+/*
+ * JavaScript Canvas to Blob 1.0.1
+ * https://github.com/blueimp/JavaScript-Canvas-to-Blob
+ *
+ * Copyright 2012, Sebastian Tschan
+ * https://blueimp.net
+ *
+ * Licensed under the MIT license:
+ * http://www.opensource.org/licenses/MIT
+ *
+ * Based on stackoverflow user Stoive's code snippet:
+ * http://stackoverflow.com/q/4998908
+ */
+
+/*jslint nomen: true, regexp: true */
+/*global window, atob, ArrayBuffer, Uint8Array, define */
+
+(function ($) {
+    'use strict';
+
+    var BlobBuilder = window.MozBlobBuilder ||
+            window.WebKitBlobBuilder || window.BlobBuilder,
+        blobTypes = /^image\/(jpeg|png)$/,
+
+        // Converts a canvas element to a Blob or File object:
+        canvasToBlob = function (canvas, callback, options) {
+            options = options || {};
+            if (canvas.toBlob) {
+                canvas.toBlob(callback, options.type);
+                return true;
+            } else if (canvas.mozGetAsFile) {
+                var name = options.name;
+                callback(canvas.mozGetAsFile(
+                    (blobTypes.test(options.type) && name) ||
+                        ((name && name.replace(/\..+$/, '')) || 'blob') + '.png',
+                    options.type
+                ));
+                return true;
+            } else if (canvas.toDataURL && BlobBuilder && window.atob &&
+                    window.ArrayBuffer && window.Uint8Array) {
+                callback(canvasToBlob.dataURItoBlob(
+                    canvas.toDataURL(options.type)
+                ));
+                return true;
+            }
+            return false;
+        };
+
+    // Converts a dataURI to a Blob:
+    canvasToBlob.dataURItoBlob = function (dataURI) {
+        var byteString,
+            arrayBuffer,
+            intArray,
+            i,
+            bb,
+            mimeString;
+        if (dataURI.split(',')[0].indexOf('base64') >= 0) {
+            // Convert base64 to raw binary data held in a string:
+            byteString = atob(dataURI.split(',')[1]);
+        } else {
+            // Convert base64/URLEncoded data component to raw binary data:
+            byteString = decodeURIComponent(dataURI.split(',')[1]);
+        }
+        // Write the bytes of the string to an ArrayBuffer:
+        arrayBuffer = new ArrayBuffer(byteString.length);
+        intArray = new Uint8Array(arrayBuffer);
+        for (i = 0; i < byteString.length; i += 1) {
+            intArray[i] = byteString.charCodeAt(i);
+        }
+        // Write the ArrayBuffer to a blob:
+        bb = new BlobBuilder();
+        bb.append(arrayBuffer);
+        // Separate out the mime component:
+        mimeString = dataURI.split(',')[0].split(':')[1].split(';')[0];
+        return bb.getBlob(mimeString);
+    };
+
+    if (typeof define !== 'undefined' && define.amd) {
+        define(function () {
+            return canvasToBlob;
+        });
+    } else {
+        $.canvasToBlob = canvasToBlob;
+    }
+}(this));

vendor/assets/javascripts/jquery-fileupload/vendor/load-image.js

@@ -0,0 +1,114 @@
+/*
+ * JavaScript Load Image 1.1.4
+ * https://github.com/blueimp/JavaScript-Load-Image
+ *
+ * Copyright 2011, Sebastian Tschan
+ * https://blueimp.net
+ *
+ * Licensed under the MIT license:
+ * http://www.opensource.org/licenses/MIT
+ */
+
+/*jslint nomen: true */
+/*global window, document, URL, webkitURL, Blob, File, FileReader, define */
+
+(function ($) {
+    'use strict';
+
+    // Loads an image for a given File object.
+    // Invokes the callback with an img or optional canvas
+    // element (if supported by the browser) as parameter:
+    var loadImage = function (file, callback, options) {
+            var img = document.createElement('img'),
+                url,
+                oUrl;
+            img.onerror = callback;
+            img.onload = function () {
+                if (oUrl) {
+                    loadImage.revokeObjectURL(oUrl);
+                }
+                callback(loadImage.scale(img, options));
+            };
+            if ((window.Blob && file instanceof Blob) ||
+                // Files are also Blob instances, but some browsers
+                // (Firefox 3.6) support the File API but not Blobs:
+                    (window.File && file instanceof File)) {
+                url = oUrl = loadImage.createObjectURL(file);
+            } else {
+                url = file;
+            }
+            if (url) {
+                img.src = url;
+                return img;
+            } else {
+                return loadImage.readFile(file, function (url) {
+                    img.src = url;
+                });
+            }
+        },
+        urlAPI = (window.createObjectURL && window) ||
+            (window.URL && URL) || (window.webkitURL && webkitURL);
+
+    // Scales the given image (img HTML element)
+    // using the given options.
+    // Returns a canvas object if the canvas option is true
+    // and the browser supports canvas, else the scaled image:
+    loadImage.scale = function (img, options) {
+        options = options || {};
+        var canvas = document.createElement('canvas'),
+            scale = Math.max(
+                (options.minWidth || img.width) / img.width,
+                (options.minHeight || img.height) / img.height
+            );
+        if (scale > 1) {
+            img.width = parseInt(img.width * scale, 10);
+            img.height = parseInt(img.height * scale, 10);
+        }
+        scale = Math.min(
+            (options.maxWidth || img.width) / img.width,
+            (options.maxHeight || img.height) / img.height
+        );
+        if (scale < 1) {
+            img.width = parseInt(img.width * scale, 10);
+            img.height = parseInt(img.height * scale, 10);
+        }
+        if (!options.canvas || !canvas.getContext) {
+            return img;
+        }
+        canvas.width = img.width;
+        canvas.height = img.height;
+        canvas.getContext('2d')
+            .drawImage(img, 0, 0, img.width, img.height);
+        return canvas;
+    };
+
+    loadImage.createObjectURL = function (file) {
+        return urlAPI ? urlAPI.createObjectURL(file) : false;
+    };
+
+    loadImage.revokeObjectURL = function (url) {
+        return urlAPI ? urlAPI.revokeObjectURL(url) : false;
+    };
+
+    // Loads a given File object via FileReader interface,
+    // invokes the callback with a data url:
+    loadImage.readFile = function (file, callback) {
+        if (window.FileReader && FileReader.prototype.readAsDataURL) {
+            var fileReader = new FileReader();
+            fileReader.onload = function (e) {
+                callback(e.target.result);
+            };
+            fileReader.readAsDataURL(file);
+            return fileReader;
+        }
+        return false;
+    };
+
+    if (typeof define !== 'undefined' && define.amd) {
+        define(function () {
+            return loadImage;
+        });
+    } else {
+        $.loadImage = loadImage;
+    }
+}(this));

vendor/assets/javascripts/jquery-fileupload/vendor/tmpl.js

@@ -0,0 +1,86 @@
+/*
+ * JavaScript Templates 2.1.0
+ * https://github.com/blueimp/JavaScript-Templates
+ *
+ * Copyright 2011, Sebastian Tschan
+ * https://blueimp.net
+ *
+ * Licensed under the MIT license:
+ * http://www.opensource.org/licenses/MIT
+ *
+ * Inspired by John Resig's JavaScript Micro-Templating:
+ * http://ejohn.org/blog/javascript-micro-templating/
+ */
+
+/*jslint evil: true, regexp: true */
+/*global document, define */
+
+(function ($) {
+    "use strict";
+    var tmpl = function (str, data) {
+        var f = !/[^\w\-\.:]/.test(str) ? tmpl.cache[str] = tmpl.cache[str] ||
+                tmpl(tmpl.load(str)) :
+                    new Function(
+                        tmpl.arg + ',tmpl',
+                        "var _e=tmpl.encode" + tmpl.helper + ",_s='" +
+                            str.replace(tmpl.regexp, tmpl.func) +
+                            "';return _s;"
+                    );
+        return data ? f(data, tmpl) : function (data) {
+            return f(data, tmpl);
+        };
+    };
+    tmpl.cache = {};
+    tmpl.load = function (id) {
+        return document.getElementById(id).innerHTML;
+    };
+    tmpl.regexp = /([\s'\\])(?![^%]*%\})|(?:\{%(=|#)([\s\S]+?)%\})|(\{%)|(%\})/g;
+    tmpl.func = function (s, p1, p2, p3, p4, p5) {
+        if (p1) { // whitespace, quote and backspace in interpolation context
+            return {
+                "\n": "\\n",
+                "\r": "\\r",
+                "\t": "\\t",
+                " " : " "
+            }[s] || "\\" + s;
+        }
+        if (p2) { // interpolation: {%=prop%}, or unescaped: {%#prop%}
+            if (p2 === "=") {
+                return "'+_e(" + p3 + ")+'";
+            }
+            return "'+(" + p3 + "||'')+'";
+        }
+        if (p4) { // evaluation start tag: {%
+            return "';";
+        }
+        if (p5) { // evaluation end tag: %}
+            return "_s+='";
+        }
+    };
+    tmpl.encReg = /[<>&"'\x00]/g;
+    tmpl.encMap = {
+        "<"   : "&lt;",
+        ">"   : "&gt;",
+        "&"   : "&amp;",
+        "\""  : "&quot;",
+        "'"   : "&#39;"
+    };
+    tmpl.encode = function (s) {
+        return String(s || "").replace(
+            tmpl.encReg,
+            function (c) {
+                return tmpl.encMap[c] || "";
+            }
+        );
+    };
+    tmpl.arg = "o";
+    tmpl.helper = ",print=function(s,e){_s+=e&&(s||'')||_e(s);}" +
+        ",include=function(s,d){_s+=tmpl(s,d);}";
+    if (typeof define === "function" && define.amd) {
+        define(function () {
+            return tmpl;
+        });
+    } else {
+        $.tmpl = tmpl;
+    }
+}(this));