uploader 0.1.3

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Justin Ball
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,275 @@
+= Uploader
+
+Uploader makes it easy to integrate multiple file uploads into your application using SWFUpload
+
+
+== Installation
+
+=== Install Dependancies:
+sudo gem install mime-types
+
+
+=== Install the gem:
+sudo gem install uploader
+
+
+=== Add the gem to environment.rb
+config.gem 'uploader'
+
+
+=== Create a model for uploads.
+We recommend creating a model called upload.rb.  acts_as_uploader accepts all valid options for paperclip via :has_attached_file => {}
+
+  class Upload < ActiveRecord::Base
+    acts_as_uploader  :enable_s3 => false,
+                      :has_attached_file => {
+                        :url     => "/system/:attachment/:id_partition/:style/:basename.:extension",
+                        :path    => ":rails_root/public/system/:attachment/:id_partition/:style/:basename.:extension",
+                        :styles  => { :icon => "30x30!", 
+                                      :thumb => "100>", 
+                                      :small => "150>", 
+                                      :medium => "300>", 
+                                      :large => "660>"},
+                        :default_url => "/images/profile_default.jpg",
+                        :storage => :s3,
+                        :s3_credentials => File.join(RAILS_ROOT, 'config', 's3.yml'),
+                        :bucket => "assets.#{SITE[:domain]}",
+                        :s3_host_alias => "assets.#{SITE[:domain]}",
+                        :convert_options => {
+                           :all => '-quality 80'
+                         }
+                           
+    # only allow images:
+    # validates_attachment_content_type :file, :content_type => ['image/jpeg', 'image/pjpeg', 'image/jpg']
+    
+    # The following method is implemented in 'acts_as_uploader'.  This is the method destroy will check to see if
+    # the user has permission to delete the object.  Add additional logic as needed or if the existing logic
+    # looks fine then feel free to delete this comment and the can_edit? method.
+    def can_edit?(check_user)
+      return false if user.blank?
+      check_user == self.user
+    end
+    
+  end
+
+
+=== Add multiple file uploads to one of your models
+
+Your uploads will need a parent object to attach to.  For example, a user might have many files:
+
+  class User < ActiveRecord::Base
+    has_many :uploads, :as => :uploadable, :order => 'created_at desc', :dependent => :destroy 
+  
+    def can_upload?(check_user)
+      self == check_user
+    end
+  end
+
+or a photo album might have many photos
+
+  class PhotoAlbum < ActiveRecord::Base
+    has_many :photos, :as => :uploadable, :order => 'created_at desc', :dependent => :destroy 
+  
+    def can_upload?(check_user)
+      self.editors.include?(check_user)
+    end
+  end
+
+Note that in both examples there is an implementation of 'can_upload?'.  This method must be
+included in any parent object and will control who has permission to upload files.
+
+=== The application controller
+Be sure you have turned on protect from forgery.  This is required for uploader to get the appropriate tokens
+from your Rails application.  It is also a good idea and is the default in new Rails applications.
+
+  protect_from_forgery # See ActionController::RequestForgeryProtection for details
+
+=== The uploads controller
+You can modify the upload controller behavior by inheriting from the uploader controller.  For example, you might want to
+require that users be logged in to upload a file.  There are a number of methods in the uploads controller that contain 
+default functionality that you may consider overriding.
+
+Be sure to modify your routes file.  Add the following line to ensure that your application uses the new uploads 
+controller instead of directly using the one inside the gem:
+
+  map.resources :uploads, :collection => { :swfupload => :post }
+  
+
+  class UploadsController < Uploader::UploadsController
+    
+    before_filter :login_required
+    
+    protected
+    
+    # The default 'get_upload_text' method throws an exception.  You must override this method in your controller.  It
+    # is used by the swf upload call to generate the html to be returned to the client.
+    # Here's an example:
+    def get_upload_text(upload)
+      render_to_string( :partial => 'uploads/upload_row', :object => upload, :locals => { :parent => @parent } )
+    end
+    
+    # The existing method will handle most cases but you might choose a different message or a different redirect:
+    def permission_denied
+      message = t("uploader.permission_denied")
+      respond_to do |format|
+        format.html do
+          flash[:notice] = message
+          redirect_to get_redirect
+        end
+        format.js { render :text => message }
+        format.json { render :json => { :success => false, :message => message } }
+      end
+    end
+  
+    # Simply attempts to redirect to the parent object.  You might want to build something more sophisticated that
+    # redirect to different areas of you site depending on the type of object that was uploaded or on based on the parent.
+    def get_redirect
+      @parent
+    end
+
+    # The default action is to call 'can_upload?' on the parent object.  Be sure to implement 'can_upload?(check_user) on
+    # your parent objects
+    def has_permission_to_upload(user, upload_parent)
+      upload_parent.can_upload?(user)
+    end
+    
+    
+    # By default the controller will use a model named 'Upload' to do a destroy.  If you want to use a different model
+    # you'll need to override 'set_upload_for_destroy in your controller to find the object using a different object.  
+    # For example:
+    def set_upload_for_destroy
+      @upload = Photo.find(params[:id])
+    end
+    
+  end
+
+
+=== Other Methods
+
+uploader assumes that you have a method called 'redirect_back_or_default' which is common in many Rails projects.  This method
+is called upon completion of destroy or created when the requested format is 'html'.  A simple implementation of this method is listed
+below:
+
+  def redirect_back_or_default(default)
+    redirect_to(session[:return_to] || default)
+    session[:return_to] = nil
+  end
+
+
+=== Configure your views.
+You'll need something like this in your layout so that uploader can add in the required css and javascript files.
+
+<%= yield :head -%>
+
+Then to add an upload form:
+<%= upload_form(parent_object) %>
+parent_object should be the object which owns the uploads.  ie a user, photo_album, etc.
+
+=== Rake Tasks
+
+Add the rake tasks for uploader to your project.  You will need to add the following to your applications's Rakefile
+
+  require 'uploader'
+  require 'uploader/tasks'
+
+Then run:
+  rake uploader:sync
+
+Last run:
+  rake db:migrate
+This will create an uploads table for you.  If you selected a different name for your model you will need to modify the migration accordingly.  
+== WARNING
+The migration will drop any existing 'uploads' table you have in place
+
+
+That will copy all the required javascript and asset files into your project
+
+
+== Amazon s3
+
+
+If you'd like to store your uploads on Amazon's S3 service there are a few extra steps involved.  See the example file above
+to view the options in context.
+
+=== Turn on s3
+Set the enable_s3 option to true in acts_as_uploader
+  :enable_s3 => true
+
+Pass your s3 credentials into acts_as_uploader
+  :has_attached_file => { :s3_credentials => File.join(RAILS_ROOT, 'config', 's3.yml') }
+
+=== Setup your credentials
+Create a file named s3.yml in your configuration directory and add the following lines:
+
+  access_key_id: PUT YOUR KEY HERE
+  secret_access_key: PUT YOUR SECRET ACCESS KEY HERE
+
+
+=== Turn on the Daemon process
+There are a number of timing issues that you will run into if you attempt to upload files directly to s3.  To overcome that
+problem uploader includes a daemon process which will send the files to Amazon asynchronously.  Note that the uploader
+will leave your local copy in place.
+TODO docs for Daemon
+
+
+== Other Stuff
+
+If you'd like to add an ajax delete to your uploads page this code might come in handy.
+
+Say you have chosen to display your upload in a table.  Your code might look like the following.  Note that there are a number of assumptions made in this code.  Modify it to suite your needs.
+
+  <tr id="<%= upload_row.dom_id %>" class="delete-container <%= cycle('odd', 'even') %>" <%=style-%> >
+  	<td><div class="file-icon"><%= image_tag upload_row.icon -%></div></td>
+  	<td><a href="<%=upload_row.file.url%>"><%= truncate(sanitize(upload_row.file_name), 100) %></a></td>
+  	<td><%= upload_row.created_at.to_s(:long) -%></td>
+  	<td>
+  		<% if parent.can_edit?(current_user) -%>
+  			<% form_for(:upload, :url => upload_path(upload_row.id), :html => { :class => "delete-form", :method => :delete} ) do |f| -%>
+  				<%= image_submit_tag '/images/icons/delete.png', {:id => 'submit-comment', :title => t('general.delete_file'), :class => 'submit-delete', :width => '12', :height => '12', :alt => t('general.delete_file') } %>
+  			<% end -%>
+  			<% if !style.empty? -%>
+  			<script type="text/javascript" language="JavaScript">
+  				jQuery("#<%= upload_row.dom_id %>").fadeIn("slow");
+  			</script>
+  			<% end -%>
+  		<% end -%>
+  	</td>
+  </tr>
+
+
+I put the following in my main upload view
+  <% content_for :javascript do  -%>
+
+    setup_submit_delete();
+
+    function upload_completed_callback(data){
+      jQuery('#upload-list').prepend(data);
+      setup_submit_delete();
+    }
+  <% end -%>
+  
+  
+
+The following jQuery code will do an ajax delete for you
+
+  function setup_submit_delete(){
+  	jQuery(".submit-delete").click(function() {
+  		// if(!confirm("Are you sure?")){
+  		// 	return false;
+  		// }
+      jQuery(this).parents('.delete-container').fadeOut();
+      var form = jQuery(this).parents('form');
+      jQuery.post(form.attr('action') + '.json', form.serialize(),
+        function(data){
+          var json = eval('(' + data + ')');
+          if(!json.success){
+            jQuery.jGrowl.info(json.message);
+          }
+        });
+      return false;
+    });
+  }
+
+
+
+Copyright (c) 2009 Justin Ball, released under the MIT license

data/Rakefile

@@ -0,0 +1,66 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the uploader plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the uploader plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Uploader'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "uploader"
+    gemspec.summary = "SWFUpload + Paperclip wrapped in an engine with love."
+    gemspec.email = "justinball@gmail.com"
+    gemspec.homepage = "http://github.com/jbasdf/uploader"
+    gemspec.description = "Uploader gem that makes it simple add multiple file uploads to your Rails project using SWFUpload and Paperclip"
+    gemspec.authors = ["Justin Ball", "David South"]
+    gemspec.files.include %w( tasks/rails.rake lib/uploader/*.rb lib/uploader/middleware/*.rb db/migrate/*.rb public/images/file_icons/* app/views/uploads/* )
+    gemspec.rubyforge_project = 'uploader'    
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+# rubyforge tasks
+begin
+  require 'rake/contrib/sshpublisher'
+  namespace :rubyforge do
+
+    desc "Release gem and RDoc documentation to RubyForge"
+    task :release => ["rubyforge:release:gem", "rubyforge:release:docs"]
+
+    namespace :release do
+      desc "Publish RDoc to RubyForge."
+      task :docs => [:rdoc] do
+        config = YAML.load(
+            File.read(File.expand_path('~/.rubyforge/user-config.yml'))
+        )
+
+        host = "#{config['username']}@rubyforge.org"
+        remote_dir = "/var/www/gforge-projects/the-perfect-gem/"
+        local_dir = 'rdoc'
+
+        Rake::SshDirPublisher.new(host, remote_dir, local_dir).upload
+      end
+    end
+  end
+rescue LoadError
+  puts "Rake SshDirPublisher is unavailable or your rubyforge environment is not configured."
+end

data/TODO

@@ -0,0 +1,2 @@
+Figure out how to localize javascript files
+Write the tests

data/VERSION

@@ -0,0 +1 @@
+0.1.3

data/app/controllers/uploader/uploads_controller.rb

@@ -0,0 +1,122 @@
+class Uploader::UploadsController < ApplicationController
+  unloadable
+  
+  before_filter :get_parent, :only => [:create, :swfupload]
+  before_filter :set_upload_for_destroy, :only => [:destroy]
+ 
+  def create
+    # Standard, one-at-a-time, upload action
+    @upload = @parent.uploads.build(params[:upload])
+    @upload.creator = current_user
+    @upload.save!
+    message = t('uploader.successful_upload')
+    upload_json = basic_uploads_json(@upload)
+
+    respond_to do |format|
+      format.html do
+        flash[:notice] = message
+        redirect_to redirect_back_or_default(get_redirect)
+      end
+      format.js { render :text => get_upload_text(@upload) }
+      format.json { render :json => upload_json }
+    end
+  rescue => ex
+    message = t('uploader.standard_file_upload_error', :error => ex)
+    respond_to do |format|
+      format.html do
+        flash[:notice] = message
+        redirect_back_or_default(get_redirect)
+      end
+      format.js { render :text => message }
+      format.json { render :json => { :success => false, :message => message } }
+    end
+  end
+
+  def swfupload
+    @upload = @parent.uploads.build
+    @upload.is_public = true if params[:is_public] == true
+    @upload.creator = current_user
+    @upload.swfupload_local = params[:Filedata]
+    @upload.save!
+    @parent.uploads << @upload
+    respond_to do |format|
+      format.js { render :text => get_upload_text(@upload) }
+      format.json { render :json => basic_uploads_json(@upload) }
+    end
+  rescue => ex
+    message = t('uploader.standard_file_upload_error', :error => ex)
+    respond_to do |format|
+      format.js { render :text => message }
+      format.json { render :json => { :success => false, :message => message } }
+    end
+  end
+
+  def destroy
+    @parent = @upload.uploadable # set this for redirect
+    if @upload.can_edit?(current_user)
+      @upload.destroy
+      message = t('uploader.file_deleted')
+      success = true
+    else
+      message = t("uploader.file_delete_permission_denied")
+      success = false
+    end
+    respond_to do |format|
+      format.html do
+        flash[:notice] = message
+        redirect_back_or_default(get_redirect)
+      end
+      format.js { render :text => message }
+      format.json { render :json => { :success => success, :message => message } }
+    end
+  end
+
+  protected
+
+  def get_upload_text(upload)
+    raise 'implement get_upload_text in your controller'
+  end
+
+  def set_upload_for_destroy
+    @upload = Upload.find(params[:id])
+  end
+
+  def permission_denied
+    message = t("uploader.permission_denied")
+    respond_to do |format|
+      format.html do
+        flash[:notice] = message
+        redirect_to get_redirect
+      end
+      format.js { render :text => message }
+      format.json { render :json => { :success => false, :message => message } }
+    end
+  end
+
+  # override this method in your controller to set the redirect file upload completion
+  # alternatively set redirect_back_or_default
+  def get_redirect
+    @parent
+  end
+
+  def get_parent
+    if !params[:parent_type] || !params[:parent_id]
+      raise t('uploader.missing_parent_id_error')
+      return
+    end
+    @klass = params[:parent_type].to_s.capitalize.constantize
+    @parent = @klass.find(params[:parent_id])
+    unless has_permission_to_upload(current_user, @parent)
+      permission_denied
+    end
+  end
+
+  def has_permission_to_upload(user, upload_parent)
+    upload_parent.can_upload?(user)
+  end
+
+  def basic_uploads_json(upload)
+    upload.to_json(:only => [:id, :file_name], :methods => [:icon])
+  end
+
+end

data/app/helpers/uploader_helper.rb

@@ -0,0 +1,17 @@
+module UploaderHelper
+
+  # parent is the object to which the uploads will be attached
+  def upload_form(parent, display_upload_indicators = true)
+    render :partial => 'uploads/swf_upload', :locals => {:parent => parent, :display_upload_indicators => display_upload_indicators}
+  end
+
+  def new_upload_path_with_session_information(upload_parent)
+    session_key = ActionController::Base.session_options[:key]
+    swfupload_uploads_path({session_key => cookies[session_key], request_forgery_protection_token => form_authenticity_token}.merge(make_parent_params(upload_parent)))
+  end
+  
+  def make_parent_params(parent)
+    { :parent_id => parent.id, :parent_type => parent.class.to_s }
+  end
+ 
+end

data/app/views/uploads/_swf_javascript.html.erb

@@ -0,0 +1,63 @@
+<% content_for :head do  -%>
+   <%= javascript_include_tag %w{
+                swfupload/swfupload.js
+                swfupload/swfupload.swfobject
+                swfupload/swfupload.cookies
+                swfupload/swfupload.queue
+                swfupload/fileprogress.js
+                swfupload/handlers.js }, :cache => 'swf_js_cached' %>
+  <%= stylesheet_link_tag 'swfupload' %>
+
+	<script type='text/javascript'>
+
+	  var swfu;
+
+		SWFUpload.onload = function () {
+			var settings = {
+			
+				flash_url : '/swf/swfupload.swf',
+				upload_url: '<%= new_upload_path_with_session_information(parent) %>',
+			
+				file_size_limit : "100 MB",
+				file_types : "*.*",
+				file_types_description : "All Files",
+				file_upload_limit : 100,
+				file_queue_limit : 0,
+				post_params : {
+  				authenticity_token : '<%= u form_authenticity_token.inspect -%>',
+  			},
+				custom_settings : {
+					<%= 'progressTarget : "swf_fs_upload_progress",' if display_upload_indicators -%>
+					cancelButtonId : "swf_cancel_button"
+				},
+				debug: false,
+
+				// Button Settings
+				button_image_url : "/images/SWFUploadButton.png", // Relative to the SWF file
+				button_placeholder_id : "swf_button_holder",
+				button_width: 61,
+				button_height: 22,
+
+				// The event handler functions are defined in handlers.js
+				swfupload_loaded_handler : swfUploadLoaded,
+				file_queued_handler : fileQueued,
+				file_queue_error_handler : fileQueueError,
+				file_dialog_complete_handler : fileDialogComplete,
+				upload_start_handler : uploadStart,
+				upload_progress_handler : uploadProgress,
+				upload_error_handler : uploadError,
+				upload_success_handler : uploadSuccess,
+				upload_complete_handler : uploadComplete,
+				queue_complete_handler : queueComplete,	// Queue plugin event
+
+				// SWFObject settings
+				minimum_flash_version : "9.0.28",
+				swfupload_pre_load_handler : swfUploadPreLoad,
+				swfupload_load_failed_handler : swfUploadLoadFailed
+			};
+
+			swfu = new SWFUpload(settings);
+		}
+		
+	</script>
+<% end -%>

data/app/views/uploads/_swf_upload.html.erb

@@ -0,0 +1,32 @@
+<div id="degraded_container" style="display:none;">  
+	<% form_for :upload, :url => uploads_path(make_parent_params(parent)), :html => { :multipart => true } do |f| -%>
+	  <p><%= f.file_field :uploaded_data, :size => 25 %></p>
+	  <%= submit_tag t('uploader.upload_file') %>
+	<% end %>
+</div>
+<div id="swfupload_container">
+	<form>
+		<div id="swf_upload_UI">
+			<p><span id="swf_button_holder"></span></p>
+			<div id="swf_fs_upload_progress">
+				<span class="legend"></span>
+				<input id="swf_cancel_button" type="button" value="<%=t('uploader.cancel_all')%>" style="display:none;" />
+				<p id="divStatus"></p>
+			</div>			
+		</div>
+		<noscript class="swf-error-msg">
+		  <%= t('uploader.javascript_not_enabled') %>
+		</noscript>
+		<div id="swf_loading_content" class="swf-error-msg" style="display:none;">
+		  <%= t('uploader.swf_loading') %>
+		</div>
+		<div id="swf_long_loading" class="swf-error-msg" style="display:none;">
+		  <%= t('uploader.swf_taking_to_long') %>
+		</div>
+		<div id="swf_alternate_content" class="swf-error-msg" style="display: none;">
+		  <%= t('uploader.swf_not_loading', :url => '<a href="http://www.adobe.com/shockwave/download/download.cgi?P1_Prod_Version=ShockwaveFlash">Adobe Website</a>') %>
+		</div>
+	</form>
+</div>
+
+<%= render :partial => 'uploads/swf_javascript', :locals => { :parent => parent, :display_upload_indicators => display_upload_indicators } %>

data/config/uploader_routes.rb

@@ -0,0 +1,3 @@
+ActionController::Routing::Routes.draw do |map|
+  map.resources :uploads, :controller => 'uploader/uploads', :collection => { :swfupload => :post }
+end

data/db/migrate/20090517040220_create_uploads.rb

@@ -0,0 +1,38 @@
+class CreateUploads < ActiveRecord::Migration
+  def self.up
+    create_table :uploads, :force => true do |t|
+      t.integer  :creator_id
+      t.string   :name
+      t.string   :caption,        :limit => 1000
+      t.text     :description
+      t.boolean  :is_public,      :default => true
+      t.integer  :uploadable_id
+      t.string   :uploadable_type
+      t.string   :width   
+      t.string   :height
+      
+      t.string   :local_file_name
+      t.string   :local_content_type
+      t.integer  :local_file_size
+      t.datetime :local_updated_at
+      
+      t.string   :remote_file_name
+      t.string   :remote_content_type
+      t.integer  :remote_file_size
+      t.datetime :remote_updated_at
+            
+      t.timestamps
+    end
+
+    add_index :uploads, ["creator_id"]
+    add_index :uploads, ["uploadable_id"]
+    add_index :uploads, ["uploadable_type"]
+    add_index :uploads, ["local_content_type"]
+
+  end
+
+  def self.down
+    drop_table :uploads
+  end
+  
+end