rails-uploader 0.2.8 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 88c10bdc5c1c64828bf15e99962dee2c0e547eea
-  data.tar.gz: 00ad13f2236fa9751d588bfac7275578dab4bd99
+  metadata.gz: 78c6ab34d67ec73bf7b3d802e186d3a179d7a25e
+  data.tar.gz: e76947d90bd1f5c0ea024a3939a0565ab7088477
 SHA512:
-  metadata.gz: 637a0ecdea91d3edabb08bb572a7a7739ae97ea6a2d8a8cbe76c724c64836c39fef17f9d6b94e96148a8f7a72bd685ea9c7615e48270e715a0e38d4e29bff136
-  data.tar.gz: 6cda451daaf4e3d7a5728dcfe49c2cf5e9b8fa07e78e76128fd3d50bc82ad45f5178ae1a15f6a57dc703d7907e321a19a8e4c8cb07d3c6a3d85fafd2e26fe0d6
+  metadata.gz: 34b3d48312fd023264a053d7c7c669dd6da137701b33c288c8e18f90bc70218d1e467f48c84673f60738f84aaec8f50a3490ff5d665587428a781ea23a73c327
+  data.tar.gz: 25737d84ebc664c361195c97b380a694297a96c9c7d5d299187cf898404ceaf8f74080f6c03cb93b77e711755b43352c5d6b9b79b66cf4a0d9127e7825d932dc

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright 2012 Fodojo http://fodojo.com/
+Copyright 2016 Fodojo LLC http://fodojo.com/
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -2,16 +2,12 @@
 
 This gem use https://github.com/blueimp/jQuery-File-Upload for upload files.
 
