thimble 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: fd59e02a2d7544b9335f96d4021adf65375adb85
-  data.tar.gz: baa7be7eb0be6c48846afc2d7e8c2a65c5b208ab
+SHA256:
+  metadata.gz: 9d5dba5ce3a256f520a9c75924f886fe3d94fd5e64369528570ef57d7b2e226a
+  data.tar.gz: d99df41c042a2360e4f8c36f8f9b00d4923174abc71b78ce6c35d06fa966cfff
 SHA512:
-  metadata.gz: 458735d7ec051f92d76c9537799cd20bf122308c97393771eaaa86023faf59181351deedb0ae3ec052f39d430cc4618551b2471375d05a7a10cb0132cc3fe9c9
-  data.tar.gz: ec3c6cabbbf5471278e65dbd724349eb9e08100d121526c349d673a61744470d93e4b7bc9498360ba3d1f3f8ac727df9c78b19d7ebeaa2163450ead3dccceea8
+  metadata.gz: a9d708451d9b0fe90a133401f4f999930067abd4af81856ad039851f8d1c0bfc44be8da8c99fcfc19eb121927490b0b1283512c8be2ff445c63fcdbd6d80f64d
+  data.tar.gz: e8026d10b4f8d7265c282d59acce8c5e8186aff83b76b75f93f54ad7cceba2f24d428941629d14a3210b467381b531ac31c8b82c2a3ee2f9c6f237ae422ceb15

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Andrew Kovanda
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,126 @@
+# Thimble
+Thimble is a Ruby gem for parallelism and concurrency. It lets you choose threads (good for IO) or processes (good for CPU) and build pipelines using stages backed by a thread-safe queue.
+
+---
+
+## Installation
+Add this line to your application's Gemfile:
+
+```
+gem 'thimble'
+```
+
+And then execute:
+
+```
+bundle install
+```
+
+Or install it yourself as:
+
+```
+gem install thimble
+```
+
+## Supported Ruby and platforms
+- Ruby >= 3.0
+- MRI: threads are limited by the GVL for CPU-bound work. Use `worker_type: :fork` for CPU-bound pipelines.
+- JRuby/TruffleRuby: threads can run in parallel; `:thread` often suffices.
+- Windows: `fork` is not available. Use `worker_type: :thread`.
+
+## Quick start
+
+Example 1: parallel map using forked processes (CPU-bound)
+```
+require 'thimble'
+
+manager = Thimble::Manager.new(max_workers: 5, batch_size: 5, queue_size: 10, worker_type: :fork)
+thimble = Thimble::Thimble.new((1..100).to_a, manager)
+results = thimble.map { |x| x * 1000 }
+# results is a Thimble::ThimbleQueue; consume it as needed
+p results.to_a
+```
+
+Example 2: feed an intermediate queue from a threaded stage (IO-bound)
+```
+require 'thimble'
+# We create a queue to store intermediate work
+queue = Thimble::ThimbleQueue.new(3, 'stage 2')
+# Our array of data
+ary = (1..10).to_a
+# A separate thread worker who will be processing the intermediate queue
+thread = Thimble::Thimble.async do
+  queue.each { |x| puts "I did work on #{x}!"; sleep 1 }
+end
+# Our Thimble, plus its manager. Note we are using Thread in this example.
+thim = Thimble::Thimble.new(ary, Thimble::Manager.new(batch_size: 1, worker_type: :thread))
+# We in parallel push data to the Thimble Queue
+thim.map { |e| queue.push(e); sleep 0.1; puts "I pushed #{e} to the queue!" }
+# The queue is closed (no more work can come in)
+queue.close
+# join the thread
+thread.join
+```
+
+Manager quick reference
+```
+m = Thimble::Manager.new(max_workers: 10, batch_size: 100, worker_type: :fork)
+Thimble::Thimble.new(array, m)
+```
+- max_workers: how many workers can run at the same time
+- batch_size: how many items to send to each worker (tune for workload)
+- worker_type: :thread or :fork
+
+The same Manager can be shared across Thimble instances to coordinate concurrency limits.
+
+All thimbles require an explicit manager.
+
+---
+
+## ThimbleQueue
+ThimbleQueue is the queue underpinning Thimble. Taking from it is destructive. It is thread-safe for multi-thread producers/consumers.
+
+```
+q = Thimble::ThimbleQueue.new(10, 'name')
+q.push(1)
+q.close
+q.each { |x| puts x }
+# => 1
+```
+If you do not close the queue, consumers will wait for more data. Creating a Thimble creates a "closed" input queue; transformations create a new queue.
+
+---
+
+## Caveats and best practices
+These are common pitfalls and how Thimble helps you avoid them:
+
+- MRI GVL and workload choice
+  - Threads do not run CPU-bound Ruby in parallel on MRI. Use `worker_type: :fork` for CPU-bound tasks; `:thread` shines for IO-bound tasks.
+- Platform differences
+  - `fork` is Unix-only. On Windows, use `:thread`.
+- Forking and safety
+  - Thimble forks child workers before creating additional threads inside children. Children trap HUP and exit cleanly; the parent detaches workers to avoid zombies.
+  - Recreate external resources in children (DB connections, sockets, clients). Don’t share them across a fork.
+- Memory and copy-on-write
+  - Each process has its own heap and GC. Batching reduces IPC overhead. Freeze large constants to improve CoW where possible.
+- Backpressure
+  - ThimbleQueue is bounded; tune `queue_size` to avoid unbounded growth.
+- Shutdown
+  - ThimbleQueue supports `close` and `close(true)` for immediate close. Avoid closing from multiple places.
+- Error propagation
+  - Exceptions in workers are propagated back through results. For `:thread`, thread exceptions are surfaced; for `:fork`, exceptions are marshaled back and re-raised when consumed.
+- Signal handling
+  - The main process receives signals; Thimble sends HUP to child workers when their results are consumed.
+- Ordering
+  - Parallel stages may reorder results. If you need original order, attach sequence numbers to items and reorder at the end.
+- Tuning
+  - Start with `max_workers` ~ number of cores for CPU-bound, higher for IO-bound. Adjust `batch_size` to minimize overhead without starving workers.
+
+---
+
+## Development
+- Run tests: `bundle exec rspec`
+- Linting: consider adding RuboCop (`rubocop`)
+- Releasing: bump `Thimble::VERSION` in `lib/thimble/version.rb`, tag and push, then build and push the gem
+
+Contributions welcome! Please open issues and PRs.

