thimble 0.0.6 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3b25fd7c92e8dafb66ba3bd700e82e25cb3cbf4f
-  data.tar.gz: 2f6d476abbfdb1d1cdad7363c865592995252d1f
+  metadata.gz: e14df83bf17841cdd0087c6c2bdf39f1f9b6644e
+  data.tar.gz: d6d77a89dcc0c3b333e44ba758f3b9b6c1709369
 SHA512:
-  metadata.gz: aa40124bea0b95345aa758fa667d264343b34296829854b954f7f6652cd177caaacac713c507a5e467eb846adc733a273fbb52d3f58e5aad99b3b1ee3cfa1240
-  data.tar.gz: 85144ec759b08b56f60b18fb0a790d9c927b9efbcb92665ca5d2c4f9e922bcc3bd88ca1e7a17ef1f163577b3cca11c75fc3219934934c997b976553759c040b6
+  metadata.gz: 1c9b4bfbf03768af041193bd4c91fdafe4b4e73e39aabafdd0668c1a88f2679b0689dd3b6f888f9df2606de6d348c2f15a9bc8a2b186cd6ebdab1edde920cb1e
+  data.tar.gz: e5866041ac437c858fec5a0dd4b25f3debe955f5852528dab93b961e259d30796fd9607662a0811b7c58490e310c58d5472bd2550ebfa4aece4da5d417b1f120

data/lib/QueueItem.rb

@@ -9,7 +9,7 @@ module Thimble
     end
 
     def to_s
-      "#{@name}: #{@item} \nID: #{@id}"
+      "#{@name}: #{@item} ID: #{@id}"
     end
 
   end

data/lib/Thimble.rb

@@ -8,32 +8,56 @@ require 'ostruct'
 module Thimble
 
   class Thimble < ThimbleQueue
-    def initialize(array, manager = Manager.new)
+    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
+      @result = if result.nil?
+        ThimbleQueue.new(array.size, "Result")
+      else
+        result
+      end
+      raise ArgumentError.new ("result needs to be an open ThimbleQueue") unless (@result.class == ThimbleQueue && !@result.closed?)
       @manager = manager
-      @result = ThimbleQueue.new(array.size, "Result")
       @running = true
-      super(array.size, "Main")
+      super(array.size, name)
+      @logger.debug("loading thimble #{name}")
       array.each {|item| push(item)}
+      @logger.debug("finished loading thimble #{name}")
       close()
     end
 
-    # This will use the manager and tranform your thimble queue.
+    # This will use the manager and transform your thimble queue.
     # requires a block 
-    # returns a new ThimbleQueue
+    # @return [ThimbleQueue]
     def map
+      @logger.debug("starting map in #{@name} with id #{Thread.current.object_id}")
       @running = true
       while @running
         manage_workers &Proc.new
       end
       @result.close()
+      @logger.debug("finishing map in #{@name} with id #{Thread.current.object_id}")
+      @result
+    end
+
+    # This will use the manager and transform the thimble queue asynchronously.
+    # Will return the result instantly, so you can use it for next stage processing.
+    # requires a block
+    # @return [ThimbleQueue]
+    def map_async
+      @logger.debug("starting async map in #{@name} with id #{Thread.current.object_id}")
+      @logger.debug("queue: #{@queue}")
+      Thimble.async do
+        map &Proc.new
+      end
+      @logger.debug("finished async map in #{@name} with id #{Thread.current.object_id}")
       @result
     end
 
     # Will perform anything handed to this asynchronously. 
     # Requires a block
-    def self.a_sync
+    # @return [Thread]
+    def self.async
       Thread.new do |e|
         yield e
       end
@@ -55,12 +79,12 @@ module Thimble
     end
 
     def manage_workers
-      while (@manager.worker_available? && batch = get_batch)
-        @manager.sub_worker( @manager.get_worker(batch, &Proc.new), @id)
-      end
       @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)
+      end
       @running = false if !@manager.working? && !batch
     end
 

data/lib/ThimbleQueue.rb

@@ -1,4 +1,5 @@
 require 'thread'
+require 'logger'
 require_relative 'QueueItem'
 
 module Thimble
@@ -16,6 +17,12 @@ module Thimble
       @close_now = false
       @empty = ConditionVariable.new
       @full = ConditionVariable.new
+      @logger = Logger.new(STDOUT)
+      @logger.sev_threshold = Logger::UNKNOWN
+    end
+
+    def setLogger(level)
+      @logger.sev_threshold = level
     end
 
     def each
@@ -24,10 +31,15 @@ module Thimble
       end
     end
 
+    # Returns the size of the ThimbleQueue
+    # @return [Fixnum]
     def length
       size
     end
 
+    # Will concatenate an enumerable to the ThimbleQueue
+    # @param [Enumerable]
+    # @return [ThimbleQueue]
     def +(other)
       raise ArgumentError.new("+ requires another Enumerable!") unless other.class < Enumerable
       merged_thimble = ThimbleQueue.new(length + other.length, @name)
@@ -36,15 +48,20 @@ module Thimble
       merged_thimble
     end
 
+    # Returns the first item in the queue
+    # @return [Object]
     def next
       @mutex.synchronize  do
         while !@close_now
           a = @queue.shift
+          @logger.debug("#{@name}'s queue shifted to: #{a}")
           if !a.nil?
             @full.broadcast
+            @empty.broadcast
             return a
           else 
-            return nil if @closed
+            @logger.debug("#{@name}'s queue is currently closed?: #{closed?}")
+            return nil if closed?
             @empty.wait(@mutex)
           end
         end
@@ -52,41 +69,58 @@ 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}")
       @mutex.synchronize do
         while !offer(x)
           @full.wait(@mutex)
+          @logger.debug("#{@name} is waiting on full")
         end
         @empty.broadcast
       end
+      @logger.debug("Finished pushing int #{@name}: #{x}")
     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)}
       else
         @mutex.synchronize do
           while !offer(x)
+            @logger.debug("#{@name} is waiting on full")
             @full.wait(@mutex)
           end
           @empty.broadcast
         end
       end
+      @logger.debug("Finished pushing flat into #{@name} values: #{x}")
     end
 
+    # Closes the ThibleQueue
+    # @param [TrueClass, FalseClass]
+    # @return [nil]
     def close(now = false)
+      raise ArgumentError.new("now must be true or false") unless (now == true || now == false)
+      @logger.debug("#{@name} is closing")
       @mutex.synchronize do
         @closed = true
         @close_now = true if now
         @full.broadcast
         @empty.broadcast
       end
+      @logger.debug("#{@name} is closed: #{@closed} now: #{@close_now}")
     end
 
+    # Will force the ThimbleQueue into an array
+    # @return [Array[Object]]
     def to_a
       a = []
       while item = self.next
@@ -95,14 +129,17 @@ module Thimble
       a
     end
 
+    # checks if the ThimbleQueue is closed
+    # @return [TrueClass, FalseClass]
     def closed?
-      @close
+      @closed
     end
 
     private
     def offer(x)
       if @queue.size < @size
         @queue << QueueItem.new(x)
+        @empty.broadcast
         true
       else
         false

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: thimble
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.7
 platform: ruby
 authors:
 - Andrew Kovanda