barney 0.1.0 → 0.2.0

data/ChangeLog

@@ -0,0 +1,8 @@
+2011-01-04  Robert Gleeson <rob@flowof.info> v0.2.0
+
+* Alias #synchronize as #sync. 
+
+2011-01-03  Robert Gleeson <rob@flowof.info> v0.2.0
+
+* Add Barney::Share#unshare.
+* Add Barney::Share#shared. 

data/README.md

@@ -0,0 +1,53 @@
+ ![Barney Picture](http://ompldr.org/vNnUwNA)
+
+Barney tries to make the sharing of data between processes as easy and **natural** as possible.  
+
+## Sharable objects
+Behind the scenes, Barney is using Marshal to send data between processes.  
+Any object that can be dumped through Marshal.dump can be shared.  
+This excludes anonymous modules, anonymous classes, Proc objects, and possibly some other objects I
+cannot think of.
+
+## Thread safety
+
+Barney is thread-safe as long as one instance of Barney::Share is used per-thread.  
+There is a mutex lock in place, but it only concerns Barney::Share#synchronize, where data is shared
+among all instances of Barney::Share.
+
+## Examples
+
+Okay, now that we've got that out of the way, let's see what using Barney is like.
+
+**Example A**
+
+      #!/usr/bin/env ruby
+      require 'barney'
+
+      message = 'foo'
+      $times  = 2
+
+      obj = Barney::Share.new
+      obj.share :message, :$times    
+      pid = obj.fork do 
+        message.sub! 'f', 'b'
+        $times += 1
+      end
+
+      Process.wait pid
+      obj.sync
+      
+      puts message * $times # output is 'boobooboo'.
+   
+### Documentation
+
+**API**  
+
+* [0.2.0](http://rubydoc.info/gems/barney/0.2.0)
+* [0.1.0](http://rubydoc.info/gems/barney/0.1.0)
+
+### Install
+
+      gem install barney
+
+The repository has a gemspec you can build and install from, too.
+I'm following the [Semantic Versioning](http://www.semver.org) policy.

data/lib/barney/share.rb

@@ -6,39 +6,49 @@ module Barney
 
     class << self
       # Serves as a temporary holder for the latest value read from the child process. 
-      #
-      # @api    private   
+      # @api private   
       # @return [void]
       attr_accessor :value
 
-      # Serves as a lock when {Barney::Share.value} is being accessed by {Barney::Share#synchronize}
-      #
-      # @api    private
+      # Serves as a lock when {Barney::Share.value Barney::Share.value} is being accessed by {Barney::Share#synchronize}
+      # @api private
       # @return [Mutex] 
-      def mutex
-        @mutex
-      end
+      attr_reader :mutex
     end
 
+    # Returns a list of all variables or constants being shared for this instance of {Barney::Share Barney::Share}.
+    # @return [Array<Symbol>] 
+    attr_reader :shared
+    def shared; @shared.keys; end
+
     # @return [Barney::Share] Returns an instance of Barney::Share.
     def initialize
-      @shared        = []
-      @communicators = nil
-      @context       = nil
+      @shared  = Hash.new
+      @context = nil
     end
 
-    # The share method marks a variable or constant to be shared between two processes. 
-    #  
-    # @param  [Symbol]        Variable   Accepts a variable amount of Symbol objects.
-    # @return [Array<Symbol>]            Returns a list of all variables that are being shared.
-    def share(*variables)
-      @shared = @shared | variables
+    # Serves as a method to mark a variable or constant to be shared between two processes. 
+    # @param  [Symbol] Variable   Accepts a variable amount of Symbol objects.
+    # @return [Array<Symbol>]     Returns a list of all variables that are being shared.
+    def share *variables
+      variables.map(&:to_sym).each do |variable|
+        @shared.store variable, IO.pipe
+      end
+      @shared.keys
     end
 
-    # This method will spawn a new child process.  
-    # It can be treated like the Kernel.fork method, but a block or Proc object is a 
-    # required argument.
-    # 
+    # Serves as a method to remove a variable or constant from being shared between two processes.
+    # @param  [Symbol] Variable Accepts a variable amount of Symbol objects.
+    # @return [Array<Symbol>]   Returns a list of the variables that are still being shared.
+    def unshare *variables
+      variables.map(&:to_sym).each do |variable|
+        @shared.delete variable
+      end
+      @shared.keys
+    end
+
+    # Serves as a method to spawn a new child process.  
+    # It can be treated like the Kernel.fork method, but a block or Proc object is a required argument.
     # @param  [Proc]  Proc    Accepts a block or Proc object that will be executed in a child 
     #                         process.
     # 
@@ -46,35 +56,35 @@ module Barney
     #                         supplied as an argument. 
     #                         
     # @return [Fixnum]        Returns the Process ID(PID) of the spawned child process.  
-    def fork(&blk)
-      raise(ArgumentError, "A block or Proc object is expected") unless block_given?
+    def fork &blk
+      raise ArgumentError, "A block or Proc object is expected" unless block_given?
 
-      @communicators = Array.new(@shared.size) { IO.pipe }  
       @context       = blk.binding
       process_id     = Kernel.fork do
         blk.call
-        @communicators.each_with_index do |pipes, i|
+        @shared.each do |variable, pipes|
           pipes[0].close  
-          pipes[1].write(Marshal.dump(eval("#{@shared[i]}", @context)))
+          pipes[1].write Marshal.dump(eval("#{variable}", @context))
           pipes[1].close
         end
       end
       process_id
     end
 
-    # This method synchronizes data between the parent and child process.  
-    # This method will block until the spawned child process has exited. 
+    # Serves as a method that synchronizes data between the parent and child process.  
+    # It will block until the spawned child process has exited. 
     # @return [void]
     def synchronize 
-      @communicators.each_with_index do |pipes,i|
+      @shared.each do |variable, pipes|
         Barney::Share.mutex.synchronize do
           pipes[1].close
-          Barney::Share.value = Marshal.load(pipes[0].read)
+          Barney::Share.value = Marshal.load pipes[0].read
           pipes[0].close
-          eval("#{@shared[i]} = Barney::Share.value", @context)
+          eval "#{variable} = Barney::Share.value", @context
         end
       end
     end
+    alias_method :sync, :synchronize
 
   end
 

data/lib/barney.rb

@@ -2,7 +2,7 @@ require('barney/share')
 
 module Barney 
 
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 
 end
 

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 1
+  - 2
   - 0
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Robert Gleeson
@@ -14,10 +14,48 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-04 00:00:00 +01:00
+date: 2011-01-04 00:00:00 +00:00
 default_executable: 
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: yard
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: bluecloth
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: riot
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
 description: Barney tries to make the sharing of data between processes as easy and natural as possible.
 email: rob@flowof.info
 executables: []
@@ -27,6 +65,8 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+- README.md
+- ChangeLog
 - lib/barney.rb
 - lib/barney/share.rb
 has_rdoc: true