-Preview:
-
-![Uploader in use](http://img39.imageshack.us/img39/2206/railsuploader.png)
-
 ## Install
 
 In Gemfile:
 
 ```
-gem "rails-uploader"
+gem 'rails-uploader'
 ```
 
 In routes:
@@ -33,44 +29,14 @@ 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
-    else
-      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
-      errors.add(:id, :access_denied)
-    end
-  end
 end
 
 class Picture < Asset
-  mount_uploader :data, PictureUploader
-
-  validates_integrity_of :data
-  validates_filesize_of :data, :maximum => 2.megabytes.to_i
+  mount_uploader :data, PictureUploader, mount_on: :data_file_name
+  validates :data, file_size: { maximum: 5.megabytes.to_i }
 
-  # structure of returned json array of files. (used in Hash.to_json operation)
-  def serializable_hash(options=nil)
-    {
-        "id" => id.to_s,
-        "filename" => File.basename(data.path),
-        "url" => data.url,
-        "thumb_url" => data.url(:thumb),
-        "public_token" => public_token
-    }
+  def thumb_url
+    url(:thumb)
   end
 end
 ```
@@ -79,12 +45,9 @@ For example user has one picture:
 
 ``` ruby
 class User < ActiveRecord::Base
-  has_one :picture, :as => :assetable, :dependent => :destroy
+  has_one :picture, as: :assetable, dependent: :destroy
 
   fileuploads :picture
-
-  # If your don't use strong_parameters, uncomment next line
-  # attr_accessible :fileupload_guid
 end
 ```
 
@@ -94,45 +57,6 @@ Find asset by foreign key or guid:
 @user.fileupload_asset(:picture)
 ```
 
-### Mongoid
-
-No parent asset model is required, one only has to `include Uploader::Asset::Mongoid` into the
-model that should act like an asset:
-
-``` ruby
-class Picture
-  include Mongoid::Document
-  include Uploader::Asset::Mongoid
-
-  belongs_to :user
-end
-
-class User
-  include Mongoid::Document
-  include Uploader::Fileuploads
-
-  has_one :picture, :as => :assetable
-
-  fileuploads :picture
-end
-```
-
-### Notice
-
-User method fileuploads only once pre model. So if you have many attached files, use this:
-
-``` ruby
-class User
-  include Uploader::Fileuploads
-
-  has_one :picture, :as => :assetable
-  has_one :avatar, :as => :assetable
-
-  fileuploads :picture, :avatar
-end
-```
-
-
 ### Include assets
 
 Javascripts:
@@ -156,19 +80,19 @@ Stylesheets:
 or FormBuilder:
 
 ```erb
-<%= form.uploader_field :photo, :sortable => true %>
+<%= form.uploader_field :photo, sortable: true %>
 ```
 
 ### Formtastic
 
 ```erb
-<%= f.input :pictures, :as => :uploader %>
+<%= f.input :pictures, as: :uploader %>
 ```
 
 ### SimpleForm
 
 ```erb
-<%= f.input :pictures, :as => :uploader, :input_html => {:sortable => true} %>
+<%= f.input :pictures, as: :uploader, input_html: { sortable: true } %>
 ```
 
 #### Confirming deletions
@@ -181,6 +105,158 @@ This is only working in Formtastic and FormBuilder:
 # the i18n lookup key would be en.formtastic.delete_confirmations.picture
 ```
 
+## Authorization
+
+Setup custom authorization adapter and current user:
+
+``` ruby
+# config/initializers/uploader.rb
+Uploader.setup do |config|
+  config.authorization_adapter = CanCanUploaderAdapter
+  config.current_user_proc = -> (request) { request.env['warden'].user }
+end
+```
+
+CanCanUploaderAdapter class just create cancan ability object and call can? method with same args:
+
+``` ruby
+class CanCanUploaderAdapter < Uploader::AuthorizationAdapter
+  def authorized?(action, subject = nil)
+    cancan_ability.can?(action, subject)
+  end
+
+  def scope_collection(collection, action = :index)
+    collection.accessible_by(cancan_ability, action)
+  end
+
+  protected
+
+  def cancan_ability
+    @cancan_ability ||= Ability.new(user)
+  end
+end
+```
+
+## JSON Response
+
+https://github.com/blueimp/jQuery-File-Upload/wiki/Setup#using-jquery-file-upload-ui-version-with-a-custom-server-side-upload-handler
+
+Extend your custom server-side upload handler to return a JSON response akin to the following output:
+
+``` json
+{"files": [
+  {
+    "name": "picture1.jpg",
+    "size": 902604,
+    "url": "http:\/\/example.org\/files\/picture1.jpg",
+    "thumb_url": "http:\/\/example.org\/files\/thumbnail\/picture1.jpg",
+    "id": 1,
+    "content_type": "image/jpg"
+  },
+  {
+    "name": "picture2.jpg",
+    "size": 841946,
+    "url": "http:\/\/example.org\/files\/picture2.jpg",
+    "thumb_url": "http:\/\/example.org\/files\/thumbnail\/picture2.jpg",
+    "id": 2,
+    "content_type": "image/jpg"
+  }
+]}
+```
+
+To return errors to the UI, just add an error property to the individual file objects:
+
+``` json
+{"files": [
+  {
+    "name": "picture1.jpg",
+    "size": 902604,
+    "error": "Filetype not allowed"
+  },
+  {
+    "name": "picture2.jpg",
+    "size": 841946,
+    "error": "Filetype not allowed"
+  }
+]}
+```
+
+When removing files using the delete button, the response should be like this:
+
+``` json
+{"files": [
+  {
+    "picture1.jpg": true
+  },
+  {
+    "picture2.jpg": true
+  }
+]}
+```
+
+Note that the response should always be a JSON object containing a files array even if only one file is uploaded.
+
+### Customize JSON response and views
+
+To customize JSON response just overwrite to_fileupload method:
+
+``` ruby
+class Asset
+  include Uploader::Asset
+
+  def to_fileupload
+    {
+      id: id,
+      name: filename,
+      content_type: content_type,
+      size: size,
+      url:  url,
+      thumb_url: thumb_url
+    }
+  end
+end
+```
+
+For exsample let's overwrite id method to public_token method:
+
+``` ruby
+class Asset
+  include Uploader::Asset
+
+  def to_fileupload
+    super.merge(id: public_token)
+  end
+
+  def self.fileupload_find_asset(params)
+    where(public_token: params[:id]).first
+  end
+end
+```
+
+To customize views just create new theme. For example create avatar theme:
+
+    app/views/uploader/avatar/_container.html.erb
+    app/views/uploader/avatar/_download.html.erb
+    app/views/uploader/avatar/_upload.html.erb
+
+And pass theme to input field:
+
+``` slim
+= form.uploader_field :photo, theme: 'avatar'
+```
+
+## Chunked file uploads
+
+Chunked file uploads are only supported by browsers with support for XHR file uploads and the Blob API, which includes Google Chrome and Mozilla Firefox 4+.
+
+To upload large files in smaller chunks, set the max_chunk_size option to a preferred maximum chunk size in Bytes:
+
+``` slim
+= f.uploader_field :video, class: 'button', theme: 'media', data: { max_chunk_size: 10_000_000 }
+```
+
+That's it!
+
 ## Contributing
 
 1. Fork it
@@ -189,4 +265,4 @@ This is only working in Formtastic and FormBuilder:
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create new Pull Request
 
-Copyright (c) 2013 Fodojo, released under the MIT license
+Copyright (c) 2016 Fodojo LLC, released under the MIT license

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

@@ -1,8 +1,10 @@
-//= require uploader/jquery.ui.widget
-//= require uploader/locales/en
-//= require uploader/tmpl.min
-//= require uploader/load-image.min
+//= require uploader/vendor/jquery.ui.widget
+//= require uploader/vendor/tmpl.min
+
 //= require uploader/jquery.iframe-transport
 //= require uploader/jquery.fileupload
+//= require uploader/jquery.fileupload-process
+//= require uploader/jquery.fileupload-validate
 //= require uploader/jquery.fileupload-ui
 
+//= require uploader/jquery.uploader

data/app/assets/javascripts/uploader/jquery.uploader.js.coffee

@@ -0,0 +1,58 @@
+$ = jQuery
+
+$.fn.uploaderWidget = (options = {}) ->
+  @each ->
+    $this = $(this)
+    data = $this.data('uploaderWidget')
+    if (!data)
+      $this.data('uploaderWidget', new UploaderWidget(this, options))
+    if (typeof options is 'string')
+      data[options]()
+
+class UploaderWidget
+  constructor: (@dom_id, options = {}) ->
+    defaults =
+      dataType: 'json'
+      autoUpload: true
+      paramName: 'asset[data]'
+      formData: (form) -> return []
+      namespace: 'uploader'
+      uploadTemplateId: 'template-upload-'
+      downloadTemplateId: 'template-download-'
+
+    @options = $.extend defaults, options
+
+    this._setup()
+
+  _setup: ->
+    @element = $(@dom_id)
+    @container = @element.find('div.uploader-files')
+    @template = @element.data('tpml')
+    @input = @element.find('input[type="file"]:eq(0)')
+
+    @options['dropZone'] = @element
+    @options['filesContainer'] = @container
+    @options['uploadTemplateId'] += @template
+    @options['downloadTemplateId'] += @template
+
+    this._initFileupload()
+
+  _initFileupload: ->
+    @input.fileupload(@options)
+
+    @uploader = (@input.data('blueimp-fileupload') || @input.data('fileupload'))
+
+    this._load() if @element.data('exists')
+
+  _load: ->
+    $.ajax(
+      url: @input.data('url')
+      dataType: 'json'
+      method: 'GET'
+      success: (data) =>
+        if data['files']?
+          this.render(data['files'])
+    )
+
+  render: (files) ->
+    @uploader._renderDownload(files).appendTo(@container)

data/app/controllers/uploader/attachments_controller.rb

@@ -1,56 +1,80 @@
 module Uploader
   class AttachmentsController < ActionController::Metal
     include AbstractController::Callbacks
-  
-    before_filter :find_klass
-    before_filter :find_asset, :only => [:destroy]
-    
+    include Uploader::Authorization
+    include Uploader::ChunkedUploads
+
+    before_action :find_klass
+    before_action :build_asset, only: [:create]
+    before_action :find_asset, only: [:destroy]
+
+    def index
+      authorize!(:index, @klass)
+
+      @assets = @klass.fileupload_find_assets(params)
+      @assets = uploader_authorization.scope_collection(@assets)
+
+      render_json(files: @assets.map(&:to_fileupload))
+    end
+
     def create
-      @asset = @klass.new(params[:asset])
-      @asset.uploader_create(params, request)
+      authorize!(:create, @asset)
+
+      with_chunked_upload(asset_params[:data]) do |file|
+        @asset.data = file
+        @asset.fileupload_create(params, request)
+      end
+
       render_resourse(@asset, 201)
     end
-    
-    def update
-      @assets = Array.wrap(params[:assets] || [])
 
-      @assets.each_with_index do |id, index|
-        @klass.where(:id => id).update_all(:sort_order => index)
-      end
+    def update
+      authorize!(:update, @klass)
 
-      render_json(:files => [])
+      @klass.fileupload_update_ordering(params)
+      render_json(files: [])
     end
 
     def destroy
-      @asset.uploader_destroy(params, request)
-      render_resourse(@asset, 200)
+      authorize!(:destroy, @asset)
+
+      @asset.fileupload_destroy(params, request)
+      render_resourse(@asset)
     end
-    
+
     protected
-    
-      def find_klass
-        @klass = Uploader.constantize(params[:klass])
-        raise ActionController::RoutingError.new("Class not found #{params[:klass]}") if @klass.nil?
-      end
 
-      def find_asset
-        @asset = @klass.where(:public_token => params[:id]).first
-        raise ActionController::RoutingError.new("Asset not found by guid #{params[:id]}") if @asset.nil? 
-      end
-      
-      def render_resourse(record, status = 200)
-        if record.errors.empty?
-          render_json({:files => [record]}, status)
-        else
-          render_json(record.errors, 422)
-        end
-      end
-      
-      def render_json(hash_or_object, status = 200)
-        self.status = status
-        self.content_type = Uploader.content_type(env["HTTP_USER_AGENT"])
-        self.response_body = hash_or_object.to_json(:root => false)
+    def find_klass
+      @klass = Uploader.constantize(params[:klass])
+      raise ActionController::RoutingError, "Class not found #{params[:klass]}" if @klass.nil?
+    end
+
+    def build_asset
+      @asset = @klass.new(asset_params)
+    end
+
+    def find_asset
+      @asset = @klass.fileupload_find_asset(params)
+      raise ActionController::RoutingError, "Asset not found by #{params[:id]}" if @asset.nil?
+    end
+
+    def render_resourse(record, status = 200)
+      if record.errors.empty?
+        render_json({ files: [record.to_fileupload] }, status)
+      else
+        hash = { name: record.filename, error: record.errors.full_messages.first }
+        render_json({ files: [hash] }, 422)
       end
-      
+    end
+
+    def render_json(hash_or_object, status = 200)
+      self.status = status
+      self.content_type = request.format
+      self.response_body = hash_or_object.to_json(root: false)
+    end
+
+    def asset_params
+      ActionController::Parameters.new(params).require(:asset).permit(:data)
+    end
   end
 end