blueimp-file-upload-rails 8.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b724168c1d92965dbcb096ab2f8dd47b7ad1013e
+  data.tar.gz: fd6d388cf58a4b2342e8526955600d54ed407ee8
+SHA512:
+  metadata.gz: 1ca334804763e0de86cecc121e9b28041c95461f1552308c2952229ce17698875ff0797334fa0d6eecfbe225f02f062642f2fb293090755894616aeb90b354a2
+  data.tar.gz: 4eb64c449e6ab193ea97dcb6176a40c02dbdefafc6dc7c6df57c20941863d4deedcd4d7d54b105af6b2adc4a005bf26bfa2b6480b7200a971d6d0a8e13d6fec8

data/app/models/blueimp/file_upload/file.rb

@@ -0,0 +1,36 @@
+module Blueimp
+  module FileUpload
+    module File
+      extend ActiveSupport::Concern
+      BLUEIMP_PARAMS = [:name, :size, :url, :thumbnail_url, :delete_url, :delete_type]
+
+      def as_json(options = {})
+        {}.tap do |json|
+          BLUEIMP_PARAMS.each do |param|
+            raise "Blueimp::FileUpload::File requires a method '#{param}'" if !respond_to?(param)
+            json[param] = send param
+          end
+        end
+      end
+
+      module ClassMethods
+        def from_params(params)
+          { :files => from_param(params[:files]) }
+        end
+
+        def from_param(param)
+          param = [param] unless param.kind_of?(Array)
+
+          [].tap do |list|
+            param.each do |p|
+              list << new.tap do |file|
+                file.name = p.original_filename
+                file.contents = p.read
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/views/blueimp/_file_upload.html.erb

@@ -0,0 +1,32 @@
+<%= form_tag action, :multipart => true, :class => "fileupload" do %>
+  <div class="row fileupload-buttonbar">
+    <div class="span7">
+      <span class="btn btn-success fileinput-button">
+        <i class="icon-plus icon-white"></i>
+        <span>Add files...</span>
+        <input type="file" name="files[]" multiple>
+      </span>
+      <button type="submit" class="btn btn-primary start">
+        <i class="icon-upload icon-white"></i>
+        <span>Start upload</span>
+      </button>
+      <button type="reset" class="btn btn-warning cancel">
+        <i class="icon-ban-circle icon-white"></i>
+        <span>Cancel upload</span>
+      </button>
+      <button type="button" class="btn btn-danger delete">
+        <i class="icon-trash icon-white"></i>
+        <span>Delete</span>
+      </button>
+      <input type="checkbox" class="toggle">
+      <span class="fileupload-loading"></span>
+    </div>
+    <div class="span5 fileupload-progress fade">
+      <div class="progress progress-success progress-striped active" role="progressbar" aria-valuemin="0" aria-valuemax="100">
+        <div class="bar" style="width: 0%;"></div>
+      </div>
+      <div class="progress-extended">&nbsp;</div>
+    </div>
+  </div>
+  <table role="presentation" class="table table-striped"><tbody class="files"></tbody></table>
+<% end %>

data/app/views/blueimp/_file_upload_templates.html.erb

