pmap 1.1.0 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0eeba30c0921e39d013d4a2cd58c00ecd1c50e69
-  data.tar.gz: 5422d1dabc31a8fb65329bc35a2dd671ccf8a24e
+  metadata.gz: 33a12fe1b02aba0a94dad82f1bcecbc127bce82d
+  data.tar.gz: 5dfd73a05a0cc5e20389a6a20a26e500f36e3503
 SHA512:
-  metadata.gz: d7321a043d56bd25f3c14b8219226c4381ccc96d5c5605708205a9b8acb56b019c5b80425ba6631272677496ef78a5525e2c1c7a8134a5424a0c050ea55bab55
-  data.tar.gz: 8f189ffaf99cf4f3d7cc7b7e97c204d63375714073559f0cbf2861e55e32e63fdfa9457bc0c79302f323ee307aa9e783100e4f5f6f945007abd2952974db3184
+  metadata.gz: 63512f68730969070721168974365ef805a98e854f52aa47a3e16fcb0760d0a73beb534f02f48919bc7b8b03d4edc237b3b906ac915eed812fa92351af8cdcfd
+  data.tar.gz: b89dbaba27beb8ce6cb8de073a6dec253ac89a87ef3ba39ecf43aa6fc473a9664990d3785199d03e0ca0d735f89ee85cfbf1d4d149586cc921f145c8abd5d2ff

data/lib/pmap.rb

@@ -5,43 +5,100 @@ require "pmap/thread_pool"
 $pmap_default_thread_count ||= 64
 
 module PMap
+  # @!method pmap
+  #
+  #   Parallel #map for any Enumerable.
+  #
+  #   When a block is given, each item is yielded to the block in a
+  #   separate thread. When no block is given, an Enumerable is
+  #   returned.
+  #
+  #   @see http://ruby-doc.org/core-2.2.3/Enumerable.html#method-i-map
+  #
+  #   @param thread_count [Integer] maximum number of threads to create
+  #     (optional)
+  #
+  #   @return [Array] of mapped objects
+  #
+
+  # @!method peach
+  #
+  #   Parallel #each for any Enumerable.
+  #
+  #   When a block is given, each item is yielded to the block in a
+  #   separate thread. When no block is given, an Enumerable is
+  #   returned.
+  #
+  #   @see http://ruby-doc.org/core-2.2.3/Enumerable.html#method-i-each
+  #
+  #   @param thead_count [Integer] maximum number of threads to create
+  #     (optional)
+  #
+  #   @return [void]
+  #
+
+  # @!method peach_with_index
+  #
+  #   Parallel #each_with_index for any Enumerable.
+  #
+  #   When a block is given, each item is yielded to the block in a
+  #   separate thread. When no block is given, an Enumerable is
+  #   returned.
+  #
+  #   @see http://ruby-doc.org/core-2.2.3/Enumerable.html#method-i-each_with_index
+  #
+  #   @param thread_count [Integer] maximum number of threads to create
+  #     (optional)
+  #
+  #   @return [void]
+  #
+
+  # @!method flat_pmap
+  #
+  #   Parallel #flat_map for any Enumerable
+  #
+  #   When a block is given, each item is yielded to the block in a
+  #   separate thread. When no block is given, an Enumerable is
+  #   returned.
+  #
+  #   @see http://ruby-doc.org/core-2.2.3/Enumerable.html#method-i-flat_map
+  #
+  #   @param thread_count [Integer] maximum number of threads to create
+  #     (optional)
+  #
+  #   @return [Array] of mapped objects
+  #
+
   def self.included(base)
     base.class_eval do
 
-      # Public: Parallel "map" for any Enumerable.
-      #
-      # thread_count - maximum number of threads to create (optional)
-      #
-      # Requires a block of code to run for each Enumerable item.
-      #
+      # @see PMap#pmap
       def pmap(thread_count=nil, &proc)
+        return self unless proc
+
+        array_mutex = Mutex.new
         Array.new.tap do |result|
           peach_with_index(thread_count) do |item, index|
-            result[index] = proc.call(item)
+            value = proc.call(item)
+            array_mutex.synchronize { result[index] = value }
           end
         end
       end
 
