fine_uploader 2.1.1 → 3.1.1

data/vendor/assets/javascripts/fine_uploader/handler.form.js

@@ -0,0 +1,202 @@
+/**
+ * Class for uploading files using form and iframe
+ * @inherits qq.UploadHandlerAbstract
+ */
+qq.UploadHandlerForm = function(o){
+    qq.UploadHandlerAbstract.apply(this, arguments);
+
+    this._inputs = {};
+    this._detach_load_events = {};
+};
+// @inherits qq.UploadHandlerAbstract
+qq.extend(qq.UploadHandlerForm.prototype, qq.UploadHandlerAbstract.prototype);
+
+qq.extend(qq.UploadHandlerForm.prototype, {
+    add: function(fileInput){
+        fileInput.setAttribute('name', this._options.inputName);
+        var id = qq.getUniqueId();
+
+        this._inputs[id] = fileInput;
+
+        // remove file input from DOM
+        if (fileInput.parentNode){
+            qq(fileInput).remove();
+        }
+
+        return id;
+    },
+    getName: function(id){
+        // get input value and remove path to normalize
+        return this._inputs[id].value.replace(/.*(\/|\\)/, "");
+    },
+    isValid: function(id) {
+        return this._inputs[id] !== undefined;
+    },
+    reset: function() {
+        qq.UploadHandlerAbstract.prototype.reset.apply(this, arguments);
+        this._inputs = {};
+        this._detach_load_events = {};
+    },
+    _cancel: function(id){
+        this._options.onCancel(id, this.getName(id));
+
+        delete this._inputs[id];
+        delete this._detach_load_events[id];
+
+        var iframe = document.getElementById(id);
+        if (iframe){
+            // to cancel request set src to something else
+            // we use src="javascript:false;" because it doesn't
+            // trigger ie6 prompt on https
+            iframe.setAttribute('src', 'javascript:false;');
+
+            qq(iframe).remove();
+        }
+    },
+    _upload: function(id){
+        this._options.onUpload(id, this.getName(id), false);
+        var input = this._inputs[id];
+
+        if (!input){
+            throw new Error('file with passed id was not added, or already uploaded or cancelled');
+        }
+
+        var fileName = this.getName(id);
+
+        var iframe = this._createIframe(id);
+        var form = this._createForm(iframe, this._options.paramsStore.getParams(id));
+        form.appendChild(input);
+
+        var self = this;
+        this._attachLoadEvent(iframe, function(){
+            self.log('iframe loaded');
+
+            var response = self._getIframeContentJSON(iframe);
+
+            // timeout added to fix busy state in FF3.6
+            setTimeout(function(){
+                self._detach_load_events[id]();
+                delete self._detach_load_events[id];
+                qq(iframe).remove();
+            }, 1);
+
+            if (!response.success) {
+                if (self._options.onAutoRetry(id, fileName, response)) {
+                    return;
+                }
+            }
+            self._options.onComplete(id, fileName, response);
+            self._dequeue(id);
+        });
+
+        this.log('Sending upload request for ' + id);
+        form.submit();
+        qq(form).remove();
+
+        return id;
+    },
+    _attachLoadEvent: function(iframe, callback){
+        var self = this;
+        this._detach_load_events[iframe.id] = qq(iframe).attach('load', function(){
+            self.log('Received response for ' + iframe.id);
+
+            // when we remove iframe from dom
+            // the request stops, but in IE load
+            // event fires
+            if (!iframe.parentNode){
+                return;
+            }
+
+            try {
+                // fixing Opera 10.53
+                if (iframe.contentDocument &&
+                    iframe.contentDocument.body &&
+                    iframe.contentDocument.body.innerHTML == "false"){
+                    // In Opera event is fired second time
+                    // when body.innerHTML changed from false
+                    // to server response approx. after 1 sec
+                    // when we upload file with iframe
+                    return;
+                }
+            }
+            catch (error) {
+                //IE may throw an "access is denied" error when attempting to access contentDocument on the iframe in some cases
+                self.log('Error when attempting to access iframe during handling of upload response (' + error + ")", 'error');
+            }
+
+            callback();
+        });
+    },
+    /**
+     * Returns json object received by iframe from server.
+     */
+    _getIframeContentJSON: function(iframe){
+        //IE may throw an "access is denied" error when attempting to access contentDocument on the iframe in some cases
+        try {
+            // iframe.contentWindow.document - for IE<7
+            var doc = iframe.contentDocument ? iframe.contentDocument: iframe.contentWindow.document,
+                response;
+
+            var innerHTML = doc.body.innerHTML;
+            this.log("converting iframe's innerHTML to JSON");
+            this.log("innerHTML = " + innerHTML);
+            //plain text response may be wrapped in <pre> tag
+            if (innerHTML && innerHTML.match(/^<pre/i)) {
+                innerHTML = doc.body.firstChild.firstChild.nodeValue;
+            }
+            response = eval("(" + innerHTML + ")");
+        } catch(error){
+            this.log('Error when attempting to parse form upload response (' + error + ")", 'error');
+            response = {success: false};
+        }
+
+        return response;
+    },
+    /**
+     * Creates iframe with unique name
+     */
+    _createIframe: function(id){
+        // We can't use following code as the name attribute
+        // won't be properly registered in IE6, and new window
+        // on form submit will open
+        // var iframe = document.createElement('iframe');
+        // iframe.setAttribute('name', id);
+
+        var iframe = qq.toElement('<iframe src="javascript:false;" name="' + id + '" />');
+        // src="javascript:false;" removes ie6 prompt on https
+
+        iframe.setAttribute('id', id);
+
+        iframe.style.display = 'none';
+        document.body.appendChild(iframe);
+
+        return iframe;
+    },
+    /**
+     * Creates form, that will be submitted to iframe
+     */
+    _createForm: function(iframe, params){
+        // We can't use the following code in IE6
+        // var form = document.createElement('form');
+        // form.setAttribute('method', 'post');
+        // form.setAttribute('enctype', 'multipart/form-data');
+        // Because in this case file won't be attached to request
+        var protocol = this._options.demoMode ? "GET" : "POST",
+            form = qq.toElement('<form method="' + protocol + '" enctype="multipart/form-data"></form>'),
+            url = this._options.endpoint;
+
+        if (!this._options.paramsInBody) {
+            url = qq.obj2url(params, this._options.endpoint);
+        }
+        else {
+            qq.obj2Inputs(params, form);
+        }
+
+        form.setAttribute('action', url);
+        form.setAttribute('target', iframe.name);
+        form.style.display = 'none';
+        document.body.appendChild(form);
+
+        return form;
+    }
+});

