agent 0.10.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 22c5bf05cd41b0171dfce316431f8c42434fa3c1
-  data.tar.gz: 96b5280262b5c4412fd366b6eb897031fa6fd709
+  metadata.gz: cb98d2b1912834ca7a296fb6dd1895c90c62d371
+  data.tar.gz: ea72c26e2be6e8bbd7ef710a2a2a87e0ef8141c6
 SHA512:
-  metadata.gz: 3aa2fcea9b6cf2e55abd8ff3f3139f12f88e8fae2304bddb4d9076ce2d5ba99959fe64cd60291a24433da577aeea104fa6c4fcf7f1d9d9f1e98c88b8037a5b0f
-  data.tar.gz: dbf9aedd6e99043347dba38415f80d7fa166afa1d36abcea0d3c61964d9b09e53f3b5c681e194836b3e7db390166580a749d801a2318ed5076b95a9c05a92618
+  metadata.gz: c3bcd58b2138db30b0c1f732673b7b9654f90b26358cf89c480efab7aa7ef8e9b5ae876949d726f64c93459cd8b995b35ff5202bf2665be23656632340b64094
+  data.tar.gz: 30116a292e6d8e36894b2da56638bda87a817be19355f4c7ffe0d70a243d3a11c9cc13e913705c4eec067f3a95c75badd62b42279c469874764adef23e20097e

data/Gemfile.lock

@@ -1,21 +1,26 @@
 PATH
   remote: .
   specs:
-    agent (0.9.1)
+    agent (0.10.0)
 
 GEM
   remote: http://rubygems.org/
   specs:
-    diff-lcs (1.1.3)
-    rake (0.9.2.2)
-    rspec (2.9.0)
-      rspec-core (~> 2.9.0)
-      rspec-expectations (~> 2.9.0)
-      rspec-mocks (~> 2.9.0)
-    rspec-core (2.9.0)
-    rspec-expectations (2.9.0)
-      diff-lcs (~> 1.1.3)
-    rspec-mocks (2.9.0)
+    diff-lcs (1.2.5)
+    rake (10.4.2)
+    rspec (3.2.0)
+      rspec-core (~> 3.2.0)
+      rspec-expectations (~> 3.2.0)
+      rspec-mocks (~> 3.2.0)
+    rspec-core (3.2.0)
+      rspec-support (~> 3.2.0)
+    rspec-expectations (3.2.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.2.0)
+    rspec-mocks (3.2.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.2.0)
+    rspec-support (3.2.1)
 
 PLATFORMS
   java

data/lib/agent/channel.rb

@@ -61,8 +61,10 @@ module Agent
     def receive(options={})
       check_direction(:receive)
       q = queue
-      return [nil, false] unless q
-      q.pop(options)
+      return q.pop(options) if q
+      pop = Pop.new(options)
+      pop.close
+      [pop.object, false]
     end
     alias :pop  :receive
 

data/lib/agent/version.rb

@@ -1,3 +1,3 @@
 module Agent
-  VERSION = "0.10.0"
+  VERSION = "0.11.0"
 end

data/spec/blocking_once_spec.rb

@@ -13,8 +13,8 @@ describe Agent::BlockingOnce do
       r << 1
     end
 
-    r.size.should == 1
-    r.first.should == 1
+    expect(r.size).to eq(1)
+    expect(r.first).to eq(1)
   end
 
   it "should only execute the first block passed to it" do
@@ -28,8 +28,8 @@ describe Agent::BlockingOnce do
       r << 2
     end
 
-    r.size.should == 1
-    r.first.should == 1
+    expect(r.size).to eq(1)
+    expect(r.first).to eq(1)
   end
 
   it "should return the value returned from the block" do
@@ -37,18 +37,18 @@ describe Agent::BlockingOnce do
       1
     end
 
-    value.should == 1
+    expect(value).to eq(1)
   end
 
   it "should return nil for value and an error if it has already been used" do
     value, error = @blocking_once.perform{ 1 }
-    value.should == 1
-    error.should be_nil
+    expect(value).to eq(1)
+    expect(error).to be_nil
 
     value, error = @blocking_once.perform{ 2 }
-    value.should be_nil
-    error.should_not be_nil
-    error.should be_message("already performed")
+    expect(value).to be_nil
+    expect(error).not_to be_nil
+    expect(error).to be_message("already performed")
   end
 
   it "should roll back and allow the block to be executed again" do
