resumablejs-rails 1.0 → 1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 193ac0f83f8157b10c100d48601be68b89c89769
-  data.tar.gz: b20ed9c5eb8af57b297b6aa904106e9f058a2cb3
+  metadata.gz: bff07b24aa9de454899e5e82e8badee9e9d0c955
+  data.tar.gz: 71402b518edf6ee1a23843a6998a43f4abf46196
 SHA512:
-  metadata.gz: 25c53ae556106fecf94eccb1b5df1cf0c556df1c8e5c535b06446c51a69471be2b9623fc28b149ffcb49e4531669325c6e0b3dd4a9249f12058f9a61b581e811
-  data.tar.gz: c0b25f735c94f26c49396d560223a711b2324ee87750fd9fac2bc259c9e488da65fb31456f63744b19d2b38fd76333aad0fca334b0ee21913a7e5913f0fc6811
+  metadata.gz: a5c525555bedc63a1d782b49161221028a54b8a7db326511e654403f132a47bb7cfc36e109e9d47e92703764da82df50787bc7f3aebfeb3254b9adacc7f2231f
+  data.tar.gz: 5ba6fcc5c4ba9514a046d487a61c457bfba0750afc5cdcedb81e1f82ddfa28d1b4732dc9212f27cba094ef3235ef5833e6b8ab775473d4545002e39b2f902ba0

data/lib/resumablejs-rails/version.rb

@@ -1,5 +1,5 @@
 module Resumablejs
   module Rails
-    VERSION = "1.0"
+    VERSION = "1.1"
   end
 end

data/vendor/assets/javascripts/resumable.js

@@ -50,7 +50,7 @@
       generateUniqueIdentifier:null,
       maxChunkRetries:undefined,
       chunkRetryInterval:undefined,
-      permanentErrors:[404, 415, 500, 501],
+      permanentErrors:[400, 404, 415, 500, 501],
       maxFiles:undefined,
       withCredentials:false,
       xhrTimeout:0,
@@ -185,13 +185,146 @@
 
     var onDrop = function(event){
       $h.stopEvent(event);
-      appendFilesFromFileList(event.dataTransfer.files, event);
+
+      //handle dropped things as items if we can (this lets us deal with folders nicer in some cases)
+      if (event.dataTransfer && event.dataTransfer.items) {
+        loadFiles(event.dataTransfer.items, event);
+      }
+      //else handle them as files
+      else if (event.dataTransfer && event.dataTransfer.files) {
+        loadFiles(event.dataTransfer.files, event);
+      }
     };
     var onDragOver = function(e) {
       e.preventDefault();
     };
 
     // INTERNAL METHODS (both handy and responsible for the heavy load)