data/lib/{Manager.rb → manager.rb}

@@ -1,13 +1,19 @@
-Thread.abort_on_exception=true
+# frozen_string_literal: true
+
+Thread.abort_on_exception = true
 
 module Thimble
   class Manager
     attr_reader :max_workers, :batch_size, :queue_size, :worker_type
-    def initialize(max_workers: 6,batch_size: 1000, queue_size: 1000, worker_type: :fork)
-      raise ArgumentError.new ("worker type must be either :fork or :thread") unless worker_type == :thread || worker_type == :fork
-      raise ArgumentError.new ("Your system does not respond to fork please use threads.") unless worker_type == :thread || Process.respond_to?(:fork)
-      raise ArgumentError.new ("max_workers must be greater than 0") if max_workers < 1
-      raise ArgumentError.new ("batch size must be greater than 0") if batch_size < 1
+
+    def initialize(max_workers: 6, batch_size: 1000, queue_size: 1000, worker_type: :fork)
+      raise ArgumentError, 'worker type must be either :fork or :thread' unless %i[thread fork].include?(worker_type)
+      unless worker_type == :thread || Process.respond_to?(:fork)
+        raise ArgumentError, 'Your system does not respond to fork please use threads.'
+      end
+      raise ArgumentError, 'max_workers must be greater than 0' if max_workers < 1
+      raise ArgumentError, 'batch size must be greater than 0' if batch_size < 1
+
       @worker_type = worker_type
       @max_workers = max_workers
       @batch_size = batch_size