@@ -0,0 +1,67 @@
+<script id="template-upload" type="text/x-tmpl">
+  {% for (var i=0, file; file=o.files[i]; i++) { %}
+    <tr class="template-upload fade">
+      <td>
+        <span class="preview"></span>
+      </td>
+      <td>
+        <p class="name">{%=file.name%}</p>
+        {% if (file.error) { %}
+          <div><span class="label label-important">Error</span> {%=file.error%}</div>
+        {% } %}
+      </td>
+      <td>
+        <p class="size">{%=o.formatFileSize(file.size)%}</p>
+        {% if (!o.files.error) { %}
+          <div class="progress progress-success progress-striped active" role="progressbar" aria-valuemin="0" aria-valuemax="100" aria-valuenow="0"><div class="bar" style="width:0%;"></div></div>
+        {% } %}
+      </td>
+      <td>
+        {% if (!o.files.error && !i && !o.options.autoUpload) { %}
+          <button class="btn btn-primary start">
+            <i class="icon-upload icon-white"></i>
+            <span>Start</span>
+          </button>
+        {% } %}
+        {% if (!i) { %}
+          <button class="btn btn-warning cancel">
+            <i class="icon-ban-circle icon-white"></i>
+            <span>Cancel</span>
+          </button>
+        {% } %}
+      </td>
+    </tr>
+  {% } %}
+</script>
+
+<script id="template-download" type="text/x-tmpl">
+  {% for (var i=0, file; file=o.files[i]; i++) { %}
+    <tr class="template-download fade">
+      <td>
+        <span class="preview">
+          {% if (file.thumbnail_url) { %}
+            <a href="{%=file.url%}" title="{%=file.name%}" class="gallery" download="{%=file.name%}"><img src="{%=file.thumbnail_url%}"></a>
+          {% } %}
+        </span>
+      </td>
+      <td>
+        <p class="name">
+          <a href="{%=file.url%}" title="{%=file.name%}" class="{%=file.thumbnail_url?'gallery':''%}" download="{%=file.name%}">{%=file.name%}</a>
+        </p>
+        {% if (file.error) { %}
+          <div><span class="label label-important">Error</span> {%=file.error%}</div>
+        {% } %}
+      </td>
+      <td>
+        <span class="size">{%=o.formatFileSize(file.size)%}</span>
+      </td>
+      <td>
+        <button class="btn btn-danger delete" data-type="{%=file.delete_type%}" data-url="{%=file.delete_url%}"{% if (file.delete_with_credentials) { %} data-xhr-fields='{"withCredentials":true}'{% } %}>
+          <i class="icon-trash icon-white"></i>
+          <span>Delete</span>
+        </button>
+        <input type="checkbox" name="delete" value="1" class="toggle">
+      </td>
+    </tr>
+  {% } %}
+</script>

data/lib/blueimp-file-upload-rails.rb

@@ -0,0 +1,15 @@
+# This is a generated file.
+require "blueimp-file-upload-rails/version"
+require "blueimp-load-image-rails"
+require "blueimp-templates-rails"
+require "blueimp-canvas-to-blob-rails"
+require "jquery-ui-rails"
+
+module Blueimp
+  module FileUpload
+    module Rails
+      class Engine < ::Rails::Engine
+      end
+    end
+  end
+end

data/lib/blueimp-file-upload-rails/version.rb

@@ -0,0 +1,14 @@
+# This is a generated file.
+module Blueimp
+  module FileUpload
+    module Rails
+      class Version
+        class << self
+          def to_s
+            "8.5.0"
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/assets/javascripts/blueimp-file-upload-basic-plus-ui.js

@@ -0,0 +1,51 @@
+//= require jquery.ui.widget
+//= require blueimp-templates
+//= require blueimp-load-image
+//= require blueimp-canvas-to-blob
+//= require jquery.iframe-transport
+//= require jquery.fileupload
+//= require jquery.fileupload-process
+//= require jquery.fileupload-image
+//= require jquery.fileupload-audio
+//= require jquery.fileupload-video
+//= require jquery.fileupload-validate
+//= require jquery.fileupload-ui
+
+$(function () {
+    $(".fileupload").each(function() {
+        var fileupload = this;
+        var $fileupload = $(this);
+        var url = $fileupload.data("url");
+
+        if (!url || $.trim(url) == "") {
+            url = $fileupload.attr("action");
+        }
+
+        $fileupload.fileupload({ url: url });
+
+        // Load existing files:
+        $fileupload.addClass("fileupload-processing");
+        $.ajax({
+            url: $fileupload.fileupload("option", "url"),
+            dataType: "json",
+            context: fileupload
+        }).always(function () {
+            $(this).removeClass("fileupload-processing");
+        }).done(function (result) {
+            $(this).fileupload("option", "done")
+                .call(this, null, {result: result});
+        });
+
+        // Show the blueimp Gallery as lightbox when clicking on image links:
+        $(".files", fileupload).on("click", ".gallery", function (event) {
+            // The :even filter removes duplicate links (thumbnail and file name links):
+            if (blueimp.Gallery($(".gallery", fileupload).filter(":even"), {
+                    index: this
+                })) {
+                // Prevent the default link action on
+                // successful Gallery initialization:
+                event.preventDefault();
+            }
+        });
+    });
+});

