dataflow 0.1.0

data/History.txt

@@ -0,0 +1,5 @@
+== 0.1.0 / 2009-06-13
+ 
+* 1 major enhancement
+ 
+  * Birthday!

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2009 Larry Diehl
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.textile

@@ -0,0 +1,172 @@
+h1. What's this?
+
+A Ruby library that adds Dataflow variables (inspired by the Oz
+language). Dataflow variables have the property that they can only
+be bound/assigned to once, or have an equivalent value as an existing
+assignment (see "unification").
+
+Dataflow variables must be declared before they are used, and can be
+passed around as data without actually being bound. If the variable
+gets used (in this library this means a method call) while being
+unbound then the currently executing thread will suspend.
+
+h1. What's the point?
+
+Ruby is Object Oriented (with the ability to mutate local, instance,
+class, and global variables, and even constants), and on top of that
+it has powerful reflection and meta-programming abilities. While these
+features are useful for certain problems, they are not within the
+declarative model. Staying in the declarative model gives one 2 advantages:
+# It is easy to reason about what the program does
+# Simple but powerful concurrency is possible
+
+Ruby, like many other OO languages, is facing the hurdles of taking
+advantage of the increase of processor cores within a simple parallel
+programming model. This library lets you program Ruby in the
+declarative concurrent model when you need to take advantage of multiple cores
+(assuming a Ruby implementation that uses native threads in one way or
+another).
+
+The trick to this kind of programming is binding variables from other
+threads. The nice thing is that many existing
+libraries/classes/methods can still be used, just avoid
+side-effects. Use regular Ruby threading to create threads, use
+"local" or "declare" to create new variables, and use "unify" to bind
+variables.
+
+h1. Examples
+
+<pre>
+# Local variables
+include Dataflow
+ 
+local do |x, y, z|
+  # notice how the order automatically gets resolved
+  Thread.new { unify y, x + 2 }
+  Thread.new { unify z, y + 3 }
+  Thread.new { unify x, 1 }
+  z #=> 6
+end
+</pre>
+
+<pre>
+# Instance variables
+class AnimalHouse
+  include Dataflow
+  declare :small_cat, :big_cat
+
+  def fetch_big_cat
+    Thread.new { unify big_cat, small_cat.upcase }
+    unify small_cat, 'cat'
+    big_cat
+  end
+end
+
+AnimalHouse.new.fetch_big_cat #=> 'CAT'
+</pre>
+
+<pre>
+# Data-driven concurrency
+include Dataflow
+
+local do |stream, doubles, triples, squares|
+  unify stream, Array.new(5) { Dataflow::Variable.new }
+
+  Thread.new { unify doubles, stream.map {|n| n*2 } }
+  Thread.new { unify triples, stream.map {|n| n*3 } }
+  Thread.new { unify squares, stream.map {|n| n**2 } }  
+
+  Thread.new { stream.each {|x| unify x, rand(100) } }
+
+  puts "original: #{stream.inspect}"
+  puts "doubles:  #{doubles.inspect}"
+  puts "triples:  #{triples.inspect}"
+  puts "squares:  #{squares.inspect}"  
+end
+</pre>
+
+<pre>
+# By-need trigger laziness
+include Dataflow
+
+local do |x, y, z|
+  Thread.new { unify y, by_need { 4 } }
+  Thread.new { unify z, x + y }
+  Thread.new { unify x, by_need { 3 } }
+  z #=> 7
+end
+</pre>
+
+<pre>
+# Need-later future expressions
+include Dataflow
+
+local do |x, y, z|
+  unify y, need_later { 4 }
+  unify z, need_later { x + y }
+  unify x, need_later { 3 }
+  z #=> 7
+end        
+</pre>
+
+h1. Ports using Dataflow
+
+Ports are an extension of the declarative concurrent model to support nondeterministic behavior. They accomplish this through the use of a single state variable. Ports are also inspired by the Oz language.
+
+An Actor class in the style of Erlang message-passing processes is also provided. It makes use of the asynchronous behavior of ports, but otherwise uses no state variables.
+
+h1. Examples using Ports
+
+<pre>
+include Dataflow
+
+local do |port, stream|
+  unify port, Dataflow::Port.new(stream)
+  Thread.new {port.send 2}
+  Thread.new {port.send 8}
+  Thread.new {port.send 1024}
+  stream.take(3).sort #=> [2, 8, 1024]
+end
+</pre>
+
+h1. Examples using Actors
+
+<pre>
+include Dataflow
+
+Ping = Actor.new {
+  3.times {
+    case receive
+    when "Ping"
+      puts "Ping"
+      Pong.send "Pong"
+    end
+  }
+}
+
+Pong = Actor.new {
+  3.times {
+    case receive
+    when "Pong"
+      puts "Pong"
+      Ping.send "Ping"
+    end
+  }
+}
+
+Actor.new { Ping.send "Ping" }
+
+Ping.join
+Pong.join
+</pre>
+
+h1. References
+
+The basis of dataflow variables around a language is not common among
+popular languages and may be confusing to some. For an in-depth
+introduction to the Oz language and the techniques used in this
+library (including by_need triggers, port objects, and comparisons to Erlang message passing) see the book "Concepts, Techniques, and Models of Computer Programming":http://en.wikipedia.org/wiki/Concepts,_Techniques,_and_Models_of_Computer_Programming
+
+h1. Contributors
+
+larrytheliquid, amiller