data/vendor/assets/javascripts/fine_uploader/handler.xhr.js

@@ -0,0 +1,168 @@
+/**
+ * Class for uploading files using xhr
+ * @inherits qq.UploadHandlerAbstract
+ */
+qq.UploadHandlerXhr = function(o){
+    qq.UploadHandlerAbstract.apply(this, arguments);
+
+    this._files = [];
+    this._xhrs = [];
+
+    // current loaded size in bytes for each file
+    this._loaded = [];
+};
+
+// @inherits qq.UploadHandlerAbstract
+qq.extend(qq.UploadHandlerXhr.prototype, qq.UploadHandlerAbstract.prototype)
+
+qq.extend(qq.UploadHandlerXhr.prototype, {
+    /**
+     * Adds file to the queue
+     * Returns id to use with upload, cancel
+     **/
+    add: function(file){
+        if (!(file instanceof File)){
+            throw new Error('Passed obj in not a File (in qq.UploadHandlerXhr)');
+        }
+
+        return this._files.push(file) - 1;
+    },
+    getName: function(id){
+        var file = this._files[id];
+        // fix missing name in Safari 4
+        //NOTE: fixed missing name firefox 11.0a2 file.fileName is actually undefined
+        return (file.fileName !== null && file.fileName !== undefined) ? file.fileName : file.name;
+    },
+    getSize: function(id){
+        var file = this._files[id];
+        return file.fileSize != null ? file.fileSize : file.size;
+    },
+    /**
+     * Returns uploaded bytes for file identified by id
+     */
+    getLoaded: function(id){
+        return this._loaded[id] || 0;
+    },
+    isValid: function(id) {
+        return this._files[id] !== undefined;
+    },
+    reset: function() {
+        qq.UploadHandlerAbstract.prototype.reset.apply(this, arguments);
+        this._files = [];
+        this._xhrs = [];
+        this._loaded = [];
+    },
+    /**
+     * Sends the file identified by id to the server
+     */
+    _upload: function(id){
+        var file = this._files[id],
+            name = this.getName(id),
+            size = this.getSize(id),
+            self = this,
+            url = this._options.endpoint,
+            protocol = this._options.demoMode ? "GET" : "POST",
+            xhr, formData, paramName, key, params;
+
+        this._options.onUpload(id, this.getName(id), true);
+
+        this._loaded[id] = 0;
+
+        xhr = this._xhrs[id] = new XMLHttpRequest();
+
+        xhr.upload.onprogress = function(e){
+            if (e.lengthComputable){
+                self._loaded[id] = e.loaded;
+                self._options.onProgress(id, name, e.loaded, e.total);
+            }
+        };
+
+        xhr.onreadystatechange = function(){
+            if (xhr.readyState === 4){
+                self._onComplete(id, xhr);
+            }
+        };
+
+        params = this._options.paramsStore.getParams(id);
+
+        //build query string
+        if (!this._options.paramsInBody) {
+            params[this._options.inputName] = name;
+            url = qq.obj2url(params, this._options.endpoint);
+        }
+
+        xhr.open(protocol, url, true);
+        xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
+        xhr.setRequestHeader("X-File-Name", encodeURIComponent(name));
+        xhr.setRequestHeader("Cache-Control", "no-cache");
+        if (this._options.forceMultipart || this._options.paramsInBody) {
+            formData = new FormData();
+
+            if (this._options.paramsInBody) {
+                qq.obj2FormData(params, formData);
+            }
+
+            formData.append(this._options.inputName, file);
+            file = formData;
+        } else {
+            xhr.setRequestHeader("Content-Type", "application/octet-stream");
+            //NOTE: return mime type in xhr works on chrome 16.0.9 firefox 11.0a2
+            xhr.setRequestHeader("X-Mime-Type", file.type);
+        }
+
+        for (key in this._options.customHeaders){
+            if (this._options.customHeaders.hasOwnProperty(key)) {
+                xhr.setRequestHeader(key, this._options.customHeaders[key]);
+            }
+        }
+
+        this.log('Sending upload request for ' + id);
+        xhr.send(file);
+    },
+    _onComplete: function(id, xhr){
+        "use strict";
+        // the request was aborted/cancelled
+        if (!this._files[id]) { return; }
+
+        var name = this.getName(id);
+        var size = this.getSize(id);
+        var response; //the parsed JSON response from the server, or the empty object if parsing failed.
+
+        this._options.onProgress(id, name, size, size);
+
+        this.log("xhr - server response received for " + id);
+        this.log("responseText = " + xhr.responseText);
+
+        try {
+            if (typeof JSON.parse === "function") {
+                response = JSON.parse(xhr.responseText);
+            } else {
+                response = eval("(" + xhr.responseText + ")");
+            }
+        } catch(error){
+            this.log('Error when attempting to parse xhr response text (' + error + ')', 'error');
+            response = {};
+        }
+
+        if (xhr.status !== 200 || !response.success){
+            if (this._options.onAutoRetry(id, name, response, xhr)) {
+                return;
+            }
+        }
+
+        this._options.onComplete(id, name, response, xhr);
+
+        this._xhrs[id] = null;
+        this._dequeue(id);
+    },
+    _cancel: function(id){
+        this._options.onCancel(id, this.getName(id));
+
+        this._files[id] = null;
+
+        if (this._xhrs[id]){
+            this._xhrs[id].abort();
+            this._xhrs[id] = null;
+        }
+    }
+});