@@ -16,16 +22,20 @@ module Thimble
       @current_workers = {}
     end
 
+    # @return [TrueClass, FalseClass]
     def worker_available?
       @current_workers.size < @max_workers
     end
 
+    # @return [TrueClass, FalseClass]
     def working?
-      @current_workers.size > 0
+      @current_workers.size.positive?
     end
 
+    # @param [Object] id
     def sub_worker(worker, id)
-      raise "Worker must contain a pid!" if worker.pid.nil?
+      raise 'Worker must contain a pid!' if worker.pid.nil?
+
       new_worker = OpenStruct.new
       new_worker.worker = worker
       new_worker.id = id
@@ -34,40 +44,44 @@ module Thimble
       end
     end
 
+    # @param [Object] worker
     def rem_worker(worker)
       @mutex.synchronize do
         @current_workers.delete(worker.pid)
       end
     end
 
+    # @param [Object] id
     def current_workers(id)
       @mutex.synchronize do
-        @current_workers.select { |k,v| v.id == id }
+        @current_workers.select { |_k, v| v.id == id }
       end
     end
 
-    def get_worker (batch)
+    # @param [Object] batch
+    # @param [Proc] block
+    # @return [Object]
+    def get_worker(batch, &block)
       @mutex.synchronize do
         if @worker_type == :fork
-          get_fork_worker(batch, &Proc.new)
+          get_fork_worker(batch, &block)
         else
-          get_thread_worker(batch, &Proc.new)
+          get_thread_worker(batch, &block)
         end
       end
     end
 
+    # @param [Object] batch
     def get_fork_worker(batch)
       rd, wr = IO.pipe
       tup = OpenStruct.new
       pid = fork do
-        Signal.trap("HUP") {exit}
+        Signal.trap('HUP') { exit }
         rd.close
         t = Marshal.dump(batch.item.map do |item|
-          begin
-            yield (item.item)
-          rescue Exception => e
-            e
-          end
+          yield item.item
+        rescue Exception => e
+          e
         end)
         wr.write(t)
         wr.close
@@ -78,6 +92,8 @@ module Thimble
       tup
     end
 
+    # @param [Object] batch
+    # @param [Proc] block
     def get_thread_worker(batch)
       tup = OpenStruct.new
       tup.pid = Thread.new do
@@ -89,12 +105,14 @@ module Thimble
       tup
     end
 
+    # @return [Thimble::Manager]
     def self.deterministic
-      self.new(max_workers: 1, batch_size: 1, queue_size: 1)
+      new(max_workers: 1, batch_size: 1, queue_size: 1)
     end
 
+    # @return [Thimble::Manager]
     def self.small
-      self.new(max_workers: 1, batch_size: 3, queue_size: 3)
+      new(max_workers: 1, batch_size: 3, queue_size: 3)
     end
   end
 end

data/lib/{QueueItem.rb → queue_item.rb}

@@ -1,8 +1,11 @@
-require "digest"
+# frozen_string_literal: true
+
+require 'digest'
 module Thimble
   class QueueItem
     attr_reader :id, :item
-    def initialize(item, name= "Item")
+
+    def initialize(item, name = 'Item')
       @id = Digest::SHA256.digest(rand(10**100).to_s + Time.now.to_i.to_s)
       @item = item
       @name = name
@@ -11,6 +14,5 @@ module Thimble
     def to_s
       "#{@name}: #{@item} ID: #{@id}"
     end
-
   end
-end
+end

data/lib/thimble/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Thimble
+  VERSION = '0.3.0'
+end
+

data/lib/{Thimble.rb → thimble.rb}

@@ -1,41 +1,49 @@
+# frozen_string_literal: true
 
-require_relative 'Manager'
-require_relative 'ThimbleQueue'
-require_relative 'QueueItem'
+require_relative 'manager'
+require_relative 'thimble_queue'
+require_relative 'queue_item'
+require_relative 'thimble/version'
 require 'io/wait'
 require 'ostruct'
 
 module Thimble
