kt-delayed_paperclip 3.1.0

data/delayed_paperclip.gemspec

@@ -0,0 +1,30 @@
+$:.push File.expand_path("../lib", __FILE__)
+require "delayed_paperclip/version"
+
+Gem::Specification.new do |s|
+  s.name        = %q{kt-delayed_paperclip}
+  s.version     = DelayedPaperclip::VERSION
+
+  s.authors     = ["Adam Anderson", "Jesse Storimer", "Bert Goethals", "James Gifford", "Scott Carleton"]
+  s.summary     = %q{Process your Paperclip attachments in the background}
+  s.description = %q{Process your Paperclip attachments in the background with ActiveJob}
+  s.email       = %w{james@jamesrgifford.com scott@artsicle.com}
+  s.homepage    = %q{https://github.com/adamtao/kt-delayed_paperclip}
+
+  s.required_ruby_version = ">= 2.0.0"
+
+  s.add_dependency 'kt-paperclip', "~> 6.4", ">= 6.4.1"
+  s.add_dependency 'activejob', ">= 4.2"
+
+  s.add_development_dependency 'mocha'
+  s.add_development_dependency "rspec", '< 3.0'
+  s.add_development_dependency 'sqlite3'
+  s.add_development_dependency 'appraisal'
+  s.add_development_dependency 'rake', '~> 10.5.0'
+  s.add_development_dependency 'bundler'
+  s.add_development_dependency 'activerecord'
+  s.add_development_dependency 'railties'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+end

data/gemfiles/.bundle/config

@@ -0,0 +1 @@
+--- {}

data/gemfiles/4.2.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "http://rubygems.org"
+
+gem "rails", "~> 4.2.0"
+
+gemspec :path => "../"

data/gemfiles/5.0.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "http://rubygems.org"
+
+gem "rails", "~> 5.0.0"
+
+gemspec :path => "../"

data/gemfiles/5.0_paperclip_master.gemfile

@@ -0,0 +1,8 @@
+# This file was generated by Appraisal
+
+source "http://rubygems.org"
+
+gem "rails", "~> 5.0.0"
+gem "paperclip", :github => "thoughtbot/paperclip"
+
+gemspec :path => "../"

data/lib/delayed_paperclip.rb

@@ -0,0 +1,119 @@
+require 'kt-paperclip'
+require 'delayed_paperclip/process_job'
+require 'delayed_paperclip/attachment'
+require 'delayed_paperclip/url_generator'
+require 'delayed_paperclip/railtie' if defined?(Rails)
+
+module DelayedPaperclip
+  class << self
+    def options
+      @options ||= {
+        :background_job_class => DelayedPaperclip::ProcessJob,
+        :url_with_processing  => true,
+        :processing_image_url => nil,
+        :queue => "paperclip"
+      }
+    end
+
+    def processor
+      options[:background_job_class]
+    end
+
+    def enqueue(instance_klass, instance_id, attachment_name)
+      processor.enqueue_delayed_paperclip(instance_klass, instance_id, attachment_name)
+    end
+
+    def process_job(instance_klass, instance_id, attachment_name)
+      instance = instance_klass.constantize.unscoped.where(id: instance_id).first
+      return if instance.blank?
+
+      instance.
+        send(attachment_name).
+        process_delayed!
+    end
+
+  end
+
+  module Glue
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.send :include, InstanceMethods
+    end
+  end
+
+  module ClassMethods
+
+    def process_in_background(name, options = {})
+      # initialize as hash
+      paperclip_definitions[name][:delayed] = {}
+
+      # Set Defaults
+      only_process_default = paperclip_definitions[name][:only_process]
+      only_process_default ||= []
+      {
+        :priority => 0,
+        :only_process => only_process_default,
+        :url_with_processing => DelayedPaperclip.options[:url_with_processing],
+        :processing_image_url => DelayedPaperclip.options[:processing_image_url],
+        :queue => DelayedPaperclip.options[:queue]
+      }.each do |option, default|
+        paperclip_definitions[name][:delayed][option] = options.key?(option) ? options[option] : default
+      end
+
+      # Sets callback
+      if respond_to?(:after_commit)
+        after_commit  :enqueue_delayed_processing
+      else
+        after_save    :enqueue_delayed_processing
+      end
+    end
+
+    def paperclip_definitions
+      if respond_to? :attachment_definitions
+        attachment_definitions
+      else
+        Paperclip::Tasks::Attachments.definitions_for(self)
+      end
+    end
+  end
+
+  module InstanceMethods
+
+    # First mark processing
+    # then enqueue
+    def enqueue_delayed_processing
+      mark_enqueue_delayed_processing
+
+      (@_enqued_for_processing || []).each do |name|
+        enqueue_post_processing_for(name)
+      end
+      @_enqued_for_processing_with_processing = []
+      @_enqued_for_processing = []
+    end
+
+    # setting each inididual NAME_processing to true, skipping the ActiveModel dirty setter
+    # Then immediately push the state to the database
+    def mark_enqueue_delayed_processing
+      unless @_enqued_for_processing_with_processing.blank? # catches nil and empty arrays
+        updates = @_enqued_for_processing_with_processing.collect{|n| "#{n}_processing = :true" }.join(", ")
+        updates = ActiveRecord::Base.send(:sanitize_sql_array, [updates, {:true => true}])
+        self.class.unscoped.where(:id => self.id).update_all(updates)
+      end
+    end
+
+    def enqueue_post_processing_for name
+      DelayedPaperclip.enqueue(self.class.name, read_attribute(:id), name.to_sym)
+    end
+
+    def prepare_enqueueing_for name
+      if self.attributes.has_key? "#{name}_processing"
+        write_attribute("#{name}_processing", true)
+        @_enqued_for_processing_with_processing ||= []
+        @_enqued_for_processing_with_processing << name
+      end
+
+      @_enqued_for_processing ||= []
+      @_enqued_for_processing << name
+    end
+  end
+end

data/lib/delayed_paperclip/attachment.rb

@@ -0,0 +1,89 @@
+module DelayedPaperclip
+  module Attachment
+    attr_accessor :job_is_processing
+
+    def delayed_options
+      options[:delayed]
+    end
+
+    # Attr accessor in Paperclip
+    def post_processing
+      !delay_processing? || split_processing?
+    end
+
+    def post_processing=(value)
+      @post_processing_with_delay = value
+    end
+
+    # if nil, returns whether it has delayed options
+    # if set, then it returns
+    def delay_processing?
+      if @post_processing_with_delay.nil?
+        !!delayed_options
+      else
+        !@post_processing_with_delay
+      end
+    end
+
+    def split_processing?
+      options[:only_process] && delayed_options &&
+        options[:only_process] != delayed_only_process
+    end
+
+    def processing?
+      column_name = :"#{@name}_processing?"
+      @instance.respond_to?(column_name) && @instance.send(column_name)
+    end
+
+    def processing_style?(style)
+      return false if !processing?
+
+      !split_processing? || delayed_only_process.include?(style)
+    end
+
+    def delayed_only_process
+      only_process = delayed_options.fetch(:only_process, []).dup
+      only_process = only_process.call(self) if only_process.respond_to?(:call)
+      only_process.map(&:to_sym)
+    end
+
+    def process_delayed!
+      self.job_is_processing = true
+      self.post_processing = true
+      reprocess!(*delayed_only_process)
+      self.job_is_processing = false
+      update_processing_column
+    end
+
+    def processing_image_url
+      processing_image_url = delayed_options[:processing_image_url]
+      processing_image_url = processing_image_url.call(self) if processing_image_url.respond_to?(:call)
+      processing_image_url
+    end
+
+    def save
+      was_dirty = @dirty
+
+      super.tap do
+        if delay_processing? && was_dirty
+          instance.prepare_enqueueing_for name
+        end
+      end
+    end
+
+    def reprocess_without_delay!(*style_args)
+      @post_processing_with_delay = true
+      reprocess!(*style_args)
+    end
+
+    private
+
+    def update_processing_column
+      if instance.respond_to?(:"#{name}_processing?")
+        instance.send("#{name}_processing=", false)
+        instance.class.unscoped.where(instance.class.primary_key => instance.id).update_all({ "#{name}_processing" => false })
+      end
+    end
+
+  end
+end

data/lib/delayed_paperclip/process_job.rb

@@ -0,0 +1,14 @@
+require "active_job"
+
+module DelayedPaperclip
+  class ProcessJob < ActiveJob::Base
+    def self.enqueue_delayed_paperclip(instance_klass, instance_id, attachment_name)
+      queue_name = instance_klass.constantize.paperclip_definitions[attachment_name][:delayed][:queue]
+      set(:queue => queue_name).perform_later(instance_klass, instance_id, attachment_name.to_s)
+    end
+
+    def perform(instance_klass, instance_id, attachment_name)
+      DelayedPaperclip.process_job(instance_klass, instance_id, attachment_name.to_sym)
+    end
+  end
+end

data/lib/delayed_paperclip/railtie.rb

@@ -0,0 +1,27 @@
+require "paperclip"
+require "delayed_paperclip"
+
+module DelayedPaperclip
+  # On initialzation, include DelayedPaperclip
+  class Railtie < Rails::Railtie
+    initializer "delayed_paperclip.insert_into_active_record" do |app|
+      ActiveSupport.on_load :active_record do
+        DelayedPaperclip::Railtie.insert
+      end
+
+      if app.config.respond_to?(:delayed_paperclip_defaults)
+        DelayedPaperclip.options.merge!(app.config.delayed_paperclip_defaults)
+      end
+    end
+  end
+
+  class Railtie
+    # Glue includes DelayedPaperclip Class Methods and Instance Methods into ActiveRecord
+    # Attachment and URL Generator extends Paperclip
+    def self.insert
+      ActiveRecord::Base.send(:include, DelayedPaperclip::Glue)
+      Paperclip::Attachment.prepend(DelayedPaperclip::Attachment)
+      Paperclip::Attachment.default_options[:url_generator] = DelayedPaperclip::UrlGenerator
+    end
+  end
+end

data/lib/delayed_paperclip/url_generator.rb

@@ -0,0 +1,61 @@
+require 'uri'
+require 'paperclip/url_generator'
+
+module DelayedPaperclip
+  class UrlGenerator < ::Paperclip::UrlGenerator
+    def initialize(attachment, _compatibility = nil)
+      @attachment = attachment
+      @attachment_options = attachment.options
+    end
+
+    def for(style_name, options)
+      most_appropriate_url = @attachment.processing_style?(style_name) ? most_appropriate_url(style_name) : most_appropriate_url()
+      timestamp_as_needed(
+        escape_url_as_needed(
+          @attachment_options[:interpolator].interpolate(most_appropriate_url, @attachment, style_name),
+          options
+        ),
+      options)
+    end
+
+    # This method is a mess
+    def most_appropriate_url(style = nil)
+      if @attachment.processing_style?(style)
+        if @attachment.original_filename.nil? || delayed_default_url?(style)
+
+          if @attachment.delayed_options.nil? ||
+            @attachment.processing_image_url.nil? ||
+            !@attachment.processing?
+            default_url
+          else
+            @attachment.processing_image_url
+          end
+
+        else
+          @attachment_options[:url]
+        end
+      else
+        super()
+      end
+    end
+
+    def timestamp_possible?
+      delayed_default_url? ? false : super
+    end
+
+    def delayed_default_url?(style = nil)
+      return false if @attachment.job_is_processing
+      return false if @attachment.dirty?
+      return false if not @attachment.delayed_options.try(:[], :url_with_processing)
+      return false if not processing?(style)
+      true
+    end
+
+    private
+
+    def processing?(style)
+      return true if @attachment.processing?
+      return @attachment.processing_style?(style) if style
+    end
+  end
+end

data/lib/delayed_paperclip/version.rb

@@ -0,0 +1,3 @@
+module DelayedPaperclip
+  VERSION = "3.1.0"
+end

data/lib/kt-delayed_paperclip.rb

@@ -0,0 +1,2 @@
+require 'delayed_paperclip'
+

data/spec/delayed_paperclip/attachment_spec.rb

@@ -0,0 +1,345 @@
+require 'spec_helper'
+
+describe DelayedPaperclip::Attachment do
+  before :each do
+    reset_dummy(dummy_options)
+  end
+
+  let(:dummy_options) { {} }
+  let(:dummy) { Dummy.create }
+
+  describe "#delayed_options" do
+    it "returns the specific options for delayed paperclip" do
+      expect(dummy.image.delayed_options).to eq({
+        :priority => 0,
+        :only_process => [],
+        :url_with_processing => true,
+        :processing_image_url => nil,
+        :queue => "paperclip"
+      })
+    end
+  end
+
+  describe "#post_processing_with_delay" do
+    it "is true if delay_processing? is false" do
+      dummy.image.stubs(:delay_processing?).returns false
+      dummy.image.post_processing.should be_truthy
+    end
+
+    it "is false if delay_processing? is true" do
+      dummy.image.stubs(:delay_processing?).returns true
+      dummy.image.post_processing.should be_falsey
+    end
+
+    context "on a non-delayed image" do
+      let(:dummy_options) { { with_processed: false } }
+
+      it "is false if delay_processing? is true" do
+        dummy.image.stubs(:delay_processing?).returns true
+        dummy.image.post_processing.should be_falsey
+      end
+    end
+  end
+
+  describe "#delay_processing?" do
+    it "returns delayed_options existence if post_processing is nil" do
+      dummy.image.post_processing = nil
+      dummy.image.delay_processing?.should be_truthy
+    end
+
+    it "returns inverse of post_processing if it's set" do
+      dummy.image.post_processing = true
+      dummy.image.delay_processing?.should be_falsey
+    end
+  end
+
+  describe "#processing?" do
+    it "delegates to the dummy instance" do
+      dummy.expects(:image_processing?)
+      dummy.image.processing?
+    end
+
+    context "without a processing column" do
+      let(:dummy_options) { { with_processed: false } }
+
+      it "returns false" do
+        expect(dummy.image.processing?).to be_falsey
+      end
+    end
+  end
+
+  describe "#processing_style?" do
+    let(:style) { :background }
+    let(:processing_style?) { dummy.image.processing_style?(style) }
+
+    context "without a processing column" do
+      let(:dummy_options) { { with_processed: true, process_column: false } }
+
+      specify { expect(processing_style?).to be_falsey }
+    end
+
+    context "with a processing column" do
+      context "when not processing" do
+        before { dummy.image_processing = false }
+
+        specify { expect(processing_style?).to be_falsey }
+      end
+
+      context "when processing" do
+        before { dummy.image_processing = true }
+
+        context "when not split processing" do
+          specify { expect(processing_style?).to be_truthy }
+        end
+
+        context "when split processing" do
+          context "when delayed :only_process is an Array" do
+            let(:dummy_options) { {
+              paperclip: {
+                styles: {
+                  online: "400x400x",
+                  background: "600x600x"
+                },
+                only_process: [:online]
+              },
+
+              only_process: [:background]
+            }}
+
+            specify { expect(processing_style?).to be }
+          end
+
+          context "when delayed :only_process is callable" do
+            let(:dummy_options) { {
+              paperclip: {
+                styles: {
+                  online: "400x400x",
+                  background: "600x600x"
+                },
+                only_process: [:online]
+              },
+
+              only_process: lambda { |a| [:background] }
+            }}
+
+            specify { expect(processing_style?).to be }
+          end
+        end
+      end
+    end
+  end
+
+  describe "#delayed_only_process" do
+    context "without only_process options" do
+      it "returns []" do
+        expect(dummy.image.delayed_only_process).to eq []
+      end
+    end
+
+    context "with only_process options" do
+      before :each do
+        reset_dummy(paperclip: { only_process: [:small, :large] } )
+      end
+
+      it "returns [:small, :large]" do
+        expect(dummy.image.delayed_only_process).to eq [:small, :large]
+      end
+    end
+
+    context "with only_process set with callable" do
+      before :each do
+        reset_dummy(paperclip: { only_process: lambda { |a| [:small, :large] } } )
+      end
+
+      # Enable when https://github.com/thoughtbot/paperclip/pull/2289 is resolved
+      xit "returns [:small, :large]" do
+        expect(dummy.image.delayed_only_process).to eq [:small, :large]
+      end
+    end
+  end
+
+  describe "#process_delayed!" do
+    it "sets job_is_processing to true" do
+      dummy.image.expects(:job_is_processing=).with(true).once
+      dummy.image.expects(:job_is_processing=).with(false).once
+      dummy.image.process_delayed!
+    end
+
+    it "sets post_processing to true" do
+      dummy.image.expects(:post_processing=).with(true).once
+      dummy.image.process_delayed!
+    end
+
+    context "without only_process options" do
+      it "calls reprocess!" do
+        dummy.image.expects(:reprocess!)
+        dummy.image.process_delayed!
+      end
+    end
+
+    context "with only_process options" do
+      before :each do
+        reset_dummy(paperclip: { only_process: [:small, :large] } )
+      end
+
+      it "calls reprocess! with options" do
+        dummy.image.expects(:reprocess!).with(:small, :large)
+        dummy.image.process_delayed!
+      end
+    end
+
+    context "with only_process set with callable" do
+      before :each do
+        reset_dummy(paperclip: { only_process: lambda { |a| [:small, :large] } } )
+      end
+
+      # Enable when https://github.com/thoughtbot/paperclip/pull/2289 is resolved
+      xit "calls reprocess! with options" do
+        dummy.image.expects(:reprocess!).with(:small, :large)
+        dummy.image.process_delayed!
+      end
+    end
+  end
+
+  describe "#processing_image_url" do
+    context "no url" do
+      it "returns nil" do
+        dummy.image.processing_image_url.should be_nil
+      end
+    end
+
+    context "static url" do
+      before :each do
+        reset_dummy(:processing_image_url => "/foo/bar.jpg")
+      end
+
+      it "returns given url" do
+        dummy.image.processing_image_url.should == "/foo/bar.jpg"
+      end
+    end
+
+    context "proc" do
+      before :each do
+        reset_dummy(:processing_image_url => proc { "Hello/World" } )
+      end
+
+      it "returns evaluates proc" do
+        dummy.image.processing_image_url.should == "Hello/World"
+      end
+    end
+  end
+
+  describe "#update_processing_column" do
+    it "updates the column to false" do
+      dummy.update_attribute(:image_processing, true)
+
+      dummy.image.send(:update_processing_column)
+
+      dummy.reload.image_processing.should be_falsey
+    end
+
+    context 'with a  default scope on the model excluding the instance' do
+      let(:dummy_options) do
+        { :default_scope => lambda { Dummy.where(hidden: false) } }
+      end
+
+      let!(:dummy) { Dummy.create(hidden: true) }
+
+      specify { Dummy.count.should be 0 }
+      specify { Dummy.unscoped.count.should be 1 }
+
+      it "ignores the default scope and updates the column to false" do
+        dummy.update_attribute(:image_processing, true)
+        dummy.image.send(:update_processing_column)
+        dummy.reload.image_processing.should be_falsey
+      end
+    end
+  end
+
+  describe "#save" do
+    context "delay processing and it was dirty" do
+      before :each do
+        dummy.image.stubs(:delay_processing?).returns true
+        dummy.image.instance_variable_set(:@dirty, true)
+      end
+
+      it "prepares the enqueing" do
+        dummy.expects(:prepare_enqueueing_for).with(:image)
+        dummy.image.save
+      end
+    end
+
+    context "without dirty or delay_processing" do
+      it "does not prepare_enqueueing" do
+        dummy.expects(:prepare_enqueueing_for).with(:image).never
+        dummy.image.save
+      end
+    end
+  end
+
+  describe "#reprocess_without_delay!" do
+    it "sets post post_processing_with_delay and reprocesses with given args" do
+      dummy.image.expects(:reprocess!).with(:small)
+      dummy.image.reprocess_without_delay!(:small)
+      dummy.image.instance_variable_get(:@post_processing_with_delay).should == true
+    end
+  end
+
+  describe "#split_processing?" do
+    let(:split_processing?) { dummy.image.split_processing? }
+
+    let(:paperclip_styles) { {
+      online: "400x400x",
+      background: "600x600x"
+    } }
+
+    context ":only_process option is set on attachment" do
+      let(:dummy_options) { {
+        paperclip: {
+          styles: paperclip_styles,
+          only_process: [:online]
+        },
+
+        only_process: delayed_only_process
+      }}
+
+      context "processing different styles in background" do
+        context "when delayed :only_process is an Array" do
+          let(:delayed_only_process) { [:background] }
+
+          specify { expect(split_processing?).to be true }
+        end
+
+        context "when delayed :only_process is callable" do
+          let(:delayed_only_process) { lambda { |a| [:background] } }
+
+          specify { expect(split_processing?).to be true }
+        end
+      end
+
+      context "processing same styles in background" do
+        context "when delayed :only_process is an Array" do
+          let(:delayed_only_process) { [:online] }
+
+          specify { expect(split_processing?).to be false }
+        end
+
+        context "when delayed :only_process is callable" do
+          let(:delayed_only_process) { lambda { |a| [:online] } }
+
+          specify { expect(split_processing?).to be false }
+        end
+      end
+    end
+
+    context ":only_process option is not set on attachment" do
+      let(:dummy_options) { {
+        paperclip: {
+          styles: paperclip_styles
+        }
+      }}
+
+      specify { expect(split_processing?).to be false }
+    end
+  end
+end