fraggle 4.0.0.pre.3 → 4.0.0

data/README.md

@@ -31,78 +31,78 @@ addresses with IP 127.0.0.1 and ports 8046, 8041, 8042, 8043.
       # other doozers until one accepts or it runs out of options; A NoAddrs
       # exception will be raised if that later happens.
 
-      c = Fraggle.connect
-
-      c.rev do |v|
-        c.get(v, "/foo") do |e, err|
-          if err
-            err.code   # => nil
-            err.detail # => nil
-          else
-            e.value    # => nil
-            e.rev      # => 0
-            e.missing? # => true
-          end
-
-          p [:get, e, err]
+      Fraggle.connect do |c, err|
+        if err
+          raise err.message
         end
 
-        ## Obtain the current revision the store is at and watch from then on for
-        ## any SET or DEL to /foo.
-        c.wait(v, "/foo") do |e, err|
-          # The event has:
-          # ------------------------
-          if err
-            err.code   # => nil
-            err.detail # => nil
-          else
-            e.path       # => "/foo"
-            e.value      # => "zomg!"
-            e.rev        # => 123
-            e.set?       # => true
-            e.del?       # => false
+        c.rev do |v|
+          c.get(v, "/foo") do |e, err|
+            if err
+              err.code   # => nil
+              err.detail # => nil
+            else
+              e.value    # => nil
+              e.rev      # => 0
+              e.missing? # => true
+            end
+
+            p [:get, e, err]
           end
 
-          p [:wait, e, err]
-        end
-      end
-
-      ## Setting a key (this will trigger the watch above)
-      f = Proc.new do |e, err|
-        p [:e, e, err]
-
-        if err && err.disconnected?
-          # Fraggle (for now) does not attempt a non-idempotent request.  This means
-          # Fraggle will hand off the error to the user if there is a SET or DEL
-          # with rev 0 (missing) and delete it during the time we may be
-          # disconnected.
-          #
-          # In this scenario, there are no other clients that can exist that will
-          # attempt to set this "lock" if it's missing then delete it.  It is safe
-          # for us to resend the request if we were disconnected from the previous
-          # server before a response.
-          #
-          # See High-Availability in the README for more information about this.
-          #
-          c.set(0, "/foo", "zomg!", &f)
-          next
+          ## Obtain the current revision the store is at and watch from then on for
+          ## any SET or DEL to /foo.
+          c.wait(v, "/foo") do |e, err|
+            # The event has:
+            # ------------------------
+            if err
+              err.code   # => nil
+              err.detail # => nil
+            else
+              e.path       # => "/foo"
+              e.value      # => "zomg!"
+              e.rev        # => 123
+              e.set?       # => true
+              e.del?       # => false
+            end
+
+            p [:wait, e, err]
+          end
         end
 
-        # Success!
-        if err
-          case err.code
+        ## Setting a key (this will trigger the watch above)
+        f = Proc.new do |e, err|
+          p [:e, e, err]
+
+          # This case statement is undesirable.  We're working
+          # on better error handling.
+          case (err && err.code rescue err)
+          when Fraggle::Connection::DisconnectedError
+            # Fraggle (for now) does not attempt a non-idempotent request.  This means
+            # Fraggle will hand off the error to the user if there is a SET or DEL
+            # with rev 0 (missing) and delete it during the time we may be
+            # disconnected.
+            #
+            # In this scenario, there are no other clients that can exist that will
+            # attempt to set this "lock" if it's missing then delete it.  It is safe
+            # for us to resend the request if we were disconnected from the previous
+            # server before a response.
+            #
+            # See High-Availability in the README for more information about this.
+            #
+            c.set(0, "/foo", "zomg!", &f)
           when Fraggle::REV_MISMATCH
             p :not_it
           when nil
-            # Success!
+              # Success!
             p [:it, e]
           else
-            fail "something bad happened: " + e.inspect
+            fail "something bad happened: " + err.inspect
           end
         end
-      end
 