-
   class Thimble < ThimbleQueue
-    def initialize(array, manager = Manager.new, result = nil, name = "Main")
-      raise ArgumentError.new ("You need to pass a manager to Thimble!") unless manager.class == Manager
-      raise ArgumentError.new ("There needs to be an iterable object passed to Thimble to start.") unless array.respond_to? :each
+    def initialize(array, manager = Manager.new, result = nil, name = 'Main')
+      raise ArgumentError, 'You need to pass a manager to Thimble!' unless manager.instance_of?(Manager)
+
+      unless array.respond_to? :each
+        raise ArgumentError,
+              'There needs to be an iterable object passed to Thimble to start.'
+      end
+
       @result = if result.nil?
-        ThimbleQueue.new(array.size, "Result")
-      else
-        result
+                  ThimbleQueue.new(array.size, 'Result')
+                else
+                  result
+                end
+      unless @result.instance_of?(ThimbleQueue) && !@result.closed?
+        raise ArgumentError,
+              'result needs to be an open ThimbleQueue'
       end
-      raise ArgumentError.new ("result needs to be an open ThimbleQueue") unless (@result.class == ThimbleQueue && !@result.closed?)
+
       @manager = manager
       @running = true
       super(array.size, name)
       @logger.debug("loading thimble #{name}")
-      array.each {|item| push(item)}
+      array.each { |item| push(item) }
       @logger.debug("finished loading thimble #{name}")
-      close()
+      close
     end
 
     # This will use the manager and transform your thimble queue.
-    # requires a block 
+    # requires a block
     # @return [ThimbleQueue]
-    def map
+    def map(&block)
       @logger.debug("starting map in #{@name} with id #{Thread.current.object_id}")
       @running = true
-      while @running
-        manage_workers &Proc.new
-      end
-      @result.close()
+      manage_workers(&block) while @running
+      @result.close
       @logger.debug("finishing map in #{@name} with id #{Thread.current.object_id}")
       @result
     end
@@ -44,46 +52,47 @@ module Thimble
     # Will return the result instantly, so you can use it for next stage processing.
     # requires a block
     # @return [ThimbleQueue]
-    def map_async
+    # @param [Proc] block
+    def map_async(&block)
       @logger.debug("starting async map in #{@name} with id #{Thread.current.object_id}")
       @logger.debug("queue: #{@queue}")
       Thimble.async do
-        map &Proc.new
+        map(&block)
       end
       @logger.debug("finished async map in #{@name} with id #{Thread.current.object_id}")
       @result
     end
 
-    # Will perform anything handed to this asynchronously. 
+    # Will perform anything handed to this asynchronously.
     # Requires a block
     # @return [Thread]
-    def self.async
-      Thread.new do |e|
-        yield e
-      end
+    def self.async(&block)
+      Thread.new(&block)
     end
 
     private
+
     def get_batch
       batch = []
       while batch.size < @manager.batch_size
         item = self.next
         if item.nil?
-          return nil if batch.size == 0
-          return QueueItem.new(batch, "Batch")
+          return nil if batch.size.zero?
+
+          return QueueItem.new(batch, 'Batch')
         else
           batch << item
         end
       end
-      QueueItem.new(batch, "Batch")
+      QueueItem.new(batch, 'Batch')
     end
 
-    def manage_workers
-      @manager.current_workers(@id).each do |pid, pair|
+    def manage_workers(&block)
+      @manager.current_workers(@id).each do |_pid, pair|
         get_result(pair.worker)
       end
-      while (@manager.worker_available? && batch = get_batch)
-        @manager.sub_worker( @manager.get_worker(batch, &Proc.new), @id)
+      while @manager.worker_available? && batch = get_batch
+        @manager.sub_worker(@manager.get_worker(batch, &block), @id)
       end
       @running = false if !@manager.working? && !batch
     end
