background_worker 0.6.0 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 21cc4f8353107acd3a07a1dbb33709a5f5629e266c64ec66eee2a558d61e6614
-  data.tar.gz: 9499f710d1e056be82da09af4c28a8229ac43e6aada29725a1d766f4638fc136
+  metadata.gz: 061e6c0338c031523b85a90f084aaf996c00cbe9e668428931a98ae3b5a12f36
+  data.tar.gz: 36304e141265bc21d2d756d2af7aab6645fbfa9596d5ab5bfe2c115132f685a8
 SHA512:
-  metadata.gz: f869b9563b92e17c75632b3de27946ac87939033c068c093e3060b8f062bb26abab31a3559def9fe06a6291016a9c26e764c25a6c96fe7f789e886e934aec709
-  data.tar.gz: fc67495315f925f92ff8e00fe4c8e3babffd1b9c6e608ae274cfa26e72364fa83ea76ea1903b636e979ef9100dd26edd8422a3b64149e6ff726bdc6c0c87a503
+  metadata.gz: f799063ea369646eea2956427aa7bc0cd551229649e9e3cb1b324a8bd1edec162c7d0852dbf0c7ce724d0332c702208097c5a975827d050742c0df11e5e3709a
+  data.tar.gz: 6d4487e464251517e318fe59be864d87da48f324aabce3b6d8964971f55fa1a4a3b5dc7f66913fe6ee5654614a72d6fb978887a84829e0afe656313b6d693ca6

data/CHANGELOG.md