+    /**
+     * @summary This function loops over the files passed in from a drag and drop operation and gets them ready for appendFilesFromFileList
+     *            It attempts to use FileSystem API calls to extract files and subfolders if the dropped items include folders
+     *            That capability is only currently available in Chrome, but if it isn't available it will just pass the items along to
+     *            appendFilesFromFileList (via enqueueFileAddition to help with asynchronous processing.)
+     * @param files {Array} - the File or Entry objects to be processed depending on your browser support
+     * @param event {Object} - the drop event object
+     * @param [queue] {Object} - an object to keep track of our progress processing the dropped items
+     * @param [path] {String} - the relative path from the originally selected folder to the current files if extracting files from subfolders
+     */
+    var loadFiles = function (files, event, queue, path){
+      //initialize the queue object if it doesn't exist
+      if (!queue) {
+        queue = {
+          total: 0,
+          files: [],
+          event: event
+        };
+      }
+
+      //update the total number of things we plan to process
+      updateQueueTotal(files.length, queue);
+
+      //loop over all the passed in objects checking if they are files or folders
+      for (var i = 0; i < files.length; i++) {
+        var file = files[i];
+        var entry, reader;
+
+        if (file.isFile || file.isDirectory) {
+          //this is an object we can handle below with no extra work needed up front
+          entry = file;
+        }
+        else if (file.getAsEntry) {
+          //get the file as an entry object if we can using the proposed HTML5 api (unlikely to get implemented by anyone)
+          entry = file.getAsEntry();
+        }
+        else if (file.webkitGetAsEntry) {
+          //get the file as an entry object if we can using the Chrome specific webkit implementation
+          entry = file.webkitGetAsEntry();
+        }
+        else if (typeof file.getAsFile === 'function') {
+          //if this is still a DataTransferItem object, get it as a file object
+          enqueueFileAddition(file.getAsFile(), queue, path);
+          //we just added this file object to the queue so we can go to the next object in the loop and skip the processing below
+          continue;
+        }
+        else if (File && file instanceof File) {
+          //this is already a file object so just queue it up and move on
+          enqueueFileAddition(file, queue, path);
+          //we just added this file object to the queue so we can go to the next object in the loop and skip the processing below
+          continue;
+        }
+        else {
+          //we can't do anything with this object, decrement the expected total and skip the processing below
+          updateQueueTotal(-1, queue);
+          continue;
+        }
+
+        if (!entry) {
+          //there isn't anything we can do with this so decrement the total expected
+          updateQueueTotal(-1, queue);
+        }
+        else if (entry.isFile) {
+          //this is handling to read an entry object representing a file, parsing the file object is asynchronous which is why we need the queue
+          //currently entry objects will only exist in this flow for Chrome
+          entry.file(function(file) {
+            enqueueFileAddition(file, queue, path);
+          }, function(err) {
+            console.warn(err);
+          });
+        }
+        else if (entry.isDirectory) {
+          //this is handling to read an entry object representing a folder, parsing the directory object is asynchronous which is why we need the queue
+          //currently entry objects will only exist in this flow for Chrome
+          reader = entry.createReader();
+
+          //wrap the callback in another function so we can store the path in a closure
+          var readDir = function(path){
+            return function(entries){
+              //process each thing in this directory recursively
+              loadFiles(entries, event, queue, path);
+              //this was a directory rather than a file so decrement the expected file count
+              updateQueueTotal(-1, queue);
+            }
+          };
+
+          reader.readEntries(readDir(entry.fullPath), function(err) {
+            console.warn(err);
+          });
+        }
+      }
+    };
+
+    /**
+     * @summary Adjust the total number of files we are expecting to process
+     *          if decrementing and the new expected total is equal to the number processed, flush the queue
+     * @param addition {Number} - the number of additional files we expect to process (may be negative)
+     * @param queue {Object} - an object to keep track of our progress processing the dropped items
+     */
+    var updateQueueTotal = function(addition, queue){
+      queue.total += addition;
+
+      // If all the files we expect have shown up, then flush the queue.
+      if (queue.files.length === queue.total) {
+        appendFilesFromFileList(queue.files, queue.event);
+      }
+    };
+
+    /**
+     * @summary Add a file to the queue of processed files, if it brings the total up to the expected total, flush the queue
+     * @param file {Object} - File object to be passed along to appendFilesFromFileList eventually
+     * @param queue {Object} - an object to keep track of our progress processing the dropped items
+     * @param [path] {String} - the file's relative path from the originally dropped folder if we are parsing folder content (Chrome only for now)
+     */
+    var enqueueFileAddition = function(file, queue, path) {
+      //store the path to this file if it came in as part of a folder
+      if (path) file.relativePath = path + '/' + file.name;
+      queue.files.push(file);
+
+      // If all the files we expect have shown up, then flush the queue.
+      if (queue.files.length === queue.total) {
+        appendFilesFromFileList(queue.files, queue.event);
+      }
+    };
+
     var appendFilesFromFileList = function(fileList, event){
       // check for uploading too many files
       var errorCount = 0;
@@ -207,13 +340,21 @@
       }
       var files = [];
       $h.each(fileList, function(file){
-        var fileName = file.name.split('.');
-        var fileType = fileName[fileName.length-1].toLowerCase();
-
-        if (o.fileType.length > 0 && !$h.contains(o.fileType, fileType)) {
-          o.fileTypeErrorCallback(file, errorCount++);
-          return false;
+        var fileName = file.name;
+        if(o.fileType.length > 0){
+      var fileTypeFound = false;
+      for(var index in o.fileType){
+        var extension = '.' + o.fileType[index];
+        if(fileName.indexOf(extension, fileName.length - extension.length) !== -1){
+          fileTypeFound = true;
+          break;
         }
+      }
+      if (!fileTypeFound) {
+        o.fileTypeErrorCallback(file, errorCount++);
+        return false;
+      }
+    }
 
         if (typeof(o.minFileSize)!=='undefined' && file.size<o.minFileSize) {
           o.minFileSizeErrorCallback(file, errorCount++);
@@ -250,7 +391,7 @@
       $.file = file;
       $.fileName = file.fileName||file.name; // Some confusion in different versions of Firefox
       $.size = file.size;
-      $.relativePath = file.webkitRelativePath || $.fileName;
+      $.relativePath = file.webkitRelativePath || file.relativePath || $.fileName;
       $.uniqueIdentifier = $h.generateUniqueIdentifier(file);
       $._pause = false;
       $.container = '';
@@ -345,7 +486,7 @@
           if(c.status()=='error') error = true;
           ret += c.progress(true); // get chunk progress relative to entire file
         });
-        ret = (error ? 1 : (ret>0.999 ? 1 : ret));
+        ret = (error ? 1 : (ret>0.99999 ? 1 : ret));
         ret = Math.max($._prevProgress, ret); // We don't want to lose percentages when an upload is paused
         $._prevProgress = ret;
         return(ret);
@@ -433,6 +574,7 @@
         };
         $.xhr.addEventListener('load', testHandler, false);
         $.xhr.addEventListener('error', testHandler, false);
+        $.xhr.addEventListener('timeout', testHandler, false);
 
         // Add data from the query options
         var params = [];
@@ -518,6 +660,7 @@
         };
         $.xhr.addEventListener('load', doneHandler, false);
         $.xhr.addEventListener('error', doneHandler, false);
+        $.xhr.addEventListener('timeout', doneHandler, false);
 
         // Set up the basic query data from Resumable
         var query = {

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: resumablejs-rails
 version: !ruby/object:Gem::Version
-  version: '1.0'
+  version: '1.1'
 platform: ruby
 authors:
 - beanie
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-22 00:00:00.000000000 Z
+date: 2015-03-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -61,7 +61,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: resumable.js for the Rails Asset Pipeline