data/vendor/assets/javascripts/fine_uploader/header.js

@@ -0,0 +1,10 @@
+/**
+ * http://github.com/Valums-File-Uploader/file-uploader
+ *
+ * Multiple file upload component with progress-bar, drag-and-drop, support for all modern browsers.
+ *
+ * Original version: 1.0 © 2010 Andrew Valums ( andrew(at)valums.com )
+ * Current Maintainer (2.0+): © 2012, Ray Nicholus ( fineuploader(at)garstasio.com )
+ *
+ * Licensed under MIT license, GNU GPL 2 or later, GNU LGPL 2 or later, see license.txt.
+ */

data/vendor/assets/javascripts/fine_uploader/jquery-plugin.js

@@ -0,0 +1,168 @@
+/*globals jQuery, qq*/
+(function($) {
+    "use strict";
+    var uploader, $el, init, dataStore, pluginOption, pluginOptions, addCallbacks, transformVariables, isValidCommand,
+        delegateCommand;
+
+    pluginOptions = ['uploaderType'];
+
+    init = function (options) {
+        if (options) {
+            var xformedOpts = transformVariables(options);
+            addCallbacks(xformedOpts);
+
+            if (pluginOption('uploaderType') === 'basic') {
+                uploader(new qq.FineUploaderBasic(xformedOpts));
+            }
+            else {
+                uploader(new qq.FineUploader(xformedOpts));
+            }
+        }
+
+        return $el;
+    };
+
+    dataStore = function(key, val) {
+        var data = $el.data('fineuploader');
+
+        if (val) {
+            if (data === undefined) {
+                data = {};
+            }
+            data[key] = val;
+            $el.data('fineuploader', data);
+        }
+        else {
+            if (data === undefined) {
+                return null;
+            }
+            return data[key];
+        }
+    };
+
+    //the underlying Fine Uploader instance is stored in jQuery's data stored, associated with the element
+    // tied to this instance of the plug-in
+    uploader = function(instanceToStore) {
+        return dataStore('uploader', instanceToStore);
+    };
+
+    pluginOption = function(option, optionVal) {
+        return dataStore(option, optionVal);
+    };
+
+    //implement all callbacks defined in Fine Uploader as functions that trigger appropriately names events and
+    // return the result of executing the bound handler back to Fine Uploader
+    addCallbacks = function(transformedOpts) {
+        var callbacks = transformedOpts.callbacks = {};
+
+        $.each(new qq.FineUploaderBasic()._options.callbacks, function(prop, func) {
+            var name, $callbackEl;
+
+            name = /^on(\w+)/.exec(prop)[1];
+            name = name.substring(0, 1).toLowerCase() + name.substring(1);
+            $callbackEl = $el;
+
+            callbacks[prop] = function() {
+                var args = Array.prototype.slice.call(arguments);
+                return $callbackEl.triggerHandler(name, args);
+            };
+        });
+    };
+
+    //transform jQuery objects into HTMLElements, and pass along all other option properties
+    transformVariables = function(source, dest) {
+        var xformed, arrayVals;
+
+        if (dest === undefined) {
+            if (source.uploaderType !== 'basic') {
+                xformed = { element : $el[0] };
+            }
+            else {
+                xformed = {};
+            }
+        }
+        else {
+            xformed = dest;
+        }
+
+        $.each(source, function(prop, val) {
+            if ($.inArray(prop, pluginOptions) >= 0) {
+                pluginOption(prop, val);
+            }
+            else if (val instanceof $) {
+                xformed[prop] = val[0];
+            }
+            else if ($.isPlainObject(val)) {
+                xformed[prop] = {};
+                transformVariables(val, xformed[prop]);
+            }
+            else if ($.isArray(val)) {
+                arrayVals = [];
+                $.each(val, function(idx, arrayVal) {
+                    if (arrayVal instanceof $) {
+                        $.merge(arrayVals, arrayVal);
+                    }
+                    else {
+                        arrayVals.push(arrayVal);
+                    }
+                });
+                xformed[prop] = arrayVals;
+            }
+            else {
+                xformed[prop] = val;
+            }
+        });
+
+        if (dest === undefined) {
+            return xformed;
+        }
+    };
+
+    isValidCommand = function(command) {
+        return $.type(command) === "string" &&
+            !command.match(/^_/) && //enforce private methods convention
+            uploader()[command] !== undefined;
+    };
+
+    //assuming we have already verified that this is a valid command, call the associated function in the underlying
+    // Fine Uploader instance (passing along the arguments from the caller) and return the result of the call back to the caller
+    delegateCommand = function(command) {
+        var xformedArgs = [], origArgs = Array.prototype.slice.call(arguments, 1);
+
+        transformVariables(origArgs, xformedArgs);
+
+        return uploader()[command].apply(uploader(), xformedArgs);
+    };
+
+    $.fn.fineUploader = function(optionsOrCommand) {
+        var self = this, selfArgs = arguments, retVals = [];
+
+        this.each(function(index, el) {
+            $el = $(el);
+
+            if (uploader() && isValidCommand(optionsOrCommand)) {
+                retVals.push(delegateCommand.apply(self, selfArgs));
+
+                if (self.length === 1) {
+                    return false;
+                }
+            }
+            else if (typeof optionsOrCommand === 'object' || !optionsOrCommand) {
+                init.apply(self, selfArgs);
+            }
+            else {
+                $.error('Method ' +  optionsOrCommand + ' does not exist on jQuery.fineUploader');
+            }
+        });
+
+        if (retVals.length === 1) {
+            return retVals[0];
+        }
+        else if (retVals.length > 1) {
+            return retVals;
+        }
+
+        return this;
+    };
+
+}(jQuery));