@@ -78,7 +78,7 @@ describe Agent::BlockingOnce do
     finished_channel.close
 
     # Three sleeps at 0.1 == 0.3, so if it's less than 0.3...
-    (Time.now.to_f - s).should < 0.3
+    expect(Time.now.to_f - s).to be < 0.3
   end
 
   it "should have minimal contention between threads when they contend for position" do
@@ -111,9 +111,9 @@ describe Agent::BlockingOnce do
     # wait for the finished channel to be completed
     2.times{ finished_channel.receive }
 
-    r.size.should == 1
+    expect(r.size).to eq(1)
     # Onlt the first sleep should be performed, so things should quickly
-    (Time.now.to_f - s).should be_within(0.05).of(0.15)
+    expect(Time.now.to_f - s).to be_within(0.05).of(0.15)
 
     waiting_channel.close
     finished_channel.close

data/spec/channel_spec.rb

@@ -5,13 +5,13 @@ describe Agent::Channel do
   context "naming" do
     it "should not be required" do
       c = nil
-      lambda { c = channel!(String) }.should_not raise_error
+      expect { c = channel!(String) }.not_to raise_error
       c.close
     end
 
     it "be able to be set" do
       c = channel!(String, :name => "gibberish")
-      c.name.should == "gibberish"
+      expect(c.name).to eq("gibberish")
       c.close
     end
   end
@@ -24,14 +24,14 @@ describe Agent::Channel do
     it "should support send only" do
       c = channel!(String, 3, :direction => :send)
 
-      lambda { c << "hello"   }.should_not raise_error
-      lambda { c.push "hello" }.should_not raise_error
-      lambda { c.send "hello" }.should_not raise_error
+      expect { c << "hello"   }.not_to raise_error
+      expect { c.push "hello" }.not_to raise_error
+      expect { c.send "hello" }.not_to raise_error
 
-      c.direction.should == :send
+      expect(c.direction).to eq(:send)
 
-      lambda { c.pop }.should raise_error Agent::Errors::InvalidDirection
-      lambda { c.receive }.should raise_error Agent::Errors::InvalidDirection
+      expect { c.pop }.to raise_error Agent::Errors::InvalidDirection
+      expect { c.receive }.to raise_error Agent::Errors::InvalidDirection
 
       c.close
     end
@@ -39,11 +39,11 @@ describe Agent::Channel do
     it "should support receive only" do
       c = channel!(String, :direction => :receive)
 
-      lambda { c << "hello"   }.should raise_error Agent::Errors::InvalidDirection
-      lambda { c.push "hello" }.should raise_error Agent::Errors::InvalidDirection
-      lambda { c.send "hello" }.should raise_error Agent::Errors::InvalidDirection
+      expect { c << "hello"   }.to raise_error Agent::Errors::InvalidDirection
+      expect { c.push "hello" }.to raise_error Agent::Errors::InvalidDirection
+      expect { c.send "hello" }.to raise_error Agent::Errors::InvalidDirection
 
-      c.direction.should == :receive
+      expect(c.direction).to eq(:receive)
 
       # timeout blocking receive calls
       timed_out = false
@@ -51,29 +51,29 @@ describe Agent::Channel do
         s.case(c, :receive)
         s.timeout(0.1){ timed_out = true }
       end
-      timed_out.should == true
+      expect(timed_out).to eq(true)
       c.close
     end
 
     it "should default to bi-directional communication" do
       c = channel!(String, 1)
-      lambda { c.send "hello" }.should_not raise_error
-      lambda { c.receive }.should_not raise_error
+      expect { c.send "hello" }.not_to raise_error
+      expect { c.receive }.not_to raise_error
 
-      c.direction.should == :bidirectional
+      expect(c.direction).to eq(:bidirectional)
     end
 
     it "should be able to be dup'd as a uni-directional channel" do
       c = channel!(String, 1)
 
       send_only = c.as_send_only
-      send_only.direction.should == :send
+      expect(send_only.direction).to eq(:send)
 
       receive_only = c.as_receive_only
-      receive_only.direction.should == :receive
+      expect(receive_only.direction).to eq(:receive)
 
       send_only.send("nifty")