-      c.set(0, "/foo", "zomg!", &f)
+        c.set(0, "/foo", "zomg!", &f)
+      end
     end
 
 ## Consistency
@@ -128,22 +128,39 @@ stores history as far back as it is configured to hold it.  The default is
 
 ## High Availability
 
-  Fraggle has mechanisms to gracefully deal with connection loss.  They are:
+Fraggle has mechanisms to gracefully deal with connection loss.  They are:
 
 *Resend / Connection loss*
 
-  When a connection is lost and Fraggle successfully reconnects to another
-  Doozer node, Fraggle will resend most pending requests to the new connection.
-  This means you will not miss events; Even events that happened while you were
-  disconnected!  All read commands will pick up where they left off.  This is
-  valuable to understand because it means you don't need to code for failure on
-  reads; Fraggle gracefully handles it for you.
-
-  Write commands will be resent if their `rev` is greater than 0.  These are
-  idempotent requests.  A rev of 0 will cause that request's error
-  callback to be invoked with a Fraggle::Connection::Disconnected response.
-  You will have to handle these yourself because Fraggle cannot know whether or
-  not it's safe to retry on your behalf.
+When a connection is lost and Fraggle successfully reconnects to another
+Doozer node, Fraggle will resend most pending requests to the new connection.
+This means you will not miss events; Even events that happened while you were
+disconnected!  All read commands will pick up where they left off.  This is
+valuable to understand because it means you don't need to code for failure on
+reads; Fraggle gracefully handles it for you.
+
+Write commands will be resent if their `rev` is greater than 0.  These are
+idempotent requests.  A rev of 0 will cause that request's error
+callback to be invoked with a Fraggle::Connection::Disconnected response.
+You will have to handle these yourself because Fraggle cannot know whether or
+not it's safe to retry on your behalf.
+
+**attempt**
+
+Before fraggle will attempt a new address after connection loss, it calls the
+block given to `Fraggle::Client#attempt`.  If the block returns `false`,
+Fraggle will not attempt that address or anymore.  The block is called with on
+parameter `addr`, which is the address being attempted.
+
+  Example:
+
+    c = Fraggle.connect
+
+    c.attempt do |addr|
+      addr =~ /^127\.*$/ # don't connect to localhost doozers
+    end
+
+  The default `attempt` is `Proc.new {|_| true }`
 
 ## Commands
 

data/bench/gs.rb

@@ -10,7 +10,7 @@ require "statsample"
 
 $stdout.sync = true
 
-abort("read <[get|set]> <total> <width> [verbose]") if (ARGV.size < 2)
+abort("gs <[get|set]> <total> <width> [verbose]") if (ARGV.size < 2)
 op = ARGV.shift.to_sym
 total = ARGV.shift.to_i
 width = ARGV.shift.to_i
@@ -19,59 +19,69 @@ latencies = []
 sent_at = nil
 
 EM.run do
-  client = Fraggle.connect
-  sent = 0
-  received = 0
-  start = Time.now
+  Fraggle.connect do |c, err|
+    if err
+      raise err.message
+    end
 
-  f = Proc.new do |r|
-    received_at = Time.now
-    received +=1
-    latency = received_at - sent_at
+    sent = 0
+    received = 0
+    start = Time.now
 
-    latencies << latency
-    if verbose
-      $stdout.puts("received=#{received} ok=#{r.ok?} rev=#{r.rev} latency=#{latency}")
-    elsif (received % 10 == 0)
-      $stdout.print(".")
-    end
-    if (received == total)
-      EM.stop
-      elapsed = Time.now - start
-      vector = latencies.to_scale
-      $stdout.puts
-      $stdout.puts("total=#{total}")
-      $stdout.puts("elapsed=#{elapsed}")
-      $stdout.puts("rate=#{total / elapsed}")
-      $stdout.puts("mean=#{vector.mean}")
-      $stdout.puts("sd=#{vector.sd}")
-      $stdout.puts("perc90=#{vector.percentil(90)}")
-      $stdout.puts("perc99=#{vector.percentil(99)}")
-      $stdout.puts("max=#{vector.max}")
-    end
-  end
+    f = Proc.new do |r, err|
+      if err
+        p [:err, err]
+        next
+      end
 