@@ -3,6 +3,18 @@ All notable changes to this project will be documented in this file.
 This project adheres to [Semantic Versioning](http://semver.org/).  
 This changelog adheres to [Keep a CHANGELOG](http://keepachangelog.com/).  
 
+## 0.8.1
+
+- Fix version
+
+## 0.8.0
+
+- [PLAT-747] Remove the ability to pass through `method_name`
+
+## 0.7.0
+
+- [PLAT-670] Add queue_as method
+
 ## 0.6.0
 
 - [PLAT-664] Align interface to ActiveJob

data/README.md

@@ -10,7 +10,7 @@ Start by making a worker class which extends from BackgroundWorker::Base
 
 ```ruby
     class MyWorker < BackgroundWorker::Base
-      def my_task(options={})
+      def perform(options={})
         report_progress('Starting')
         if options[:message].blank?
           report_failed("No message provided")
@@ -27,7 +27,7 @@ Then, when you want to perform a task in the background, use
 klass#perform_in_background which exists in Base:
 
 ```ruby
-    worker_id = MyWorker.perform_in_background(:my_task, message: "hello!")
+    worker_id = MyWorker.perform_later(message: "hello!")
 ```
 
 # Backgrounded
@@ -37,8 +37,8 @@ provide an #enqueue_with configuration like so:
 
 ```ruby
     BackgroundWorker.configure(
-      enqueue_with: -> klass, method_name, options {
-        Resque.enqueue(klass, method_name, options)
+      enqueue_with: -> klass, options {
+        Resque.enqueue(klass, options)
       }
     )
 ```

data/lib/background_worker/base.rb

@@ -15,6 +15,10 @@ module BackgroundWorker
       log("Options are: #{options.inspect}")
     end
 
+    def perform
+      raise AbstractError, 'Must be implemented in Job Class'
+    end
+
     # Report progress...
     def report_progress(message)
       state.message = message
@@ -53,22 +57,22 @@ module BackgroundWorker
     end
 
     class << self
+      attr_reader :queue
       def get_state_of(worker_id)
         BackgroundWorker::PersistentState.get_state_of(worker_id)
       end
 
       # Public method to do in background...
-      def perform_later(method_name, options = {})
+      def perform_later(options = {})
         opts = options.symbolize_keys
 
-        method_name = method_name.to_sym
-        opts[:uid] ||= BackgroundWorker::Uid.new(to_s, method_name).generate
+        opts[:uid] ||= BackgroundWorker::Uid.new(to_s).generate
 
         # Store into shared-cache before kicking job off
         BackgroundWorker::PersistentState.new(opts[:uid], opts.except(:uid))
 
         # Enqueue to the background queue
-        BackgroundWorker.enqueue(self, method_name, opts)
+        BackgroundWorker.enqueue(self, opts)
 
         opts[:uid]
       end
@@ -76,15 +80,19 @@ module BackgroundWorker
       # This method is called by the job runner
       #
       # It will just call your preferred method in the worker.
-      def perform_now(method_name, options = {})
+      def perform_now(options = {})
         BackgroundWorker.verify_active_connections! if BackgroundWorker.config.backgrounded
 
         worker = new(options)
-        execution = WorkerExecution.new(worker, method_name, options)
+        execution = WorkerExecution.new(worker, options)
         execution.call
       ensure
         BackgroundWorker.release_connections! if BackgroundWorker.config.backgrounded
       end
+
+      def queue_as(queue = nil)
+        @queue = queue&.to_sym || :default
+      end
     end
   end
 end

data/lib/background_worker/config.rb

@@ -27,8 +27,8 @@ module BackgroundWorker
       @after_exception.call(e)
     end
 
-    def foreground_enqueue(klass, method_name, opts)
-      klass.perform_now(method_name, opts)
+    def foreground_enqueue(klass, opts)
+      klass.perform_now(opts)
     end
 
     def default_after_exception(e)

data/lib/background_worker/uid.rb

@@ -1,11 +1,10 @@
 # Generates a unique identifier for a particular job identified by class_name/method
 module BackgroundWorker
   class Uid
-    attr_reader :class_name, :method
+    attr_reader :class_name
 
-    def initialize(class_name, method)
+    def initialize(class_name)
       @class_name = class_name
-      @method = method
     end
 
     def generate
@@ -15,11 +14,11 @@ module BackgroundWorker
     private
 
     def generate_uid_hash
-      ::Digest::MD5.hexdigest("#{class_name}:#{method}:#{rand(1 << 64)}:#{Time.now}")
+      ::Digest::MD5.hexdigest("#{class_name}:#{rand(1 << 64)}:#{Time.now}")
     end
 
     def generate_uid_name
-      "#{class_name.underscore}/#{method}".split('/').join(':')
+      "#{class_name.underscore}".split('/').join(':')
     end
   end
 end

data/lib/background_worker/version.rb

@@ -1,3 +1,3 @@
 module BackgroundWorker
-  VERSION = '0.6.0'
+  VERSION = '0.8.1'
 end

data/lib/background_worker/worker_execution.rb

@@ -2,15 +2,14 @@ module BackgroundWorker
   class WorkerExecution
     attr_reader :worker, :method_name, :options
 
-    def initialize(worker, method_name, options)
+    def initialize(worker, options)
       fail ArgumentError, "'uid' is required to identify worker" unless options[:uid].present?
       @worker = worker
-      @method_name = method_name
       @options = options
     end
 
     def call
-      worker.send(method_name, options)
+      worker.perform(options)
       report_implicitly_successful unless completed?
 
     rescue StandardError => e

data/lib/background_worker.rb

@@ -8,15 +8,15 @@ module BackgroundWorker
   # eg:
   # BackgroundWorker.configure(
   #   logger: Rails.logger,
-  #   enqueue_with: -> klass, method_name, opts { Resque.enqueue(klass, method_name, opts) },
+  #   enqueue_with: -> klass, opts { Resque.enqueue(klass, opts) },
   #   after_exception: -> e { Airbrake.notify(e) }
   # )
   def self.configure(options)
     @config = Config.new(options)
   end
 
-  def self.enqueue(klass, method_name, options)
-    config.enqueue_with.call(klass, method_name, options)
+  def self.enqueue(klass, options)
+    config.enqueue_with.call(klass, options)
   end
 
   def self.logger

data/spec/base_spec.rb

@@ -18,7 +18,7 @@ describe BackgroundWorker::Base do
   let(:model_class) { Model = Class.new(ActiveRecord::Base) }
   let(:worker_class) {
     Class.new(BackgroundWorker::Base) do
-      def store_in_cache(opts)
+      def perform(opts)
         Rails.cache.store(opts[:value])
       end
     end
@@ -32,8 +32,15 @@ describe BackgroundWorker::Base do
 
   it 'should perform action and handle transactions/connections appropriately' do
     Model.transaction do
-      worker_class.perform_later(:store_in_cache, value: 42)
+      worker_class.perform_later(value: 42)
     end
     expect(cache).to have_received(:store).with(42)
   end
+
+  context '#queue_as' do
+    it 'should value queue correctly' do
+      worker_class.queue_as('low')
+      expect(worker_class.queue).to be :low
+    end
+  end
 end

data/spec/support/coverage_loader.rb

@@ -1,3 +1,3 @@
 require 'coverage/kit'
 
-Coverage::Kit.setup(minimum_coverage: 82.75)
+Coverage::Kit.setup(minimum_coverage: 82.30)

data/spec/uid_spec.rb

@@ -2,11 +2,10 @@ require 'spec_helper'
 
 describe BackgroundWorker::Uid do
   let(:class_name) { 'CopyWorker' }
-  let(:method) { 'make_copy' }
-  let(:uid_object) { BackgroundWorker::Uid.new(class_name, method) }
+  let(:uid_object) { BackgroundWorker::Uid.new(class_name) }
 
   context '#generate' do
     subject(:uid) { uid_object.generate }
-    it { is_expected.to match(/copy_worker:make_copy:[0-9a-f]{16}/) }
+    it { is_expected.to match(/copy_worker:[0-9a-f]{16}/) }
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: background_worker
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.8.1
 platform: ruby
 authors:
 - Michael Noack
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-09-02 00:00:00.000000000 Z
+date: 2022-09-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport