glebtv-rails-uploader 0.1.3 → 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7d583687777e18cb84615643e8d052d340b42fc2
+  data.tar.gz: 736689da394ccc26adb783a08ba1914f1a196a29
+SHA512:
+  metadata.gz: 93268c2f5c15e9c184e389174e309dae458ddb0c776063e6cbc8f54d3b74e6ea78811e1bbc42719e3ad7063908a341a6ecf2c0eb0c7c0b1381c6e888c76cc96d
+  data.tar.gz: 19d7de68f7c36612dfcd58b3a195eab73787e3d6ef609b8ed084294fec1331b2da9ae441dac35aadfeb291f8eae8d25ecb308d253c2bdfea059332342b9c6ed7

data/README.md

@@ -1,10 +1,10 @@
-# this fork adds mongoid and rails_admin support
+## this fork adds mongoid and rails_admin support
 
 This fork works when both simple form and formtastic are loaded
 
 Also nested associations are working
 
-# HTML5 File uploader for rails
+## HTML5 File uploader for rails
 
 This gem use https://github.com/blueimp/jQuery-File-Upload for upload files.
 
@@ -37,8 +37,15 @@ mount Uploader::Engine => '/uploader'
 
       field :guid, type: String
       belongs_to :assetable, polymorphic: true
+
+      # this workaround is sometimes needed so IDs are ObjectIDs not strings  before_save do
+      if !assetable_id.blank? && !assetable_id.class.name == "Moped::BSON::ObjectId" && Moped::BSON::ObjectId.legal?(assetable_id)
+        self.assetable_id = Moped::BSON::ObjectId.from_string(assetable_id)
+      end
+      true
     end
-```
+  end
+  ```
 
 ### Your asset model
 ``` ruby
@@ -142,10 +149,10 @@ Architecture to store uploaded files (cancan integration):
 ``` ruby
 class Asset < ActiveRecord::Base
   include Uploader::Asset
-  
+
   def uploader_create(params, request = nil)
     ability = Ability.new(request.env['warden'].user)
-    
+
     if ability.can? :create, self
       self.user = request.env['warden'].user
       super
@@ -153,10 +160,10 @@ class Asset < ActiveRecord::Base
       errors.add(:id, :access_denied)
     end
   end
-  
+
   def uploader_destroy(params, request = nil)
     ability = Ability.new(request.env['warden'].user)
-    
+
     if ability.can? :delete, self
       super
     else
@@ -167,7 +174,7 @@ end
 
 class Picture < Asset
   mount_uploader :data, PictureUploader
-  
+
   validates_integrity_of :data
   validates_filesize_of :data, :maximum => 2.megabytes.to_i
 end
@@ -178,7 +185,7 @@ For example user has one picture:
 ``` ruby
 class User < ActiveRecord::Base
   has_one :picture, :as => :assetable, :dependent => :destroy
-  
+
   fileuploads :picture
 
   # If your don't use strong_parameters, uncomment next line
@@ -203,7 +210,7 @@ Javascripts:
 Stylesheets:
 
 ``` ruby
