jbasdf-uploader 0.1.8

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

data/lib/active_record/acts/uploader_upload.rb

@@ -0,0 +1,234 @@
+module ActiveRecord
+  module Acts #:nodoc:
+
+    module UploaderUpload #:nodoc:
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+
+        # acts_as_uploader requires an option for :has_attached_file.  These values will be passed to paperclip.
+        # i.e.
+        # acts_as_uploader :has_attached_file => {
+        # :url     => "/uploads/:class/:id/:style_:basename.:extension",
+        # :path    => ":rails_root/public/uploads/:class/:id/:style_:basename.:extension",
+        # :styles  => { :icon => "30x30!", :thumb => "100>", :small => "150>", :medium => "300>", :large => "660>"},
+        # :default_url => "/images/profile_default.jpg" }
+        def acts_as_uploader(options)
+
+          #Named scopes
+          named_scope :newest_first, :order => "created_at DESC"
+          named_scope :alphabetic, :order => "filename DESC"
+          named_scope :recent, :order => "created_at DESC"
+          named_scope :public, :conditions => 'is_public = true'
+          named_scope :images, :conditions => "local_content_type IN (#{Uploader::MimeTypeGroups::IMAGE_TYPES.collect{|type| "'#{type}'"}.join(',')})"
+          named_scope :documents, :conditions => "local_content_type IN (#{(Uploader::MimeTypeGroups::WORD_TYPES + Uploader::MimeTypeGroups::EXCEL_TYPES + Uploader::MimeTypeGroups::PDF_TYPES).collect{|type| "'#{type}'"}.join(',')})" 
+          named_scope :files, :conditions => "local_content_type NOT IN (#{Uploader::MimeTypeGroups::IMAGE_TYPES.collect{|type| "'#{type}'"}.join(',')})"
+          named_scope :since, lambda { |*args| { :conditions => ["created_at > ?", (args.first || 7.days.ago.to_s(:db)) ]} }
+          named_scope :pending_s3_migration, lambda { { :conditions =>  ["remote_file_name IS NULL AND created_at <= ?", 20.minutes.ago.to_s(:db)], :order => 'created_at DESC' } }
+          
+          # Paperclip
+          has_attached_file :local, options[:has_attached_file].merge(:storage => :filesystem) # Override any storage settings.  This one has to be local.
+          if options[:enable_s3] == true
+            has_attached_file :remote, options[:has_attached_file].merge(:url => ':s3_alias_url',
+                                                                         :path => options[:s3_path],
+                                                                         :storage => :s3)
+          end
+
+
+          belongs_to :uploadable, :polymorphic => true
+          belongs_to :creator, :class_name => 'User', :foreign_key => 'creator_id'
+                                        
+          class_eval <<-EOV
+            validates_attachment_size :local, :less_than => 10.megabytes
+            
+            before_post_process :transliterate_file_name
+            before_create :add_width_and_height
+            
+            # prevents a user from submitting a crafted form that bypasses activation
+            attr_protected :creator_id, :uploadable_id, :uploadable_type
+          EOV
+
+          include ActiveRecord::Acts::UploaderUpload::InstanceMethods
+          extend ActiveRecord::Acts::UploaderUpload::SingletonMethods
+        end
+      end
+
+      # class methods
+      module SingletonMethods
+
+      end
+      
+      # All the methods available to a record that has had <tt>acts_as_uploader</tt> specified.
+      module InstanceMethods
+        
+        def file
+          local_file_name ? local : remote
+        end
+
+        def file_name
+          remote_file_name || local_file_name
+        end
+        
+        def send_to_remote
+          if local_file_name
+            self.remote = local.to_file
+            if self.save and remote.original_filename and remote.exists?
+              self.local = nil
+              self.save
+            else
+              false
+            end
+          end
+        end
+        
+        def swfupload_local=(filedata)
+          filedata.content_type = MIME::Types.type_for(filedata.original_filename)[0].to_s
+          self.local = filedata
+        end
+        
+        def is_image?
+          Uploader::MimeTypeGroups::IMAGE_TYPES.include?(self.local_content_type)
+        end
+
+        def is_mp3?
+          Uploader::MimeTypeGroups::MP3_TYPES.include?(self.local_content_type)
+        end
+
+        def is_excel?
+          Uploader::MimeTypeGroups::EXCEL_TYPES.include?(self.local_content_type)
+        end
+
+        def is_pdf?
+          Uploader::MimeTypeGroups::PDF_TYPES.include?(self.local_content_type)
+        end
+
+        def is_word?
+          Uploader::MimeTypeGroups::WORD_TYPES.include?(self.local_content_type)
+        end
+
+        def is_text?
+          Uploader::MimeTypeGroups::TEXT_TYPES.include?(self.local_content_type)
+        end
+        
+        def upload_type
+          if self.is_pdf?
+            'Adobe pdf file'
+          elsif self.is_word?
+            'Word document'
+          elsif self.is_image?
+            'photo'
+          elsif self.is_mp3?
+            'mp3'
+          elsif self.is_excel?
+            'Excel document'
+          elsif self.is_text?
+            'text file'
+          else
+            'file'
+          end
+        end
+
+        def icon
+          if self.is_pdf?
+            '/images/file_icons/file_pdf.gif'
+          elsif self.is_word?
+            '/images/file_icons/file_doc.gif'
+          elsif self.is_image?
+            self.file.url(:icon)
+          elsif self.is_mp3?
+            '/images/file_icons/file_mp3.gif'
+          elsif self.is_excel?
+            '/images/file_icons/file_xls.gif'
+          elsif self.is_text?
+            '/images/file_icons/file_txt.gif'
+          else
+            '/images/file_icons/file_raw.gif'
+          end
+        end
+        
+        def display_name
+          CGI::escapeHTML(self.local_file_name)
+        end
+        
+        def can_edit?(check_user)
+          return false if check_user.blank?
+          check_user == self.creator
+        end
+        
+        # Image dimension calculations
+
+        def width(style = :default)
+          return nil unless self[:width]
+          return self[:width] if style == :default
+          calculate_sizes(style.to_sym)
+          return @image_width.to_i
+        end
+
+        def height(style = :default)
+          return nil unless self[:height]
+          return self[:height] if style == :default
+          calculate_sizes(style.to_sym)
+          return @image_height.to_i
+        end
+
+        def size(style = :default)
+          return nil unless width || height
+          return "#{width}x#{height}" if style == :default
+          calculate_sizes(style.to_sym)
+          return @image_size
+        end
+
+        def max_dimension(style)
+          @max_dimension ||= Paperclip::Geometry.parse(self.local.styles[style][:geometry]).width.to_f
+        end
+
+        def image_ratio
+          @image_ratio ||= width.to_f / height.to_f
+        end
+
+        def calculate_sizes(style)
+          if image_ratio > 1
+            @image_width ||= width > max_dimension(style) ? max_dimension(style) : width
+            @image_height ||= (@image_width / image_ratio).round
+          else
+            @image_height ||= height > max_dimension(style) ? max_dimension(style) : height
+            @image_width ||= (@image_height * image_ratio).round
+          end
+          @image_size ||= "#{@image_width.to_i}x#{@image_height.to_i}"
+        end
+        
+        protected
+          def transliterate_file_name
+            extension = File.extname(local_file_name).gsub(/^\.+/, '')
+            filename = local_file_name.gsub(/\.#{extension}$/, '')
+            self.local.instance_write(:file_name, "#{transliterate(filename)}.#{transliterate(extension)}")
+          end
+          
+          def transliterate(str)
+            # Lifted from permalink_fu by Rick Olsen
+            # Escape str by transliterating to UTF-8 with Iconv,
+            # downcasing, then removing illegal characters and replacing them with ’-’
+            s = Iconv.iconv('ascii//ignore//translit', 'utf-8', str).to_s
+            s.downcase!
+            s.gsub!(/\'/, '')
+            s.gsub!(/[^A-Za-z0-9]+/, ' ')
+            s.strip!
+            s.gsub!(/\ +/, '-') # set single or multiple spaces to a single dash
+            return s
+          end
+          
+          def add_width_and_height
+            return unless self.is_image?
+            if self.local.to_file
+              geometry = Paperclip::Geometry.from_file self.local.to_file
+              self[:width] = geometry.width.to_i
+              self[:height] = geometry.height.to_i
+            end
+          end
+          
+      end 
+    end
+  end
+end

data/lib/daemons/amazonaws.rb

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+
+# You might want to change this
+ENV["RAILS_ENV"] ||= "production"
+
+require File.dirname(__FILE__) + "/../../config/environment"
+
+$running = true
+Signal.trap("TERM") do 
+  $running = false
+end
+
+# Waiting is a timer variable to allow the daemon to restart
+# within two seconds of the Signal rather than using a long
+# sleep command and forcing the daemon to wait.
+$waiting = 0
+
+ActiveRecord::Base.logger.info "[AmazonS3] Migration daemon started at #{Time.now}.\n"
+
+while($running) do
+
+  if $waiting < 120
+    $waiting += 2
+    sleep 2
+  else
+    $waiting = 0
+    upload = Upload.pending_s3_migration.first
+
+    if upload
+      $waiting = 120 - 2
+      ActiveRecord::Base.logger.info "[AmazonS3] Migrating upload ##{upload.id}\n"
+      upload.remote = upload.local
+      upload.save!
+    end
+  end
+end

data/lib/uploader.rb

@@ -0,0 +1,24 @@
+require 'uploader/exceptions'
+require 'uploader/mime_type_groups'
+require 'uploader/middleware/flash_session_cookie_middleware'
+
+begin
+  require 'thoughtbot-paperclip'
+rescue LoadError
+  begin
+    gem 'thoughtbot-paperclip'
+  rescue Gem::LoadError
+    puts "Please install the thoughtbot-paperclip gem"
+  end
+end
+
+
+begin
+  require 'mime/types'
+rescue LoadError
+  begin
+    gem 'mime-types'
+  rescue Gem::LoadError
+    puts "Please install the mime-types gem"
+  end
+end