iprocess 1.0.8 → 2.0.0

data/README.md

@@ -10,42 +10,36 @@ __OVERVIEW__
 
 __DESCRIPTION__
 
-  IProcess, short for _Inter Process Communication(IPC) Process_, is a    
-  Domain Specific Language(DSL) that you can use to share Ruby objects     
-  between processes on UNIX-like operating systems. The README covers the   
-  basics, and there is the API documentation for everything else.
-
-  This project was formerly known as 'Barney'. 
+  IProcess, short for _Inter Process Communication(IPC) Process_, is a collection 
+  of classes you can use to transport Ruby objects between processes running on 
+  UNIX-like operating systems. 
 
 __EXAMPLES__
 
 __1.__
 
-Sequential in nature (each subprocess must finish before another can execute):
+A single subprocess is spawned:
+  
+    message = IProcess.spawn { [:yes, :no] }
+    p message # => [[:yes, :no]]
 
-    name = "rob"
+__2.__
 
-    IProcess.new do
-      share :name
-      
-      fork do 
-        name.capitalize!
-      end
-    end
+A unit of work does not need to be a block, though, and the number of 
+subprocesses you can spawn is variable (5, in this example):
 
-    p name # => "Rob"
-    
-__2.__
+    class Worker
+      def initialize
+        @num = 1
+      end
 
-A subprocess is spawned 5 times, in parallel:
+      def call
+        @num + 1
+      end
+    end
 
-    workload = 
-    IProcess::Job.spawn(5) {
-      # Replace this with heavily CPU-bound code ;-) 
-      1 + 1
-    }
+    IProcess.spawn(5, Worker.new) # => [2, 2, 2, 2, 2]
 
-    p workload # [2, 2, 2, 2, 2]
 
 __PLATFORM SUPPORT__
 

data/iprocess.gemspec

@@ -7,7 +7,7 @@ Gem::Specification.new do |s|
   s.authors      = ["Rob Gleeson"]
   s.email        = 'rob@flowof.info'
   s.homepage     = 'https://github.com/robgleeson/iprocess'
-  s.summary      = 'A Domain Specific Language(DSL) for sharing Ruby objects' \
+  s.summary      = 'A set of classes you can use to transport ruby objects ' \
                    'between processes on UNIX-like operating systems.'  
   s.description  = s.summary
 

data/lib/iprocess/job.rb

@@ -1,75 +1,5 @@
 class IProcess::Job
 
-  #
-  # @overload spawn(number_of_jobs = 1, worker)
-  #
-  #   Spawn one or more jobs to be run in parallel.
-  #
-  #   @param [Integer] number_of_jobs
-  #     The number of jobs to spawn.
-  #
-  #   @param [#call] worker
-  #     The unit of work to execute in one or more jobs.
-  #
-  #   @return [Array<Object>]
-  #     The return value of one or more workers.
-  #
-  def self.spawn number_of_jobs = 1, obj = nil, &worker
-    worker = obj || worker
 
-    jobs =
-    Array.new(number_of_jobs) do
-      job = IProcess::Job.new(worker)
-      job.execute
-      job
-    end
-
-    jobs.map do |job|
-      job.result
-    end
-  end
-
-  #
-  # @param [#call] worker
-  #   The unit of work to execute in a subprocess.
-  #
-  # @raise [ArgumentError]
-  #   If a worker is not given.
-  #
-  # @return [IProcess::Job]
-  #   Returns self.
-  #
-  def initialize worker
-    @worker  = worker
-    @channel = nil
-    @pid     = nil
-
-    unless @worker.respond_to?(:call)
-      raise ArgumentError,
-            "Expected worker to implement #{@worker.class}#call"
-    end
-  end
-
-  #
-  # Executes a unit of work in a subprocess.
-  #
-  # @return [Fixnum]
-  #   The process ID of the spawned subprocess.
-  #
-  def execute
-    @channel = IProcess::Channel.new
-    @pid = fork { @channel.write(@worker.call) }
-  end
-
-  #
-  # @return [Object]
-  #   Returns the return value of the unit of work.
-  #
-  def result
-    Process.wait(@pid)
-    @channel.recv
-  end
 
 end
