jbasdf-uploader 0.1.8

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,323 @@
+= 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'
+
+
+=== Install jQuery
+uploader uses jQuery.  You'll need to include it in your application.  Download it here:
+http://jquery.com/
+
+Then include it in your layout:
+  <%= javascript_include_tag 'jquery/jquery.js' %>
+            
+Another option is to use jRails
+http://ennerchi.com/projects/jrails
+
+=== 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 => AMAZON_S3_CREDENTIALS,
+                       :bucket => "assets.example.com",
+                       :s3_host_alias => "assets.example.com",
+                       :convert_options => {
+                          :all => '-quality 80'
+                        }
+                     },
+                     :s3_path => ':id_partition/:style/:basename.:extension'
+                                                                  
+    # 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
+    
+    prepend_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.
+    # source can be :destroy_success, :create_success, :create_failure, :permission_denied
+    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
+
+=== 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.
+
+Add the daemons gem and plugin:
+  sudo gem install daemons
+
+Then inside your Rails project:
+  script/plugin install git://github.com/dougal/daemon_generator.git
+  script/generate daemon amazonaws
+  
+  RAILS_ENV=development lib/daemons/mailer_ctl start
+
+Learn more about the custom daemon gem with Ryan Bates screencast:
+  http://railscasts.com/episodes/129-custom-daemon
+
+
+== Use Rake to send files to s3
+uploader includes a task capable of sending files to s3 but it makes an assumption that the model you are interacting with
+is named 'Upload'.
+
+  rake uploader:upload_to_s3 
+
+If you want to use a different model or several models just add a rake task to your project:
+
+  desc 'Send all uploads to S3.  (Will only send uploads from a model named Upload)'
+  task :upload_to_s3 do
+    
+    uploads = Upload.pending_s3_migration
+    uploads.each do |upload|
+      upload.remote = upload.local
+      upload.save!
+    end
+    
+    photos = Photo.pending_s3_migration
+    photos.each do |photo|
+      photo.remote = photo.local
+      photo.save!
+    end
+    
+  end
+
+== Setup Domains
+If you use Amazon's S3 service you can setup a cname to clean up your urls.  Configure your s3 bucket as above:
+
+  :bucket => "assets.example.com"
+  :s3_host_alias => "assets.example.com"
+
+Your assets will be available at assets.example.com.s3.amazon.com.  You can then create a CNAME in your DNS entries
+to point "assets.example.com" to "assets.example.com.s3.amazon.com".  Your assets will then appear to be
+be served from assets.example.com even though they are loaded from Amazon.
+
+
+== 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,67 @@
+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.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'
+    gemspec.add_dependency "mime-types"
+  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/uploader/"
+        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,3 @@
+Figure out how to localize javascript files
+Write the tests
+Match up icons with mime types in uploader_upload.rb

data/VERSION

@@ -0,0 +1 @@
+0.1.8

data/app/controllers/uploader/uploads_controller.rb

@@ -0,0 +1,126 @@
+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 = get_creator
+    @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 get_redirect(:create_success)
+      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_to get_redirect(:create_failure)
+      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 = get_creator
+    @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_to get_redirect(:destroy_success)
+      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(:permission_denied)
+      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
+  # source can be :destroy_success, :create_success, :create_failure, :permission_denied
+  def get_redirect(source)
+    @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 get_creator
+    current_user
+  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