delayed_job_active_record_unique 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9a312fd580e5364d7fd29e8091d11b239ec993ae
-  data.tar.gz: 4155177e47c0c4801ee14e94455d9770d757378a
+  metadata.gz: 40c7c3aa6b67950fa13299fc54a60f37a2a2994c
+  data.tar.gz: 01397e6296e7eb44c21fa5e711f6ba8c80de05b8
 SHA512:
-  metadata.gz: 85e8b3b6a8764141e503b077e2a7a2aa8eb4174f238f33bc2cbaa60e44ac5d8d9cdda06330b39280beee776d971d48fb719676cd05c134cdb117deebd1937e03
-  data.tar.gz: e9d700c83b72bcbc00c730da0f8f18183626c5acfb8a06ea0d12ac2c5426052b0926233b8f3d80b1fe133af3e011e06cb818788f44600a5964ebb489d0ea2456
+  metadata.gz: 18c07e6a7045d68b629d3b169257b8320aa91c0915cca0e471b7286d63a877c7126ec77c8b4d86e30cffbe165b41d41002cf44540301bff5820fc81901da6eab
+  data.tar.gz: e82e17e69f2aa17af28c93b512089d3c84876ab88b1338575b813f67bdd8e5813634714275a63b338805c1eb97ff8f01b0990d9c1c1efa84781372a5dff4511a

data/README.md

