delayed_paperclip 2.6.0.0 → 2.6.1

data/gemfiles/rails3_2.gemfile.lock

@@ -0,0 +1,159 @@
+PATH
+  remote: ..
+  specs:
+    delayed_paperclip (2.6.1)
+      paperclip (>= 3.3.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    actionmailer (3.2.13)
+      actionpack (= 3.2.13)
+      mail (~> 2.5.3)
+    actionpack (3.2.13)
+      activemodel (= 3.2.13)
+      activesupport (= 3.2.13)
+      builder (~> 3.0.0)
+      erubis (~> 2.7.0)
+      journey (~> 1.0.4)
+      rack (~> 1.4.5)
+      rack-cache (~> 1.2)
+      rack-test (~> 0.6.1)
+      sprockets (~> 2.2.1)
+    activemodel (3.2.13)
+      activesupport (= 3.2.13)
+      builder (~> 3.0.0)
+    activerecord (3.2.13)
+      activemodel (= 3.2.13)
+      activesupport (= 3.2.13)
+      arel (~> 3.0.2)
+      tzinfo (~> 0.3.29)
+    activeresource (3.2.13)
+      activemodel (= 3.2.13)
+      activesupport (= 3.2.13)
+    activesupport (3.2.13)
+      i18n (= 0.6.1)
+      multi_json (~> 1.0)
+    appraisal (0.5.2)
+      bundler
+      rake
+    arel (3.0.2)
+    builder (3.0.4)
+    celluloid (0.14.1)
+      timers (>= 1.0.0)
+    climate_control (0.0.3)
+      activesupport (>= 3.0)
+    cocaine (0.5.1)
+      climate_control (>= 0.0.3, < 1.0)
+    connection_pool (1.0.0)
+    delayed_job (3.0.5)
+      activesupport (~> 3.0)
+    delayed_job_active_record (0.4.4)
+      activerecord (>= 2.1.0, < 4)
+      delayed_job (~> 3.0)
+    diff-lcs (1.2.4)
+    erubis (2.7.0)
+    hike (1.2.2)
+    i18n (0.6.1)
+    journey (1.0.4)
+    json (1.8.0)
+    mail (2.5.4)
+      mime-types (~> 1.16)
+      treetop (~> 1.4.8)
+    metaclass (0.0.1)
+    mime-types (1.23)
+    mocha (0.14.0)
+      metaclass (~> 0.0.1)
+    mono_logger (1.1.0)
+    multi_json (1.7.5)
+    paperclip (3.5.0)
+      activemodel (>= 3.0.0)
+      activesupport (>= 3.0.0)
+      cocaine (~> 0.5.0)
+      mime-types
+    polyglot (0.3.3)
+    rack (1.4.5)
+    rack-cache (1.2)
+      rack (>= 0.4)
+    rack-protection (1.5.0)
+      rack
+    rack-ssl (1.3.3)
+      rack
+    rack-test (0.6.2)
+      rack (>= 1.0)
+    rails (3.2.13)
+      actionmailer (= 3.2.13)
+      actionpack (= 3.2.13)
+      activerecord (= 3.2.13)
+      activeresource (= 3.2.13)
+      activesupport (= 3.2.13)
+      bundler (~> 1.0)
+      railties (= 3.2.13)
+    railties (3.2.13)
+      actionpack (= 3.2.13)
+      activesupport (= 3.2.13)
+      rack-ssl (~> 1.3.2)
+      rake (>= 0.8.7)
+      rdoc (~> 3.4)
+      thor (>= 0.14.6, < 2.0)
+    rake (10.0.4)
+    rdoc (3.12.2)
+      json (~> 1.4)
+    redis (3.0.4)
+    redis-namespace (1.3.0)
+      redis (~> 3.0.0)
+    resque (1.24.1)
+      mono_logger (~> 1.0)
+      multi_json (~> 1.0)
+      redis-namespace (~> 1.2)
+      sinatra (>= 0.9.2)
+      vegas (~> 0.1.2)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.4)
+    rspec-expectations (2.14.0)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.1)
+    sidekiq (2.12.1)
+      celluloid (>= 0.14.1)
+      connection_pool (>= 1.0.0)
+      json
+      redis (>= 3.0)
+      redis-namespace
+    sinatra (1.3.6)
+      rack (~> 1.4)
+      rack-protection (~> 1.3)
+      tilt (~> 1.3, >= 1.3.3)
+    sprockets (2.2.2)
+      hike (~> 1.2)
+      multi_json (~> 1.0)
+      rack (~> 1.0)
+      tilt (~> 1.1, != 1.3.0)
+    sqlite3 (1.3.7)
+    thor (0.18.1)
+    tilt (1.4.1)
+    timers (1.1.0)
+    treetop (1.4.12)
+      polyglot
+      polyglot (>= 0.3.1)
+    tzinfo (0.3.37)
+    vegas (0.1.11)
+      rack (>= 1.0.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  appraisal
+  delayed_job
+  delayed_job_active_record
+  delayed_paperclip!
+  json
+  mocha
+  rails (~> 3.2.8)
+  resque
+  rspec
+  sidekiq
+  sqlite3

data/lib/delayed_paperclip/attachment.rb

@@ -12,6 +12,11 @@ module DelayedPaperclip
 
     module InstanceMethods
 
+      def delayed_options
+        @instance.class.paperclip_definitions[@name][:delayed]
+      end
+
+      # Attr accessor in Paperclip
       def post_processing_with_delay
         !delay_processing?
       end
@@ -20,15 +25,13 @@ module DelayedPaperclip
         @post_processing_with_delay = value
       end
 
-      def delayed_options
-        @instance.class.attachment_definitions[@name][:delayed]
-      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
+          !@post_processing_with_delay
         end
       end
 
@@ -49,10 +52,9 @@ module DelayedPaperclip
         processing_image_url
       end
 
-
+      # Updates _processing column to false
       def after_flush_writes_with_processing(*args)
         after_flush_writes_without_processing(*args)
-
         # update_column is available in rails 3.1 instead we can do this to update the attribute without callbacks
 
         # instance.update_column("#{name}_processing", false) if instance.respond_to?(:"#{name}_processing?")

data/lib/delayed_paperclip/jobs/delayed_job.rb

@@ -9,7 +9,7 @@ module DelayedPaperclip
         def self.enqueue_delayed_paperclip(instance_klass, instance_id, attachment_name)
           ::Delayed::Job.enqueue(
             :payload_object => new(instance_klass, instance_id, attachment_name),
-            :priority => instance_klass.constantize.attachment_definitions[attachment_name][:delayed][:priority].to_i
+            :priority => instance_klass.constantize.paperclip_definitions[attachment_name][:delayed][:priority].to_i
           )
         end
 
@@ -18,7 +18,7 @@ module DelayedPaperclip
         def self.enqueue_delayed_paperclip(instance_klass, instance_id, attachment_name)
           ::Delayed::Job.enqueue(
             new(instance_klass, instance_id, attachment_name),
-            instance_klass.constantize.attachment_definitions[attachment_name][:delayed][:priority].to_i
+            instance_klass.constantize.paperclip_definitions[attachment_name][:delayed][:priority].to_i
           )
         end
 

data/lib/delayed_paperclip/jobs.rb

@@ -1,7 +1,7 @@
 module DelayedPaperclip
   module Jobs
     autoload :DelayedJob, 'delayed_paperclip/jobs/delayed_job'
-    autoload :Resque, 'delayed_paperclip/jobs/resque'
-    autoload :Sidekiq, 'delayed_paperclip/jobs/sidekiq'
+    autoload :Resque,     'delayed_paperclip/jobs/resque'
+    autoload :Sidekiq,    'delayed_paperclip/jobs/sidekiq'
   end
 end

data/lib/delayed_paperclip/railtie.rb

@@ -4,6 +4,8 @@ require 'delayed_paperclip'
 module DelayedPaperclip
   if defined? Rails::Railtie
     require 'rails'
+
+    # On initialzation, include DelayedPaperclip
     class Railtie < Rails::Railtie
       initializer 'delayed_paperclip.insert_into_active_record' do
         ActiveSupport.on_load :active_record do
@@ -14,6 +16,9 @@ module DelayedPaperclip
   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.send(:include, DelayedPaperclip::Attachment)

data/lib/delayed_paperclip/url_generator.rb

@@ -1,8 +1,8 @@
 require 'uri'
+
 module DelayedPaperclip
   module UrlGenerator
     def self.included(base)
-      base.send :include, InstanceMethods
       base.alias_method_chain :most_appropriate_url, :processed
       base.alias_method_chain :timestamp_possible?, :processed
     end
@@ -28,7 +28,20 @@ module DelayedPaperclip
     end
 
     def delayed_default_url?
-      !(@attachment.job_is_processing || @attachment.dirty? || !@attachment.delayed_options.try(:[], :url_with_processing) || !(@attachment.instance.respond_to?(:"#{@attachment.name}_processing?") && @attachment.processing?))
+      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 (@attachment.instance.respond_to?(:"#{@attachment.name}_processing?") && @attachment.processing?)
+      true
+
+      # OLD CRAZY CONDITIONAL
+      # TODO: Delete
+      # !(
+      #   @attachment.job_is_processing ||
+      #   @attachment.dirty? ||
+      #   !@attachment.delayed_options.try(:[], :url_with_processing) ||
+      #   !(@attachment.instance.respond_to?(:"#{@attachment.name}_processing?") && @attachment.processing?)
+      # )
     end
   end
 

data/lib/delayed_paperclip/version.rb

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

data/lib/delayed_paperclip.rb

@@ -38,50 +38,51 @@ module DelayedPaperclip
   end
 
   module Glue
-    def self.included base #:nodoc:
+    def self.included(base)
       base.extend(ClassMethods)
+      base.send :include, InstanceMethods
     end
   end
 
   module ClassMethods
 
     def process_in_background(name, options = {})
-      include InstanceMethods
+      # initialize as hash
+      paperclip_definitions[name][:delayed] = {}
 
-      attachment_definitions[name][:delayed] = {}
+      # Set Defaults
       {
         :priority => 0,
-        :only_process => attachment_definitions[name][:only_process],
+        :only_process => paperclip_definitions[name][:only_process],
         :url_with_processing => DelayedPaperclip.options[:url_with_processing],
         :processing_image_url => options[:processing_image_url]
       }.each do |option, default|
 
-        attachment_definitions[name][:delayed][option] = options.key?(option) ? options[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
+        after_save    :enqueue_delayed_processing
       end
     end
-  end
-
-  module InstanceMethods
 
-    # 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.where(:id => self.id).update_all(updates)
+    def paperclip_definitions
+      @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 create
+    # then enqueue
     def enqueue_delayed_processing
       mark_enqueue_delayed_processing
 
@@ -92,6 +93,16 @@ module DelayedPaperclip
       @_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.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

data/spec/delayed_paperclip/attachment_spec.rb

@@ -0,0 +1,153 @@
+require 'spec_helper'
+
+describe DelayedPaperclip::Attachment do
+
+  before :all do
+    DelayedPaperclip.options[:background_job_class] = DelayedPaperclip::Jobs::Resque
+    reset_dummy
+  end
+
+  let(:dummy) { Dummy.create }
+
+  describe "#delayed_options" do
+
+    it "returns the specific options for delayed paperclip" do
+      dummy.image.delayed_options.should == {
+        :priority => 0,
+        :only_process => nil,
+        :url_with_processing => true,
+        :processing_image_url => nil
+      }
+    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_with_delay.should be_true
+    end
+
+    it "is false if delay_processing? is true" do
+      dummy.image.stubs(:delay_processing?).returns true
+      dummy.image.post_processing_with_delay.should be_false
+    end
+  end
+
+  describe "delay_processing?" do
+    it "returns delayed_options existence if post_processing_with_delay is nil" do
+      dummy.image.post_processing_with_delay = nil
+      dummy.image.delay_processing?.should be_true
+    end
+
+    it "returns inverse of post_processing_with_delay if it's set" do
+      dummy.image.post_processing_with_delay = true
+      dummy.image.delay_processing?.should be_false
+    end
+  end
+
+  describe "processing?" do
+    it "delegates to the dummy instance" do
+      dummy.expects(:image_processing?)
+      dummy.image.processing?
+    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
+  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 "#after_flush_writes_with_processing" do
+    it "updates the column to false" do
+      dummy.update_attribute(:image_processing, true)
+
+      dummy.image.after_flush_writes_with_processing
+
+      dummy.image_processing.should be_false
+    end
+  end
+
+  describe "#save_with_prepare_enqueueing" 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_with_prepare_enqueueing
+      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_with_prepare_enqueueing
+      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
+end

data/spec/delayed_paperclip/class_methods_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+describe DelayedPaperclip::ClassMethods do
+
+  before :all do
+    DelayedPaperclip.options[:background_job_class] = DelayedPaperclip::Jobs::Resque
+    reset_dummy(with_processed: false)
+  end
+
+  describe ".process_in_background" do
+
+    it "is empty to start" do
+      Dummy.paperclip_definitions.should == { :image => {} }
+    end
+
+    it "adds basics to paperclip_definitions" do
+      Dummy.process_in_background(:image)
+      Dummy.paperclip_definitions.should == { :image => {
+        :delayed => {
+          :priority => 0,
+          :only_process => nil,
+          :url_with_processing => true,
+          :processing_image_url => nil}
+        }
+      }
+    end
+
+    context "with processing_image_url" do
+      before :each do
+        Dummy.process_in_background(:image, processing_image_url: "/processing/url")
+      end
+
+      it "incorporates processing url" do
+        Dummy.paperclip_definitions.should == { :image => {
+          :delayed => {
+            :priority => 0,
+            :only_process => nil,
+            :url_with_processing => true,
+            :processing_image_url => "/processing/url"}
+          }
+        }
+      end
+    end
+
+    context "inherits only_process options" do
+      before :each do
+        reset_class("Dummy", paperclip: { only_process: [:small, :large] } )
+        Dummy.process_in_background(:image)
+      end
+
+      it "incorporates processing url" do
+        Dummy.paperclip_definitions.should == { :image => {
+          :only_process => [:small, :large],
+          :delayed => {
+            :priority => 0,
+            :only_process => [:small, :large],
+            :url_with_processing => true,
+            :processing_image_url => nil }
+          }
+        }
+      end
+    end
+
+    context "sets callback" do
+      context "commit" do
+        it "sets after_commit callback" do
+          Dummy.expects(:after_commit).with(:enqueue_delayed_processing)
+          Dummy.process_in_background(:image)
+        end
+      end
+
+      context "save" do
+        before :each do
+          Dummy.stubs(:respond_to?).with(:after_commit).returns(false)
+        end
+
+        it "sets after_save callback" do
+          Dummy.expects(:after_save).with(:enqueue_delayed_processing)
+          Dummy.process_in_background(:image)
+        end
+      end
+    end
+  end
+
+end

data/spec/delayed_paperclip/instance_methods_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+describe DelayedPaperclip::InstanceMethods do
+
+  before :all do
+    DelayedPaperclip.options[:background_job_class] = DelayedPaperclip::Jobs::Resque
+    reset_dummy
+  end
+
+  let(:dummy) { Dummy.create }
+
+  describe "#enqueue_delayed_processing" do
+
+    it "marks enqueue_delayed_processing" do
+      dummy.expects(:mark_enqueue_delayed_processing)
+      dummy.enqueue_delayed_processing
+    end
+
+    it "enqueues post processing for all enqueued" do
+      dummy.instance_variable_set(:@_enqued_for_processing, ['image'])
+      dummy.expects(:enqueue_post_processing_for).with('image')
+      dummy.enqueue_delayed_processing
+    end
+
+    it "clears instance variables" do
+      dummy.instance_variable_set(:@_enqued_for_processing, ['foo'])
+      dummy.instance_variable_set(:@_enqued_for_processing_with_processing, ['image'])
+      dummy.enqueue_delayed_processing
+      dummy.instance_variable_get(:@_enqued_for_processing).should == []
+      dummy.instance_variable_get(:@_enqued_for_processing_with_processing).should == []
+    end
+
+  end
+
+  describe "#mark_enqueue_delayed_processing" do
+    it "updates columns of _processing" do
+      dummy.image_processing.should be_false
+      dummy.instance_variable_set(:@_enqued_for_processing_with_processing, ['image'])
+      dummy.mark_enqueue_delayed_processing
+      dummy.reload.image_processing.should be_true
+    end
+
+    it "does nothing if instance variable not set" do
+      dummy.image_processing.should be_false
+      dummy.mark_enqueue_delayed_processing
+      dummy.reload.image_processing.should be_false
+    end
+  end
+
+  describe "#enqueue_post_processing_for" do
+    it "enqueues the instance and image" do
+      DelayedPaperclip.expects(:enqueue).with("Dummy", dummy.id, :image)
+      dummy.enqueue_post_processing_for("image")
+    end
+  end
+
+  describe "#prepare_enqueueing_for" do
+
+    it "updates processing column to true" do
+      pending
+      # TODO: Why would it be writing the attribute here as well as in mark_enqueue_delayed_processing
+      dummy.image_processing.should be_false
+      dummy.expects(:write_attribute).with("image_processing", true)
+      dummy.prepare_enqueueing_for("image")
+      dummy.image_processing.should be_true
+    end
+
+    it "sets instance variables for column updating" do
+      dummy.prepare_enqueueing_for("image")
+      dummy.instance_variable_get(:@_enqued_for_processing_with_processing).should == ["image"]
+    end
+
+    it "sets instance variables for processing" do
+      dummy.prepare_enqueueing_for("image")
+      dummy.instance_variable_get(:@_enqued_for_processing).should == ["image"]
+    end
+  end
+
+
+end