-      receive_only.receive[0].should == "nifty"
+      expect(receive_only.receive[0]).to eq("nifty")
     end
   end
 
@@ -83,35 +83,35 @@ describe Agent::Channel do
     end
 
     it "not raise an error the first time it is called" do
-      lambda { @c.close }.should_not raise_error
-      @c.closed?.should be_true
+      expect { @c.close }.not_to raise_error
+      expect(@c).to be_closed
     end
 
     it "should raise an error the second time it is called" do
       @c.close
-      lambda { @c.close }.should raise_error(Agent::Errors::ChannelClosed)
+      expect { @c.close }.to raise_error(Agent::Errors::ChannelClosed)
     end
 
     it "should respond to closed?" do
-      @c.closed?.should be_false
+      expect(@c).not_to be_closed
       @c.close
-      @c.closed?.should be_true
+      expect(@c).to be_closed
     end
 
     it "should return that a receive was a failure when a channel is closed while being read from" do
       go!{ sleep 0.01; @c.close }
       _, ok = @c.receive
-      ok.should be_false
+      expect(ok).to eq(false)
     end
 
     it "should raise an error when sending to a channel that has already been closed" do
       @c.close
-      lambda { @c.send("a") }.should raise_error(Agent::Errors::ChannelClosed)
+      expect { @c.send("a") }.to raise_error(Agent::Errors::ChannelClosed)
     end
 
     it "should return [nil, false] when receiving from a channel that has already been closed" do
       @c.close
-      @c.receive.should == [nil, false]
+      expect(@c.receive).to eq([nil, false])
     end
   end
 
@@ -121,28 +121,28 @@ describe Agent::Channel do
     end
 
     it "should deadlock on single thread", :vm => :ruby do
-      lambda { @c.receive }.should raise_error
+      expect { @c.receive }.to raise_error
     end
 
     it "should not deadlock with multiple threads" do
       go!{ sleep(0.1); @c.push "hi" }
-      lambda { @c.receive }.should_not raise_error
+      expect { @c.receive }.not_to raise_error
     end
   end
 
   context "typed" do
     it "should create a typed channel" do
-      lambda { channel! }.should raise_error Agent::Errors::Untyped
+      expect { channel! }.to raise_error Agent::Errors::Untyped
       c = nil
-      lambda { c = channel!(Integer) }.should_not raise_error
+      expect { c = channel!(Integer) }.not_to raise_error
       c.close
     end
 
     it "should reject messages of invalid type" do
       c = channel!(String)
       go!{ c.receive }
-      lambda { c.send 1 }.should raise_error(Agent::Errors::InvalidType)
-      lambda { c.send "hello" }.should_not raise_error
+      expect { c.send 1 }.to raise_error(Agent::Errors::InvalidType)
+      expect { c.send "hello" }.not_to raise_error
       c.close
     end
   end
@@ -158,9 +158,9 @@ describe Agent::Channel do
       c = channel!(String)
 
       go!{ sleep(0.15); c.send("hello") }
-      c.receive[0].should == "hello"
+      expect(c.receive[0]).to eq("hello")
 
-      (Time.now - n).should be_within(0.05).of(0.15)
+      expect(Time.now - n).to be_within(0.05).of(0.15)
     end
 
     it "should support buffered" do
@@ -175,8 +175,8 @@ describe Agent::Channel do
         s.timeout(0.1)
       end
 
-      c.receive[0].should == "hello 1"
-      c.receive[0].should == "hello 2"
+      expect(c.receive[0]).to eq("hello 1")
+      expect(c.receive[0]).to eq("hello 2")
       select! do |s|
         s.case(c, :receive){|v| r.push(v) }
         s.timeout(0.1)
@@ -201,15 +201,15 @@ describe Agent::Channel do
     # - http://golang.org/doc/effective_go.html#chan_of_chan
 
     it "should be a first class, serializable value" do
-      lambda { Marshal.dump(@c) }.should_not raise_error
-      lambda { Marshal.load(Marshal.dump(@c)).is_a?(Agent::Channel) }.should_not raise_error
+      expect { Marshal.dump(@c) }.not_to raise_error
+      expect { Marshal.load(Marshal.dump(@c)).is_a?(Agent::Channel) }.not_to raise_error
     end
 
     it "should be able to pass as a value on a different channel" do
       @c.send "hello"
 
       cm = Marshal.load(Marshal.dump(@c))
