resque-unique_in_queue 2.0.0 → 2.0.2

data/lib/resque/plugins/unique_in_queue.rb

@@ -18,6 +18,8 @@ module Resque
       end
 
       module ClassMethods
+        # The plugin stores per-job configuration on the job class.
+        # rubocop:disable ThreadSafety/ClassInstanceVariable
         def unique_in_queue_redis_key(queue, item)
           "#{unique_in_queue_key_base}:queue:#{queue}:job:#{Resque::UniqueInQueue::Queue.const_for(item).redis_key(item)}"
         end
@@ -26,8 +28,8 @@ module Resque
         # a hash containing string keys 'class' and 'args'
         def redis_key(payload)
           payload = Resque.decode(Resque.encode(payload))
-          job  = payload['class']
-          args = payload['args']
+          job = payload["class"]
+          args = payload["args"]
           args.map! do |arg|
             arg.is_a?(Hash) ? arg.sort : arg
           end
@@ -46,7 +48,7 @@ module Resque
         # end
         def lock_after_execution_period
           instance_variable_get(:@lock_after_execution_period) ||
-              instance_variable_set(:lock_after_execution_period, Resque::UniqueInQueue.configuration&.lock_after_execution_period)
+            instance_variable_set(:@lock_after_execution_period, Resque::UniqueInQueue.configuration&.lock_after_execution_period)
         end
 
         # The default ttl of a locking key is -1 (forever).
@@ -59,7 +61,7 @@ module Resque
         # end
         def ttl
           instance_variable_get(:@ttl) ||
-              instance_variable_set(:ttl, Resque::UniqueInQueue.configuration&.ttl)
+            instance_variable_set(:@ttl, Resque::UniqueInQueue.configuration&.ttl)
         end
 
         # Should not generally be overridden per each class because it wouldn't
@@ -68,8 +70,9 @@ module Resque
         #   and general cleanup of stray keys would be nearly impossible.
         def unique_in_queue_key_base
           instance_variable_get(:@unique_in_queue_key_base) ||
-              instance_variable_set(:@unique_in_queue_key_base, Resque::UniqueInQueue.configuration&.unique_in_queue_key_base)
+            instance_variable_set(:@unique_in_queue_key_base, Resque::UniqueInQueue.configuration&.unique_in_queue_key_base)
         end
+        # rubocop:enable ThreadSafety/ClassInstanceVariable
       end
     end
   end

data/lib/resque/unique_in_queue/configuration.rb

@@ -1,20 +1,21 @@
-require 'logger'
+require "logger"
 module Resque
   module UniqueInQueue
     class Configuration
       DEFAULT_LOCK_AFTER_EXECUTION_PERIOD = 0
       DEFAULT_TTL = -1
-      DEFAULT_UNIQUE_IN_QUEUE_KEY_BASE = 'r-uiq'.freeze
+      DEFAULT_UNIQUE_IN_QUEUE_KEY_BASE = "r-uiq".freeze
       DEFAULT_LOG_LEVEL = :debug
 
       include Singleton
 
-      attr_accessor :debug_mode,
-                    :lock_after_execution_period,
-                    :log_level,
-                    :logger,
-                    :ttl,
-                    :unique_in_queue_key_base
+      attr_reader :debug_mode
+
+      attr_accessor :lock_after_execution_period,
+        :log_level,
+        :logger,
+        :ttl,
+        :unique_in_queue_key_base
 
       def initialize
         debug_mode_from_env
@@ -25,18 +26,18 @@ module Resque
         @unique_in_queue_key_base = DEFAULT_UNIQUE_IN_QUEUE_KEY_BASE
         if @debug_mode
           # Make sure there is a logger when in debug_mode
-          @logger ||= Logger.new(STDOUT)
+          @logger ||= Logger.new($stdout)
         end
       end
 
       def to_hash
         {
-            debug_mode: debug_mode,
-            lock_after_execution_period: lock_after_execution_period,
-            log_level: log_level,
-            logger: logger,
-            ttl: ttl,
-            unique_in_queue_key_base: unique_in_queue_key_base
+          debug_mode: debug_mode,
+          lock_after_execution_period: lock_after_execution_period,
+          log_level: log_level,
+          logger: logger,
+          ttl: ttl,
+          unique_in_queue_key_base: unique_in_queue_key_base
         }
       end
 
@@ -47,8 +48,8 @@ module Resque
       private
 
       def debug_mode_from_env