-  tick = Proc.new do
-    if (sent == total)
-      # done sending
-    elsif ((sent - received) < width)
-      # pipe open
-      sent_at = Time.now
-      sent += 1
+      received_at = Time.now
+      received +=1
+      latency = received_at - sent_at
+
+      latencies << latency
       if verbose
-        $stdout.puts("sent=#{sent}")
+        $stdout.puts("received=#{received} ok=#{r.ok?} rev=#{r.rev} latency=#{latency}")
+      elsif (received % 10 == 0)
+        $stdout.print(".")
+      end
+      if (received == total)
+        EM.stop
+        elapsed = Time.now - start
+        vector = latencies.to_scale
+        $stdout.puts
+        $stdout.puts("total=#{total}")
+        $stdout.puts("elapsed=#{elapsed}")
+        $stdout.puts("rate=#{total / elapsed}")
+        $stdout.puts("mean=#{vector.mean}")
+        $stdout.puts("sd=#{vector.sd}")
+        $stdout.puts("perc90=#{vector.percentil(90)}")
+        $stdout.puts("perc99=#{vector.percentil(99)}")
+        $stdout.puts("max=#{vector.max}")
       end
+    end
+
+    tick = Proc.new do
+      if (sent == total)
+        # done sending
+      elsif ((sent - received) < width)
+        # pipe open
+        sent_at = Time.now
+        sent += 1
+        if verbose
+          $stdout.puts("sent=#{sent}")
+        end
 
-      case op
-      when :get
-        client.get(nil, "/processes/#{sent}", &f)
-      when :set
-        client.set(Fraggle::Clobber, "/processes/#{sent}", "1", &f)
+        case op
+        when :get
+          c.get(nil, "/processes/#{sent}", &f)
+        when :set
+          c.set(Fraggle::Clobber, "/processes/#{sent}", "1", &f)
+        end
+      else
+        # pipe closed
       end
-    else
-      # pipe closed
+      EM.next_tick(&tick)
     end
-    EM.next_tick(&tick)
+    tick.call
   end
-  tick.call
 end

data/example/getdir.rb

@@ -2,28 +2,28 @@ require 'rubygems'
 require 'fraggle'
 
 EM.run do
-  c = Fraggle.connect
-
-  c.rev do |v|
-    # Valid
-    req = c.getdir(v, "/ctl/node") do |ents, err|
-      if err
-        p [:err, err]
-      else
-        ents.each do |e|
-          puts File.join(req.path, e.path)
+  c = Fraggle.connect do |c, err|
+    c.rev do |v|
+      # Valid
+      req = c.getdir(v, "/ctl/node") do |ents, err|
+        if err
+          p [:err, err]
+        else
+          ents.each do |e|
+            puts File.join(req.path, e.path)
+          end
         end
       end
-    end
 
-    # Limit 0 return nothing
-    c.getdir(v, "/ctl/node", 0, 0) do |ents, err|
-      p [:ret, ents, err]
-    end
+      # Limit 0 return nothing
+      c.getdir(v, "/ctl/node", 0, 0) do |ents, err|
+        p [:ret, ents, err]
+      end
 
-    # Error
-    c.getdir(v, "/nothere") do |ents, err|
-      p [:ret, ents, err]
+      # Error
+      c.getdir(v, "/nothere") do |ents, err|
+        p [:ret, ents, err]
+      end
     end
   end
 end

data/example/readme.rb

@@ -7,76 +7,76 @@ EM.run do
   # other doozers until one accepts or it runs out of options; A NoAddrs
   # exception will be raised if that later happens.
 
-  c = Fraggle.connect
+  Fraggle.connect do |c, err|
+    if err
+      raise err.message
+    end
 