-
-

data/lib/iprocess/version.rb

@@ -1,3 +1,3 @@
 class IProcess
-  VERSION = '1.0.8'
+  VERSION = '2.0.0'
 end

data/lib/iprocess.rb

@@ -1,97 +1,75 @@
 class IProcess
 
-  require 'set'
   require_relative 'iprocess/version'
   require_relative 'iprocess/channel'
-  require_relative 'iprocess/job'
-  require_relative 'iprocess/delegator'
-
+  
+  #
+  # @overload spawn(number_of_jobs = 1, worker)
+  #
+  #   Spawn one or more jobs to be run in parallel.
+  #
+  #   @param [Integer] number_of_jobs
+  #     The number of jobs to spawn.
   #
-  # @return [IProcess]
+  #   @param [#call] worker
+  #     The unit of work to execute in one or more jobs.
   #
-  def initialize &block
-    @variables = SortedSet.new
-    @scope = nil
+  #   @return [Array<Object>]
+  #     The return value of one or more workers.
+  #
+  def self.spawn(number_of = 1, obj = nil, &worker)
+    worker = obj || worker
 
-    if block_given?
-      @scope = block.binding
-      IProcess::Delegator.new(self).instance_eval(&block)
+    jobs =
+    Array.new(number_of) do
+      job = IProcess.new(worker)
+      job.execute
+      job
     end
-  end
 
-  #
-  # @return [Array<Symbol>]
-  #   Returns a list of shared variables.
-  #
-  def variables
-    @variables.to_a
+    jobs.map do |job|
+      job.result
+    end
   end
 
   #
-  # Marks a variable or constant to be shared between two processes.
+  # @param [#call] worker
+  #   The unit of work to execute in a subprocess.
   #
-  # @param [Array<#to_sym>] variables
-  #   Accepts the name(s) of the variables or constants to share.
+  # @raise [ArgumentError]
+  #   If a worker is not given.
   #
-  # @return [Array<Symbol>]
-  #   Returns a list of all variables that are being shared.
+  # @return [IProcess::Job]
+  #   Returns self.
   #
-  def share *variables
-    @variables.merge variables.map(&:to_sym)
-    @variables.to_a
+  def initialize(worker)
+    @worker  = worker
+    @channel = nil
+    @pid     = nil
+
+    unless @worker.respond_to?(:call)
+      raise ArgumentError,
+            "Expected worker to implement #{@worker.class}#call"
+    end
   end
 
   #
-  # Removes a variable or constant from being shared between two processes.
-  #
-  # @param [Array<#to_sym>] variables
-  #   Accepts the name(s) of the variables or constants to stop sharing.
+  # Executes a unit of work in a subprocess.
   #
-  # @return [Array<Symbol>]
-  #   Returns a list of the variables that are still being shared.
+  # @return [Fixnum]
+  #   The process ID of the spawned subprocess.
   #
-  def unshare *variables
-    @variables.subtract variables.map(&:to_sym)
-    @variables.to_a
+  def execute
+    @channel = IProcess::Channel.new
+    @pid = fork { @channel.write(@worker.call) }
   end
 
   #
-  # Spawns a subprocess.
-  # The subprocess is waited on via Process.wait().
+  # @return [Object]
+  #   Returns the return value of the unit of work.
   #
