fileuploader-rails 2.1.2 → 3.0.0

data/vendor/assets/javascripts/fineuploader/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 = [];
+};
+
+// static method
+qq.UploadHandlerXhr.isSupported = function(){
+    var input = document.createElement('input');
+    input.type = 'file';
+
+    return (
+        'multiple' in input &&
+            typeof File != "undefined" &&
+            typeof FormData != "undefined" &&
+            typeof (new XMLHttpRequest()).upload != "undefined" );
+};
+
+// @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 and additional query params to the server
+     * @param {Object} params name-value string pairs
+     */
+    _upload: function(id, params){
+        this._options.onUpload(id, this.getName(id), true);
+
+        var file = this._files[id],
+            name = this.getName(id),
+            size = this.getSize(id);
+
+        this._loaded[id] = 0;
+
+        var xhr = this._xhrs[id] = new XMLHttpRequest();
+        var self = this;
+
+        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);
+            }
+        };
+
+        // build query string
+        params = params || {};
+        params[this._options.inputName] = name;
+        var queryString = qq.obj2url(params, this._options.endpoint);
+
+        var protocol = this._options.demoMode ? "GET" : "POST";
+        xhr.open(protocol, queryString, true);
+        xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
+        xhr.setRequestHeader("X-File-Name", encodeURIComponent(name));
+        xhr.setRequestHeader("Cache-Control", "no-cache");
+        if (this._options.forceMultipart) {
+            var formData = new 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){
+            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/fineuploader/header.js

@@ -0,0 +1,12 @@
+/**
+ * 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.
+ */
+
+var qq = qq || {};

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

@@ -0,0 +1,148 @@
+(function($) {
+    "use strict";
+    var uploader, $el, init, dataStore, pluginOption, pluginOptions, addCallbacks, transformOptions, isValidCommand,
+        delegateCommand;
+
+    pluginOptions = ['uploaderType'];
+
+    init = function (options) {
+        if (options) {
+            var xformedOpts = transformOptions(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
+    transformOptions = 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] = {};
+                transformOptions(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) {
+        return uploader()[command].apply(uploader(), Array.prototype.slice.call(arguments, 1));
+    };
+
+    $.fn.fineUploader = function(optionsOrCommand) {
+        $el = this;
+
+        if (uploader() && isValidCommand(optionsOrCommand)) {
+            return delegateCommand.apply(this, arguments);
+        }
+        else if (typeof optionsOrCommand === 'object' || !optionsOrCommand) {
+            return init.apply(this, arguments);
+        }
+        else {
+            $.error('Method ' +  optionsOrCommand + ' does not exist on jQuery.fineUploader');
+        }
+
+        return this;
+    };
+
+}(jQuery));

data/vendor/assets/javascripts/fineuploader/uploader.basic.js

@@ -0,0 +1,483 @@
+qq.FineUploaderBasic = function(o){
+    var that = this;
+    this._options = {
+        debug: false,
+        button: null,
+        multiple: true,
+        maxConnections: 3,
+        disableCancelForFormUploads: false,
+        autoUpload: true,
+        request: {
+            endpoint: '/server/upload',
+            params: {},
+            customHeaders: {},
+            forceMultipart: false,
+            inputName: 'qqfile'
+        },
+        validation: {
+            allowedExtensions: [],
+            sizeLimit: 0,
+            minSizeLimit: 0,
+            stopOnFirstInvalidFile: true
+        },
+        callbacks: {
+            onSubmit: function(id, fileName){}, // return false to cancel submit
+            onComplete: function(id, fileName, responseJSON){},
+            onCancel: function(id, fileName){},
+            onUpload: function(id, fileName, xhr){},
+            onProgress: function(id, fileName, loaded, total){},
+            onError: function(id, fileName, reason) {},
+            onAutoRetry: function(id, fileName, attemptNumber) {},
+            onManualRetry: function(id, fileName) {},
+            onValidate: function(fileData) {} // return false to prevent upload
+        },
+        messages: {
+            typeError: "{file} has an invalid extension. Valid extension(s): {extensions}.",
+            sizeError: "{file} is too large, maximum file size is {sizeLimit}.",
+            minSizeError: "{file} is too small, minimum file size is {minSizeLimit}.",
+            emptyError: "{file} is empty, please select files again without it.",
+            noFilesError: "No files to upload.",
+            onLeave: "The files are being uploaded, if you leave now the upload will be cancelled."
+        },
+        retry: {
+            enableAuto: false,
+            maxAutoAttempts: 3,
+            autoAttemptDelay: 5,
+            preventRetryResponseProperty: 'preventRetry'
+        }
+    };
+
+    qq.extend(this._options, o, true);
+    this._wrapCallbacks();
+    qq.extend(this, qq.DisposeSupport);
+
+    // number of files being uploaded
+    this._filesInProgress = 0;
+
+    this._storedFileIds = [];
+
+    this._autoRetries = [];
+    this._retryTimeouts = [];
+    this._preventRetries = [];
+
+    this._handler = this._createUploadHandler();
+
+    if (this._options.button){
+        this._button = this._createUploadButton(this._options.button);
+    }
+
+    this._preventLeaveInProgress();
+};
+
+qq.FineUploaderBasic.prototype = {
+    log: function(str, level) {
+        if (this._options.debug && (!level || level === 'info')) {
+            qq.log('[FineUploader] ' + str);
+        }
+        else if (level && level !== 'info') {
+            qq.log('[FineUploader] ' + str, level);
+
+        }
+    },
+    setParams: function(params){
+        this._options.request.params = params;
+    },
+    getInProgress: function(){
+        return this._filesInProgress;
+    },
+    uploadStoredFiles: function(){
+        "use strict";
+        while(this._storedFileIds.length) {
+            this._filesInProgress++;
+            this._handler.upload(this._storedFileIds.shift(), this._options.request.params);
+        }
+    },
+    clearStoredFiles: function(){
+        this._storedFileIds = [];
+    },
+    retry: function(id) {
+        if (this._onBeforeManualRetry(id)) {
+            this._handler.retry(id);
+            return true;
+        }
+        else {
+            return false;
+        }
+    },
+    cancel: function(fileId) {
+        this._handler.cancel(fileId);
+    },
+    reset: function() {
+        this.log("Resetting uploader...");
+        this._handler.reset();
+        this._filesInProgress = 0;
+        this._storedFileIds = [];
+        this._autoRetries = [];
+        this._retryTimeouts = [];
+        this._preventRetries = [];
+        this._button.reset();
+    },
+    _createUploadButton: function(element){
+        var self = this;
+
+        var button = new qq.UploadButton({
+            element: element,
+            multiple: this._options.multiple && qq.UploadHandlerXhr.isSupported(),
+            acceptFiles: this._options.validation.acceptFiles,
+            onChange: function(input){
+                self._onInputChange(input);
+            }
+        });
+
+        this.addDisposer(function() { button.dispose(); });
+        return button;
+    },
+    _createUploadHandler: function(){
+        var self = this,
+            handlerClass;
+
+        if(qq.UploadHandlerXhr.isSupported()){
+            handlerClass = 'UploadHandlerXhr';
+        } else {
+            handlerClass = 'UploadHandlerForm';
+        }
+
+        var handler = new qq[handlerClass]({
+            debug: this._options.debug,
+            endpoint: this._options.request.endpoint,
+            forceMultipart: this._options.request.forceMultipart,
+            maxConnections: this._options.maxConnections,
+            customHeaders: this._options.request.customHeaders,
+            inputName: this._options.request.inputName,
+            demoMode: this._options.demoMode,
+            log: this.log,
+            onProgress: function(id, fileName, loaded, total){
+                self._onProgress(id, fileName, loaded, total);
+                self._options.callbacks.onProgress(id, fileName, loaded, total);
+            },
+            onComplete: function(id, fileName, result, xhr){
+                self._onComplete(id, fileName, result, xhr);
+                self._options.callbacks.onComplete(id, fileName, result);
+            },
+            onCancel: function(id, fileName){
+                self._onCancel(id, fileName);
+                self._options.callbacks.onCancel(id, fileName);
+            },
+            onUpload: function(id, fileName, xhr){
+                self._onUpload(id, fileName, xhr);
+                self._options.callbacks.onUpload(id, fileName, xhr);
+            },
+            onAutoRetry: function(id, fileName, responseJSON, xhr) {
+                self._preventRetries[id] = responseJSON[self._options.retry.preventRetryResponseProperty];
+
+                if (self._shouldAutoRetry(id, fileName, responseJSON)) {
+                    self._maybeParseAndSendUploadError(id, fileName, responseJSON, xhr);
+                    self._options.callbacks.onAutoRetry(id, fileName, self._autoRetries[id] + 1);
+                    self._onBeforeAutoRetry(id, fileName);
+
+                    self._retryTimeouts[id] = setTimeout(function() {
+                        self._onAutoRetry(id, fileName, responseJSON)
+                    }, self._options.retry.autoAttemptDelay * 1000);
+
+                    return true;
+                }
+                else {
+                    return false;
+                }
+            }
+        });
+
+        return handler;
+    },
+    _preventLeaveInProgress: function(){
+        var self = this;
+
+        this._attach(window, 'beforeunload', function(e){
+            if (!self._filesInProgress){return;}
+
+            var e = e || window.event;
+            // for ie, ff
+            e.returnValue = self._options.messages.onLeave;
+            // for webkit
+            return self._options.messages.onLeave;
+        });
+    },
+    _onSubmit: function(id, fileName){
+        if (this._options.autoUpload) {
+            this._filesInProgress++;
+        }
+    },
+    _onProgress: function(id, fileName, loaded, total){
+    },
+    _onComplete: function(id, fileName, result, xhr){
+        this._filesInProgress--;
+        this._maybeParseAndSendUploadError(id, fileName, result, xhr);
+    },
+    _onCancel: function(id, fileName){
+        clearTimeout(this._retryTimeouts[id]);
+
+        var storedFileIndex = qq.indexOf(this._storedFileIds, id);
+        if (this._options.autoUpload || storedFileIndex < 0) {
+            this._filesInProgress--;
+        }
+        else if (!this._options.autoUpload) {
+            this._storedFileIds.splice(storedFileIndex, 1);
+        }
+    },
+    _onUpload: function(id, fileName, xhr){
+    },
+    _onInputChange: function(input){
+        if (this._handler instanceof qq.UploadHandlerXhr){
+            this._uploadFileList(input.files);
+        } else {
+            if (this._validateFile(input)){
+                this._uploadFile(input);
+            }
+        }
+        this._button.reset();
+    },
+    _onBeforeAutoRetry: function(id, fileName) {
+        this.log("Waiting " + this._options.retry.autoAttemptDelay + " seconds before retrying " + fileName + "...");
+    },
+    _onAutoRetry: function(id, fileName, responseJSON) {
+        this.log("Retrying " + fileName + "...");
+        this._autoRetries[id]++;
+        this._handler.retry(id);
+    },
+    _shouldAutoRetry: function(id, fileName, responseJSON) {
+        if (!this._preventRetries[id] && this._options.retry.enableAuto) {
+            if (this._autoRetries[id] === undefined) {
+                this._autoRetries[id] = 0;
+            }
+
+            return this._autoRetries[id] < this._options.retry.maxAutoAttempts
+        }
+
+        return false;
+    },
+    //return false if we should not attempt the requested retry
+    _onBeforeManualRetry: function(id) {
+        if (this._preventRetries[id]) {
+            this.log("Retries are forbidden for id " + id, 'warn');
+            return false;
+        }
+        else if (this._handler.isValid(id)) {
+            var fileName = this._handler.getName(id);
+
+            if (this._options.callbacks.onManualRetry(id, fileName) === false) {
+                return false;
+            }
+
+            this.log("Retrying upload for '" + fileName + "' (id: " + id + ")...");
+            this._filesInProgress++;
+            return true;
+        }
+        else {
+            this.log("'" + id + "' is not a valid file ID", 'error');
+            return false;
+        }
+    },
+    _maybeParseAndSendUploadError: function(id, fileName, response, xhr) {
+        //assuming no one will actually set the response code to something other than 200 and still set 'success' to true
+        if (!response.success){
+            if (xhr && xhr.status !== 200 && !response.error) {
+                this._options.callbacks.onError(id, fileName, "XHR returned response code " + xhr.status);
+            }
+            else {
+                var errorReason = response.error ? response.error : "Upload failure reason unknown";
+                this._options.callbacks.onError(id, fileName, errorReason);
+            }
+        }
+    },
+    _uploadFileList: function(files){
+        var validationDescriptors, index, batchInvalid;
+
+        validationDescriptors = this._getValidationDescriptors(files);
+        if (validationDescriptors.length > 1) {
+            batchInvalid = this._options.callbacks.onValidate(validationDescriptors) === false;
+        }
+
+        if (!batchInvalid) {
+            if (files.length > 0) {
+                for (index = 0; index < files.length; index++){
+                    if (this._validateFile(files[index])){
+                        this._uploadFile(files[index]);
+                    } else {
+                        if (this._options.validation.stopOnFirstInvalidFile){
+                            return;
+                        }
+                    }
+                }
+            }
+            else {
+                this._error('noFilesError', "");
+            }
+        }
+    },
+    _uploadFile: function(fileContainer){
+        var id = this._handler.add(fileContainer);
+        var fileName = this._handler.getName(id);
+
+        if (this._options.callbacks.onSubmit(id, fileName) !== false){
+            this._onSubmit(id, fileName);
+            if (this._options.autoUpload) {
+                this._handler.upload(id, this._options.request.params);
+            }
+            else {
+                this._storeFileForLater(id);
+            }
+        }
+    },
+    _storeFileForLater: function(id) {
+        this._storedFileIds.push(id);
+    },
+    _validateFile: function(file){
+        var validationDescriptor, name, size;
+
+        validationDescriptor = this._getValidationDescriptor(file);
+        name = validationDescriptor.name;
+        size = validationDescriptor.size;
+
+        if (this._options.callbacks.onValidate([validationDescriptor]) === false) {
+            return false;
+        }
+
+        if (!this._isAllowedExtension(name)){
+            this._error('typeError', name);
+            return false;
+
+        }
+        else if (size === 0){
+            this._error('emptyError', name);
+            return false;
+
+        }
+        else if (size && this._options.validation.sizeLimit && size > this._options.validation.sizeLimit){
+            this._error('sizeError', name);
+            return false;
+
+        }
+        else if (size && size < this._options.validation.minSizeLimit){
+            this._error('minSizeError', name);
+            return false;
+        }
+
+        return true;
+    },
+    _error: function(code, fileName){
+        var message = this._options.messages[code];
+        function r(name, replacement){ message = message.replace(name, replacement); }
+
+        var extensions = this._options.validation.allowedExtensions.join(', ');
+
+        r('{file}', this._formatFileName(fileName));
+        r('{extensions}', extensions);
+        r('{sizeLimit}', this._formatSize(this._options.validation.sizeLimit));
+        r('{minSizeLimit}', this._formatSize(this._options.validation.minSizeLimit));
+
+        this._options.callbacks.onError(null, fileName, message);
+
+        return message;
+    },
+    _formatFileName: function(name){
+        if (name.length > 33){
+            name = name.slice(0, 19) + '...' + name.slice(-13);
+        }
+        return name;
+    },
+    _isAllowedExtension: function(fileName){
+        var ext = (-1 !== fileName.indexOf('.'))
+            ? fileName.replace(/.*[.]/, '').toLowerCase()
+            : '';
+        var allowed = this._options.validation.allowedExtensions;
+
+        if (!allowed.length){return true;}
+
+        for (var i=0; i<allowed.length; i++){
+            if (allowed[i].toLowerCase() == ext){ return true;}
+        }
+
+        return false;
+    },
+    _formatSize: function(bytes){
+        var i = -1;
+        do {
+            bytes = bytes / 1024;
+            i++;
+        } while (bytes > 99);
+
+        return Math.max(bytes, 0.1).toFixed(1) + ['kB', 'MB', 'GB', 'TB', 'PB', 'EB'][i];
+    },
+    _wrapCallbacks: function() {
+        var self, safeCallback;
+
+        self = this;
+
+        safeCallback = function(name, callback, args) {
+            try {
+                return callback.apply(self, args);
+            }
+            catch (exception) {
+                self.log("Caught exception in '" + name + "' callback - " + exception, 'error');
+            }
+        }
+
+        for (var prop in this._options.callbacks) {
+            (function() {
+                var oldCallback = self._options.callbacks[prop];
+                self._options.callbacks[prop] = function() {
+                    return safeCallback(prop, oldCallback, arguments);
+                }
+            }());
+        }
+    },
+    _parseFileName: function(file) {
+        var name;
+
+        if (file.value){
+            // it is a file input
+            // get input value and remove path to normalize
+            name = file.value.replace(/.*(\/|\\)/, "");
+        } else {
+            // fix missing properties in Safari 4 and firefox 11.0a2
+            name = (file.fileName !== null && file.fileName !== undefined) ? file.fileName : file.name;
+        }
+
+        return name;
+    },
+    _parseFileSize: function(file) {
+        var size;
+
+        if (!file.value){
+            // fix missing properties in Safari 4 and firefox 11.0a2
+            size = (file.fileSize !== null && file.fileSize !== undefined) ? file.fileSize : file.size;
+        }
+
+        return size;
+    },
+    _getValidationDescriptor: function(file) {
+        var name, size, fileDescriptor;
+
+        fileDescriptor = {};
+        name = this._parseFileName(file);
+        size = this._parseFileSize(file);
+
+        fileDescriptor.name = name;
+        if (size) {
+            fileDescriptor.size = size;
+        }
+
+        return fileDescriptor;
+    },
+    _getValidationDescriptors: function(files) {
+        var index, fileDescriptors;
+
+        fileDescriptors = [];
+
+        for (index = 0; index < files.length; index++) {
+            fileDescriptors.push(files[index]);
+        }
+
+        return fileDescriptors;
+    }
+};