-        env_debug = ENV['RESQUE_DEBUG']
-        @debug_mode = !!(env_debug == 'true' || (env_debug.is_a?(String) && env_debug.match?(/queue/)))
+        env_debug = ENV["RESQUE_DEBUG"]
+        @debug_mode = !!(env_debug == "true" || (env_debug.is_a?(String) && env_debug.match?(/queue/)))
       end
     end
   end

data/lib/resque/unique_in_queue/queue.rb

@@ -4,7 +4,7 @@ module Resque
       def queued?(queue, item)
         return false unless is_unique?(item)
 
-        redis.get(unique_key(queue, item)) == '1'
+        redis.get(unique_key(queue, item)) == "1"
       end
 
       def mark_queued(queue, item)
@@ -56,16 +56,17 @@ module Resque
 
         redis.lrange(redis_queue, 0, -1).each do |string|
           json = Resque.decode(string)
-          next unless json['class'] == klass
-          next if args.any? && json['args'] != args
+          next unless json["class"] == klass
+          next if args.any? && json["args"] != args
 
           Resque::UniqueInQueue::Queue.mark_unqueued(queue, json)
         end
       end
 
       def cleanup(queue)
-        keys = redis.keys("#{Resque::UniqueInQueue.configuration&.unique_in_queue_key_base}:queue:#{queue}:job:*")
-        redis.del(*keys) if keys.any?
+        pattern = "#{Resque::UniqueInQueue.configuration&.unique_in_queue_key_base}:queue:#{queue}:job:*"
+        keys = redis.scan_each(match: pattern, count: 1_000_000).to_a
+        redis.del(keys) if keys.any?
       end
 
       private
@@ -75,12 +76,12 @@ module Resque
       end
 
       def item_class(item)
-        item[:class] || item['class']
+        item[:class] || item["class"]
       end
 
       def const_for(item)
         Resque.constantize(item_class(item))
-        end
+      end
 
       module_function :queued?, :mark_queued, :mark_unqueued, :unique_key
       module_function :is_unique?, :item_ttl, :lock_after_execution_period

data/lib/resque/unique_in_queue/resque_ext/job.rb

@@ -3,11 +3,11 @@ module Resque
     class << self
       # Mark an item as queued
       def create_unique_in_queue(queue, klass, *args)
-        item = { class: klass.to_s, args: args }
+        item = {class: klass.to_s, args: args}
         if Resque.inline? || !Resque::UniqueInQueue::Queue.is_unique?(item)
           return create_without_unique_in_queue(queue, klass, *args)
         end
-        return 'EXISTED' if Resque::UniqueInQueue::Queue.queued?(queue, item)
+        return "EXISTED" if Resque::UniqueInQueue::Queue.queued?(queue, item)
 
         create_return_value = false
         # redis transaction block
@@ -31,21 +31,21 @@ module Resque
         destroy_without_unique_in_queue(queue, klass, *args)
       end
 
-      alias create_without_unique_in_queue create
-      alias create create_unique_in_queue
-      alias reserve_without_unique_in_queue reserve
-      alias reserve reserve_unique_in_queue
-      alias destroy_without_unique_in_queue destroy
-      alias destroy destroy_unique_in_queue
+      alias_method :create_without_unique_in_queue, :create
+      alias_method :create, :create_unique_in_queue
+      alias_method :reserve_without_unique_in_queue, :reserve
+      alias_method :reserve, :reserve_unique_in_queue
+      alias_method :destroy_without_unique_in_queue, :destroy
+      alias_method :destroy, :destroy_unique_in_queue
 
       if defined?(Resque::Plugins::PriorityEnqueue::Resque)
         # Hack to support resque-priority_enqueue: https://github.com/coupa/resque-priority_enqueue
         def priority_create_unique_in_queue(queue, klass, *args)
-          item = { class: klass.to_s, args: args }
+          item = {class: klass.to_s, args: args}
           if Resque.inline? || !Resque::UniqueInQueue::Queue.is_unique?(item)
             return priority_create_without_unique_in_queue(queue, klass, *args)
           end
-          return 'EXISTED' if Resque::UniqueInQueue::Queue.queued?(queue, item)
+          return "EXISTED" if Resque::UniqueInQueue::Queue.queued?(queue, item)
 
           priority_create_return_value = false
           # redis transaction block
@@ -56,8 +56,8 @@ module Resque
           priority_create_return_value
         end
 
-        alias priority_create_without_unique_in_queue priority_create
-        alias priority_create priority_create_unique_in_queue
+        alias_method :priority_create_without_unique_in_queue, :priority_create
+        alias_method :priority_create, :priority_create_unique_in_queue
       end
     end
   end