-  # @param [Proc] &block
-  #   A block executed within a subprocess.
-  #
-  # @raise [ArgumentError]
-  #   If no block is given.
-  #
-  # @return [Fixnum]
-  #   The Process ID(PID) of the subprocess.
-  #
-  def fork &block
-    unless block_given?
-      raise ArgumentError, "Wrong number of arguments (0 for 1)"
-    end
-
-    scope = @scope || block.binding
-    channels = @variables.map { |name| IProcess::Channel.new(name) }
-
-    pid = Kernel.fork do
-      scope.eval("self").instance_eval(&block)
-      channels.each do |channel|
-        channel.write scope.eval(channel.name.to_s)
-      end
-    end
-
-    Process.wait(pid)
-
-    channels.each do |channel|
-      Thread.current[:__iprocess_obj__] = channel.recv
-      scope.eval("#{channel.name} = Thread.current[:__iprocess_obj__]")
-    end
-
-    Thread.current[:__iprocess_obj__] = nil
-    pid
+  def result
+    Process.wait(@pid)
+    @channel.recv
   end
-
 end

data/test/test_IProcess_class.rb

@@ -1,109 +1,26 @@
 context IProcess do
-
-  context 'initialize' do
-    it 'calls a block, if given.' do
-      mock = MiniTest::Mock.new
-      mock.expect :ok, nil
-      
-      IProcess.new do
-        mock.ok
-      end
-
-      mock.verify
-    end
-  end
-
-  context 'share' do
-    it 'shares a variable.' do
-      IProcess.new do
-        share :a
-        variables.must_equal [:a]
-      end
-    end
-
-    it "does not store duplicate variables" do
-      IProcess.new do
-        share :a, :a
-        variables.must_equal [:a]
-      end
-    end
-  end
-
-  context 'unshare' do
-    it "unshares a variable." do
-      IProcess.new do
-        share :a
-        unshare :a
-        variables.must_be_empty
-      end
-    end
-  end
-
-  context 'fork' do
-    it 'returns the Process ID(PID) on success.' do
-      pid = IProcess.new.fork { }
-      assert_equal Fixnum, pid.class
-    end
-
-    it 'raises if no block is given.' do
-      obj = IProcess.new
-
-      assert_raises(ArgumentError) do
-        obj.fork
-      end
+  context 'spawn' do
+    it 'spawns two Proc workers.' do
+      topic = IProcess.spawn(2) { :ok }
+      topic.must_equal([:ok, :ok])
     end
 
-    it 'synchronizes a shared variable.' do
-      local = 1
-
-      IProcess.new do
-        share :local
-        fork { local = 2 }
-      end
-
-      local.must_equal(2)
-    end
-
-    it 'synchronizes two shared variables.' do
-      local1, local2 = 1, 2
-
-      IProcess.new do
-        share :local1, :local2
-
-        fork do
-          local1 = 5
-          local2 = 9
+    it 'spawns two non-Proc workers.' do
+      worker = 
+      Class.new do
+        def call
+          :ok
         end
       end
 
-      local1.must_equal(5)
-      local2.must_equal(9)
+      topic = IProcess.spawn(2, worker.new)
+      topic.must_equal([:ok, :ok])
     end
+  end
 
-    it 'synchronizes a instance variable.' do
-      @ivar = :ivar
-
-      IProcess.new do
-        share :@ivar
-
-        fork do
-          @ivar = 2
-        end
-      end
-
-      @ivar.must_equal(2)
-    end
-
-    it 'provide access to surrounding local variables.' do
-      local = :local
-
-      IProcess.new do
-        fork do
-          local.must_equal(:local)
-        end
-      end
+  context 'initialize' do
+    it "raises if given an object who cannot respond to #call." do
+      proc { IProcess.new(nil) }.must_raise(ArgumentError)
     end
   end
-
 end
-

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: iprocess
 version: !ruby/object:Gem::Version
-  version: 1.0.8
+  version: 2.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-18 00:00:00.000000000 Z
+date: 2012-04-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: yard
-  requirement: &70341456473680 !ruby/object:Gem::Requirement
+  requirement: &12570880 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: '0.7'
   type: :development
   prerelease: false
-  version_requirements: *70341456473680
+  version_requirements: *12570880
 - !ruby/object:Gem::Dependency
   name: redcarpet