data/Rakefile

@@ -0,0 +1,35 @@
+require "rubygems"
+require "rake/gempackagetask"
+require "rake/clean"
+require "spec/rake/spectask"
+require File.expand_path("./dataflow")
+
+Spec::Rake::SpecTask.new do |t|
+  t.spec_opts = ['--options', "\"#{File.dirname(__FILE__)}/spec/spec.opts\""]
+end
+
+desc "Run the specs"
+task :default => :spec
+
+spec = Gem::Specification.new do |s|
+  s.name              = "dataflow"
+  s.rubyforge_project = s.name
+  s.version           = Dataflow::VERSION
+  s.author            = "Larry Diehl"
+  s.email             = "larrytheliquid" + "@" + "gmail.com"
+  s.homepage          = "http://github.com/larrytheliquid/dataflow"
+  s.summary           = "Dataflow concurrency for Ruby (inspired by the Oz language)"
+  s.description       = s.summary
+  s.files             = %w[LICENSE History.txt Rakefile README.textile dataflow.rb] + Dir["lib/**/*"] + Dir["examples/**/*"]
+  s.test_files        = Dir["spec/**/*"]
+end
+
+Rake::GemPackageTask.new(spec) do |package|
+  package.gem_spec = spec
+end
+
+desc 'Install the package as a gem.'
+task :install => [:clean, :package] do
+  gem = Dir['pkg/*.gem'].first
+  sh "sudo gem install --no-rdoc --no-ri --local #{gem}"
+end

data/dataflow.rb