-  c.rev do |v|
-    c.get(v, "/foo") do |e, err|
-      if err
-        err.code   # => nil
-        err.detail # => nil
-      else
-        e.value    # => nil
-        e.rev      # => 0
-        e.missing? # => true
+    c.rev do |v|
+      c.get(v, "/foo") do |e, err|
+        if err
+          err.code   # => nil
+          err.detail # => nil
+        else
+          e.value    # => nil
+          e.rev      # => 0
+          e.missing? # => true
+        end
+
+        p [:get, e, err]
       end
 
-      p [:get, e, err]
-    end
+      ## Obtain the current revision the store is at and watch from then on for
+      ## any SET or DEL to /foo.
+      c.wait(v, "/foo") do |e, err|
+        # The event has:
+        # ------------------------
+        if err
+          err.code   # => nil
+          err.detail # => nil
+        else
+          e.path       # => "/foo"
+          e.value      # => "zomg!"
+          e.rev        # => 123
+          e.set?       # => true
+          e.del?       # => false
+        end
 
-    ## Obtain the current revision the store is at and watch from then on for
-    ## any SET or DEL to /foo.
-    c.wait(v, "/foo") do |e, err|
-      # The event has:
-      # ------------------------
-      if err
-        err.code   # => nil
-        err.detail # => nil
-      else
-        e.path       # => "/foo"
-        e.value      # => "zomg!"
-        e.rev        # => 123
-        e.set?       # => true
-        e.del?       # => false
+        p [:wait, e, err]
       end
-
-      p [:wait, e, err]
     end
-  end
-
-  ## Setting a key (this will trigger the watch above)
-  f = Proc.new do |e, err|
-    p [:e, e, err]
 
-    if err && err.disconnected?
-      # Fraggle (for now) does not attempt a non-idempotent request.  This means
-      # Fraggle will hand off the error to the user if there is a SET or DEL
-      # with rev 0 (missing) and delete it during the time we may be
-      # disconnected.
-      #
-      # In this scenario, there are no other clients that can exist that will
-      # attempt to set this "lock" if it's missing then delete it.  It is safe
-      # for us to resend the request if we were disconnected from the previous
-      # server before a response.
-      #
-      # See High-Availability in the README for more information about this.
-      #
-      c.set(0, "/foo", "zomg!", &f)
-      next
-    end
+    ## Setting a key (this will trigger the watch above)
+    f = Proc.new do |e, err|
+      p [:e, e, err]
 
-    # Success!
-    if err
-      case err.code
+      # This case statement is undesirable.  We're working
+      # on better error handling.
+      case (err && err.code rescue err)
+      when Fraggle::Connection::DisconnectedError
+        # Fraggle (for now) does not attempt a non-idempotent request.  This means
+        # Fraggle will hand off the error to the user if there is a SET or DEL
+        # with rev 0 (missing) and delete it during the time we may be
+        # disconnected.
+        #
+        # In this scenario, there are no other clients that can exist that will
+        # attempt to set this "lock" if it's missing then delete it.  It is safe
+        # for us to resend the request if we were disconnected from the previous
+        # server before a response.
+        #
+        # See High-Availability in the README for more information about this.
+        #
+        c.set(0, "/foo", "zomg!", &f)
       when Fraggle::REV_MISMATCH
         p :not_it
       when nil
-        # Success!
+          # Success!
         p [:it, e]
       else
-        fail "something bad happened: " + e.inspect
+        fail "something bad happened: " + err.inspect
       end
     end
-  end
 
-  c.set(0, "/foo", "zomg!", &f)
+    c.set(0, "/foo", "zomg!", &f)
+  end
 end

data/example/walk.rb

@@ -2,28 +2,32 @@ require 'rubygems'
 require 'fraggle'
 
 EM.run do
-  c = Fraggle.connect
+  c = Fraggle.connect do |c, err|
+    if err
+      fail err.message
+    end
 
