fine_uploader 2.1.1 → 3.1.1

data/README.md

@@ -1,6 +1,6 @@
-# FineUploader
+# Fine Uploader
 
-TODO: Write a gem description
+Fine Uploader is a project attempts to achieve a user-friendly file-uploading experience over the web. It's built as a Javascript plugin for developers looking to incorporate file-uploading into their website.
 
 ## Installation
 
@@ -18,7 +18,13 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+Add `application.js`
+
+    //= require fine_uploader
+
+and `application.css`
+
+    /*= require fine_uploader
 
 ## Contributing
 

data/Vendorfile

@@ -1,9 +1,21 @@
-from 'git://github.com/valums/file-uploader.git', branch: '2.1.1' do
-  file 'vendor/assets/images/loading.gif', 'client/loading.gif'
-  file 'vendor/assets/javascripts/fine_uploader.js', 'client/fileuploader.js'
-  file 'vendor/assets/stylesheets/fine_uploader.css.scss', 'client/fileuploader.css' do |path|
+from 'git://github.com/valums/file-uploader.git', ref: 'be738538a57633e355529ec13c63a7b2493b7ec8' do
+  file 'vendor/assets/images/fine_uploader/loading.gif', 'client/loading.gif'
+  file 'vendor/assets/images/fine_uploader/processing.gif', 'client/processing.gif'
+  file 'vendor/assets/javascripts/fine_uploader/header.js', 'client/js/header.js'
+  file 'vendor/assets/javascripts/fine_uploader/util.js', 'client/js/util.js'
+  file 'vendor/assets/javascripts/fine_uploader/button.js', 'client/js/button.js'
+  file 'vendor/assets/javascripts/fine_uploader/handler.base.js', 'client/js/handler.base.js'
+  file 'vendor/assets/javascripts/fine_uploader/handler.form.js', 'client/js/handler.form.js'
+  file 'vendor/assets/javascripts/fine_uploader/handler.xhr.js', 'client/js/handler.xhr.js'
+  file 'vendor/assets/javascripts/fine_uploader/uploader.basic.js', 'client/js/uploader.basic.js'
+  file 'vendor/assets/javascripts/fine_uploader/dnd.js', 'client/js/dnd.js'
+  file 'vendor/assets/javascripts/fine_uploader/uploader.js', 'client/js/uploader.js'
+  file 'vendor/assets/javascripts/fine_uploader/jquery-plugin.js', 'client/js/jquery-plugin.js'
+  file 'vendor/assets/stylesheets/fine_uploader.css.scss', 'client/fineuploader.css' do |path|
     rewrite(path) do |content|
-      content.gsub('url', 'image-url')
+      content.gsub!('url', 'image-url')
+      content.gsub!('loading.gif', 'fine_uploader/loading.gif')
+      content.gsub!('processing.gif', 'fine_uploader/processing.gif')
     end
   end
 end

data/lib/fine_uploader/version.rb

@@ -1,3 +1,3 @@
 module FineUploader
-  VERSION = "2.1.1"
+  VERSION = "3.1.1"
 end

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

@@ -0,0 +1,102 @@
+qq.UploadButton = function(o){
+    this._options = {
+        element: null,
+        // if set to true adds multiple attribute to file input
+        multiple: false,
+        acceptFiles: null,
+        // name attribute of file input
+        name: 'file',
+        onChange: function(input){},
+        hoverClass: 'qq-upload-button-hover',
+        focusClass: 'qq-upload-button-focus'
+    };
+
+    qq.extend(this._options, o);
+    this._disposeSupport = new qq.DisposeSupport();
+
+    this._element = this._options.element;
+
+    // make button suitable container for input
+    qq(this._element).css({
+        position: 'relative',
+        overflow: 'hidden',
+        // Make sure browse button is in the right side
+        // in Internet Explorer
+        direction: 'ltr'
+    });
+
+    this._input = this._createInput();
+};
+
+qq.UploadButton.prototype = {
+    /* returns file input element */
+    getInput: function(){
+        return this._input;
+    },
+    /* cleans/recreates the file input */
+    reset: function(){
+        if (this._input.parentNode){
+            qq(this._input).remove();
+        }
+
+        qq(this._element).removeClass(this._options.focusClass);
+        this._input = this._createInput();
+    },
+    _createInput: function(){
+        var input = document.createElement("input");
+
+        if (this._options.multiple){
+            input.setAttribute("multiple", "multiple");
+        }
+
+        if (this._options.acceptFiles) input.setAttribute("accept", this._options.acceptFiles);
+
+        input.setAttribute("type", "file");
+        input.setAttribute("name", this._options.name);
+
+        qq(input).css({
+            position: 'absolute',
+            // in Opera only 'browse' button
+            // is clickable and it is located at
+            // the right side of the input
+            right: 0,
+            top: 0,
+            fontFamily: 'Arial',
+            // 4 persons reported this, the max values that worked for them were 243, 236, 236, 118
+            fontSize: '118px',
+            margin: 0,
+            padding: 0,
+            cursor: 'pointer',
+            opacity: 0
+        });
+
+        this._element.appendChild(input);
+
+        var self = this;
+        this._disposeSupport.attach(input, 'change', function(){
+            self._options.onChange(input);
+        });
+
+        this._disposeSupport.attach(input, 'mouseover', function(){
+            qq(self._element).addClass(self._options.hoverClass);
+        });
+        this._disposeSupport.attach(input, 'mouseout', function(){
+            qq(self._element).removeClass(self._options.hoverClass);
+        });
+        this._disposeSupport.attach(input, 'focus', function(){
+            qq(self._element).addClass(self._options.focusClass);
+        });
+        this._disposeSupport.attach(input, 'blur', function(){
+            qq(self._element).removeClass(self._options.focusClass);
+        });
+
+        // IE and Opera, unfortunately have 2 tab stops on file input
+        // which is unacceptable in our case, disable keyboard access
+        if (window.attachEvent){
+            // it is IE or Opera
+            input.setAttribute('tabIndex', "-1");
+        }
+
+        return input;
+    }
+};

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

