thimble 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: fd59e02a2d7544b9335f96d4021adf65375adb85
-  data.tar.gz: baa7be7eb0be6c48846afc2d7e8c2a65c5b208ab
+SHA256:
+  metadata.gz: 1fbffaeb62da2fbbb2c0cfa474aa2411b0bc32e32736af38f20e83890921c3af
+  data.tar.gz: 78ce3f45be02b118af41229ecd82ede236e3b8817cb9f7dfe742aad6171a560f
 SHA512:
-  metadata.gz: 458735d7ec051f92d76c9537799cd20bf122308c97393771eaaa86023faf59181351deedb0ae3ec052f39d430cc4618551b2471375d05a7a10cb0132cc3fe9c9
-  data.tar.gz: ec3c6cabbbf5471278e65dbd724349eb9e08100d121526c349d673a61744470d93e4b7bc9498360ba3d1f3f8ac727df9c78b19d7ebeaa2163450ead3dccceea8
+  metadata.gz: 8df7d0f0444515437e2d70038d399f85d3732456b299c2ab92f128abc5b7cfbde4f9ec71221c2b1a0c6e76dd9dcfefe91358d27582086ed5135ea9dc4974062a
+  data.tar.gz: 61f615dd222a89da1624f96ea35ca308db5fd2137e59395753e4db2dab6c66917d224667d158525b64574eee18c06156960f99e70b5263dce2746536e257ad56

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.rb → thimble.rb}

@@ -1,41 +1,48 @@
+# 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 '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 +51,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
@@ -95,20 +103,18 @@ module Thimble
           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)
+          Process.kill('HUP', tuple.pid)
           @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,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: thimble
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Andrew Kovanda
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2017-04-11 00:00:00.000000000 Z
+date: 2022-06-29 00:00:00.000000000 Z
 dependencies: []
 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
@@ -19,15 +19,15 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/Manager.rb
-- lib/QueueItem.rb
-- lib/Thimble.rb
-- lib/ThimbleQueue.rb
+- lib/manager.rb
+- lib/queue_item.rb
+- lib/thimble.rb
+- lib/thimble_queue.rb
 homepage: https://github.com/akovanda/thimble
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -42,9 +42,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.10
-signing_key: 
+rubygems_version: 3.3.7
+signing_key:
 specification_version: 4
 summary: Concurrency and Parallelism gem that uses blocks to move data
 test_files: []