-  c.rev do |v|
-    # Valid
-    req = c.walk(v, "/ctl/node/**") do |ents, err|
-      if err
-        p [:err, err]
-      else
-        ents.each do |e|
-          puts File.join(req.path, e.path) + "=" + e.value
+    c.rev do |v|
+      # Valid
+      req = c.walk(v, "/ctl/node/**") do |ents, err|
+        if err
+          p [:err, err]
+        else
+          ents.each do |e|
+            puts File.join(req.path, e.path) + "=" + e.value
+          end
         end
       end
-    end
 
-    # Limit 0 return nothing
-    c.walk(v, "/ctl/node/**", 0, 0) do |ents, err|
-      p [:nothing, ents, err]
-    end
+      # Limit 0 return nothing
+      c.walk(v, "/ctl/node/**", 0, 0) do |ents, err|
+        p [:nothing, ents, err]
+      end
 
-    # Error
-    c.walk(v, "/nothere") do |ents, err|
-      p [:nothere, ents, err]
+      # Error
+      c.walk(v, "/nothere") do |ents, err|
+        p [:nothere, ents, err]
+      end
     end
   end
 end

data/example/watch.rb

@@ -2,11 +2,15 @@ require 'rubygems'
 require 'fraggle'
 
 EM.run do
-  c = Fraggle.connect
+  c = Fraggle.connect do |c, err|
+    if err
+      fail err.message
+    end
 
-  c.rev do |v|
-    c.watch(v, "/ctl/node/**") do |e, err|
-      p [e, err]
+    c.rev do |v|
+      c.watch(v, "/ctl/node/**") do |e, err|
+        p [e, err]
+      end
     end
   end
 end

data/lib/fraggle.rb

@@ -12,10 +12,10 @@ module Fraggle
     "ca=127.0.0.1:8043"
   ].join("&")
 
-  def self.connect(uri=nil)
+  def self.connect(uri=nil, &blk)
     uri = uri || ENV["DOOZER_URI"] || DEFAULT_URI
 
-    addrs = uri(uri)
+    addrs, sk = uri(uri)
 
     if addrs.length == 0
       raise ArgumentError, "there were no addrs supplied in the uri (#{uri.inspect})"
@@ -25,22 +25,35 @@ module Fraggle
     host, port = addr.split(":")
 
     cn = EM.connect(host, port, Connection, addr)
-    Client.new(cn, addrs)
+    c  = Client.new(cn, addrs)
+    c.access(sk) do |_, err|
+      if err
+        blk.call(nil, err)
+      else
+        blk.call(c, nil)
+      end
+    end
   end
 
   def self.uri(u)
+    addrs, sk = [], ""
+
     if u =~ /^doozer:\?(.*)$/
       parts = $1.split("&")
-      parts.inject([]) do |m, pt|
+      parts.each do |pt|
         k, v = pt.split("=")
-        if k == "ca"
-          m << v
+        case k
+        when "ca"
+          addrs << v
+        when "sk"
+          sk = v
         end
-        m
       end
     else
       raise ArgumentError, "invalid doozer uri"
     end
+
+    [addrs, sk]
   end
 
 end

data/lib/fraggle/client.rb

@@ -7,13 +7,11 @@ module Fraggle
 
     MaxInt64 = 1<<63 - 1
 
-    class NoMoreAddrs < StandardError
-    end
-
     attr_reader :cn, :addrs
 
     def initialize(cn, addrs)
       @cn, @addrs = cn, addrs
+      @attempt = Proc.new {|_| true }
     end
 
     def addr
@@ -187,11 +185,18 @@ module Fraggle
       end
     end
 
+    ##
+    # Setting `blk` will cause a client to call it before attempting to reconnect.
+    # `blk` is called with one parameter `addr`, which is the address that will be
+    # for reconnect.
+    def attempt(&blk)
+      @attempt = blk
+    end
+
     def reconnect!
-      if addr = @addrs.slice!(rand(@addrs.length))
+      addr = @addrs.slice(rand(@addrs.length))
+      if @attempt.call(addr)
         reconnect(addr)