data/vendor/assets/javascripts/cors/jquery.postmessage-transport.js

@@ -0,0 +1,118 @@
+/*
+ * jQuery postMessage Transport Plugin 1.1.1
+ * https://github.com/blueimp/jQuery-File-Upload
+ *
+ * Copyright 2011, Sebastian Tschan
+ * https://blueimp.net
+ *
+ * Licensed under the MIT license:
+ * http://www.opensource.org/licenses/MIT
+ */
+
+/*jslint unparam: true, nomen: true */
+/*global define, window, document */
+
+(function (factory) {
+    'use strict';
+    if (typeof define === 'function' && define.amd) {
+        // Register as an anonymous AMD module:
+        define(['jquery'], factory);
+    } else {
+        // Browser globals:
+        factory(window.jQuery);
+    }
+}(function ($) {
+    'use strict';
+
+    var counter = 0,
+        names = [
+            'accepts',
+            'cache',
+            'contents',
+            'contentType',
+            'crossDomain',
+            'data',
+            'dataType',
+            'headers',
+            'ifModified',
+            'mimeType',
+            'password',
+            'processData',
+            'timeout',
+            'traditional',
+            'type',
+            'url',
+            'username'
+        ],
+        convert = function (p) {
+            return p;
+        };
+
+    $.ajaxSetup({
+        converters: {
+            'postmessage text': convert,
+            'postmessage json': convert,
+            'postmessage html': convert
+        }
+    });
+
+    $.ajaxTransport('postmessage', function (options) {
+        if (options.postMessage && window.postMessage) {
+            var iframe,
+                loc = $('<a>').prop('href', options.postMessage)[0],
+                target = loc.protocol + '//' + loc.host,
+                xhrUpload = options.xhr().upload;
+            return {
+                send: function (_, completeCallback) {
+                    counter += 1;
+                    var message = {
+                            id: 'postmessage-transport-' + counter
+                        },
+                        eventName = 'message.' + message.id;
+                    iframe = $(
+                        '<iframe style="display:none;" src="' +
+                            options.postMessage + '" name="' +
+                            message.id + '"></iframe>'
+                    ).bind('load', function () {
+                        $.each(names, function (i, name) {
+                            message[name] = options[name];
+                        });
+                        message.dataType = message.dataType.replace('postmessage ', '');
+                        $(window).bind(eventName, function (e) {
+                            e = e.originalEvent;
+                            var data = e.data,
+                                ev;
+                            if (e.origin === target && data.id === message.id) {
+                                if (data.type === 'progress') {
+                                    ev = document.createEvent('Event');
+                                    ev.initEvent(data.type, false, true);
+                                    $.extend(ev, data);
+                                    xhrUpload.dispatchEvent(ev);
+                                } else {
+                                    completeCallback(
+                                        data.status,
+                                        data.statusText,
+                                        {postmessage: data.result},
+                                        data.headers
+                                    );
+                                    iframe.remove();
+                                    $(window).unbind(eventName);
+                                }
+                            }
+                        });
+                        iframe[0].contentWindow.postMessage(
+                            message,
+                            target
+                        );
+                    }).appendTo(document.body);
+                },
+                abort: function () {
+                    if (iframe) {
+                        iframe.remove();
+                    }
+                }
+            };
+        }
+    });
+
+}));

data/vendor/assets/javascripts/cors/jquery.xdr-transport.js