-      cm.receive[0].should == "hello"
+      expect(cm.receive[0]).to eq("hello")
     end
   end
 
@@ -219,21 +219,21 @@ describe Agent::Channel do
       string = "foo"
       c.send(string)
       string_copy = c.receive[0]
-      string_copy.should == string
-      string_copy.object_id.should_not == string.object_id
+      expect(string_copy).to eq(string)
+      expect(string_copy.object_id).not_to eq(string.object_id)
     end
 
     it "skips marshaling when configured to" do
       c = channel!(String, 1, :skip_marshal => true)
       string = "foo"
       c.send(string)
-      c.receive[0].object_id.should == string.object_id
+      expect(c.receive[0].object_id).to eq(string.object_id)
     end
 
     it "skips marshaling for channels by default" do
       c = channel!(Agent::Channel, 1)
       c.send(c)
-      c.receive[0].object_id.should == c.object_id
+      expect(c.receive[0].object_id).to eq(c.object_id)
     end
   end
 end

data/spec/error_spec.rb

@@ -6,10 +6,10 @@ describe Agent::Error do
   end
 
   it "should create an error" do
-    @error.to_s.should == "msg"
+    expect(@error.to_s).to eq("msg")
   end
 
   it "should match the error's message" do
-    @error.should be_message("msg")
+    expect(@error).to be_message("msg")
   end
 end

data/spec/examples/channel_of_channels_spec.rb

@@ -10,7 +10,7 @@ describe "Channel of Channels" do
         res = Request.new(n, channel!(Integer))
 
         reqs << res
-        res.resultChan.receive[0].should == n+1
+        expect(res.resultChan.receive[0]).to eq(n+1)
         res.resultChan.close
       end
     end
@@ -52,7 +52,7 @@ describe "Channel of Channels" do
         res = Request.new(n, channel!(Integer))
 
         reqs << res
-        res.resultChan.receive[0].should == n+1
+        expect(res.resultChan.receive[0]).to eq(n+1)
         res.resultChan.close
       end
     end

data/spec/examples/producer_consumer_spec.rb

@@ -66,8 +66,8 @@ describe "Producer-Consumer" do
     go!(c, 3, s, &consumer)
 
     messages = [s.pop[0], s.pop[0]]
-    messages.should include("producer finished")
-    messages.should include("consumer finished")
+    expect(messages).to include("producer finished")
+    expect(messages).to include("consumer finished")
 
     c.close
     s.close
@@ -85,9 +85,9 @@ describe "Producer-Consumer" do
 
     go!(g, &producer)
 
-    c.receive[0].should == 1
-    c.receive[0].should == 2
-    c.receive[0].should == 3
+    expect(c.receive[0]).to eq(1)
+    expect(c.receive[0]).to eq(2)
+    expect(c.receive[0]).to eq(3)
     c.close
   end
 end

data/spec/examples/sieve_spec.rb

@@ -69,7 +69,7 @@ describe "sieve of Eratosthenes" do
       end
     end
 
-    result.should == [2,3,5,7,11,13,17,19]
+    expect(result).to eq([2,3,5,7,11,13,17,19])
     channels.each(&:close)
   end
 
@@ -143,7 +143,7 @@ describe "sieve of Eratosthenes" do
       end
     end
 
-    result.should == [2,3,5,7,11,13,17,19]
+    expect(result).to eq([2,3,5,7,11,13,17,19])
     channels.each(&:close)
   end
 end

data/spec/go_spec.rb

@@ -2,16 +2,16 @@ require "spec_helper"
 
 describe "Agent.go!" do
   it "should launch a 'goroutine' that is actually a thread" do
-    Agent.go!{}.should be_a(Thread)
+    expect(Agent.go!{}).to be_a(Thread)
   end
 
   it "should pass into the thread any arguments passed to it" do
     b = nil
     Agent.go!(1){|a| b = a }.join
-    b.should == 1
+    expect(b).to eq(1)
   end
 
   it "should raise an error if no block is passed" do
-    lambda{ Agent.go! }.should raise_error(Agent::Errors::BlockMissing)
+    expect{ Agent.go! }.to raise_error(Agent::Errors::BlockMissing)
   end
 end