fileuploader-rails 3.0.0 → 3.0.0.1

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

@@ -1,168 +0,0 @@
-/**
- * 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

@@ -1,12 +0,0 @@
-/**
- * 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

@@ -1,148 +0,0 @@
-(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

@@ -1,483 +0,0 @@
-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;
-    }
-};