@@ -0,0 +1,87 @@
+/*
+ * jQuery XDomainRequest Transport Plugin 1.1.3
+ * https://github.com/blueimp/jQuery-File-Upload
+ *
+ * Copyright 2011, Sebastian Tschan
+ * https://blueimp.net
+ *
+ * Licensed under the MIT license:
+ * http://www.opensource.org/licenses/MIT
+ *
+ * Based on Julian Aubourg's ajaxHooks xdr.js:
+ * https://github.com/jaubourg/ajaxHooks/
+ */
+
+/*jslint unparam: true */
+/*global define, window, XDomainRequest */
+
+(function (factory) {
+    'use strict';
+    if (typeof define === 'function' && define.amd) {
+        // Register as an anonymous AMD module:
+        define(['jquery'], factory);
+    } else {
+        // Browser globals:
+        factory(window.jQuery);
+    }
+}(function ($) {
+    'use strict';
+    if (window.XDomainRequest && !$.support.cors) {
+        $.ajaxTransport(function (s) {
+            if (s.crossDomain && s.async) {
+                if (s.timeout) {
+                    s.xdrTimeout = s.timeout;
+                    delete s.timeout;
+                }
+                var xdr;
+                return {
+                    send: function (headers, completeCallback) {
+                        var addParamChar = /\?/.test(s.url) ? '&' : '?';
+                        function callback(status, statusText, responses, responseHeaders) {
+                            xdr.onload = xdr.onerror = xdr.ontimeout = $.noop;
+                            xdr = null;
+                            completeCallback(status, statusText, responses, responseHeaders);
+                        }
+                        xdr = new XDomainRequest();
+                        // XDomainRequest only supports GET and POST:
+                        if (s.type === 'DELETE') {
+                            s.url = s.url + addParamChar + '_method=DELETE';
+                            s.type = 'POST';
+                        } else if (s.type === 'PUT') {
+                            s.url = s.url + addParamChar + '_method=PUT';
+                            s.type = 'POST';
+                        } else if (s.type === 'PATCH') {
+                            s.url = s.url + addParamChar + '_method=PATCH';
+                            s.type = 'POST';
+                        }
+                        xdr.open(s.type, s.url);
+                        xdr.onload = function () {
+                            callback(
+                                200,
+                                'OK',
+                                {text: xdr.responseText},
+                                'Content-Type: ' + xdr.contentType
+                            );
+                        };
+                        xdr.onerror = function () {
+                            callback(404, 'Not Found');
+                        };
+                        if (s.xdrTimeout) {
+                            xdr.ontimeout = function () {
+                                callback(0, 'timeout');
+                            };
+                            xdr.timeout = s.xdrTimeout;
+                        }
+                        xdr.send((s.hasContent && s.data) || null);
+                    },
+                    abort: function () {
+                        if (xdr) {
+                            xdr.onerror = $.noop();
+                            xdr.abort();
+                        }
+                    }
+                };
+            }
+        });
+    }
+}));

data/vendor/assets/javascripts/jquery.fileupload-angular.js

