engineyard-serverside 2.0.4 → 2.0.5.pre

data/lib/vendor/dataflow/examples/messages.rb

@@ -1,26 +0,0 @@
-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/lib/vendor/dataflow/examples/port_http_gets.rb

@@ -1,13 +0,0 @@
-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/lib/vendor/dataflow/examples/port_send.rb

@@ -1,10 +0,0 @@
-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/lib/vendor/dataflow/examples/ring.rb

@@ -1,21 +0,0 @@
-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/vendor/dataflow/spec/actor_spec.rb

@@ -1,28 +0,0 @@
-require "#{File.dirname(__FILE__)}/spec_helper"
-
-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/lib/vendor/dataflow/spec/anonymous_variables_spec.rb

@@ -1,21 +0,0 @@
-require "#{File.dirname(__FILE__)}/spec_helper"
-
-describe 'Using an anonymous variable' do
-  it 'works with Variable instances' do
-    container = [Dataflow::Variable.new]
-    unify container.first, 1337
-    container.first.should == 1337
-  end
-
-  it 'works with Dataflow.local' do
-    container = [Dataflow.local]
-    unify container.first, 1337
-    container.first.should == 1337
-  end
-
-  it 'works with #local' do
-    container = [local]
-    unify container.first, 1337
-    container.first.should == 1337
-  end
-end

data/lib/vendor/dataflow/spec/barrier_spec.rb

@@ -1,25 +0,0 @@
-require "#{File.dirname(__FILE__)}/spec_helper"
-
-describe 'A barrier' do
-  it 'waits for variables to be bound before continuing' do
-    local do |x, y, barrier_broken|
-      Thread.new do 
-        barrier x, y
-        unify barrier_broken, true
-      end
-      Thread.new { unify x, :x }
-      Thread.new { unify y, :y }
-      barrier_broken.should be_true
-    end
-  end
-
-  it 'continues for variables that are already bound' do
-    local do |x, y, barrier_broken|
-      unify x, :x
-      unify y, :y
-      barrier x, y
-      unify barrier_broken, true
-      barrier_broken.should be_true
-    end
-  end
-end

data/lib/vendor/dataflow/spec/by_need_spec.rb

@@ -1,55 +0,0 @@
-require "#{File.dirname(__FILE__)}/spec_helper"
-
-describe 'A by_need expression' do
-  describe 'when a method is called on it' do
-    it 'binds its variable' 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
-
-  describe 'when a bound variable is unified to it' do
-    it 'passes unififcation for equal values' do
-      local do |x|
-        unify x, by_need { 1 }
-        unify x, 1
-        x.should == 1
-
-        y = by_need { 1 }
-        unify y, 1
-        y.should == 1
-      end
-    end
-
-    it 'fails unififcation for unequal values' do
-      local do |x|
-        unify x, by_need { 1 }
-        lambda { unify x, 2 }.should raise_error(Dataflow::UnificationError)
-
-        y = by_need { 1 }
-        lambda { unify y, 2 }.should raise_error(Dataflow::UnificationError)
-      end
-    end
-
-    describe 'when it is unified to a bound variable' do
-      it 'passes unififcation for equal values' do
-        local do |x|
-          unify x, 1
-          unify x, by_need { 1 }
-          x.should == 1
-        end
-      end
-      
-      it 'fails unification for unequal values' do
-        local do |x|
-          unify x, 1
-          lambda { unify x, by_need { 2 } }.should raise_error(Dataflow::UnificationError)
-        end
-      end
-    end
-  end
-end

data/lib/vendor/dataflow/spec/dataflow_spec.rb

@@ -1,151 +0,0 @@
-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
-
-describe 'Binding a variable that proxies through another' do
-  it 'binds through successfully' do
-    local do |x, y|
-      lambda do
-        unify x, y
-        unify x, 1337
-        x.should == 1337
-        y.should == 1337
-      end.should_not raise_error
-    end
-  end
-end
-
-describe 'Using static/module method' do
-  it 'works like the mixin versions' do
-    Dataflow.local do |big_cat, small_cat|
-      Thread.new { Dataflow.unify big_cat, small_cat.upcase }
-      Dataflow.unify small_cat, 'cat'
-      big_cat.should == 'CAT'
-    end
-  end
-end

data/lib/vendor/dataflow/spec/equality_spec.rb

@@ -1,40 +0,0 @@
-require "#{File.dirname(__FILE__)}/spec_helper"
-
-describe 'Unifying a bound value' do
-  [nil, true, false,
-   :sym, "str", /regex/,
-   3, 2.0,
-   Object.new, Class.new.new,
-   [], {}].each do |type|
-    describe "for #{type.class} instances" do
-      it 'passes unification for an object of equal value' do
-        local do |var, var2|
-          unify var, type
-          var.should == type
-          type.should == var
-          lambda {unify var, type}.should_not raise_error
-
-          unify var2, type
-          var.should == var2
-          var2.should == var
-          lambda {unify var, var2}.should_not raise_error
-        end
-      end
-
-      it 'fails unification for an object of inequal value' do
-        different = Object.new
-        local do |var, var2|
-          unify var, type
-          var.should_not == different
-          different.should_not == var
-          lambda {unify var, different}.should raise_error(Dataflow::UnificationError)
-
-          unify var2, different
-          var.should_not == var2
-          var2.should_not == var
-          lambda {unify var, different}.should raise_error(Dataflow::UnificationError)
-        end
-      end
-    end
-  end
-end

data/lib/vendor/dataflow/spec/flow_spec.rb

@@ -1,25 +0,0 @@
-require "#{File.dirname(__FILE__)}/spec_helper"
-
-describe 'Using flow without a parameter' do
-  it 'works like normal threads' do
-    local do |big_cat, small_cat|
-      flow { unify big_cat, small_cat.upcase }
-      unify small_cat, 'cat'
-      big_cat.should == 'CAT'
-    end
-  end
-end
-
-describe 'Using flow with a parameter' do
-  it 'binds the parameter to the last line of the block' do
-    local do |big_cat, small_cat, output|
-      flow(output) do
-        unify big_cat, small_cat.upcase
-        'returned'
-      end
-      unify small_cat, 'cat'
-      big_cat.should == 'CAT'
-      output.should == 'returned'
-    end
-  end
-end

data/lib/vendor/dataflow/spec/forker_spec.rb

@@ -1,28 +0,0 @@
-require "#{File.dirname(__FILE__)}/spec_helper"
-
-describe 'Setting a customer forker' do
-  before(:all) do
-    @original_forker = Dataflow.forker
-    Dataflow.forker = Class.new do
-      def self.synchronous_forker(&block)
-        block.call
-      end
-    end.method(:synchronous_forker)
-  end
-
-  after(:all) do
-    Dataflow.forker = @original_forker
-  end
-  
-  it 'uses the custom forker in #flow' do
-    local do |my_var|
-      flow(my_var) { 1337 }
-      my_var.should == 1337
-    end
-  end
-
-  it 'uses the custom forker in #need_later' do
-    my_var = need_later { 1337 }
-    my_var.should == 1337
-  end
-end