@@ -0,0 +1,355 @@
+/*globals qq, document*/
+qq.DragAndDrop = function(o) {
+    "use strict";
+
+    var options, dz, dirPending,
+        droppedFiles = [],
+        droppedEntriesCount = 0,
+        droppedEntriesParsedCount = 0,
+        disposeSupport = new qq.DisposeSupport();
+
+     options = {
+        dropArea: null,
+        extraDropzones: [],
+        hideDropzones: true,
+        multiple: true,
+        classes: {
+            dropActive: null
+        },
+        callbacks: {
+            dropProcessing: function(isProcessing, files) {},
+            error: function(code, filename) {},
+            log: function(message, level) {}
+        }
+    };
+
+    qq.extend(options, o);
+
+    function maybeUploadDroppedFiles() {
+        if (droppedEntriesCount === droppedEntriesParsedCount && !dirPending) {
+            options.callbacks.log('Grabbed ' + droppedFiles.length + " files after tree traversal.");
+            dz.dropDisabled(false);
+            options.callbacks.dropProcessing(false, droppedFiles);
+        }
+    }
+    function addDroppedFile(file) {
+        droppedFiles.push(file);
+        droppedEntriesParsedCount+=1;
+        maybeUploadDroppedFiles();
+    }
+
+    function traverseFileTree(entry) {
+        var dirReader, i;
+
+        droppedEntriesCount+=1;
+
+        if (entry.isFile) {
+            entry.file(function(file) {
+                addDroppedFile(file);
+            });
+        }
+        else if (entry.isDirectory) {
+            dirPending = true;
+            dirReader = entry.createReader();
+            dirReader.readEntries(function(entries) {
+                droppedEntriesParsedCount+=1;
+                for (i = 0; i < entries.length; i+=1) {
+                    traverseFileTree(entries[i]);
+                }
+
+                dirPending = false;
+
+                if (!entries.length) {
+                    maybeUploadDroppedFiles();
+                }
+            });
+        }
+    }
+
+    function handleDataTransfer(dataTransfer) {
+        var i, items, entry;
+
+        options.callbacks.dropProcessing(true);
+        dz.dropDisabled(true);
+
+        if (dataTransfer.files.length > 1 && !options.multiple) {
+            options.callbacks.error('tooManyFilesError', "");
+        }
+        else {
+            droppedFiles = [];
+            droppedEntriesCount = 0;
+            droppedEntriesParsedCount = 0;
+
+            if (qq.isFolderDropSupported(dataTransfer)) {
+                items = dataTransfer.items;
+
+                for (i = 0; i < items.length; i+=1) {
+                    entry = items[i].webkitGetAsEntry();
+                    if (entry) {
+                        //due to a bug in Chrome's File System API impl - #149735
+                        if (entry.isFile) {
+                            droppedFiles.push(items[i].getAsFile());
+                            if (i === items.length-1) {
+                                maybeUploadDroppedFiles();
+                            }
+                        }
+
+                        else {
+                            traverseFileTree(entry);
+                        }
+                    }
+                }
+            }
+            else {
+                options.callbacks.dropProcessing(false, dataTransfer.files);
+                dz.dropDisabled(false);
+            }
+        }
+    }
+
+    function setupDropzone(dropArea){
+        dz = new qq.UploadDropZone({
+            element: dropArea,
+            onEnter: function(e){
+                qq(dropArea).addClass(options.classes.dropActive);
+                e.stopPropagation();
+            },
+            onLeaveNotDescendants: function(e){
+                qq(dropArea).removeClass(options.classes.dropActive);
+            },
+            onDrop: function(e){
+                if (options.hideDropzones) {
+                    qq(dropArea).hide();
+                }
+                qq(dropArea).removeClass(options.classes.dropActive);
+
+                handleDataTransfer(e.dataTransfer);
+            }
+        });
+
+        disposeSupport.addDisposer(function() {
+            dz.dispose();
+        });
+
+        if (options.hideDropzones) {
+            qq(dropArea).hide();
+        }
+    }
+
+    function isFileDrag(dragEvent) {
+        var fileDrag;
+
+        qq.each(dragEvent.dataTransfer.types, function(key, val) {
+            if (val === 'Files') {
+                fileDrag = true;
+                return false;
+            }
+        });
+
+        return fileDrag;
+    }
+
+    function setupDragDrop(){
+        if (options.dropArea) {
+            options.extraDropzones.push(options.dropArea);
+        }
+
+        var i, dropzones = options.extraDropzones;
+
+        for (i=0; i < dropzones.length; i+=1){
+            setupDropzone(dropzones[i]);
+        }
+
+        // IE <= 9 does not support the File API used for drag+drop uploads
+        if (options.dropArea && (!qq.ie() || qq.ie10())) {
+            disposeSupport.attach(document, 'dragenter', function(e) {
+                if (!dz.dropDisabled() && isFileDrag(e)) {
+                    if (qq(options.dropArea).hasClass(options.classes.dropDisabled)) {
+                        return;
+                    }
+
+                    options.dropArea.style.display = 'block';
+                    for (i=0; i < dropzones.length; i+=1) {
+                        dropzones[i].style.display = 'block';
+                    }
+                }
+            });
+        }
+        disposeSupport.attach(document, 'dragleave', function(e){
+            if (options.hideDropzones && qq.FineUploader.prototype._leaving_document_out(e)) {
+                for (i=0; i < dropzones.length; i+=1) {
+                    qq(dropzones[i]).hide();
+                }
+            }
+        });
+        disposeSupport.attach(document, 'drop', function(e){
+            if (options.hideDropzones) {
+                for (i=0; i < dropzones.length; i+=1) {
+                    qq(dropzones[i]).hide();
+                }
+            }
+            e.preventDefault();
+        });
+    }
+
+    return {
+        setup: function() {
+            setupDragDrop();
+        },
+
+        setupExtraDropzone: function(element) {
+            options.extraDropzones.push(element);
+            setupDropzone(element);
+        },
+
+        removeExtraDropzone: function(element) {
+            var i, dzs = options.extraDropzones;
+            for(i in dzs) {
+                if (dzs[i] === element) {
+                    return dzs.splice(i, 1);
+                }
+            }
+        },
+
+        dispose: function() {
+            disposeSupport.dispose();
+            dz.dispose();
+        }
+    };
+};
+
+
+qq.UploadDropZone = function(o){
+    "use strict";
+
+    var options, element, preventDrop, dropOutsideDisabled, disposeSupport = new qq.DisposeSupport();
+
+    options = {
+        element: null,
+        onEnter: function(e){},
+        onLeave: function(e){},
+        // is not fired when leaving element by hovering descendants
+        onLeaveNotDescendants: function(e){},
+        onDrop: function(e){}
+    };
+
+    qq.extend(options, o);
+    element = options.element;
+
+    function dragover_should_be_canceled(){
+        return qq.safari() || (qq.firefox() && qq.windows());
+    }
+
+    function disableDropOutside(e){
+        // run only once for all instances
+        if (!dropOutsideDisabled ){
+
+            // for these cases we need to catch onDrop to reset dropArea
+            if (dragover_should_be_canceled){
+               disposeSupport.attach(document, 'dragover', function(e){
+                    e.preventDefault();
+                });
+            } else {
+                disposeSupport.attach(document, 'dragover', function(e){
+                    if (e.dataTransfer){
+                        e.dataTransfer.dropEffect = 'none';
+                        e.preventDefault();
+                    }
+                });
+            }
+
+            dropOutsideDisabled = true;
+        }
+    }
+
+    function isValidFileDrag(e){
+        // e.dataTransfer currently causing IE errors
+        // IE9 does NOT support file API, so drag-and-drop is not possible
+        if (qq.ie() && !qq.ie10()) {
+            return false;
+        }
+
+        var effectTest, dt = e.dataTransfer,
+        // do not check dt.types.contains in webkit, because it crashes safari 4
+        isSafari = qq.safari();
+
+        // dt.effectAllowed is none in Safari 5
+        // dt.types.contains check is for firefox
+        effectTest = qq.ie10() ? true : dt.effectAllowed !== 'none';
+        return dt && effectTest && (dt.files || (!isSafari && dt.types.contains && dt.types.contains('Files')));
+    }
+
+    function isOrSetDropDisabled(isDisabled) {
+        if (isDisabled !== undefined) {
+            preventDrop = isDisabled;
+        }
+        return preventDrop;
+    }
+
+    function attachEvents(){
+        disposeSupport.attach(element, 'dragover', function(e){
+            if (!isValidFileDrag(e)) {
+                return;
+            }
+
+            var effect = qq.ie() ? null : e.dataTransfer.effectAllowed;
+            if (effect === 'move' || effect === 'linkMove'){
+                e.dataTransfer.dropEffect = 'move'; // for FF (only move allowed)
+            } else {
+                e.dataTransfer.dropEffect = 'copy'; // for Chrome
+            }
+
+            e.stopPropagation();
+            e.preventDefault();
+        });
+
+        disposeSupport.attach(element, 'dragenter', function(e){
+            if (!isOrSetDropDisabled()) {
+                if (!isValidFileDrag(e)) {
+                    return;
+                }
+                options.onEnter(e);
+            }
+        });
+
+        disposeSupport.attach(element, 'dragleave', function(e){
+            if (!isValidFileDrag(e)) {
+                return;
+            }
+
+            options.onLeave(e);
+
+            var relatedTarget = document.elementFromPoint(e.clientX, e.clientY);
+            // do not fire when moving a mouse over a descendant
+            if (qq(this).contains(relatedTarget)) {
+                return;
+            }
+
+            options.onLeaveNotDescendants(e);
+        });
+
+        disposeSupport.attach(element, 'drop', function(e){
+            if (!isOrSetDropDisabled()) {
+                if (!isValidFileDrag(e)) {
+                    return;
+                }
+
+                e.preventDefault();
+                options.onDrop(e);
+            }
+        });
+    }
+
+    disableDropOutside();
+    attachEvents();
+
+    return {
+        dropDisabled: function(isDisabled) {
+            return isOrSetDropDisabled(isDisabled);
+        },
+
+        dispose: function() {
+            disposeSupport.dispose();
+        }
+    };
+};

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