@@ -0,0 +1,397 @@
+/*
+ * jQuery File Upload AngularJS Plugin 1.4.0
+ * 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 define, angular */
+
+(function (factory) {
+    'use strict';
+    if (typeof define === 'function' && define.amd) {
+        // Register as an anonymous AMD module:
+        define([
+            'jquery',
+            'angular',
+            './jquery.fileupload-image',
+            './jquery.fileupload-audio',
+            './jquery.fileupload-video',
+            './jquery.fileupload-validate'
+        ], factory);
+    } else {
+        factory();
+    }
+}(function () {
+    'use strict';
+
+    angular.module('blueimp.fileupload', [])
+
+        // The fileUpload service provides configuration options
+        // for the fileUpload directive and default handlers for
+        // File Upload events:
+        .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();
+                                },
+                                i;
+                            for (i = 0; i < data.files.length; i += 1) {
+                                data.files[i]._index = i;
+                            }
+                            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 &&
+                            data.dataType.indexOf('json') === data.dataType.length - 4) {
+                        try {
+                            data.result = angular.fromJson(data.jqXHR.responseText);
+                        } catch (ignore) {}
+                    }
+                    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
+                    };
+                }
+            ];
+        })
+
+        // Format byte numbers to readable presentations:
+        .provider('formatFileSizeFilter', function () {
+            var $config = {
+                // 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.defaults = $config;
+            this.$get = function () {
+                return function (bytes) {
+                    if (!angular.isNumber(bytes)) {
+                        return '';
+                    }
+                    var unit = true,
+                        i = 0,
+                        prefix,
+                        suffix;
+                    while (unit) {
+                        unit = $config.units[i];
+                        prefix = unit.prefix || '';
+                        suffix = unit.suffix || '';
+                        if (i === $config.units.length - 1 || bytes >= unit.size) {
+                            return prefix + (bytes / unit.size).toFixed(2) + suffix;
+                        }
+                        i += 1;
+                    }
+                };
+            };
+        })
+
+        // The FileUploadController initializes the fileupload widget and
+        // provides scope methods to control the File Upload functionality: 
+        .controller('FileUploadController', [
+            '$scope', '$element', '$attrs', '$window', 'fileUpload',
+            function ($scope, $element, $attrs, $window, fileUpload) {
+                var uploadMethods = {
+                    progress: function () {
+                        return $element.fileupload('progress');
+                    },
+                    active: function () {
+                        return $element.fileupload('active');
+                    },
+                    option: function (option, data) {
+                        return $element.fileupload('option', option, data);
+                    },
+                    add: function (data) {
+                        return $element.fileupload('add', data);
+                    },
+                    send: function (data) {
+                        return $element.fileupload('send', data);
+                    },
+                    process: function (data) {
+                        return $element.fileupload('process', data);
+                    },
+                    processing: function (data) {
+                        return $element.fileupload('processing', data);
+                    }
+                };
+                $scope.disabled = !$window.jQuery.support.fileInput;
+                $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) {
+                        i -= 1;
+                        if (queue[i] === 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.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');
+                };
+                // Add upload methods to the scope:
+                angular.extend($scope, uploadMethods);
+                // 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);
+                }).on('remove', function () {
+                    // Remove upload methods from the scope,
+                    // when the widget is removed:
+                    var method;
+                    for (method in uploadMethods) {
+                        if (uploadMethods.hasOwnProperty(method)) {
+                            delete $scope[method];
+                        }
+                    }
+                });
+                // Observe option changes:
+                $scope.$watch(
+                    $attrs.fileUpload,
+                    function (newOptions) {
+                        if (newOptions) {
+                            $element.fileupload('option', newOptions);
+                        }
+                    }
+                );
+            }
+        ])
+
+        // Provide File Upload progress feedback:
+        .controller('FileUploadProgressController', [
+            '$scope', '$attrs', '$parse',
+            function ($scope, $attrs, $parse) {
+                var fn = $parse($attrs.fileUploadProgress),
+                    update = function () {
+                        var progress = fn($scope);
+                        if (!progress || !progress.total) {
+                            return;
+                        }
+                        $scope.num = Math.floor(
+                            progress.loaded / progress.total * 100
+                        );
+                    };
+                update();
+                $scope.$watch(
+                    $attrs.fileUploadProgress + '.loaded',
+                    function (newValue, oldValue) {
+                        if (newValue !== oldValue) {
+                            update();
+                        }
+                    }
+                );
+            }
+        ])
+
+        // Display File Upload previews:
+        .controller('FileUploadPreviewController', [
+            '$scope', '$element', '$attrs', '$parse',
+            function ($scope, $element, $attrs, $parse) {
+                var fn = $parse($attrs.fileUploadPreview),
+                    file = fn($scope);
+                if (file.preview) {
+                    $element.append(file.preview);
+                }
+            }
+        ])
+
+        .directive('fileUpload', function () {
+            return {
+                controller: 'FileUploadController'
+            };
+        })
+
+        .directive('fileUploadProgress', function () {
+            return {
+                controller: 'FileUploadProgressController'
+            };
+        })
+
+        .directive('fileUploadPreview', function () {
+            return {
+                controller: 'FileUploadPreviewController'
+            };
+        })
+
+        // Enhance the HTML5 download attribute to
+        // allow drag&drop of files to the desktop:
+        .directive('download', function () {
+            return function (scope, elm) {
+                elm.on('dragstart', function (e) {
+                    try {
+                        e.originalEvent.dataTransfer.setData(
+                            'DownloadURL',
+                            [
+                                'application/octet-stream',
+                                elm.prop('download'),
+                                elm.prop('href')
+                            ].join(':')
+                        );
+                    } catch (ignore) {}
+                });
+            };
+        });
+
+}));