-      else
-        raise NoMoreAddrs
       end
     end
 

data/lib/fraggle/version.rb

@@ -1,3 +1,3 @@
 module Fraggle
-  VERSION = "4.0.0.pre.3"
+  VERSION = "4.0.0"
 end

data/test/fraggle_client_test.rb

@@ -31,7 +31,7 @@ class FraggleClientTest < Test::Unit::TestCase
     res = reply(req.tag, :err_code => E::OTHER)
     c.cn.receive_response(res)
 
-    assert_equal [[nil, C::ResponseError.new(res)]], log.valid
+    assert_equal [[nil, C::ResponseError.new(res)]], log
   end
 
   def test_reconnect_without_pending_requests
@@ -50,7 +50,7 @@ class FraggleClientTest < Test::Unit::TestCase
     assert exp.include?(c.cn.addr), "#{c.cn.addr.inspect} not in #{exp.inspect}"
 
     # If the client can handle an error, it should not mention it to the user.
-    assert_equal [[nil, C::DisconnectedError.new("127.0.0.1:0")]], log.valid
+    assert_equal [[nil, C::DisconnectedError.new("127.0.0.1:0")]], log
   end
 
   def test_reconnect_with_pending_request
@@ -68,7 +68,7 @@ class FraggleClientTest < Test::Unit::TestCase
 
     assert exp.include?(c.cn.addr), "#{c.cn.addr.inspect} not in #{exp.inspect}"
 
-    assert_equal [[nil, C::DisconnectedError.new("127.0.0.1:0")]], log.valid
+    assert_equal [[nil, C::DisconnectedError.new("127.0.0.1:0")]], log
   end
 
   def test_reconnect_with_multiple_pending_requests
@@ -89,12 +89,9 @@ class FraggleClientTest < Test::Unit::TestCase
 
     assert exp.include?(c.cn.addr), "#{c.cn.addr.inspect} not in #{exp.inspect}"
 
-    # Reconnect should only be called once.
-    assert_equal exp.length - 1, c.addrs.length
-
     # If the client can handle an error, it should not mention it to the user.
-    assert_equal [[nil, C::DisconnectedError.new("127.0.0.1:0")]], loga.valid
-    assert_equal [[nil, C::DisconnectedError.new("127.0.0.1:0")]], logb.valid
+    assert_equal [[nil, C::DisconnectedError.new("127.0.0.1:0")]], loga
+    assert_equal [[nil, C::DisconnectedError.new("127.0.0.1:0")]], logb
   end
 
   def test_resend_pending_requests
@@ -117,7 +114,7 @@ class FraggleClientTest < Test::Unit::TestCase
 
     assert_equal [one], c.cn.sent
 
-    assert_equal [[nil, C::DisconnectedError.new("127.0.0.1:0")]], zlog.valid
+    assert_equal [[nil, C::DisconnectedError.new("127.0.0.1:0")]], zlog
   end
 
   def test_idemp_unhandled_error
@@ -127,7 +124,7 @@ class FraggleClientTest < Test::Unit::TestCase
     res = reply(req.tag, :err_code => E::OTHER)
     c.cn.receive_response(res)
 
-    assert_equal [[nil, C::ResponseError.new(res)]], log.valid
+    assert_equal [[nil, C::ResponseError.new(res)]], log
   end
 
   ###

data/test/fraggle_test.rb

@@ -3,9 +3,10 @@ require 'fraggle'
 class FraggleTest < Test::Unit::TestCase
 
   def test_uri
-    uri = "doozer:?ca=1:1&ca=2:2&ca=3:3&ignore=this"
-    addrs = Fraggle.uri(uri)
+    uri = "doozer:?ca=1:1&ca=2:2&ca=3:3&ignore=this&sk=foo"
+    addrs, sk = Fraggle.uri(uri)
     assert_equal ["1:1", "2:2", "3:3"], addrs
+    assert_equal "foo", sk
   end
 
 end