@@ -0,0 +1,115 @@
+/**
+ * Class for uploading files, uploading itself is handled by child classes
+ */
+qq.UploadHandlerAbstract = function(o){
+    // Default options, can be overridden by the user
+    this._options = {
+        debug: false,
+        endpoint: '/upload.php',
+        paramsInBody: false,
+        // maximum number of concurrent uploads
+        maxConnections: 999,
+        log: function(str, level) {},
+        onProgress: function(id, fileName, loaded, total){},
+        onComplete: function(id, fileName, response, xhr){},
+        onCancel: function(id, fileName){},
+        onUpload: function(id, fileName, xhr){},
+        onAutoRetry: function(id, fileName, response, xhr){}
+
+    };
+    qq.extend(this._options, o);
+
+    this._queue = [];
+
+    this.log = this._options.log;
+};
+qq.UploadHandlerAbstract.prototype = {
+    /**
+     * Adds file or file input to the queue
+     * @returns id
+     **/
+    add: function(file){},
+    /**
+     * Sends the file identified by id
+     */
+    upload: function(id){
+        var len = this._queue.push(id);
+
+        // if too many active uploads, wait...
+        if (len <= this._options.maxConnections){
+            this._upload(id);
+        }
+    },
+    retry: function(id) {
+        var i = qq.indexOf(this._queue, id);
+        if (i >= 0) {
+            this._upload(id);
+        }
+        else {
+            this.upload(id);
+        }
+    },
+    /**
+     * Cancels file upload by id
+     */
+    cancel: function(id){
+        this.log('Cancelling ' + id);
+        this._options.paramsStore.remove(id);
+        this._cancel(id);
+        this._dequeue(id);
+    },
+    /**
+     * Cancells all uploads
+     */
+    cancelAll: function(){
+        for (var i=0; i<this._queue.length; i++){
+            this._cancel(this._queue[i]);
+        }
+        this._queue = [];
+    },
+    /**
+     * Returns name of the file identified by id
+     */
+    getName: function(id){},
+    /**
+     * Returns size of the file identified by id
+     */
+    getSize: function(id){},
+    /**
+     * Returns id of files being uploaded or
+     * waiting for their turn
+     */
+    getQueue: function(){
+        return this._queue;
+    },
+    reset: function() {
+        this.log('Resetting upload handler');
+        this._queue = [];
+    },
+    /**
+     * Actual upload method
+     */
+    _upload: function(id){},
+    /**
+     * Actual cancel method
+     */
+    _cancel: function(id){},
+    /**
+     * Removes element from queue, starts upload of next
+     */
+    _dequeue: function(id){
+        var i = qq.indexOf(this._queue, id);
+        this._queue.splice(i, 1);
+
+        var max = this._options.maxConnections;
+
+        if (this._queue.length >= max && i < max){
+            var nextId = this._queue[max-1];
+            this._upload(nextId);
+        }
+    },
+    /**
+     * Determine if the file exists.
+     */
+    isValid: function(id) {}
+};