data/lib/resque/unique_in_queue/resque_ext/resque.rb

@@ -10,7 +10,7 @@ module Resque
       return nil if before_hooks.any? { |result| result == false }
 
       result = Job.create(queue, klass, *args)
-      return nil if result == 'EXISTED'
+      return nil if result == "EXISTED"
 
       Plugin.after_enqueue_hooks(klass).each do |hook|
         klass.send(hook, *args)
@@ -24,7 +24,7 @@ module Resque
     end
 
     def enqueued_in?(queue, klass, *args)
-      item = { class: klass.to_s, args: args }
+      item = {class: klass.to_s, args: args}
       return nil unless Resque::UniqueInQueue::Queue.is_unique?(item)
 
       Resque::UniqueInQueue::Queue.queued?(queue, item)
@@ -35,7 +35,7 @@ module Resque
       Resque::UniqueInQueue::Queue.cleanup(queue)
     end
 
-    alias remove_queue_without_unique_in_queue_cleanup remove_queue
-    alias remove_queue remove_queue_with_unique_in_queue_cleanup
+    alias_method :remove_queue_without_unique_in_queue_cleanup, :remove_queue
+    alias_method :remove_queue, :remove_queue_with_unique_in_queue_cleanup
   end
 end

data/lib/resque/unique_in_queue/version.rb

@@ -2,6 +2,12 @@
 
 module Resque
   module UniqueInQueue
-    VERSION = '2.0.0'.freeze
+    # Version namespace for this gem.
+    module Version
+      # Current gem version.
+      VERSION = "2.0.2"
+    end
+    # Current gem version exposed at the traditional constant location.
+    VERSION = Version::VERSION # Traditional Constant Location
   end
 end

data/lib/resque/unique_in_queue.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative "unique_in_queue/version"
+
+module Resque
+  module UniqueInQueue
+  end
+end

data/lib/resque-unique_in_queue.rb

@@ -1,20 +1,19 @@
 # frozen_string_literal: true
 
-require 'resque/unique_in_queue/version'
+require "resque/unique_in_queue/version"
 
 # Ruby Std Lib
-require 'digest/md5'
+require "digest/md5"
 
 # External Gems
-require 'colorized_string'
-require 'resque'
+require "resque"
 
 # This Gem
-require 'resque/plugins/unique_in_queue'
-require 'resque/unique_in_queue/resque_ext/job'
-require 'resque/unique_in_queue/resque_ext/resque'
-require 'resque/unique_in_queue/queue'
-require 'resque/unique_in_queue/configuration'
+require "resque/plugins/unique_in_queue"
+require "resque/unique_in_queue/resque_ext/job"
+require "resque/unique_in_queue/resque_ext/resque"
+require "resque/unique_in_queue/queue"
+require "resque/unique_in_queue/configuration"
 
 # See lib/resque/plugins/unique_in_queue.rb for the actual plugin
 #
@@ -23,10 +22,16 @@ require 'resque/unique_in_queue/configuration'
 #   Resque, Resque::Job, or Resque::Queue.
 module Resque
   module UniqueInQueue
-    PLUGIN_TAG = (ColorizedString['[R-UIQ] '].blue).freeze
+    # Wraps text in ANSI blue escape codes. Replaces the former `colorize`
+    # dependency; produces the exact sequence colorize's String#blue emitted.
+    def self.blue_text(text)
+      "\e[0;34;49m#{text}\e[0m"
+    end
+
+    PLUGIN_TAG = blue_text("[R-UIQ] ").freeze
 
     def log(message)
-      configuration.logger&.send(configuration.log_level, message) if configuration.logger
+      configuration.logger&.send(configuration.log_level, message)
     end
 
     def debug(message)
@@ -40,12 +45,15 @@ module Resque
 
     #### CONFIG ####
     class << self
+      # The plugin exposes one replaceable configuration object by design.
+      # rubocop:disable ThreadSafety/ClassAndModuleAttributes
       attr_accessor :configuration
+      # rubocop:enable ThreadSafety/ClassAndModuleAttributes
     end
 
     self.configuration = Configuration.instance # setup defaults
 
     module_function(:log,
-                    :debug)
+      :debug)
   end
 end

data/sig/resque/unique_in_queue.rbs

@@ -0,0 +1,8 @@
+module Resque
+  module UniqueInQueue
+    module Version
+      VERSION: String
+    end
+    VERSION: String
+  end
+end