data/test/fraggle_transaction_test.rb

@@ -18,7 +18,7 @@ class FraggleTransactionTest < Test::Unit::TestCase
     assert_equal 2, cn.send_request(req, _).tag
   end
 
-  def test_valid
+  def test
     req, log = request(V::REV)
 
     cn.send_request(req, log)
@@ -26,7 +26,7 @@ class FraggleTransactionTest < Test::Unit::TestCase
     res = reply(req.tag)
     cn.receive_response(res)
 
-    assert_equal [[res, nil]], log.valid
+    assert_equal [[res, nil]], log
   end
 
   def test_error
@@ -38,10 +38,10 @@ class FraggleTransactionTest < Test::Unit::TestCase
     cn.receive_response(res)
 
     err = C::ResponseError.new(res)
-    assert_equal [[nil, err]], log.valid
+    assert_equal [[nil, err]], log
   end
 
-  def test_invalid_tag
+  def test_i_tag
     res = reply(0, :err_code => E::OTHER)
 
     assert_nothing_raised do
@@ -60,7 +60,7 @@ class FraggleTransactionTest < Test::Unit::TestCase
     # This should be ignored
     cn.receive_response(res)
 
-    assert_equal [[res, nil]], log.valid
+    assert_equal [[res, nil]], log
   end
 
   def test_error_deletes_callback
@@ -74,7 +74,7 @@ class FraggleTransactionTest < Test::Unit::TestCase
     # This should be ignored
     cn.receive_response(res)
 
-    assert_equal [[nil, C::ResponseError.new(res)]], log.valid
+    assert_equal [[nil, C::ResponseError.new(res)]], log
   end
 
   def test_cannot_reuse_sent_request
@@ -96,9 +96,9 @@ class FraggleTransactionTest < Test::Unit::TestCase
 
     cn.unbind
 
-    assert_equal [[nil, C::DisconnectedError.new("127.0.0.1:0")]], al.valid
-    assert_equal [[nil, C::DisconnectedError.new("127.0.0.1:0")]], bl.valid
-    assert_equal [[nil, C::DisconnectedError.new("127.0.0.1:0")]], cl.valid
+    assert_equal [[nil, C::DisconnectedError.new("127.0.0.1:0")]], al
+    assert_equal [[nil, C::DisconnectedError.new("127.0.0.1:0")]], bl
+    assert_equal [[nil, C::DisconnectedError.new("127.0.0.1:0")]], cl
   end
 
   def test_send_when_disconnected
@@ -111,6 +111,6 @@ class FraggleTransactionTest < Test::Unit::TestCase
 
     cn.tick!
 
-    assert_equal [[nil, C::DisconnectedError.new("127.0.0.1:0")]], log.valid
+    assert_equal [[nil, C::DisconnectedError.new("127.0.0.1:0")]], log
   end
 end

data/test/helper.rb

@@ -51,15 +51,9 @@ class Test::Unit::TestCase
   F = Fraggle::Response
   E = Fraggle::Response::Err
 
-  class Log
-    attr_reader :valid
-
-    def initialize
-      @valid = []
-    end
-
+  class Log < Array
     def call(e, err)
-      @valid << [e, err]
+      self << [e, err]
     end
 
     def to_proc

metadata

@@ -1,15 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: fraggle
 version: !ruby/object:Gem::Version 
-  hash: 1923831855
-  prerelease: 6
+  hash: 63
+  prerelease: 
   segments: 
   - 4
   - 0
   - 0
-  - pre
-  - 3
-  version: 4.0.0.pre.3
+  version: 4.0.0
 platform: ruby
 authors: 
 - Blake Mizerany
@@ -17,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-09 00:00:00 -07:00
+date: 2011-06-03 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -130,14 +128,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version 
-      hash: 25
+      hash: 3
       segments: 
-      - 1
-      - 3
-      - 1
-      version: 1.3.1
+      - 0
+      version: "0"
 requirements: []
 
 rubyforge_project: fraggle