carrierwave_backgrounder_revived 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ccace65db06c5331ce7b76332f8089fa38ee077b
+  data.tar.gz: 2fd227027c62fa5edda188835ef027bfbfce1621
+SHA512:
+  metadata.gz: 2b563d3c48e2361ab57003ec3d036e1b0c990ad19ab2ff14c41bbffce2e06935395f547d4d81d58b76e93ea75435d107145ff16abd00d822a6a4b2a96fbc3a0d
+  data.tar.gz: 0e74a658376645778a376bdb542a37d87e5eddf3dd3af1ee22af506160185af47b65c1abb6a9c2719b02337c2b52b153f96817d7c6d3bc983d28e59c1f0cc7d9

data/.gitignore

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

data/.rspec

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

data/.travis.yml

@@ -0,0 +1,15 @@
+language: ruby
+
+rvm:
+ - 1.9.3
+ - 2.0.0
+ - 2.1
+ - 2.2
+ - ruby-head
+
+before_install:
+ - gem install bundler
+
+matrix:
+  allow_failures:
+    - rvm: ruby-head

data/CHANGELOG.md

@@ -0,0 +1,99 @@
+
+## 0.4.2
+
+### enhancements
+  * Allow overridden worker to set a queue name
+  * [#190] Respect Carrierwave's enable_processing flag if set to false [jherdman]
+
+### bug fixes
+  * [#216] Fix for NoMethodError: undefined method `read' for nil:NilClass [kntmrkm]
+
+## 0.4.1
+
+### enhancements
+  * [#179] Set column_processing to false instead of nil [mockdeep]
+
+## 0.4.0
+
+### enhancements
+  * [#175] SuckerPunch v1.0 support (no longer support < 1.0). [janko-m]
+
+### bug fixes
+  * [#176] Check if record exists before running backgrounder [gdott9]
+  * [#169] Correctly remove files on update if marked for deletion [sunny]
+
+## 0.3.0
+
+### enhancements
+  * [#123] Fail silently when record not found in worker. [DouweM]
+
+## 0.2.2
+
+### bug fixes
+  * [#141] Fix naming collisions of support module by namespacing.
+
+## 0.2.1
+
+### enhancements
+  * [#119] Add support for SuckerPunch [rewritten].
+
+### bug fixes
+  * [#115] column_remove! should not trigger a background job
+  * [#112] Raise a NoMethodError when using backend= instead of silent failure.
+
+## 0.2.0
+
+### enhancements
+  * [Breaking Change] Require configure block to be set in an initializer removing autodetect backend.
+
+### bug fixes
+  * [#108] Remove the need to set an order in the Gemfile when using sidekiq [matthewsmart].
+
+## 0.1.5
+
+### bug fixes
+  * [Revert #108] This is a breaking change and will be released in 0.2.0.
+
+## 0.1.4
+
+### bug fixes
+  * [#109] Fix issue where setting Carrierwave.cache_dir to a full path would raise an exception [Sastopher].
+
+## 0.1.3
+
+### enhancements
+  * CarrierWave::Workers::ProcessAsset now uses #update_attribute when setting [column]_processing.
+  * [#104] Change the Sidekiq integration to use client_push [petergoldstein]
+
+### bug fixes
+  * [#103] Fix determine_backend behavior so that it doesn't throw an exception [petergoldstein].
+
+## 0.1.2
+
+### enhancements
+  * Add a rails generator to generate the config file.
+```bash
+  rails g carrierwave_backgrounder:install
+```
+
+### bug fixes
+  * Check [column]_cache to make sure we are processing when a form fails and [column]_cache is used.
+
+## 0.1.1
+
+### enhancements
+  * Allow passing of all options to sidekiq in config file.
+
+### bug fixes
+  * Revert where sidekiq was broken due to Sidekiq::Worker not properly being included.
+
+## 0.1.0
+
+### enhancements
+  * Add support to pass options to backends allowing queue names to be set in the initializer.
+  * Make threadsafe. [gitt]
+  * Add support to immediately process jobs if :immediate is set in config backend. [Antiarchitect]
+
+### bug fixes
+  * Girl Friday incorrectly referenses class #92
+  * Add documentation for testing with rspec #84.

data/Gemfile

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

data/README.md

@@ -0,0 +1,229 @@
+# CarrierWave Backgrounder Revived
+
+[![Build Status](https://secure.travis-ci.org/lardawge/carrierwave_backgrounder.png)](http://travis-ci.org/lardawge/carrierwave_backgrounder)
+[![Code Climate](https://codeclimate.com/github/lardawge/carrierwave_backgrounder.png)](https://codeclimate.com/github/lardawge/carrierwave_backgrounder)
+
+Decided to revive this project. Currently changes are;
+* ActiveJob no longer errors out but is basically working as InlineJob
+* Released v1.0.0 to prevent having to point to master
+
+```ruby
+gem 'carrierwave_backgrounder_revived'
+```
+
+---
+
+I like CarrierWave. That being said, I don't like tying up app instances waiting for images to process.
+
+This gem addresses that by offloading processing or storage/processing to a background task.
+We currently support Delayed Job, Resque, Sidekiq, SuckerPunch, Girl Friday, Qu, and Queue Classic.
+
+## Background options
+
+There are currently two offerings for backgrounding upload tasks which are as follows;
+
+```ruby
+# This stores the original file with no processing/versioning.
+# It will upload the original file to s3.
+# This was developed to use where you do not have control over the cache location such as Heroku.
+
+Backgrounder::ORM::Base::process_in_background
+```
+
+```ruby
+# This 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 so the background job can access it.
+# The drawback to using this method is the need for a central location to store the cached files.
+# Heroku may deploy workers on separate servers from where your dyno cached the files.
+#
+# IMPORTANT: Only use this method if you have full control over your tmp storage directory.
+
+Backgrounder::ORM::Base::store_in_background
+```
+
+## Installation and Usage
+
+These instructions assume you have previously set up [CarrierWave](https://github.com/jnicklas/carrierwave) and your queuing lib of choice.
+
+In Rails, add the following your Gemfile:
+
+```ruby
+gem 'carrierwave_backgrounder'
+```
+
+Run the generator which will create an initializer in config/initializers.
+```bash
+  rails g carrierwave_backgrounder:install
+```
+
+You can pass additional configuration options to Girl Friday and Sidekiq:
+
+```ruby
+CarrierWave::Backgrounder.configure do |c|
+  c.backend :girl_friday, queue: :awesome_queue, size: 3, store: GirlFriday::Store::Redis
+end
+```
+
+In your CarrierWave uploader file:
+
+```ruby
+class AvatarUploader < CarrierWave::Uploader::Base
+  include ::CarrierWave::Backgrounder::Delay
+
+  #etc...
+end
+```
+
+### To use process_in_background
+
+In your model:
+
+```ruby
+mount_uploader :avatar, AvatarUploader
+process_in_background :avatar
+```
+
+Optionally you can add a column to the database which will be set to `true` when
+the background processing is started and to `false` when the background processing is complete.
+
+```ruby
+add_column :users, :avatar_processing, :boolean, null: false, default: false
+```
+
+### To use store_in_background
+
+In your model:
+
+```ruby
+mount_uploader :avatar, AvatarUploader
+store_in_background :avatar
+```
+
+Add a column to the model you want to background which will store the temp file location:
+
+```ruby
+add_column :users, :avatar_tmp, :string
+```
+
+## Usage Tips
+
+### Bypass backgrounding
+If you need to process/store the upload immediately:
+
+```ruby
+@user.process_<column>_upload = true
+```
+
+This must be set before you assign an upload:
+
+```ruby
+# In a controller
+@user = User.new
+@user.process_avatar_upload = true
+@user.attributes = params[:user]
+```
+
+### Override worker
+To override the worker in cases where additional methods need to be called or you have app specific requirements, pass the worker class as the
+second argument:
+
+```ruby
+process_in_background :avatar, MyParanoidWorker
+```
+
+Then create a worker that subclasses carrierwave_backgrounder's worker:
+
+```ruby
+class MyParanoidWorker < ::CarrierWave::Workers::ProcessAsset
+  # ...or subclass CarrierWave::Workers::StoreAsset if you're using store_in_background
+
+  def error(job, exception)
+    report_job_failure  # or whatever
+  end
+
+  # other hooks you might care about
+end
+```
+
+### ActiveJob
+Use overriden worker that inherits from ActiveJob::Base and includes relevant worker mixin:
+```ruby
+class MyActiveJobWorker < ActiveJob::Base
+  include ::CarrierWave::Workers::ProcessAssetMixin
+  # ... or include ::CarrierWave::Workers::StoreAssetMixin
+
+  after_perform do
+    # your code here
+  end
+
+  # Sometimes job gets performed before the file is uploaded and ready.
+  # You can define how to handle that case by overriding `when_not_ready` method
+  # (by default it does nothing)
+  def when_not_ready
+    retry_job
+  end
+end
+```
+Don't forget to set `active_job` as a backend in the config:
+```ruby
+CarrierWave::Backgrounder.configure do |c|
+  c.backend :active_job, queue: :carrierwave
+end
+```
+
+### Testing with Rspec
+We use the after_commit hook when using active_record. This creates a problem when testing with Rspec because after_commit never gets fired
+if you're using trasactional fixtures. One solution to the problem is to use the [TestAfterCommit gem](https://github.com/grosser/test_after_commit).
+There are various other solutions in which case google is your friend.
+
+### Uploaders mounted on mongoid embedded documents
+The workers fetch the document with the mounted uploader using the model class name and id. Uploads on embedded documents
+cannot be obtained this way. If the position of the document in the root document structure is known, a workaround is to override the embedded models
+find method like this:
+
+```ruby
+class SomeRootDocument
+  include Mongoid::Document
+
+  embeds_many :embedded_documents
+end
+
+class EmbeddedDocument
+  include Mongoid::Document
+
+  embedded_in :some_root_document
+
+  mount_uploader :image, ImageUploader
+  process_in_background :image
+
+  def self.find(id)
+    bson_id = Moped::BSON::ObjectId.from_string(id) # needed for Mongoid 3
+
+    root = SomeRootDocument.where('embedded_documents._id' => bson_id).first
+    root.embedded_documents.find(id)
+  end
+end
+```
+
+## 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,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

@@ -0,0 +1,25 @@
+# encoding: utf-8
+$:.push File.expand_path("../lib", __FILE__)
+require "backgrounder/version"
+
+Gem::Specification.new do |s|
+  s.name        = "carrierwave_backgrounder_revived"
+  s.version     = CarrierWave::Backgrounder::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Larry Sprock"]
+  s.email       = ["larry@lucidbleu.com"]
+  s.homepage    = "https://github.com/lardawge/carrierwave_backgrounder"
+  s.licenses    = ["MIT"]
+  s.summary     = %q{Offload CarrierWave's image processing and storage to a background process using Delayed Job, Resque, Sidekiq, Qu, Queue Classic or Girl Friday}
+
+  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"]
+
+  s.add_dependency "carrierwave", [">= 0.5", "< 2.0"]
+  s.add_dependency "mime-types", ["~> 2.99"]
+
+  s.add_development_dependency "rspec", ["~> 3.5.0"]
+  s.add_development_dependency "rake"
+end

data/lib/backgrounder/delay.rb

@@ -0,0 +1,26 @@
+module CarrierWave
+  module Backgrounder
+
+    module Delay
+      def cache_versions!(new_file)
+        super if proceed_with_versioning?
+      end
+
+      def store_versions!(*args)
+        super if proceed_with_versioning?
+      end
+
+      def process!(new_file=nil)
+        super if proceed_with_versioning?
+      end
+
+      private
+
+      def proceed_with_versioning?
+        !model.respond_to?(:"process_#{mounted_as}_upload") && enable_processing ||
+          !!(model.send(:"process_#{mounted_as}_upload") && enable_processing)
+      end
+    end # Delay
+
+  end # Backgrounder
+end # CarrierWave

data/lib/backgrounder/orm/activemodel.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+
+module CarrierWave
+  module Backgrounder
+    module ORM
+
+      module ActiveModel
+        include CarrierWave::Backgrounder::ORM::Base
+
+        private
+
+        def _define_shared_backgrounder_methods(mod, column, worker)
+          before_save :"set_#{column}_processing", :if => :"enqueue_#{column}_background_job?"
+          send _supported_callback, :"enqueue_#{column}_background_job", :if => :"enqueue_#{column}_background_job?"
+
+          super
+
+          define_method :"#{column}_updated?" do
+            options = self.class.uploader_options[column] || {}
+            serialization_column = options[:mount_on] || column
+
+            send(:"#{serialization_column}_changed?") ||              # after_save support
+            previous_changes.has_key?(:"#{serialization_column}") ||  # after_commit support
+            send(:"remote_#{column}_url").present? ||                 # Remote upload support
+            send(:"#{column}_cache").present?                         # Form failure support
+          end
+        end
+
+        def _supported_callback
+          respond_to?(:after_commit) ? :after_commit : :after_save
+        end
+      end # ActiveModel
+
+    end # ORM
+  end # Backgrounder
+end # CarrierWave