@@ -92,23 +101,26 @@ module Thimble
       if @manager.worker_type == :fork
         if tuple.reader.ready?
           piped_result = tuple.reader.read
+          tuple.reader.close unless tuple.reader.closed?
           loadedResult = Marshal.load(piped_result)
           loadedResult.each { |r| raise r if r.class <= Exception }
           push_result(loadedResult)
-          Process.kill("HUP", tuple.pid)
-          @manager.rem_worker(tuple)
-        end
-      else
-        if tuple.done == true
-          push_result(tuple.result)
+          begin
+            Process.kill('HUP', tuple.pid)
+          rescue Errno::ESRCH
+            # Process already exited; nothing to do
+          end
           @manager.rem_worker(tuple)
         end
+      elsif tuple.done == true
+        push_result(tuple.result)
+        @manager.rem_worker(tuple)
       end
     end
 
     def push_result(result)
       if result.respond_to? :each
-        result.each {|r| @result.push(r)}
+        result.each { |r| @result.push(r) }
       else
         @result.push(result)
       end

data/lib/{ThimbleQueue.rb → thimble_queue.rb}

@@ -1,13 +1,16 @@
-require 'thread'
+# frozen_string_literal: true
+
 require 'logger'
-require_relative 'QueueItem'
+require_relative 'queue_item'
 
 module Thimble
+  # noinspection RubyTooManyInstanceVariablesInspection
   class ThimbleQueue
-    include Enumerable
-    attr_reader :size
     def initialize(size, name)
-      raise ArgumentError.new("make sure there is a size for the queue greater than 1! size received #{size}") unless size >= 1
+      unless size >= 1
+        raise ArgumentError, "make sure there is a size for the queue greater than 1! size received #{size}"
+      end
+
       @id = Digest::SHA256.digest(rand(10**100).to_s + Time.now.to_i.to_s)
       @name = name
       @size = size
@@ -17,51 +20,56 @@ module Thimble
       @close_now = false
       @empty = ConditionVariable.new
       @full = ConditionVariable.new
-      @logger = Logger.new(STDOUT)
+      @logger = Logger.new($stdout)
       @logger.sev_threshold = Logger::UNKNOWN
     end
 
-    def setLogger(level)
+    include Enumerable
+    attr_reader :size
+
+    def set_logger(level)
       @logger.sev_threshold = level
     end
 
     def each
-      while item = self.next
+      while (item = self.next)
         yield item.item
       end
     end
 
     # Returns the size of the ThimbleQueue
-    # @return [Fixnum]
+    # @return [Integer]
     def length
       size
     end
 
     # Will concatenate an enumerable to the ThimbleQueue
-    # @param [Enumerable]
     # @return [ThimbleQueue]
+    # @param [Module<Enumerable>] other
     def +(other)
-      raise ArgumentError.new("+ requires another Enumerable!") unless other.class < Enumerable
+      raise ArgumentError, '+ requires another Enumerable!' unless other.class < Enumerable
+
       merged_thimble = ThimbleQueue.new(length + other.length, @name)
-      self.each {|item| merged_thimble.push(item)}
-      other.each {|item| merged_thimble.push(item)}
+      each { |item| merged_thimble.push(item) }
+      other.each { |item| merged_thimble.push(item) }
       merged_thimble
     end
 
     # Returns the first item in the queue
     # @return [Object]
     def next
-      @mutex.synchronize  do
-        while !@close_now
+      @mutex.synchronize do
+        until @close_now
           a = @queue.shift
           @logger.debug("#{@name}'s queue shifted to: #{a}")
           if !a.nil?
             @full.broadcast
             @empty.broadcast
             return a
-          else 
+          else
             @logger.debug("#{@name}'s queue is currently closed?: #{closed?}")
             return nil if closed?
+
             @empty.wait(@mutex)
           end
         end
@@ -69,46 +77,49 @@ module Thimble
     end
 
     # This will push whatever it is handed to the queue