-  requirement: &70341456471200 !ruby/object:Gem::Requirement
+  requirement: &12570400 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,10 +32,10 @@ dependencies:
         version: '1.17'
   type: :development
   prerelease: false
-  version_requirements: *70341456471200
+  version_requirements: *12570400
 - !ruby/object:Gem::Dependency
   name: minitest
-  requirement: &70341456462240 !ruby/object:Gem::Requirement
+  requirement: &12569880 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,10 +43,10 @@ dependencies:
         version: '2.6'
   type: :development
   prerelease: false
-  version_requirements: *70341456462240
+  version_requirements: *12569880
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70341456460660 !ruby/object:Gem::Requirement
+  requirement: &12569380 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -54,8 +54,8 @@ dependencies:
         version: 0.9.2
   type: :development
   prerelease: false
-  version_requirements: *70341456460660
-description: A Domain Specific Language(DSL) for sharing Ruby objectsbetween processes
+  version_requirements: *12569380
+description: A set of classes you can use to transport ruby objects between processes
   on UNIX-like operating systems.
 email: rob@flowof.info
 executables: []
@@ -73,11 +73,9 @@ files:
 - iprocess.gemspec
 - lib/iprocess.rb
 - lib/iprocess/channel.rb
-- lib/iprocess/delegator.rb
 - lib/iprocess/job.rb
 - lib/iprocess/version.rb
 - test/setup.rb
-- test/test_IProcess_Job_class.rb
 - test/test_IProcess_class.rb
 homepage: https://github.com/robgleeson/iprocess
 licenses: []
@@ -102,10 +100,9 @@ rubyforge_project: ! '[none]'
 rubygems_version: 1.8.11
 signing_key: 
 specification_version: 3
-summary: A Domain Specific Language(DSL) for sharing Ruby objectsbetween processes
+summary: A set of classes you can use to transport ruby objects between processes
   on UNIX-like operating systems.
 test_files:
-- test/setup.rb
 - test/test_IProcess_class.rb
-- test/test_IProcess_Job_class.rb
+- test/setup.rb
 has_rdoc: 

data/lib/iprocess/delegator.rb

@@ -1,55 +0,0 @@
-class IProcess::Delegator
-
-  #
-  # @param [IProcess] delegate
-  #   An instance of {IProcess}.
-  #
-  def initialize delegate
-    @__delegate__ = delegate
-  end
-
-  #
-  # @param
-  #   (see IProcess#share)
-  #
-  # @return
-  #   (see IProcess#share)
-  #
-  def share *args
-    @__delegate__.share *args
-  end
-
-  #
-  # @param
-  #   (see IProcess#unshare)
-  #
-  # @return
-  #   (see IProcess#unshare)
-  #
-  def unshare *args
-    @__delegate__.unshare *args
-  end
-
-  #
-  # @return
-  #   (see IProcess#variables)
-  #
-  def variables
-    @__delegate__.variables
-  end
-
-  #
-  # @param
-  #   (see IProcess#fork)
-  #
-  # @raise
-  #   (see IProcess#fork)
-  #
-  # @return
-  #   (see IProcess#fork)
-  #
-  def fork(&block)
-    @__delegate__.fork(&block)
-  end
-
-end

data/test/test_IProcess_Job_class.rb

@@ -1,27 +0,0 @@
-context IProcess::Job do
-  context 'spawn' do
-    it 'spawns two Proc workers.' do
-      topic = IProcess::Job.spawn(2) { :ok }
-      topic.must_equal([:ok, :ok])
-    end
-
-    it 'spawns two non-Proc workers.' do
-      worker = 
-      Class.new do
-        def call
-          :ok
-        end
-      end
-
-      topic = IProcess::Job.spawn(2, worker.new)
-      topic.must_equal([:ok, :ok])
-    end
-  end
-
-  context 'initialize' do
-    it "raises if given an object who cannot respond to #call." do
-      proc { IProcess::Job.new(nil) }.must_raise(ArgumentError)
-    end
-  end
-end
-