picky 3.1.8 → 3.1.9

data/lib/picky/cores.rb

@@ -6,15 +6,17 @@ module Picky
   #
   class Cores # :nodoc:all
 
-    # Pass it an ary or generator.
+    # Pass it an ary.
     #
-    #   generator = (1..10).each
-    #   forked generator, :max => 5 do |element|
+    #   ary = (1..10).to_a
+    #   forked ary, :max => 5 do |element|
     #
     #   end
     #
     # Options include:
     #  * max: Maximum # of processors to use. Default is all it can get.
+    #  * amount: An exactly defined amount of processors to use.
+    #  * randomly: Whether to use random order or not.
     #
     def self.forked elements, options = {}, &block
       return if elements.empty?
@@ -29,40 +31,58 @@ module Picky
 
       # Get the maximum number of processors.
       #
-      max        = max_processors options
-      processing = 0
+      max = max_processors options
 
-      loop do
-        while processing < max
-          # Get the next element
-          #
-          element = elements.shift
-          break unless element
-          processing += 1
+      # Decide whether to use forking.
+      #
+      if fork?(max)
+        processing = 0
 
-          # Fork and yield.
-          #
-          Process.fork do
-            sleep 0.05*processing
-            block.call element
+        loop do
+          while processing < max
+            # Get the next element
+            #
+            element = elements.shift
+            break unless element
+            processing += 1
+
+            # Fork and yield.
+            #
+            Process.fork do
+              sleep 0.05*processing
+              block.call element
+            end
           end
-        end
 
-        # Block and wait for any child to finish.
-        #
-        begin
-          Process.wait 0
-        rescue Errno::ECHILD => e
-          break
-        ensure
-          processing -= 1
+          # Block and wait for any child to finish.
+          #
+          begin
+            Process.wait 0
+          rescue Errno::ECHILD => e
+            break
+          ensure
+            processing -= 1
+          end
         end
+      else
+        elements.each &block
       end
 
     end
 
+    # Do not fork if there is just one processor,
+    # or as in Windows, if there isn't the
+    # possibility of forking.
+    #
+    def self.fork? max_processors
+      max_processors > 1 && Process.respond_to?(:fork)
+    end
+
     # Return the number of maximum usable processors.
     #
+    # Options
+    #   max: The maximum amount of cores used.
+    #
     def self.max_processors options = {}
       options[:amount] || [number_of_cores, (options[:max] || Infinity)].min
     end

data/spec/lib/cores_spec.rb

@@ -4,44 +4,121 @@ require 'spec_helper'
 describe Picky::Cores do
   
   describe ".forked" do
-    before(:each) do
-      Process.should_receive(:fork).any_number_of_times.and_yield
-    end
-    context "with array" do
-      context "with block" do
-        it "runs ok" do
-          described_class.forked([1, 2]) do |e|
-            
-          end
+    context 'without fork' do
+      before(:each) do
+        Picky::Cores.stub! :fork? => false
+      end
+      it 'should not fork' do
+        Process.should_receive(:fork).never
+        
+        described_class.forked([1,2]) do |element|
+          
         end
-        it "yields the elements" do
-          result = []
-          described_class.forked([1, 2]) do |e|
-            result << e
-          end
-          result.should == [1, 2]
+      end
+      it 'should yield the two elements' do
+        result = []
+        
+        described_class.forked([1,2]) do |element|
+          result << element
         end
+        
+        result.should == [1,2]
       end
-      context "without block" do
-        it "fails" do
-          lambda {
-            described_class.forked [1, 2]
-          }.should raise_error("Block argument needed when running Cores.forked")
+      it 'should yield the two elements' do
+        result = []
+        
+        described_class.forked([1,2], randomly: true) do |element|
+          result << element
+        end
+        
+        # This test remains like this because I
+        # like the stupidity of it.
+        #
+        if result == [1,2]
+          result.should == [1,2]
+        else
+          result.should == [2,1]
         end
       end
     end
-    context "with empty array" do
-      context "with block" do
-        it "runs ok" do
-          described_class.forked([]) do
+    context 'with forking' do
+      before(:each) do
+        Picky::Cores.stub! :fork? => true
+        Process.should_receive(:fork).any_number_of_times.and_yield
+      end
+      context "with array" do
+        context "with block" do
+          it "runs ok" do
+            # TODO Problematic test. Should not raise the first time
+            #
+            Process.should_receive(:wait).once.and_raise Errno::ECHILD.new
+            
+            described_class.forked([1, 2]) do |e|
+
+            end
+          end
+          it "yields the elements" do
+            result = []
+            
+            described_class.forked([1, 2]) do |e|
+              result << e
+            end
             
+            result.should == [1, 2]
+          end
+          it 'should not fork with amount option' do
+            Process.should_receive(:fork).never
+
+            described_class.forked([1,2], amount: 1) do |element|
+
+            end
+          end
+          it 'should not fork with max == 1 option' do
+            Process.should_receive(:fork).never
+
+            described_class.forked([1,2], max: 1) do |element|
+
+            end
+          end
+        end
+        context "without block" do
+          it "fails" do
+            lambda {
+              described_class.forked [1, 2]
+            }.should raise_error("Block argument needed when running Cores.forked")
           end
         end
       end
-      context "without block" do
-        it "runs ok" do
-          described_class.forked []
+      context "with empty array" do
+        context "with block" do
+          it "runs ok" do
+            described_class.forked([]) do
+
+            end
+          end
         end
+        context "without block" do
+          it "runs ok" do
+            described_class.forked []
+          end
+        end
+      end
+    end
+  end
+  
+  describe 'fork?' do
+    context 'with forking capabilities' do
+      before(:all) do
+        # Process.should_receive(:respond_to?).any_number_of_times.with(:fork).and_return true
+      end
+      it 'returns false' do
+        Picky::Cores.fork?(0).should == false
+      end
+      it 'returns false' do
+        Picky::Cores.fork?(1).should == false
+      end
+      it 'returns true' do
+        Picky::Cores.fork?(2).should == true
       end
     end
   end

metadata

@@ -2,7 +2,7 @@
 name: picky
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 3.1.8
+  version: 3.1.9
 platform: ruby
 authors: 
 - Florian Hanke
@@ -32,7 +32,7 @@ dependencies:
     requirements: 
     - - "="
       - !ruby/object:Gem::Version 
-        version: 3.1.8
+        version: 3.1.9
   type: :development
   version_requirements: *id002
 description: Fast Ruby semantic text search engine with comfortable single field interface.