@@ -0,0 +1,90 @@
+require 'monitor'
+
+module Dataflow
+  VERSION = "0.1.0"
+  
+  def self.included(cls)
+    class << cls
+      def declare(*readers)
+        readers.each do |name|
+          class_eval <<-RUBY
+            def #{name}
+              return @__dataflow_#{name}__ if defined? @__dataflow_#{name}__
+              Variable::LOCK.synchronize { @__dataflow_#{name}__ ||= Variable.new }
+            end
+          RUBY
+        end
+      end
+    end
+  end
+  
+  def local(&block)
+    vars = Array.new(block.arity) { Variable.new }
+    block.call *vars
+  end
+
+  def unify(variable, value)
+    variable.__unify__ value
+  end
+
+  def by_need(&block)
+    Variable.new &block
+  end
+
+  def need_later(&block)
+    local do |future|
+      Thread.new { unify future, block.call }
+      future
+    end
+  end
+
+  # Note that this class uses instance variables directly rather than nicely
+  # initialized instance variables in get/set methods for memory and
+  # performance reasons
+  class Variable
+    instance_methods.each { |m| undef_method m unless m =~ /^__/ }
+    LOCK = Monitor.new
+    def initialize(&block) @__trigger__ = block if block_given? end
+    
+    # Lazy-load conditions to be nice on memory usage
+    def __binding_condition__() @__binding_condition__ ||= LOCK.new_cond end
+
+    def __unify__(value)
+      LOCK.synchronize do
+        if @__bound__
+          raise UnificationError if @__value__ != value
+        else
+          @__value__ = value
+          @__bound__ = true
+          __binding_condition__.broadcast # wakeup all method callers
+          remove_instance_variable :@__binding_condition__ # GC
+        end
+      end
+      @__value__
+    end
+
+    def __activate_trigger__
+      @__value__ = @__trigger__.call
+      @__bound__ = true
+      remove_instance_variable :@__trigger__ # GC
+    end
+
+    def method_missing(name, *args, &block)
+      LOCK.synchronize do
+        unless @__bound__
+          if @__trigger__
+            __activate_trigger__
+          else
+            __binding_condition__.wait
+          end
+        end
+      end unless @__bound__
+      @__value__.__send__(name, *args, &block)
+    end
+  end
+
+  UnificationError = Class.new StandardError
+end
+
+require "#{File.dirname(__FILE__)}/lib/port"
+require "#{File.dirname(__FILE__)}/lib/actor"

data/examples/data_driven.rb

@@ -0,0 +1,17 @@
+require "#{File.dirname(__FILE__)}/../dataflow"
+include Dataflow
+
+local do |stream, doubles, triples, squares|
+  unify stream, Array.new(5) { Dataflow::Variable.new }
+  
+  Thread.new { unify doubles, stream.map {|n| n*2 } }
+  Thread.new { unify triples, stream.map {|n| n*3 } }
+  Thread.new { unify squares, stream.map {|n| n**2 } }  
+
+  Thread.new { stream.each {|x| unify x, rand(100) } }
+
+  puts "original: #{stream.inspect}"
+  puts "doubles:  #{doubles.inspect}"
+  puts "triples:  #{triples.inspect}"
+  puts "squares:  #{squares.inspect}"  
+end

data/examples/dataflow_http_gets.rb

@@ -0,0 +1,13 @@
+require "#{File.dirname(__FILE__)}/../dataflow"
+require 'net/http'
+include Dataflow
+
+# Be gentle running this one
+Thread.abort_on_exception = true
+local do |stream, branding_occurences, number_of_mentions|
+  unify stream, Array.new(10) { Dataflow::Variable.new }
+  stream.each {|s| Thread.new(s) {|v| unify v, Net::HTTP.get_response(URI.parse("http://www.cuil.com/search?q=#{rand(1000)}")).body } }
+  Thread.new { unify branding_occurences, stream.map {|http_body| http_body.scan /cuil/ } }
+  Thread.new { unify number_of_mentions, branding_occurences.map {|occurences| occurences.length } }
+  puts number_of_mentions.inspect
+end

data/examples/future_http_gets.rb

@@ -0,0 +1,12 @@
+require "#{File.dirname(__FILE__)}/../dataflow"
+require 'net/http'
+include Dataflow
+
+# Be gentle running this one
+Thread.abort_on_exception = true
+local do |stream, branding_occurences, number_of_mentions|
+  unify stream, Array.new(10) { need_later { Net::HTTP.get_response(URI.parse("http://www.cuil.com/search?q=#{rand(1000)}")).body } }
+  unify branding_occurences, need_later { stream.map {|http_body| http_body.scan /cuil/ } }
+  unify number_of_mentions, need_later { branding_occurences.map {|occurences| occurences.length } }
+  puts number_of_mentions.inspect
+end

data/examples/instance_variables.rb

@@ -0,0 +1,15 @@
+require "#{File.dirname(__FILE__)}/../dataflow"
+
+class AnimalHouse
+  include Dataflow
+  declare :small_cat, :big_cat
+
+  def fetch_big_cat
+    Thread.new { unify big_cat, small_cat.upcase }
+    unify small_cat, 'cat'
+    big_cat
+  end
+end
+
+puts AnimalHouse.new.fetch_big_cat
+

data/examples/laziness.rb

@@ -0,0 +1,9 @@
+require "#{File.dirname(__FILE__)}/../dataflow"
+include Dataflow
+
+local do |x, y, z|
+  Thread.new { unify y, by_need { 4 } }
+  Thread.new { unify z, x + y }
+  Thread.new { unify x, by_need { 3 } }  
+  puts z
+end

data/examples/local_variables.rb

@@ -0,0 +1,11 @@
+require "#{File.dirname(__FILE__)}/../dataflow"
+include Dataflow
+
+local do |x, y, z|
+  # notice how the order automatically gets resolved
+  Thread.new { unify y, x + 2 }
+  Thread.new { unify z, y + 3 }
+  Thread.new { unify x, 1 }
+  puts z
+end
+  

data/examples/messages.rb

@@ -0,0 +1,26 @@
+require "#{File.dirname(__FILE__)}/../dataflow"
+include Dataflow
+
+Ping = Actor.new {
+  3.times {
+    case receive
+    when "Ping"
+      puts "Ping"
+      Pong.send "Pong"
+    end
+  }
+}
+
+Pong = Actor.new {
+  3.times {
+    case receive
+    when "Pong"
+      puts "Pong"
+      Ping.send "Ping"
+    end
+  }
+}
+
+Ping.send "Ping"
+Ping.join
+Pong.join

data/examples/port_http_gets.rb

@@ -0,0 +1,13 @@
+require "#{File.dirname(__FILE__)}/../dataflow"
+require 'net/http'
+include Dataflow
+
+# Be gentle running this one
+Thread.abort_on_exception = true
+local do |port, stream, branding_occurences, number_of_mentions|
+  unify port, Dataflow::Port.new(stream)
+  10.times { Thread.new(port) {|p| p.send Net::HTTP.get_response(URI.parse("http://www.cuil.com/search?q=#{rand(1000)}")).body } }
+  Thread.new { unify branding_occurences, stream.take(10).map {|http_body| http_body.scan /cuil/ } }
+  Thread.new { unify number_of_mentions, branding_occurences.map {|occurences| occurences.length } }
+  puts number_of_mentions.inspect
+end

data/examples/port_send.rb

@@ -0,0 +1,10 @@
+require "#{File.dirname(__FILE__)}/../dataflow"
+include Dataflow
+
+local do |port, stream|
+  unify port, Dataflow::Port.new(stream)
+  Thread.new {port.send 2}
+  Thread.new {port.send 8}
+  Thread.new {port.send 1024}
+  puts stream.take(3).sort.inspect
+end

data/examples/ring.rb

@@ -0,0 +1,21 @@
+require "#{File.dirname(__FILE__)}/../dataflow"
+include Dataflow
+
+# Send M messages each along a ring of N nodes
+N = 4
+M = 2
+actors = Array.new(N) { Dataflow::Variable.new }
+
+N.times do |n|
+  unify actors[n], Actor.new {
+    M.times do |m|
+      receive
+      puts "[#{n} #{m}]"
+      actors[(n+1) % N].send :msg
+    end
+    puts "[#{n}] done"
+  }
+end
+
+actors.first.send :msg
+actors.each { |x| x.join }

data/lib/actor.rb

@@ -0,0 +1,22 @@
+module Dataflow
+  class Actor < Thread
+    def initialize(&block)
+      @stream = Variable.new
+      @port = Port.new(@stream)
+      # Run this block in a new thread
+      super { instance_eval &block }
+    end
+
+    def send message
+      @port.send message
+    end
+
+  private
+    
+    def receive
+      result = @stream.head
+      @stream = @stream.tail
+      result
+    end
+  end
+end

data/lib/port.rb

@@ -0,0 +1,54 @@
+require 'thread'
+
+module Dataflow
+  class Port  
+    include Dataflow
+    LOCK = Mutex.new
+
+    class Stream
+      include Dataflow
+      declare :head, :tail
+    
+      # Defining each allows us to use the enumerable mixin
+      # None of the list can be garbage collected less the head is
+      # garbage collected, so it will grow indefinitely even though
+      # the function isn't recursive.
+      include Enumerable
+      def each
+        s = self
+        loop do
+          yield s.head
+          s = s.tail
+        end
+      end
+
+      # Backported Enumerable#take for any 1.8.6 compatible Ruby
+      unless method_defined?(:take)
+        def take(num)
+          result = []
+          each_with_index do |x, i|
+            return result if num == i
+            result << x
+          end
+        end
+      end
+    end
+  
+    # Create a stream object, bind it to the input variable
+    # Instance variables are necessary because @end is state
+    def initialize(x)
+      @end = Stream.new
+      unify x, @end
+    end
+  
+    # This needs to be synchronized because it uses @end as state
+    def send value
+      LOCK.synchronize do
+        unify @end.head, value
+        unify @end.tail, Stream.new
+        @end = @end.tail
+      end
+    end
+  end
+end
+

data/spec/actor_spec.rb

@@ -0,0 +1,29 @@
+require "#{File.dirname(__FILE__)}/spec_helper"
+Thread.abort_on_exception = true
+
+describe 'Syncronously sending to an Actor' do  
+  it 'passes in each message received and preserves order' do
+    local do |port, stream, actor|
+      unify port, Dataflow::Port.new(stream)
+      unify actor, Dataflow::Actor.new { 3.times { port.send receive } }
+      actor.send 1
+      actor.send 2
+      stream.take(2).should == [1, 2]
+      actor.send 3
+      stream.take(3).should == [1, 2, 3]
+    end
+  end
+end
+
+describe 'Asyncronously sending to an Actor' do
+  it 'passes in each message received and preserves order' do
+    local do |port, stream, actor|
+      unify port, Dataflow::Port.new(stream)
+      unify actor, Dataflow::Actor.new { 3.times { port.send receive } }
+      Thread.new {actor.send 2}
+      Thread.new {actor.send 8}
+      Thread.new {actor.send 1024}
+      stream.take(3).sort.should == [2, 8, 1024]      
+    end
+  end
+end

data/spec/by_need_spec.rb

@@ -0,0 +1,12 @@
+require "#{File.dirname(__FILE__)}/spec_helper"
+
+describe 'A by_need trigger' do
+  it 'creates a need when a method is called on it' do
+    local do |x, y, z|
+      Thread.new { unify y, by_need { 4 } }
+      Thread.new { unify z, x + y }
+      Thread.new { unify x, by_need { 3 } }      
+      z.should == 7
+    end
+  end
+end

data/spec/dataflow_spec.rb

@@ -0,0 +1,128 @@
+require "#{File.dirname(__FILE__)}/spec_helper"
+
+context 'Using "local" for local variables' do
+  describe 'An unbound Variable' do
+    it 'suspends if an unbound variable has a method called on it until it is bound' do
+      local do |big_cat, small_cat|
+        Thread.new { unify big_cat, small_cat.upcase }
+        unify small_cat, 'cat'
+        big_cat.should == 'CAT'
+      end
+    end
+
+    it 'suspends if an unbound variable has a method called on it until it is bound with nil' do
+      local do |is_nil, var_nil|
+        Thread.new { unify is_nil, var_nil.nil? }
+        unify var_nil, nil 
+        is_nil.should be_true
+      end
+    end
+
+    it 'suspends if an unbound variable has a method called on it until it is bound (with nested local variables)' do
+      local do |small_cat|
+        local do |big_cat|
+          Thread.new { unify big_cat, small_cat.upcase }
+          unify small_cat, 'cat'
+          big_cat.should == 'CAT'
+        end
+      end
+    end
+
+    it 'performs order-determining concurrency' do
+      local do |x, y, z|
+        Thread.new { unify y, x + 2 }
+        Thread.new { unify z, y + 3 }
+        Thread.new { unify x, 1 }
+        z.should == 6
+      end
+    end
+    
+    it 'binds on unification' do
+      local do |animal|
+        unify animal, 'cat'
+        animal.should == 'cat'
+      end
+    end
+  end
+end
+
+describe 'A bound Variable' do
+  it 'does not complain when unifying with an equal object' do
+    lambda do
+      local do |animal|
+        unify animal, 'cat'
+        unify animal, 'cat'        
+      end
+    end.should_not raise_error
+  end
+
+  it 'does not complain when unifying with an unequal object when shadowing' do
+    lambda do
+      local do |animal|
+        unify animal, 'cat'
+        local do |animal|
+          unify animal, 'dog'
+        end
+      end
+    end.should_not raise_error
+  end
+
+  it 'complains when unifying with an unequal object' do
+    lambda do
+      local do |animal|
+        unify animal, 'cat'
+        unify animal, 'dog'
+      end
+    end.should raise_error(Dataflow::UnificationError)
+  end
+end
+
+context 'Using "declare" for object-specific read-only attributes' do
+  class Store
+    include Dataflow
+    declare :animal, :big_cat, :small_cat, :x, :y, :z, :is_nil, :var_nil
+  end
+  before { @store = Store.new }
+  
+  describe 'An unbound Variable' do
+    it 'suspends if an unbound variable has a method called on it until it is bound' do
+      Thread.new { unify @store.big_cat, @store.small_cat.upcase }
+      unify @store.small_cat, 'cat'
+      @store.big_cat.should == 'CAT'
+    end
+
+    it 'suspends if an unbound variable has a method called on it until it is bound with nil' do
+      Thread.new { unify @store.is_nil, @store.var_nil.nil? }
+      unify @store.var_nil, nil 
+      @store.is_nil.should be_true
+    end
+
+    it 'performs order-determining concurrency' do
+      Thread.new { unify @store.y, @store.x + 2 }
+      Thread.new { unify @store.z, @store.y + 3 }
+      Thread.new { unify @store.x, 1 }
+      @store.z.should == 6
+    end
+    
+    it 'binds on unification' do
+      unify @store.animal, 'cat'
+      @store.animal.should == 'cat'
+    end
+  end
+
+  describe 'A bound Variable' do
+    it 'does not complain when unifying with an equal object' do
+      lambda do
+        unify @store.animal, 'cat'
+        unify @store.animal, 'cat'        
+      end.should_not raise_error
+    end
+
+    it 'complains when unifying with an unequal object' do
+      lambda do
+        unify @store.animal, 'cat'
+        unify @store.animal, 'dog'
+      end.should raise_error(Dataflow::UnificationError)
+    end
+  end
+end

data/spec/need_later_spec.rb

@@ -0,0 +1,12 @@
+require "#{File.dirname(__FILE__)}/spec_helper"
+
+describe 'A need_later expression' do
+  it 'returns a future to be calculated later' do
+    local do |x, y, z|
+      unify y, need_later { 4 }
+      unify z, need_later { x + y }
+      unify x, need_later { 3 }      
+      z.should == 7
+    end
+  end
+end

data/spec/port_spec.rb

@@ -0,0 +1,26 @@
+require "#{File.dirname(__FILE__)}/spec_helper"
+
+describe 'Syncronously sending to a Port' do
+  it 'extends the length of the stream and preserves order' do
+    local do |port, stream|
+      unify port, Dataflow::Port.new(stream)
+      port.send 1
+      port.send 2
+      stream.take(2).should == [1, 2]
+      port.send 3
+      stream.take(3).should == [1, 2, 3]
+    end
+  end
+end
+
+describe 'Asyncronously sending to a Port' do
+  it 'extends the length of the stream and does not preserve order' do
+    local do |port, stream|
+      unify port, Dataflow::Port.new(stream)
+      Thread.new {port.send 2}
+      Thread.new {port.send 8}
+      Thread.new {port.send 1024}
+      stream.take(3).sort.should == [2, 8, 1024]
+    end
+  end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'rubygems'
+require 'spec'
+require 'dataflow'
+
+Spec::Runner.configure do |config|
+  config.include Dataflow
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification 
+name: dataflow
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Larry Diehl
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-06-13 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Dataflow concurrency for Ruby (inspired by the Oz language)
+email: larrytheliquid@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- LICENSE
+- History.txt
+- Rakefile
+- README.textile
+- dataflow.rb
+- lib/actor.rb
+- lib/port.rb
+- examples/local_variables.rb
+- examples/dataflow_http_gets.rb
+- examples/instance_variables.rb
+- examples/data_driven.rb
+- examples/ring.rb
+- examples/port_send.rb
+- examples/laziness.rb
+- examples/port_http_gets.rb
+- examples/future_http_gets.rb
+- examples/messages.rb
+has_rdoc: false
+homepage: http://github.com/larrytheliquid/dataflow
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: dataflow
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: Dataflow concurrency for Ruby (inspired by the Oz language)
+test_files: 
+- spec/need_later_spec.rb
+- spec/by_need_spec.rb
+- spec/spec_helper.rb
+- spec/port_spec.rb
+- spec/spec.opts
+- spec/dataflow_spec.rb
+- spec/actor_spec.rb