-    # @param [Object]
-    def push(x)
-      raise RuntimeError.new("Queue is closed!") if @closed
-      @logger.debug("Pushing into #{@name} values: #{x}")
+    # @param [Object] input_item
+    def push(input_item)
+      raise 'Queue is closed!' if @closed
+
+      @logger.debug("Pushing into #{@name} values: #{input_item}")
       @mutex.synchronize do
-        while !offer(x)
+        until offer(input_item)
           @full.wait(@mutex)
           @logger.debug("#{@name} is waiting on full")
         end
         @empty.broadcast
       end
-      @logger.debug("Finished pushing int #{@name}: #{x}")
+      @logger.debug("Finished pushing int #{@name}: #{input_item}")
     end
 
     # This will flatten any nested arrays out and feed them one at
     # a time to the queue.
-    # @param [Object, Enumerable]
     # @return [nil]
-    def push_flat(x)
-      raise RuntimeError.new("Queue is closed!") if @closed
-      @logger.debug("Pushing flat into #{@name} values: #{x}")
-      if x.respond_to? :each
-        x.each {|item| push(item)}
+    # @param [Object] input_item
+    def push_flat(input_item)
+      raise 'Queue is closed!' if @closed
+
+      @logger.debug("Pushing flat into #{@name} values: #{input_item}")
+      if input_item.respond_to? :each
+        input_item.each { |item| push(item) }
       else
         @mutex.synchronize do
-          while !offer(x)
+          until offer(input_item)
             @logger.debug("#{@name} is waiting on full")
             @full.wait(@mutex)
           end
           @empty.broadcast
         end
       end
-      @logger.debug("Finished pushing flat into #{@name} values: #{x}")
+      @logger.debug("Finished pushing flat into #{@name} values: #{input_item}")
     end
 
-    # Closes the ThibleQueue
+    # Closes the ThimbleQueue
     # @param [TrueClass, FalseClass]
     # @return [nil]
     def close(now = false)
-      raise ArgumentError.new("now must be true or false") unless (now == true || now == false)
+      raise ArgumentError, 'now must be true or false' unless [true, false].include?(now)
+
       @logger.debug("#{@name} is closing")
       @mutex.synchronize do
         @closed = true
@@ -123,7 +134,7 @@ module Thimble
     # @return [Array[Object]]
     def to_a
       a = []
-      while item = self.next
+      while (item = self.next)
         a << item.item
       end
       a
@@ -136,6 +147,8 @@ module Thimble
     end
 
     private
+
+    # @param [Object] x
     def offer(x)
       if @queue.size < @size
         @queue << QueueItem.new(x)
@@ -146,4 +159,4 @@ module Thimble
       end
     end
   end
-end
+end

metadata

@@ -1,15 +1,42 @@
 --- !ruby/object:Gem::Specification
 name: thimble
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Andrew Kovanda
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-11 00:00:00.000000000 Z
-dependencies: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ostruct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Thimble is a ruby gem for parallelism and concurrency. It allows you
   to decide if you want to use separate processes, or if you want to use threads in
   ruby. It allows you to create stages with a thread safe queue, and break apart large
@@ -19,15 +46,22 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/Manager.rb
-- lib/QueueItem.rb
-- lib/Thimble.rb
-- lib/ThimbleQueue.rb
+- LICENSE
+- README.md
+- lib/manager.rb
+- lib/queue_item.rb
+- lib/thimble.rb
+- lib/thimble/version.rb
+- lib/thimble_queue.rb
 homepage: https://github.com/akovanda/thimble
 licenses:
 - MIT
-metadata: {}
-post_install_message: 
+metadata:
+  source_code_uri: https://github.com/akovanda/thimble
+  bug_tracker_uri: https://github.com/akovanda/thimble/issues
+  changelog_uri: https://github.com/akovanda/thimble/releases
+  documentation_uri: https://github.com/akovanda/thimble#readme
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -35,16 +69,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 3.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.10
-signing_key: 
+rubygems_version: 3.6.7
 specification_version: 4
 summary: Concurrency and Parallelism gem that uses blocks to move data
 test_files: []