-*= require uploader/application  
+*= require uploader/application
 ```
 
 ### Views

data/app/assets/javascripts/uploader/application.js

@@ -1,6 +1,6 @@
 //= require uploader/locales/en
-//= require uploader/tmpl.min
-//= require uploader/load-image.min
+//= require uploader/tmpl
+//= require uploader/load-image
 //= require uploader/jquery.ui.widget
 //= require uploader/jquery.iframe-transport
 //= require uploader/jquery.fileupload

data/app/assets/javascripts/uploader/canvas-to-blob.js

@@ -0,0 +1,95 @@
+/*
+ * JavaScript Canvas to Blob 2.0.5
+ * https://github.com/blueimp/JavaScript-Canvas-to-Blob
+ *
+ * Copyright 2012, Sebastian Tschan
+ * https://blueimp.net
+ *
+ * Licensed under the MIT license:
+ * http://www.opensource.org/licenses/MIT
+ *
+ * Based on stackoverflow user Stoive's code snippet:
+ * http://stackoverflow.com/q/4998908
+ */
+
+/*jslint nomen: true, regexp: true */
+/*global window, atob, Blob, ArrayBuffer, Uint8Array, define */
+
+(function (window) {
+    'use strict';
+    var CanvasPrototype = window.HTMLCanvasElement &&
+            window.HTMLCanvasElement.prototype,
+        hasBlobConstructor = window.Blob && (function () {
+            try {
+                return Boolean(new Blob());
+            } catch (e) {
+                return false;
+            }
+        }()),
+        hasArrayBufferViewSupport = hasBlobConstructor && window.Uint8Array &&
+            (function () {
+                try {
+                    return new Blob([new Uint8Array(100)]).size === 100;
+                } catch (e) {
+                    return false;
+                }
+            }()),
+        BlobBuilder = window.BlobBuilder || window.WebKitBlobBuilder ||
+            window.MozBlobBuilder || window.MSBlobBuilder,
+        dataURLtoBlob = (hasBlobConstructor || BlobBuilder) && window.atob &&
+            window.ArrayBuffer && window.Uint8Array && function (dataURI) {
+                var byteString,
+                    arrayBuffer,
+                    intArray,
+                    i,
+                    mimeString,
+                    bb;
+                if (dataURI.split(',')[0].indexOf('base64') >= 0) {
+                    // Convert base64 to raw binary data held in a string:
+                    byteString = atob(dataURI.split(',')[1]);
+                } else {
+                    // Convert base64/URLEncoded data component to raw binary data:
+                    byteString = decodeURIComponent(dataURI.split(',')[1]);
+                }
+                // Write the bytes of the string to an ArrayBuffer:
+                arrayBuffer = new ArrayBuffer(byteString.length);
+                intArray = new Uint8Array(arrayBuffer);
+                for (i = 0; i < byteString.length; i += 1) {
+                    intArray[i] = byteString.charCodeAt(i);
+                }
+                // Separate out the mime component:
+                mimeString = dataURI.split(',')[0].split(':')[1].split(';')[0];
+                // Write the ArrayBuffer (or ArrayBufferView) to a blob:
+                if (hasBlobConstructor) {
+                    return new Blob(
+                        [hasArrayBufferViewSupport ? intArray : arrayBuffer],
+                        {type: mimeString}
+                    );
+                }
+                bb = new BlobBuilder();
+                bb.append(arrayBuffer);
+                return bb.getBlob(mimeString);
+            };
+    if (window.HTMLCanvasElement && !CanvasPrototype.toBlob) {
+        if (CanvasPrototype.mozGetAsFile) {
+            CanvasPrototype.toBlob = function (callback, type, quality) {
+                if (quality && CanvasPrototype.toDataURL && dataURLtoBlob) {
+                    callback(dataURLtoBlob(this.toDataURL(type, quality)));
+                } else {
+                    callback(this.mozGetAsFile('blob', type));
+                }
+            };
+        } else if (CanvasPrototype.toDataURL && dataURLtoBlob) {
+            CanvasPrototype.toBlob = function (callback, type, quality) {
+                callback(dataURLtoBlob(this.toDataURL(type, quality)));
+            };
+        }
+    }
+    if (typeof define === 'function' && define.amd) {
+        define(function () {
+            return dataURLtoBlob;
+        });
+    } else {
+        window.dataURLtoBlob = dataURLtoBlob;
+    }
+}(this));

data/app/assets/javascripts/uploader/jquery.fileupload-angular.js

@@ -0,0 +1,348 @@
+/*
+ * jQuery File Upload AngularJS Plugin 1.0.1
+ * https://github.com/blueimp/jQuery-File-Upload
+ *
+ * Copyright 2013, Sebastian Tschan
+ * https://blueimp.net
+ *
+ * Licensed under the MIT license:
+ * http://www.opensource.org/licenses/MIT
+ */
+
+/*jslint nomen: true, unparam: true */
+/*global angular */
+
+(function () {
+    'use strict';
+
+    angular.module('blueimp.fileupload', [])
+
+        .provider('fileUpload', function () {
+            var scopeApply = function () {
+                    var scope = angular.element(this)
+                        .fileupload('option', 'scope')();
+                    if (!scope.$$phase) {
+                        scope.$apply();
+                    }
+                },
+                $config;
+            $config = this.defaults = {
+                handleResponse: function (e, data) {
+                    var files = data.result && data.result.files;
+                    if (files) {
+                        data.scope().replace(data.files, files);
+                    } else if (data.errorThrown ||
+                            data.textStatus === 'error') {
+                        data.files[0].error = data.errorThrown ||
+                            data.textStatus;
+                    }
+                },
+                add: function (e, data) {
+                    var scope = data.scope();
+                    data.process(function () {
+                        return scope.process(data);
+                    }).always(
+                        function () {
+                            var file = data.files[0],
+                                submit = function () {
+                                    return data.submit();
+                                };
+                            file.$cancel = function () {
+                                scope.clear(data.files);
+                                return data.abort();
+                            };
+                            file.$state = function () {
+                                return data.state();
+                            };
+                            file.$progress = function () {
+                                return data.progress();
+                            };
+                            file.$response = function () {
+                                return data.response();
+                            };
+                            if (file.$state() === 'rejected') {
+                                file._$submit = submit;
+                            } else {
+                                file.$submit = submit;
+                            }
+                            scope.$apply(function () {
+                                var method = scope.option('prependFiles') ?
+                                        'unshift' : 'push';
+                                Array.prototype[method].apply(
+                                    scope.queue,
+                                    data.files
+                                );
+                                if (file.$submit &&
+                                        (scope.option('autoUpload') ||
+                                        data.autoUpload) &&
+                                        data.autoUpload !== false) {
+                                    file.$submit();
+                                }
+                            });
+                        }
+                    );
+                },
+                progress: function (e, data) {
+                    data.scope().$apply();
+                },
+                done: function (e, data) {
+                    var that = this;
+                    data.scope().$apply(function () {
+                        data.handleResponse.call(that, e, data);
+                    });
+                },
+                fail: function (e, data) {
+                    var that = this;
+                    if (data.errorThrown === 'abort') {
+                        return;
+                    }
+                    if (data.dataType.indexOf('json') === data.dataType.length - 4) {
+                        try {
+                            data.result = angular.fromJson(data.jqXHR.responseText);
+                        } catch (err) {}
+                    }
+                    data.scope().$apply(function () {
+                        data.handleResponse.call(that, e, data);
+                    });
+                },
+                stop: scopeApply,
+                processstart: scopeApply,
+                processstop: scopeApply,
+                getNumberOfFiles: function () {
+                    return this.scope().queue.length;
+                },
+                dataType: 'json',
+                prependFiles: true,
+                autoUpload: false
+            };
+            this.$get = [
+                function () {
+                    return {
+                        defaults: $config
+                    };
+                }
+            ];
+        })
+
+        .provider('formatFileSizeFilter', function () {
+            var $config = this.defaults = {
+                // Byte units following the IEC format
+                // http://en.wikipedia.org/wiki/Kilobyte
+                units: [
+                    {size: 1000000000, suffix: ' GB'},
+                    {size: 1000000, suffix: ' MB'},
+                    {size: 1000, suffix: ' KB'}
+                ]
+            };
+            this.$get = function () {
+                return function (bytes) {
+                    if (!angular.isNumber(bytes)) {
+                        return '';
+                    }
+                    var unit = true,
+                        i = -1;
+                    while (unit) {
+                        unit = $config.units[i += 1];
+                        if (i === $config.units.length - 1 || bytes >= unit.size) {
+                            return (bytes / unit.size).toFixed(2) + unit.suffix;
+                        }
+                    }
+                };
+            };
+        })
+
+        .controller('FileUploadController', [
+            '$scope', '$element', '$attrs', 'fileUpload',
+            function ($scope, $element, $attrs, fileUpload) {
+                $scope.disabled = angular.element('<input type="file">')
+                    .prop('disabled');
+                $scope.queue = $scope.queue || [];
+                $scope.clear = function (files) {
+                    var queue = this.queue,
+                        i = queue.length,
+                        file = files,
+                        length = 1;
+                    if (angular.isArray(files)) {
+                        file = files[0];
+                        length = files.length;
+                    }
+                    while (i) {
+                        if (queue[i -= 1] === file) {
+                            return queue.splice(i, length);
+                        }
+                    }
+                };
+                $scope.replace = function (oldFiles, newFiles) {
+                    var queue = this.queue,
+                        file = oldFiles[0],
+                        i,
+                        j;
+                    for (i = 0; i < queue.length; i += 1) {
+                        if (queue[i] === file) {
+                            for (j = 0; j < newFiles.length; j += 1) {
+                                queue[i + j] = newFiles[j];
+                            }
+                            return;
+                        }
+                    }
+                };
+                $scope.progress = function () {
+                    return $element.fileupload('progress');
+                };
+                $scope.active = function () {
+                    return $element.fileupload('active');
+                };
+                $scope.option = function (option, data) {
+                    return $element.fileupload('option', option, data);
+                };
+                $scope.add = function (data) {
+                    return $element.fileupload('add', data);
+                };
+                $scope.send = function (data) {
+                    return $element.fileupload('send', data);
+                };
+                $scope.process = function (data) {
+                    return $element.fileupload('process', data);
+                };
+                $scope.processing = function (data) {
+                    return $element.fileupload('processing', data);
+                };
+                $scope.applyOnQueue = function (method) {
+                    var list = this.queue.slice(0),
+                        i,
+                        file;
+                    for (i = 0; i < list.length; i += 1) {
+                        file = list[i];
+                        if (file[method]) {
+                            file[method]();
+                        }
+                    }
+                };
+                $scope.submit = function () {
+                    this.applyOnQueue('$submit');
+                };
+                $scope.cancel = function () {
+                    this.applyOnQueue('$cancel');
+                };
+                // The fileupload widget will initialize with
+                // the options provided via "data-"-parameters,
+                // as well as those given via options object:
+                $element.fileupload(angular.extend(
+                    {scope: function () {
+                        return $scope;
+                    }},
+                    fileUpload.defaults
+                )).on('fileuploadadd', function (e, data) {
+                    data.scope = $scope.option('scope');
+                }).on([
+                    'fileuploadadd',
+                    'fileuploadsubmit',
+                    'fileuploadsend',
+                    'fileuploaddone',
+                    'fileuploadfail',
+                    'fileuploadalways',
+                    'fileuploadprogress',
+                    'fileuploadprogressall',
+                    'fileuploadstart',
+                    'fileuploadstop',
+                    'fileuploadchange',
+                    'fileuploadpaste',
+                    'fileuploaddrop',
+                    'fileuploaddragover',
+                    'fileuploadchunksend',
+                    'fileuploadchunkdone',
+                    'fileuploadchunkfail',
+                    'fileuploadchunkalways',
+                    'fileuploadprocessstart',
+                    'fileuploadprocess',
+                    'fileuploadprocessdone',
+                    'fileuploadprocessfail',
+                    'fileuploadprocessalways',
+                    'fileuploadprocessstop'
+                ].join(' '), function (e, data) {
+                    $scope.$emit(e.type, data);
+                });
+                // Observe option changes:
+                $scope.$watch(
+                    $attrs.fileupload,
+                    function (newOptions, oldOptions) {
+                        if (newOptions) {
+                            $element.fileupload('option', newOptions);
+                        }
+                    }
+                );
+            }
+        ])
+
+        .controller('FileUploadProgressController', [
+            '$scope', '$attrs', '$parse',
+            function ($scope, $attrs, $parse) {
+                var fn = $parse($attrs.progress),
+                    update = function () {
+                        var progress = fn($scope);
+                        if (!progress || !progress.total) {
+                            return;
+                        }
+                        $scope.num = Math.floor(
+                            progress.loaded / progress.total * 100
+                        );
+                    };
+                update();
+                $scope.$watch(
+                    $attrs.progress + '.loaded',
+                    function (newValue, oldValue) {
+                        if (newValue !== oldValue) {
+                            update();
+                        }
+                    }
+                );
+            }
+        ])
+
+        .controller('FileUploadPreviewController', [
+            '$scope', '$element', '$attrs', '$parse',
+            function ($scope, $element, $attrs, $parse) {
+                var fn = $parse($attrs.preview),
+                    file = fn($scope);
+                if (file.preview) {
+                    $element.append(file.preview);
+                }
+            }
+        ])
+
+        .directive('fileupload', function () {
+            return {
+                controller: 'FileUploadController'
+            };
+        })
+
+        .directive('progress', function () {
+            return {
+                controller: 'FileUploadProgressController'
+            };
+        })
+
+        .directive('preview', function () {
+            return {
+                controller: 'FileUploadPreviewController'
+            };
+        })
+
+        .directive('download', function () {
+            return function (scope, elm, attrs) {
+                elm.on('dragstart', function (e) {
+                    try {
+                        e.originalEvent.dataTransfer.setData(
+                            'DownloadURL',
+                            [
+                                'application/octet-stream',
+                                elm.prop('download'),
+                                elm.prop('href')
+                            ].join(':')
+                        );
+                    } catch (err) {}
+                });
+            };
+        });
+
+}());