sucker_punch 2.0.1 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: bf92e4a48564bae41998ae57c236a47b89285dbc
-  data.tar.gz: 52889bcf6c537626a756ed72b9aa384426c38e72
+SHA256:
+  metadata.gz: e1edad787473a077f23f2fae95150cdb92e3834a12150fbd4d910fade5692516
+  data.tar.gz: 4ba7b7fa6cf3a1c99706a3bda43b0fd2fc291ae1825a23466b00a5b7a3354003
 SHA512:
-  metadata.gz: ebf79f943dd84a524c613556efbe009d022c85aa111675170abbceb2d7ac5b45b09cedf273846fd963e0e4ae13eb0f82c427ca72d8407687a9fd0be85fe5f587
-  data.tar.gz: 1e8c7a238309b242624cc3a594efa1efd371f9fccccdabb76ab8ddb884972ce0956adf99969a6c7b7a63955555c1595d55e0472dc1f17a0875c56ebe235b0bd5
+  metadata.gz: a8184cafe29937ad818920951c3c760e8435b4e35a348e27629053bae1b56e2f44ab412154fb3769e6878034a9351ad5e60fb44d9385bf5bb4f2bf58cc91c71c
+  data.tar.gz: fde16057612312085f59a955e783007b6a0cf0b4ff7d08312963bc0c76b3be2e5d254e5eb1df1625db3c554403485e5df8a1c995ab50b71dda4e1358b00e8d23

data/.travis.yml

@@ -4,7 +4,8 @@ rvm:
   - 2.0.0
   - 2.1.8
   - 2.2.4
-  - 2.3.0
+  - 2.3.4
+  - 2.4.1
   - ruby-head
 
 matrix:

data/CHANGES.md

