carrierwave_backgrounder 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in carrierwave_backgrounder.gemspec
+gemspec

data/README.rdoc

@@ -0,0 +1,69 @@
+= CarrierWave Backgrounder
+
+I like CarrierWave. That being said, I don't like tying up app instances waiting for images to process and upload to S3. Depending on the size of the file, this could take a while sometimes timing out Heroku. This gem addresses that. After the file has been uploaded and CarrierWave caches the base file, it halts the process and queues a job.
+
+== Installation
+
+These instructions assume you have previously set up {CarrierWave}[https://github.com/jnicklas/carrierwave] and {DelayedJob}[https://github.com/collectiveidea/delayed_job]
+
+In Rails, add the following your Gemfile:
+    
+    gem 'carrierwave_backgrounder'
+    
+== Getting Started
+
+Add a column to the model you wan to background which will store the temp file location:
+    
+    add_column :users, :avatar_tmp, :string
+
+In your CarrierWave uploader file:
+    
+    class AvatarUploader < CarrierWave::Uploader::Base
+      include ::CarrierWave::Backgrounder::DelayStorage
+      
+      #ect...
+    end
+    
+In your model:
+    
+    mount_uploader :avatar, AvatarUploader
+    store_in_background :avatar
+    
+Currently ActiveRecord is the default orm and I have not tested this with others but it should work by adding the following to your carrierwave initializer:
+
+    DataMapper::Model.send(:include, ::CarrierWave::Backgrounder::ORM)
+    # or
+    Mongoid::Document::ClassMethods.send(:include, ::CarrierWave::Backgrounder::ORM)
+    # or
+    Sequel::Model.send(:extend, ::CarrierWave::Backgrounder::ORM)
+
+== Word Of Caution
+
+Temp files are stored by default in the tmp directory. They are not guaranteed to be available when your workers process them! For instance, on Heroku, they get blown away on every deploy. If image upload is the main function of your app, I would store the tmp files in a non-volatile directory if you have the option.
+
+== TODO
+
+Transfer tests from rails app.
+
+== License
+
+Copyright (c) 2011 Larry Sprock
+
+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/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/carrierwave_backgrounder.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "backgrounder/version"
+
+Gem::Specification.new do |s|
+  s.name        = "carrierwave_backgrounder"
+  s.version     = CarrierwaveBackgrounder::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Larry Sprock"]
+  s.email       = ["larry@lucidbleu.com"]
+  s.homepage    = ""
+  s.summary     = %q{Offload CarrierWave's image processing and storage to a background process using Delayed Job}
+
+  s.rubyforge_project = "carrierwave_backgrounder"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/lib/backgrounder/delay_storage.rb

@@ -0,0 +1,15 @@
+module CarrierWave
+  module Backgrounder
+
+    module DelayStorage
+      def cache_versions!(new_file)
+        super(new_file) if proceed_with_versioning?
+      end
+      
+      def proceed_with_versioning?
+        !model.respond_to?(:process_upload) || model.process_upload
+      end
+    end # DelayStorage
+    
+  end # Backgrounder
+end # CarrierWave

data/lib/backgrounder/orm.rb

@@ -0,0 +1,38 @@
+require 'backgrounder/workers/store_asset'
+
+module CarrierWave
+  module Backgrounder
+    
+    module ORM
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        
+        def store_in_background(column, version=false)
+          send :after_save, :"enqueue_#{column}_storage"
+          
+          class_eval  <<-RUBY, __FILE__, __LINE__ + 1
+            attr_accessor :process_upload
+            
+            def write_#{column}_identifier
+              super() and return if process_upload
+              self.#{column}_tmp = _mounter(:#{column}).cache_name
+            end
+        
+            def store_#{column}!
+              super() if process_upload
+            end
+            
+            def enqueue_#{column}_storage
+              if !process_upload && #{column}_tmp
+                ::Delayed::Job.enqueue ::CarrierWave::Workers::StoreAsset.new(self.class, id, #{column}.mounted_as)
+              end
+            end
+          RUBY
+        end
+        
+      end # ClassMethods
+    end # ActiveRecord
+
+  end #Backgrounder
+end #CarrierWave

data/lib/backgrounder/version.rb

@@ -0,0 +1,3 @@
+module CarrierwaveBackgrounder
+  VERSION = "0.0.1"
+end

data/lib/backgrounder/workers/store_asset.rb

@@ -0,0 +1,24 @@
+module CarrierWave
+  module Workers
+
+    class StoreAsset < Struct.new(:klass, :id, :column)
+  
+      def perform
+        record = klass.find id
+        if record.send :"#{column}_tmp"
+          cache_dir  = record.send(:"#{column}").root.join(record.send(:"#{column}").cache_dir)
+          cache_path = cache_dir.join record.send(:"#{column}_tmp")
+        
+          record.send :"process_upload=", true
+          record.send :"#{column}=", File.open(cache_path)
+          record.send :"#{column}_tmp=", nil
+          if record.save!
+            FileUtils.rm(cache_path)
+          end
+        end
+      end
+      
+    end # StoreAsset
+    
+  end # Workers
+end # Backgrounder

data/lib/carrierwave_backgrounder.rb

@@ -0,0 +1,20 @@
+module CarrierWave
+  module Backgrounder
+    autoload :DelayStorage, 'backgrounder/delay_storage'
+    autoload :ORM,          'backgrounder/orm'
+  end
+end
+
+if defined?(Rails)
+  module CarrierWave
+    module Backgrounder
+      class Railtie < Rails::Railtie
+        initializer "carrierwave_backgrounder.active_record" do
+          ActiveSupport.on_load :active_record do
+            ::ActiveRecord::Base.send :include, ::CarrierWave::Backgrounder::ORM
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification 
+name: carrierwave_backgrounder
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Larry Sprock
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-25 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: 
+- larry@lucidbleu.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.rdoc
+- Rakefile
+- carrierwave_backgrounder.gemspec
+- lib/backgrounder/delay_storage.rb
+- lib/backgrounder/orm.rb
+- lib/backgrounder/version.rb
+- lib/backgrounder/workers/store_asset.rb
+- lib/carrierwave_backgrounder.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: carrierwave_backgrounder
+rubygems_version: 1.5.0
+signing_key: 
+specification_version: 3
+summary: Offload CarrierWave's image processing and storage to a background process using Delayed Job
+test_files: 
+- spec/spec_helper.rb