-      # Public: Parallel "each" for any Enumerable.
-      #
-      # thread_count - maximum number of threads to create (optional)
-      #
-      # Requires a block of code to run for each Enumerable item.
-      #
+      # @see PMap#peach
       def peach(thread_count=nil, &proc)
-        peach_with_index(thread_count) do |item, index|
-          proc.call(item)
+        if proc
+          peach_with_index(thread_count) do |item, index|
+            proc.call(item)
+          end
         end
         self
       end
 
-      # Public: Parallel each_with_index for any Enumerable
-      #
-      # thread_count - maximum number of threads to create (optional)
-      #
-      # Requires a block of code to run for each Enumerable item.
-      #
+      # @see PMap#peach_with_index
       def peach_with_index(thread_count=nil, &proc)
+        return each_with_index unless proc
+
         thread_count ||= $pmap_default_thread_count
         pool = ThreadPool.new(thread_count)
 
@@ -51,6 +108,13 @@ module PMap
         pool.shutdown
         self
       end
+
+      # @see PMap#flat_pmap
+      def flat_pmap(thread_count=nil, &proc)
+        return self unless proc
+
+        pmap(thread_count, &proc).flatten(1)
+      end
     end
   end
 end

data/lib/pmap/version.rb

@@ -1,3 +1,3 @@
 module Pmap
-  VERSION = "1.1.0"
+  VERSION = "1.1.1"
 end

data/test/pmap_test.rb

@@ -8,9 +8,19 @@ require 'pmap'
 
 class Pmap_Test < Test::Unit::TestCase
 
-  def bad_test_noproc_range
+  def test_noproc_range
     range = (1..10)
-    assert_equal(range.map, range.pmap)
+    assert_equal(range.map.to_a, range.pmap.to_a)
+  end
+
+  def test_noproc_peach
+    range = (1..10)
+    assert_equal(range.each.to_a, range.peach.to_a)
+  end
+
+  def test_noproc_peach_with_index
+    range = (1..10)
+    assert_equal(range.each_with_index.to_a, range.peach_with_index.to_a)
   end
 
   def test_basic_range
@@ -19,17 +29,20 @@ class Pmap_Test < Test::Unit::TestCase
     assert_equal(range.map(&proc), range.pmap(&proc))
   end
 
-  def bad_test_noproc_array
+  def test_noproc_array
     array = (1..10).to_a
-    assert_equal(array.map, array.pmap)
+    assert_equal(array.map.to_a, array.pmap.to_a)
   end
 
   def test_basic_array
-    proc = Proc.new {|x| x*x*x}
-    array = (1..10).to_a
-    assert_equal(array.map(&proc), array.pmap(&proc))
+    1_000.times do
+      proc = Proc.new {|x| x*x*x}
+      array = (1..10).to_a
+      assert_equal(array.map(&proc), array.pmap(&proc))
+    end
   end
 
+
   def test_time_savings
     start = Time.now
     (1..10).peach{ sleep 1 }
@@ -71,4 +84,25 @@ class Pmap_Test < Test::Unit::TestCase
 
     assert_equal([["a", 0], ["b", 1], ["c", 2]].sort, output.sort)
   end
+
+  def test_flat_pmap
+    subject = [["a"], [["b"]], [[["c"]]]]
+    proc    = Proc.new { |x| x + ["X"] }
+
+    if subject.respond_to?(:flat_map)
+      assert_equal(subject.flat_map(&proc), subject.flat_pmap(&proc))
+    else
+      assert_equal(subject.map(&proc).flatten(1), subject.flat_pmap(&proc))
+    end
+  end
+
+  def test_noproc_flat_pmap
+    subject = [["a"], [["b"]], [[["c"]]]]
+
+    if subject.respond_to?(:flat_map)
+      assert_equal(subject.flat_map.to_a, subject.flat_pmap.to_a)
+    else
+      assert_equal(subject.map.to_a, subject.flat_pmap.to_a)
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pmap
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.1.1
 platform: ruby
 authors:
 - Bruce Adams
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-08 00:00:00.000000000 Z
+date: 2015-11-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: test-unit