@@ -1,3 +1,4 @@
+[![Gem Version](https://badge.fury.io/rb/delayed_job_active_record_unique.svg)](http://badge.fury.io/rb/delayed_job_active_record_unique)
 [![Build Status](https://travis-ci.org/rajiteh/delayed_job_active_record_unique.svg)](https://travis-ci.org/rajiteh/delayed_job_active_record_unique)
 [![Coverage Status](https://coveralls.io/repos/rajiteh/delayed_job_active_record_unique/badge.svg)](https://coveralls.io/r/rajiteh/delayed_job_active_record_unique)
 [![Dependency Status](https://gemnasium.com/rajiteh/delayed_job_active_record_unique.svg)](https://gemnasium.com/rajiteh/delayed_job_active_record_unique)
@@ -44,32 +45,75 @@ delayed_job table.
 Uniqueness of the job can be specified by passing the key `unique_job` to the DelayedJob enqueue call. 
 
 ```ruby
-    unique_job: {
-        attr: :id # Required. A method name in the object that will be called to obtain a uniquely identifiable value.
-        replace: true # Optional. Default = false. # Default behaviour will not enqueue a job that already exists.
-                      # On true, Any job that is already queued under this unique ID will be replaced by the current.
-    }
+unique_job: {
+    attr: :id # Required. A method name in the object that will be called to obtain a uniquely identifiable value.
+    replace: true # Optional. Default = false.
+                  # Default behaviour will not enqueue a job that already exists.
+                  # On true, Any job that is already queued under this unique ID will be replaced by the current.
+}
 ```
 
 It is possible to just supply a `Symbol` to `unique_job` to set the attr value and proceed with default options.
 
+
 *Note:* You must supply a `queue` name to enqueue options or via class method `queue_name` as the uniqueness is only global to the queue.  
-## Example
+
+### Example
 
 If using `#handle_asynchronously`
 
 ```ruby
-    handle_asynchronously :solr_index, queue: 'solr_indexing', priority: 50, unique_job: { attr: :id, replace: true }
+handle_asynchronously :solr_index, queue: 'solr_indexing', priority: 50, unique_job: { attr: :id, replace: true }
 ```
 
 If using a standalone class
 
 ```ruby
-    Delayed::Job.enqueue NewsletterJob.new('lorem ipsum...', Customers.pluck(:email)), unique_job: :get_id
-    #NewsLetterJob must have a 'get_id' method that will return a unique value to it's context.
+Delayed::Job.enqueue NewsletterJob.new('lorem ipsum...'), queue: 'news_letters', unique_job: :get_id
+#NewsLetterJob must have a 'get_id' method that will return a unique value to it's context.
 ```
 
+### Using Procs
 
+Version 0.0.2 supports Procs as 'attr' values. The proc will be evaluated with the payload sent as the first argument. 
+ 
+```ruby
+unique_job: {
+    attr: Proc.new { |obj| "custom_attr_#{obj.id}" }
+    replace: true
+}
+# OR
+unique_job: Proc.new { |obj| "custom_attr_#{obj.id}" }
+```
+ 
+### Standalone Classes
+ 
+If not supplied as an option, Unique Job will look for methods `delayed_job` and `delayed_job_replace?` methods in the
+enqueued object and configure it self accordingly.
+
+```ruby
+class NewsletterJob < Struct.new(:some_object)
+
+    def unique_job
+        "#{some_object.length}_can_manipulate"
+    end
+    
+    def unique_job_replace?
+        true
+    end
+    
+    def queue_name
+        'new_letters_ftw'
+    end
+    
+    def perform
+        #some stuff happening here
+    end
+    
+end
+Delayed::Job.enqueue NewsletterJob.new('lorem ipsum...')
+```
+ 
 ## Contributing
 
 1. Fork it ( https://github.com/rajiteh/delayed_job_active_record_unique/fork )

data/delayed_job_active_record_unique.gemspec

@@ -4,7 +4,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |spec|
   spec.name          = "delayed_job_active_record_unique"
-  spec.version       = "0.0.1"
+  spec.version       = "0.0.2"
   spec.authors       = ["Rajitha Perera"]
   spec.email         = ["rajiteh@gmail.com"]
   spec.summary       = %q{Extend DelayedJob to support unique job indentification.}

data/lib/delayed/backend/base/class_methods/unique_job.rb

@@ -7,35 +7,55 @@ module Delayed
         class UniqueJob
           ERROR_NO_QUEUE = ":queue MUST be specified in the options or a method "\
                            "queue_name must exist in the object for unique_job enqueue."
-          ERROR_BAD_ARGS = "'unique_job' must be one of: Hash with 'attr' key, a Symbol "\
-                           "or non blank String."
+          ERROR_BAD_ARGS = "'unique_job' must be one of: Hash with key 'attr', a Symbol "\
+                           "or non blank String and must be supplied with enqueue options "\
+                           "or provided via a method named `unique_job` in the enqueued class."
 
           attr_accessor :opts
+          attr_accessor :key
+          
           def initialize(opts)
             self.opts = opts
 
-            if self.opts.has_key?(:unique_job)
-              self.opts[:queue] ||= class_queue_name #get class queue if specified
-              raise ArgumentError.new ERROR_NO_QUEUE if opts[:queue].nil?
+            if detect_unique_job!
+              uj = self.opts[:unique_job]
+              puts "UJ: #{uj.inspect}"
+              candidate = if uj.is_a?(Hash)
+                            if uj[:attr].is_a?(Proc)
+                              uj[:attr].call(opts[:payload_object])
+                            else
+                              get_value_of(uj[:attr]) unless uj[:attr].blank?
+                            end
+                          elsif (uj.is_a?(String) || uj.is_a?(Symbol))
+                            get_value_of(uj) unless uj.blank?
+                          elsif uj.is_a?(Proc)
+                            uj.call(opts[:payload_object])
+                          end
+
+              raise ArgumentError.new ERROR_NO_QUEUE unless detect_queue_name!
+              puts "CANDIDATE: #{candidate}"
+              raise ArgumentError.new ERROR_BAD_ARGS if candidate.blank?
+
+              self.key = "#{candidate}"
             else
-              @attr = false
+              disable_unique_job!
             end
           end
 
-          def attr
-            @attr ||= opts.has_key?(:unique_job) &&
-                begin
-                  candidate = opts[:unique_job].is_a?(Hash) ? opts[:unique_job][:attr] : opts[:unique_job]
-                  if (candidate.is_a?(String) || candidate.is_a?(Symbol)) && !candidate.blank?
-                    "#{candidate}"
-                  else
-                    raise ArgumentError.new ERROR_BAD_ARGS
-                  end
-                end
+          def get_value_of(attr)
+            if opts[:payload_object].is_a? Delayed::PerformableMethod
+              opts[:payload_object].object.send(attr)
+            else
+              opts[:payload_object].send(attr)
+            end
+          end
+
+          def disable_unique_job!
+            self.key = false
           end
 
           def require_unique?
-            attr != false
+            key != false
           end
 
           def replace_job?
@@ -53,24 +73,35 @@ module Delayed
           end
 
           def ready_to_run_uniquely
-            Delayed::Job.ready_to_run('', Delayed::Worker.max_run_time).where(:unique_id => generate_key)
+            Delayed::Job.ready_to_run('', Delayed::Worker.max_run_time).where(:unique_id => slugged_key)
           end
 
-          def generate_key
-            @key ||= if opts[:payload_object].is_a? Delayed::PerformableMethod
-                       "#{opts[:queue]}_#{opts[:payload_object].object.send(attr)}"
-                     else
-                       "#{opts[:queue]}_#{opts[:payload_object].send(attr)}"
-                     end
+          def slugged_key
+            @slugged_key ||= "#{opts[:queue]}_#{key}"
           end
 
-          def class_queue_name
-            unless opts[:payload_object].is_a? Delayed::PerformableMethod
-              opts[:payload_object].queue_name if opts[:payload_object].respond_to? :queue_name
-            end
+          def detect_unique_job!
+            self.opts.has_key?(:unique_job) ||
+                (opts[:payload_object].respond_to? :unique_job) &&
+                    (opts[:unique_job] = { attr: Proc.new { opts[:payload_object].unique_job } } ) &&
+                    (detect_unique_job_replace! || true)
+
+
+          end
+
+          def detect_unique_job_replace!
+            (opts[:payload_object].respond_to? :unique_job_replace?) &&
+                (opts[:unique_job][:replace] = opts[:payload_object].unique_job_replace?)
           end
+
+          def detect_queue_name!
+            self.opts.has_key?(:queue) ||
+                (opts[:payload_object].respond_to? :queue_name) &&
+                    (opts[:queue] = opts[:payload_object].queue_name)
+          end
+
           def enqueue_opts
-            require_unique? ? opts.except(:unique_job).merge(unique_id: generate_key) : opts
+            require_unique? ? opts.except(:unique_job).merge(unique_id: slugged_key) : opts
           end
 
         end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: delayed_job_active_record_unique
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Rajitha Perera
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-01 00:00:00.000000000 Z
+date: 2015-04-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: delayed_job_active_record
@@ -74,7 +74,6 @@ files:
 - lib/delayed/backend/base/class_methods/unique_job.rb
 - lib/delayed_job_active_record_unique.rb
 - lib/generators/delayed_job/active_record_unique_generator.rb
-- lib/generators/delayed_job/next_migration_version.rb
 - lib/generators/delayed_job/templates/unique_id.rb
 homepage: http://github.com/rajiteh/delayed_job_active_record_unique
 licenses:

data/lib/generators/delayed_job/next_migration_version.rb

@@ -1,14 +0,0 @@
-module DelayedJob
-  module NextMigrationVersion
-    # while methods have moved around this has been the implementation
-    # since ActiveRecord 3.0
-    def next_migration_number(dirname)
-      next_migration_number = current_migration_number(dirname) + 1
-      if ActiveRecord::Base.timestamped_migrations
-        [Time.now.utc.strftime("%Y%m%d%H%M%S"), format("%.14d", next_migration_number)].max
-      else
-        format("%.3d", next_migration_number)
-      end
-    end
-  end
-end