@@ -1,3 +1,49 @@
+3.0.0
+-------
+- Add support for keyword arguments in ruby `>= 3.0`. More details in [release notes](https://www.ruby-lang.org/en/news/2020/12/25/ruby-3-0-0-released/).
+
+2.1.1
+-------
+- Relax versioning constraint of `concurrent-ruby` to make way for 1.1 release
+
+2.1.0
+-------
+- Add `max_jobs` configuration option to set the maximum number of tasks that
+  may be waiting in the work queue
+
+    ```ruby
+    class JobWithLimit
+      include SuckerPunch::Job
+      max_jobs 2
+
+      def perform(data)
+        # work...
+      end
+    end
+
+    10.times do
+      begin
+        JobWithLimit.perform_async('work') }
+      rescue Concurrent::RejectedExecutionError => e
+        # Queue maxed out, this job didn't get queued
+      end
+    end
+
+2.0.4
+-------
+- Better initialization of variables and names to remove warnings
+
+2.0.3
+-------
+- Rewrite shutdown strategy to fix bug related to premature shutdown when only
+    1 job is in enqueued when a job has more than 1 worker
+
+2.0.2
+-------
+- Don't consider global shutdown bool when exhausting the queue during
+  shutdown. This led to `shutdown_timeout` not being respected when
+  processing remaining jobs left in the queue with a high `shutdown_timeout`.
+
 2.0.1
 -------
 - Remove scripts from `bin/`

data/README.md

@@ -1,7 +1,7 @@
 # Sucker Punch
 
-[![Build Status](https://travis-ci.org/brandonhilkert/sucker_punch.png?branch=master)](https://travis-ci.org/brandonhilkert/sucker_punch)
-[![Code Climate](https://codeclimate.com/github/brandonhilkert/sucker_punch.png)](https://codeclimate.com/github/brandonhilkert/sucker_punch)
+[![Build Status](https://travis-ci.org/brandonhilkert/sucker_punch.svg?branch=master)](https://travis-ci.org/brandonhilkert/sucker_punch)
+[![Code Climate](https://codeclimate.com/github/brandonhilkert/sucker_punch.svg)](https://codeclimate.com/github/brandonhilkert/sucker_punch)
 
 Sucker Punch is a single-process Ruby asynchronous processing library.
 This reduces costs
@@ -14,8 +14,7 @@ crunching, or social platform manipulation. No reason to hold up a
 user when you can do these things in the background within the same
 process as your web application...
 
-Sucker Punch is built on top of [concurrent-ruby]
-(https://github.com/ruby-concurrency/concurrent-ruby). Each job is setup as
+Sucker Punch is built on top of [concurrent-ruby](https://github.com/ruby-concurrency/concurrent-ruby). Each job is setup as
 a pool, which equates to its own queue with individual workers working against
 the jobs. Unlike most other background processing libraries, Sucker
 Punch's jobs are stored in memory. The benefit to this is there is no
@@ -115,6 +114,22 @@ class LogJob
 end
 ```
 
+#### Configure the Queue Size
+
+The default number of jobs that can be queued is unlimited. If you wish to restrict this you can set
+max\_jobs as follows:
+
+```Ruby
+class LogJob
+  include SuckerPunch::Job
+  max_jobs 10
+
+  def perform(event)
+    Log.new(event).track
+  end
+end
+```
+
 #### Executing Jobs in the Future
 
 Many background processing libraries have methods to perform operations after a
@@ -132,7 +147,7 @@ class DataJob
 end
 
 DataJob.perform_async("asdf") # immediately perform asynchronously
-DataJob.perform_in(60, "asdf") # `perform` will be excuted 60 sec. later
+DataJob.perform_in(60, "asdf") # `perform` will be executed 60 sec. later
 ```
 
 #### `ActiveRecord` Connection Pool Connections
@@ -255,6 +270,19 @@ $ rails g sucker_punch:job logger
 would create the file `app/jobs/logger_job.rb` with a unimplemented `#perform`
 method.
 
+## Sinatra
+
+If you're using Sucker Punch with Sinatra, you must require Sucker Punch before Sinatra:
+
+```ruby
+# app.rb
+
+require 'sucker_punch'
+require 'sinatra'
+```
+
+This will ensure Sucker Punch's `at_exit()` handler to clean up and shutdown queues does not happen **before** Sinatra *starts up* via its own `at_exit()` handler.
+
 ## Active Job
 
 Sucker Punch has been added as an Active Job adapter in Rails 4.2.
@@ -270,11 +298,11 @@ gem 'sucker_punch'
 And then configure the backend to use Sucker Punch:
 
 ```Ruby
-# config/initializers/sucker_punch.rb
-Rails.application.configure do
+# config/application.rb
+class Application < Rails::Application
+  # ...
   config.active_job.queue_adapter = :sucker_punch
 end
-
 ```
 
 If you want to use Sucker Punch version `2.0.0+` with Rails `< 5.0.0`, be sure

data/lib/generators/sucker_punch/templates/job.rb

@@ -1,6 +1,6 @@
-class <%= class_name %>Job 
+class <%= class_name %>Job
   include SuckerPunch::Job
-  
+
   def perform
     raise NotImplementedError
   end

data/lib/sucker_punch.rb

@@ -10,12 +10,12 @@ module SuckerPunch
   RUNNING = Concurrent::AtomicBoolean.new(true)
 
   class << self
-    def exception_handler=(handler)
-      @exception_handler = handler
+    def exception_handler
+      @exception_handler ||= method(:default_exception_handler)
     end
 
-    def exception_handler
-      @exception_handler || method(:default_exception_handler)
+    def exception_handler=(handler)
+      @exception_handler = handler
     end
 
     def default_exception_handler(ex, klass, args)
@@ -26,11 +26,7 @@ module SuckerPunch
     end
 
     def logger
-      @logger || default_logger
-    end
-
-    def logger=(log)
-      @logger = (log ? log : Logger.new('/dev/null'))
+      @logger ||= default_logger
     end
 
     def default_logger
@@ -39,9 +35,13 @@ module SuckerPunch
       l
     end
 
+    def logger=(log)
+      @logger = (log ? log : Logger.new('/dev/null'))
+    end
+
     def shutdown_timeout
       # 10 seconds on heroku, minus a grace period
-      @shutdown_timeout || 8
+      @shutdown_timeout ||= 8
     end
 
     def shutdown_timeout=(timeout)

data/lib/sucker_punch/async_syntax.rb

@@ -10,9 +10,8 @@ module SuckerPunch
       @job = job
     end
 
-    def perform(*args)
-      @job.class.perform_async(*args)
+    def perform(*args, **kwargs)
+      @job.class.perform_async(*args, **kwargs)
     end
   end
 end
-

data/lib/sucker_punch/job.rb

@@ -14,15 +14,17 @@ module SuckerPunch
   # To trigger asynchronous job:
   #
   #   LogJob.perform_async(1, 2, 3)
-  #   LogJob.perform_in(60, 1, 2, 3) # `perform` will be excuted 60 sec. later
+  #   LogJob.perform_in(60, 1, 2, 3) # `perform` will be executed 60 sec. later
   #
   # Note that perform_async is a class method, perform is an instance method.
   module Job
     def self.included(base)
       base.extend(ClassMethods)
       base.class_attribute :num_workers
+      base.class_attribute :num_jobs_max
 
       base.num_workers = 2
+      base.num_jobs_max = nil
     end
 
     def logger
@@ -30,17 +32,17 @@ module SuckerPunch
     end
 
     module ClassMethods
-      def perform_async(*args)
+      def perform_async(*args, **kwargs)
         return unless SuckerPunch::RUNNING.true?
-        queue = SuckerPunch::Queue.find_or_create(self.to_s, num_workers)
-        queue.post(args) { |args| __run_perform(*args) }
+        queue = SuckerPunch::Queue.find_or_create(self.to_s, num_workers, num_jobs_max)
+        queue.post { __run_perform(*args, **kwargs) }
       end
 
-      def perform_in(interval, *args)
+      def perform_in(interval, *args, **kwargs)
         return unless SuckerPunch::RUNNING.true?
-        queue = SuckerPunch::Queue.find_or_create(self.to_s, num_workers)
+        queue = SuckerPunch::Queue.find_or_create(self.to_s, num_workers, num_jobs_max)
         job = Concurrent::ScheduledTask.execute(interval.to_f, args: args, executor: queue) do
-          __run_perform(*args)
+          __run_perform(*args, **kwargs)
         end
         job.pending?
       end
@@ -49,17 +51,24 @@ module SuckerPunch
         self.num_workers = num
       end
 
-      def __run_perform(*args)
-        # break if shutdown began while I was waiting in the queue
-        return unless SuckerPunch::RUNNING.true?
+      def max_jobs(num)
+        self.num_jobs_max = num
+      end
 
+      def __run_perform(*args, **kwargs)
         SuckerPunch::Counter::Busy.new(self.to_s).increment
-        result = self.new.perform(*args)
+
+        result = if RUBY_VERSION >= '2.5'
+                   self.new.perform(*args, **kwargs)
+                 else
+                   self.new.perform(*args, *(kwargs.any? ? [kwargs] : nil))
+                 end
+
         SuckerPunch::Counter::Processed.new(self.to_s).increment
         result
       rescue => ex
         SuckerPunch::Counter::Failed.new(self.to_s).increment
-        SuckerPunch.exception_handler.call(ex, self, args)
+        SuckerPunch.exception_handler.call(ex, self, [*args, **kwargs])
       ensure
         SuckerPunch::Counter::Busy.new(self.to_s).decrement
       end

data/lib/sucker_punch/queue.rb

@@ -5,23 +5,26 @@ module SuckerPunch
     extend Forwardable
     include Concurrent::ExecutorService
 
+    DEFAULT_MAX_QUEUE_SIZE = 0 # Unlimited
+
     DEFAULT_EXECUTOR_OPTIONS = {
       min_threads:     2,
       max_threads:     2,
       idletime:        60, # 1 minute
-      max_queue:       0, # unlimited
       auto_terminate:  false # Let shutdown modes handle thread termination
     }.freeze
 
     QUEUES = Concurrent::Map.new
 
-    def self.find_or_create(name, num_workers = 2)
+    def self.find_or_create(name, num_workers = 2, num_jobs_max = nil)
       pool = QUEUES.fetch_or_store(name) do
-        options = DEFAULT_EXECUTOR_OPTIONS.merge({
-          min_threads: num_workers,
-          max_threads: num_workers
-        })
-        Concurrent::ThreadPoolExecutor.new(options)
+        options = DEFAULT_EXECUTOR_OPTIONS
+          .merge(
+            min_threads: num_workers,
+            max_threads: num_workers,
+            max_queue: num_jobs_max || DEFAULT_MAX_QUEUE_SIZE
+          )
+        Concurrent::ThreadPoolExecutor.new(**options)
       end
 
       new(name, pool)
@@ -66,21 +69,43 @@ module SuckerPunch
       queues
     end
 
+    PAUSE_TIME = STDOUT.tty? ? 0.1 : 0.5
+
     def self.shutdown_all
+      deadline = Time.now + SuckerPunch.shutdown_timeout
+
       if SuckerPunch::RUNNING.make_false
+        # If a job is enqueued right before the script exits
+        # (command line, rake task, etc.), the system needs an
+        # interval to allow the enqueue jobs to make it in to the system
+        # otherwise the queue will look idle
+        sleep PAUSE_TIME
 
         queues = all
-        latch = Concurrent::CountDownLatch.new(queues.length)
 
-        queues.each do |queue|
-          queue.post(latch) { |l| l.count_down }
-          queue.shutdown
-        end
+        # Issue shutdown to each queue and let them wrap up their work. This
+        # prevents new jobs from being enqueued and lets the pool clean up
+        # after itself
+        queues.each { |queue| queue.shutdown }
+
+        # return if every queue is empty and workers in every queue are idle
+        return if queues.all? { |queue| queue.idle? }
+
+        SuckerPunch.logger.info("Pausing to allow workers to finish...")
 
-        unless latch.wait(SuckerPunch.shutdown_timeout)
-          queues.each { |queue| queue.kill }
-          SuckerPunch.logger.info("Queued jobs didn't finish before shutdown_timeout...killing remaining jobs")
+        remaining = deadline - Time.now
+
+        # Continue to loop through each queue and test if it's idle, while
+        # respecting the shutdown timeout
+        while remaining > PAUSE_TIME
+          return if queues.all? { |queue| queue.idle? }
+          sleep PAUSE_TIME
+          remaining = deadline - Time.now
         end
+
+        # Queues haven't finished work. Aggressively kill them.
+        SuckerPunch.logger.warn("Queued jobs didn't finish before shutdown_timeout...killing remaining jobs")
+        queues.each { |queue| queue.kill }
       end
     end
 
@@ -89,6 +114,7 @@ module SuckerPunch
     def_delegators :@pool,
       :max_length,
       :min_length,
+      :max_queue,
       :length,
       :queue_length,
       :wait_for_termination#,
@@ -115,6 +141,10 @@ module SuckerPunch
       synchronize { @running }
     end
 
+    def idle?
+      enqueued_jobs == 0 && busy_workers == 0
+    end
+
     def ==(other)
       pool == other.pool
     end
@@ -135,10 +165,10 @@ module SuckerPunch
       SuckerPunch::Counter::Failed.new(name).value
     end
 
-    def post(*args, &block)
+    def post(*args, **kwargs, &block)
       synchronize do
         if @running
-          @pool.post(*args, &block)
+          @pool.post(*args, **kwargs, &block)
         else
           false
         end
@@ -146,15 +176,12 @@ module SuckerPunch
     end
 
     def kill
-      if can_initiate_shutdown?
-        @pool.kill
-      end
+      @pool.kill
     end
 
     def shutdown
-      if can_initiate_shutdown?
-        @pool.shutdown
-      end
+      synchronize { @running = false }
+      @pool.shutdown
     end
 
     protected
@@ -162,19 +189,5 @@ module SuckerPunch
     def pool
       @pool
     end
-
-    private
-
-    def can_initiate_shutdown?
-      synchronize do
-        if @running
-          @running = false
-          true
-        else
-          false
-        end
-      end
-    end
   end
 end
-

data/lib/sucker_punch/testing.rb

@@ -0,0 +1,44 @@
+require 'sucker_punch'
+
+# Include this in your tests to simulate
+# a fake job queue. Jobs won't be executed
+# as they normal would be the thread pool.
+# They'll instead be pushed to a fake queue
+# to be checked in a test environment.
+#
+# Include in your test_helper.rb:
+#
+# require 'sucker_punch/testing'
+#
+# In your application code:
+#
+#   LogJob.perform_async(1, 2, 3)
+#
+# In your tests:
+#
+#   LogJob.jobs => [{ "args" => [1, 2, 3]]
+
+module SuckerPunch
+  module Job
+    def self.jobs
+      SuckerPunch::Queue.find_or_create(self.to_s)
+    end
+
+    def self.clear_all
+
+    end
+  end
+
+  class Queue
+    def self.find_or_create(name, _number_workers = 2, _num_jobs_max = nil)
+      QUEUES.fetch_or_store(name) do
+        []
+      end
+    end
+
+
+    def kill
+      true
+    end
+  end
+end

data/lib/sucker_punch/testing/inline.rb

@@ -17,7 +17,7 @@ require 'sucker_punch'
 #
 # Include inline testing lib:
 #
-# require 'sucker_punch/testing/inline"
+# require 'sucker_punch/testing/inline'
 #
 # LogJob.perform_async(1, 2, 3) is now synchronous
 # LogJob.perform_in(1, 2, 3) is now synchronous
@@ -25,12 +25,12 @@ require 'sucker_punch'
 module SuckerPunch
   module Job
     module ClassMethods
-      def perform_async(*args)
-        self.new.perform(*args)
+      def perform_async(*args, **kwargs)
+        self.new.perform(*args, **kwargs)
       end
 
-      def perform_in(_, *args)
-        self.new.perform(*args)
+      def perform_in(_, *args, **kwargs)
+        self.new.perform(*args, **kwargs)
       end
     end
   end

data/lib/sucker_punch/version.rb

@@ -1,3 +1,3 @@
 module SuckerPunch
-  VERSION = "2.0.1"
+  VERSION = "3.0.0"
 end

data/sucker_punch.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |gem|
   gem.authors       = ["Brandon Hilkert"]
   gem.email         = ["brandonhilkert@gmail.com"]
   gem.description   = %q{Asynchronous processing library for Ruby}
-  gem.summary       = %q{Sucker Punch is a Ruby asynchronous processing using Celluloid, heavily influenced by Sidekiq and girl_friday.}
+  gem.summary       = %q{Sucker Punch is a Ruby asynchronous processing using concurrent-ruby, heavily influenced by Sidekiq and girl_friday.}
   gem.homepage      = "https://github.com/brandonhilkert/sucker_punch"
   gem.license       = "MIT"
 
@@ -18,11 +18,17 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
-  gem.post_install_message = "Sucker Punch v2.0 introduces backwards-incompatible changes.\nPlease see https://github.com/brandonhilkert/sucker_punch/blob/master/CHANGES.md#20 for details."
+  gem.post_install_message = "Sucker Punch v2.0 introduces backwards-incompatible changes.\nPlease see https://github.com/brandonhilkert/sucker_punch/blob/master/CHANGES.md#200 for details."
 
   gem.add_development_dependency "rake", "~> 10.0"
   gem.add_development_dependency "minitest"
   gem.add_development_dependency "pry"
 
-  gem.add_dependency "concurrent-ruby", "~> 1.0.0"
+  gem.add_dependency "concurrent-ruby", "~> 1.0"
+  
+  if gem.respond_to?(:metadata)
+    gem.metadata['changelog_uri'] = 'https://github.com/brandonhilkert/sucker_punch/blob/master/CHANGES.md'
+    gem.metadata['source_code_uri'] = 'https://github.com/brandonhilkert/sucker_punch'
+    gem.metadata['bug_tracker_uri'] = 'https://github.com/brandonhilkert/sucker_punch/issues'
+  end
 end

data/test/sucker_punch/job_test.rb

@@ -55,6 +55,11 @@ module SuckerPunch
       FakeLogJob.workers(2)
     end
 
+    def test_can_set_max_jobs
+      FakeLogJob.max_jobs(10)
+      assert_equal 10, FakeLogJob.num_jobs_max
+    end
+
     def test_logger_is_accessible_from_instance
       SuckerPunch.logger = SuckerPunch.default_logger
       assert_equal SuckerPunch.logger, FakeLogJob.new.logger
@@ -177,4 +182,3 @@ module SuckerPunch
     end
   end
 end
-

data/test/sucker_punch/queue_test.rb

@@ -29,6 +29,11 @@ module SuckerPunch
       assert_equal 4, queue.min_length
     end
 
+    def test_queue_max_queue_can_be_set
+      queue = SuckerPunch::Queue.find_or_create(@queue, 4, 10)
+      assert_equal(10, queue.max_queue)
+    end
+
     def test_same_queue_is_returned_on_subsequent_queries
       queue = SuckerPunch::Queue.find_or_create(@queue)
       assert_equal queue, SuckerPunch::Queue.find_or_create(@queue)
@@ -82,33 +87,29 @@ module SuckerPunch
       assert_equal true, queue.running?
     end
 
-    def test_jobs_can_be_posted_to_pool
-      arr = []
-      fake_pool = FakePool.new
-      queue = SuckerPunch::Queue.new "fake", fake_pool
-      queue.post(1, 2) { |args| arr.push args }
-      assert_equal [1, 2], arr.first
+    def test_idle_considers_queue_workers_and_length
+      queue = SuckerPunch::Queue.find_or_create(FakeNilJob.to_s)
+      assert_equal true, queue.idle?
     end
 
-    def test_jobs_arent_posted_if_queue_isnt_running
+    def test_jobs_can_be_posted_to_pool
       arr = []
       fake_pool = FakePool.new
-      queue = SuckerPunch::Queue.new "fake", fake_pool
-      queue.kill
+      queue     = SuckerPunch::Queue.new "fake", fake_pool
       queue.post(1, 2) { |args| arr.push args }
-      assert arr.empty?
+      assert_equal [1, 2], arr.first
     end
 
     def test_kill_sends_kill_to_pool
       fake_pool = FakePool.new
-      queue = SuckerPunch::Queue.new "fake", fake_pool
+      queue     = SuckerPunch::Queue.new "fake", fake_pool
       queue.kill
       assert_equal :kill, fake_pool.signals.first
     end
 
     def test_shutdown_sends_shutdown_to_pool
       fake_pool = FakePool.new
-      queue = SuckerPunch::Queue.new "fake", fake_pool
+      queue     = SuckerPunch::Queue.new "fake", fake_pool
       queue.shutdown
       assert_equal :shutdown, fake_pool.signals.first
     end
@@ -135,9 +136,9 @@ module SuckerPunch
         @signals = []
       end
 
-      def post(*args, &block)
+      def post(*args, **kwargs, &block)
         if block_given?
-          block.call(args)
+          block.call(args, **kwargs)
         end
       end
 

data/test/sucker_punch_test.rb

@@ -41,7 +41,7 @@ class SuckerPunchTest < Minitest::Test
   end
 
   def test_exception_handler_can_be_set
-    SuckerPunch.exception_handler = -> (ex, _, _) { raise "bad stuff" }
+    SuckerPunch.exception_handler = -> (_ex, _, _) { raise "bad stuff" }
     assert_raises(::RuntimeError) { SuckerPunch.exception_handler.call(StandardError.new("bad"), nil, nil) }
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sucker_punch
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 3.0.0
 platform: ruby
 authors:
 - Brandon Hilkert
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-02-14 00:00:00.000000000 Z
+date: 2021-02-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -58,14 +58,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: '1.0'
 description: Asynchronous processing library for Ruby
 email:
 - brandonhilkert@gmail.com
@@ -89,6 +89,7 @@ files:
 - lib/sucker_punch/job.rb
 - lib/sucker_punch/queue.rb
 - lib/sucker_punch/railtie.rb
+- lib/sucker_punch/testing.rb
 - lib/sucker_punch/testing/inline.rb
 - lib/sucker_punch/version.rb
 - sucker_punch.gemspec
@@ -101,10 +102,13 @@ files:
 homepage: https://github.com/brandonhilkert/sucker_punch
 licenses:
 - MIT
-metadata: {}
+metadata:
+  changelog_uri: https://github.com/brandonhilkert/sucker_punch/blob/master/CHANGES.md
+  source_code_uri: https://github.com/brandonhilkert/sucker_punch
+  bug_tracker_uri: https://github.com/brandonhilkert/sucker_punch/issues
 post_install_message: |-
   Sucker Punch v2.0 introduces backwards-incompatible changes.
-  Please see https://github.com/brandonhilkert/sucker_punch/blob/master/CHANGES.md#20 for details.
+  Please see https://github.com/brandonhilkert/sucker_punch/blob/master/CHANGES.md#200 for details.
 rdoc_options: []
 require_paths:
 - lib
@@ -119,12 +123,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.1
-signing_key: 
+rubygems_version: 3.1.2
+signing_key:
 specification_version: 4
-summary: Sucker Punch is a Ruby asynchronous processing using Celluloid, heavily influenced
-  by Sidekiq and girl_friday.
+summary: Sucker Punch is a Ruby asynchronous processing using concurrent-ruby, heavily
+  influenced by Sidekiq and girl_friday.
 test_files:
 - test/sucker_punch/async_syntax_test.rb
 - test/sucker_punch/counter_test.rb