carrierwave_backgrounder 0.0.2 → 0.0.3

data/.rspec

@@ -0,0 +1,2 @@
+--format progress
+--colour

data/README.rdoc

@@ -1,6 +1,18 @@
 = 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.
+I like CarrierWave. That being said, I don't like tying up app instances waiting for images to process. This gem addresses that issue.
+
+== Background options
+  
+There are currently two offerings for backgrounding upload tasks which are as follows;
+
+    Backgrounder::ORM::Base::process_in_background
+
+This method stores the original file and does no processing or versioning. Optionally you can add a column to the database which will be set to nil when the background processing is complete.
+  
+    Backgrounder::ORM::Base::store_in_background
+  
+This method does nothing to the file after it is cached which makes it super fast. It requires a column in the database which stores the cache location set by carrierwave. The drawback to using this method is the need for a central location to store the cached files. This leave heroku out. Heroku may deploy workers on separate servers from where your dyno cached the files. That being said, I only recommend using this method if you have full control over your temp storage directory.
 
 == Installation
 
@@ -12,44 +24,53 @@ In Rails, add the following your Gemfile:
     
 == Getting Started
 
-Add a column to the model you wan to background which will store the temp file location:
+=== To use process_in_background
+    
+In your model:
+    
+    mount_uploader :avatar, AvatarUploader
+    process_in_background :avatar
+ 
+=== To use store_in_background
     
+In your model:
+
+    mount_uploader :avatar, AvatarUploader
+    process_in_background :avatar
+
+Add a column to the model you want 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)
 
-== Usage
+== Usage Tips
 
 If you need to process/store the upload immediately:
 
-    @user.process_upload = true 
+    @user.process_<column>_upload = true 
+    
+== ORM
 
-== Word Of Caution
+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:
 
-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.
+    DataMapper::Model.send(:include, ::CarrierWave::Backgrounder::ORM::Base)
+    # or
+    Mongoid::Document::ClassMethods.send(:include, ::CarrierWave::Backgrounder::ORM::Base)
+    # or
+    Sequel::Model.send(:extend, ::CarrierWave::Backgrounder::ORM::Base)
+    
+Contributions are gladly accepted from those who use these orms.
 
 == TODO
 
-Transfer tests from rails app.
+More specs
 
 == License
 

data/Rakefile

@@ -1,2 +1,12 @@
+# encoding: UTF-8
 require 'bundler'
 Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+desc "Run all examples"
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = ["-c", "-f progress", "-r ./spec/spec_helper.rb"]
+  t.pattern = 'spec/**/*_spec.rb'
+end
+
+task :default => :spec

data/carrierwave_backgrounder.gemspec

@@ -1,10 +1,10 @@
-# -*- encoding: utf-8 -*-
+# 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.version     = CarrierWave::Backgrounder::VERSION
   s.platform    = Gem::Platform::RUBY
   s.authors     = ["Larry Sprock"]
   s.email       = ["larry@lucidbleu.com"]
@@ -17,4 +17,9 @@ Gem::Specification.new do |s|
   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"]
+
+  s.add_dependency "carrierwave", ["~> 0.5"]
+
+  s.add_development_dependency "rspec", ["2.5.0"]
+  s.add_development_dependency "mocha", ["~> 0.9"]
 end

data/lib/backgrounder/delay_storage.rb

@@ -7,7 +7,7 @@ module CarrierWave
       end
       
       def proceed_with_versioning?
-        !model.respond_to?(:process_upload) || model.process_upload
+        !model.respond_to?(:"process_#{mounted_as}_upload") || model.send(:"process_#{mounted_as}_upload")
       end
     end # DelayStorage
     

data/lib/backgrounder/orm/activerecord.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+require 'active_record'
+
+module CarrierWave
+  module Backgrounder
+    module ORM
+
+      module ActiveRecord
+        include CarrierWave::Backgrounder::ORM::Base
+
+        def process_in_background(column, worker=::CarrierWave::Workers::ProcessAsset)
+          super
+
+          class_eval  <<-RUBY, __FILE__, __LINE__ + 1
+            def trigger_#{column}_background_processing?
+              process_#{column}_upload != true && #{column}_changed?
+            end
+          RUBY
+        end
+
+        def store_in_background(column, worker=::CarrierWave::Workers::StoreAsset)
+          super
+
+          class_eval  <<-RUBY, __FILE__, __LINE__ + 1
+            def trigger_#{column}_background_storage?
+              process_#{column}_upload != true && #{column}_changed?
+            end
+          RUBY
+        end
+      end # ActiveRecord
+
+    end # ORM
+  end # Backgrounder
+end # CarrierWave
+
+ActiveRecord::Base.extend CarrierWave::Backgrounder::ORM::ActiveRecord

data/lib/backgrounder/orm/base.rb

@@ -0,0 +1,115 @@
+# encoding: utf-8
+require 'backgrounder/workers'
+
+module CarrierWave
+  module Backgrounder
+    module ORM
+
+      ##
+      # Base class for all things orm
+      module Base
+
+        ##
+        # User#process_in_background will process and create versions in a background process.
+        #
+        # class User < ActiveRecord::Base
+        #   mount_uploader :avatar, AvatarUploader
+        #   process_in_background :avatar
+        # end
+        #
+        # The above adds a User#process_upload method which can be used at times when you want to bypass
+        # background storage and processing.
+        #
+        #   @user.process_avatar = true
+        #   @user.save
+        #
+        # You can also pass in your own workers using the second argument in case you need other things done
+        # during processing.
+        #
+        #   class User < ActiveRecord::Base
+        #     mount_uploader :avatar, AvatarUploader
+        #     process_in_background :avatar, CustomWorker
+        #   end
+        #
+        # In addition you can also add a column to the database appended by _processing with a type of boolean
+        # which can be used to check if processing is complete.
+        #
+        #   def self.up
+        #     add_column :users, :avatar_processing, :boolean
+        #   end
+        #
+        def process_in_background(column, worker=::CarrierWave::Workers::ProcessAsset)
+          send :before_save, :"set_#{column}_processing", :if => :"trigger_#{column}_background_processing?"
+          send :after_save,  :"enqueue_#{column}_background_job", :if => :"trigger_#{column}_background_processing?"
+
+          class_eval  <<-RUBY, __FILE__, __LINE__ + 1
+            attr_accessor :process_#{column}_upload
+
+            def set_#{column}_processing
+              self.#{column}_processing = true if respond_to?(:#{column}_processing)
+            end
+
+            def enqueue_#{column}_background_job
+              ::Delayed::Job.enqueue #{worker}.new(self.class, id, #{column}.mounted_as)
+            end
+
+            def trigger_#{column}_background_processing?
+              process_#{column}_upload != true
+            end
+
+          RUBY
+        end
+
+        ##
+        # #store_in_background  will process, version and store uploads in a background process.
+        #
+        # class User < ActiveRecord::Base
+        #   mount_uploader :avatar, AvatarUploader
+        #   store_in_background :avatar
+        # end
+        #
+        # The above adds a User#process_<column> method which can be used at times when you want to bypass
+        # background storage and processing.
+        #
+        #   @user.process_avatar = true
+        #   @user.save
+        #
+        # You can also pass in your own workers using the second argument in case you need other things done
+        # durring processing.
+        #
+        #   class User < ActiveRecord::Base
+        #     mount_uploader :avatar, AvatarUploader
+        #     store_in_background :avatar, CustomWorker
+        #   end
+        #
+        def store_in_background(column, worker=::CarrierWave::Workers::StoreAsset)
+          send :after_save, :"enqueue_#{column}_background_job", :if => :"trigger_#{column}_background_storage?"
+
+          class_eval  <<-RUBY, __FILE__, __LINE__ + 1
+            attr_accessor :process_#{column}_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_#{column}_upload
+            end
+
+            def enqueue_#{column}_background_job
+              ::Delayed::Job.enqueue #{worker}.new(self.class, id, #{column}.mounted_as)
+            end
+
+            def trigger_#{column}_background_storage?
+              process_#{column}_upload != true
+            end
+
+          RUBY
+        end
+
+      end # Base
+
+    end #ORM
+  end #Backgrounder
+end #CarrierWave

data/lib/backgrounder/version.rb

@@ -1,3 +1,5 @@
-module CarrierwaveBackgrounder
-  VERSION = "0.0.2"
+module CarrierWave
+  module Backgrounder
+    VERSION = "0.0.3"
+  end
 end

data/lib/backgrounder/workers.rb

@@ -0,0 +1,2 @@
+require 'backgrounder/workers/process_asset'
+require 'backgrounder/workers/store_asset'

data/lib/backgrounder/workers/process_asset.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+module CarrierWave
+  module Workers
+
+    class ProcessAsset < Struct.new(:klass, :id, :column)
+  
+      def perform
+        record = klass.find id
+        record.send(:"process_#{column}_upload=", true)
+        if record.send(:"#{column}").recreate_versions! && record.respond_to?(:"#{column}_processing")
+          record.update_attribute :"#{column}_processing", nil
+        end
+      end
+      
+    end # ProcessAsset
+    
+  end # Workers
+end # Backgrounder

data/lib/backgrounder/workers/store_asset.rb

@@ -1,3 +1,4 @@
+# encoding: utf-8
 module CarrierWave
   module Workers
 
@@ -5,11 +6,12 @@ module CarrierWave
   
       def perform
         record = klass.find id
-        if record.send :"#{column}_tmp"
-          cache_dir  = [record.send(:"#{column}").root, record.send(:"#{column}").cache_dir].join("/")
-          cache_path = [cache_dir, record.send(:"#{column}_tmp")].join("/")
+        if tmp = record.send(:"#{column}_tmp")
+          asset = record.send(:"#{column}")
+          cache_dir  = [asset.root, asset.cache_dir].join("/")
+          cache_path = [cache_dir, tmp].join("/")
         
-          record.send :"process_upload=", true
+          record.send :"process_#{column}_upload=", true
           record.send :"#{column}=", File.open(cache_path)
           record.send :"#{column}_tmp=", nil
           if record.save!
@@ -21,4 +23,4 @@ module CarrierWave
     end # StoreAsset
     
   end # Workers
-end # Backgrounder
+end # Backgrounder

data/lib/carrierwave_backgrounder.rb

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

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+require 'rubygems'
+require 'bundler/setup'
+
+RSpec.configure do |c|
+  c.mock_with :mocha
+end

data/spec/workers/process_asset_spec.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'backgrounder/workers/process_asset'
+
+describe worker = CarrierWave::Workers::ProcessAsset do
+  before do
+    @user   = mock('User')
+    @image  = mock('UserAsset')
+    @worker = worker.new(@user, '22', :image)
+  end
+
+  context "#perform" do
+    it 'processes versions' do
+      @user.expects(:find).with('22').returns(@user).once
+      @user.expects(:image).once.returns(@image)
+      @user.expects(:process_image_upload=).with(true).once
+
+      @image.expects(:recreate_versions!).once.returns(true)
+      @user.expects(:respond_to?).with(:image_processing).once.returns(true)
+      @user.expects(:update_attribute).with(:image_processing, nil).once
+
+      @worker.perform
+    end
+  end
+end

data/spec/workers/store_asset_spec.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'backgrounder/workers/store_asset'
+
+describe worker = CarrierWave::Workers::StoreAsset do
+  before do
+    @user   = mock('User')
+    @image  = mock('UserAsset')
+    @worker = worker.new(@user, '22', :image)
+  end
+
+  context "#perform" do
+    it 'processes versions' do
+      File.expects(:open).with('../fixtures/test.jpg').once.returns('apple')
+      FileUtils.expects(:rm).with('../fixtures/test.jpg').once
+      @user.expects(:find).with('22').once.returns(@user)
+      @user.expects(:image_tmp).once.returns('test.jpg')
+      @user.expects(:image).once.returns(@image)
+      @image.expects(:root).once.returns('..')
+      @image.expects(:cache_dir).once.returns('fixtures')
+      @user.expects(:process_image_upload=).with(true).once
+      @user.expects(:image=).with('apple').once
+      @user.expects(:image_tmp=).with(nil).once
+      @user.expects(:save!).once.returns(true)
+
+      @worker.perform
+    end
+  end
+end

metadata

@@ -2,7 +2,7 @@
 name: carrierwave_backgrounder
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors: 
 - Larry Sprock
@@ -10,10 +10,42 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-28 00:00:00 -07:00
+date: 2011-04-29 00:00:00 -07:00
 default_executable: 
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: carrierwave
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "0.5"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 2.5.0
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "0.9"
+  type: :development
+  version_requirements: *id003
 description: 
 email: 
 - larry@lucidbleu.com
@@ -25,16 +57,22 @@ extra_rdoc_files: []
 
 files: 
 - .gitignore
+- .rspec
 - Gemfile
 - README.rdoc
 - Rakefile
 - carrierwave_backgrounder.gemspec
 - lib/backgrounder/delay_storage.rb
-- lib/backgrounder/orm.rb
+- lib/backgrounder/orm/activerecord.rb
+- lib/backgrounder/orm/base.rb
 - lib/backgrounder/version.rb
+- lib/backgrounder/workers.rb
+- lib/backgrounder/workers/process_asset.rb
 - lib/backgrounder/workers/store_asset.rb
 - lib/carrierwave_backgrounder.rb
 - spec/spec_helper.rb
+- spec/workers/process_asset_spec.rb
+- spec/workers/store_asset_spec.rb
 has_rdoc: true
 homepage: ""
 licenses: []
@@ -65,3 +103,5 @@ specification_version: 3
 summary: Offload CarrierWave's image processing and storage to a background process using Delayed Job
 test_files: 
 - spec/spec_helper.rb
+- spec/workers/process_asset_spec.rb
+- spec/workers/store_asset_spec.rb

data/lib/backgrounder/orm.rb

@@ -1,38 +0,0 @@
-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