RubyGems - vibes-bj - Versions diffs - 1.2.1 - Mend

vibes-bj 1.2.1

Files changed (1379) hide show

data/spec/rails_root/vendor/rails/activesupport/lib/active_support/vendor/builder-2.1.2/builder/xmlevents.rb ADDED

@@ -0,0 +1,63 @@
+#!/usr/bin/env ruby
+#--
+# Copyright 2004 by Jim Weirich (jim@weirichhouse.org).
+# All rights reserved.
+# Permission is granted for use, copying, modification, distribution,
+# and distribution of modified versions of this work as long as the
+# above copyright notice is included.
+#++
+require 'builder/xmlmarkup'
+module Builder
+  # Create a series of SAX-like XML events (e.g. start_tag, end_tag)
+  # from the markup code.  XmlEvent objects are used in a way similar
+  # to XmlMarkup objects, except that a series of events are generated
+  # and passed to a handler rather than generating character-based
+  # markup.
+  #
+  # Usage:
+  #   xe = Builder::XmlEvents.new(hander)
+  #   xe.title("HI")    # Sends start_tag/end_tag/text messages to the handler.
+  #
+  # Indentation may also be selected by providing value for the
+  # indentation size and initial indentation level.
+  #
+  #   xe = Builder::XmlEvents.new(handler, indent_size, initial_indent_level)
+  #
+  # == XML Event Handler
+  #
+  # The handler object must expect the following events.
+  #
+  # [<tt>start_tag(tag, attrs)</tt>]
+  #     Announces that a new tag has been found.  +tag+ is the name of
+  #     the tag and +attrs+ is a hash of attributes for the tag.
+  #
+  # [<tt>end_tag(tag)</tt>]
+  #     Announces that an end tag for +tag+ has been found.
+  #
+  # [<tt>text(text)</tt>]
+  #     Announces that a string of characters (+text+) has been found.
+  #     A series of characters may be broken up into more than one
+  #     +text+ call, so the client cannot assume that a single
+  #     callback contains all the text data.
+  #
+  class XmlEvents < XmlMarkup
+    def text!(text)
+      @target.text(text)
+    end
+    def _start_tag(sym, attrs, end_too=false)
+      @target.start_tag(sym, attrs)
+      _end_tag(sym) if end_too
+    end
+    def _end_tag(sym)
+      @target.end_tag(sym)
+    end
+  end
+end

data/spec/rails_root/vendor/rails/activesupport/lib/active_support/vendor/builder-2.1.2/builder/xmlmarkup.rb ADDED

@@ -0,0 +1,328 @@
+#!/usr/bin/env ruby
+#--
+# Copyright 2004, 2005 by Jim Weirich (jim@weirichhouse.org).
+# All rights reserved.
+# Permission is granted for use, copying, modification, distribution,
+# and distribution of modified versions of this work as long as the
+# above copyright notice is included.
+#++
+# Provide a flexible and easy to use Builder for creating XML markup.
+# See XmlBuilder for usage details.
+require 'builder/xmlbase'
+module Builder
+  # Create XML markup easily.  All (well, almost all) methods sent to
+  # an XmlMarkup object will be translated to the equivalent XML
+  # markup.  Any method with a block will be treated as an XML markup
+  # tag with nested markup in the block.
+  #
+  # Examples will demonstrate this easier than words.  In the
+  # following, +xm+ is an +XmlMarkup+ object.
+  #
+  #   xm.em("emphasized")             # => <em>emphasized</em>
+  #   xm.em { xmm.b("emp & bold") }   # => <em><b>emph &amp; bold</b></em>
+  #   xm.a("A Link", "href"=>"http://onestepback.org")
+  #                                   # => <a href="http://onestepback.org">A Link</a>
+  #   xm.div { br }                    # => <div><br/></div>
+  #   xm.target("name"=>"compile", "option"=>"fast")
+  #                                   # => <target option="fast" name="compile"\>
+  #                                   # NOTE: order of attributes is not specified.
+  #
+  #   xm.instruct!                   # <?xml version="1.0" encoding="UTF-8"?>
+  #   xm.html {                      # <html>
+  #     xm.head {                    #   <head>
+  #       xm.title("History")        #     <title>History</title>
+  #     }                            #   </head>
+  #     xm.body {                    #   <body>
+  #       xm.comment! "HI"           #     <! -- HI -->
+  #       xm.h1("Header")            #     <h1>Header</h1>
+  #       xm.p("paragraph")          #     <p>paragraph</p>
+  #     }                            #   </body>
+  #   }                              # </html>
+  #
+  # == Notes:
+  #
+  # * The order that attributes are inserted in markup tags is
+  #   undefined.
+  #
+  # * Sometimes you wish to insert text without enclosing tags.  Use
+  #   the <tt>text!</tt> method to accomplish this.
+  #
+  #   Example:
+  #
+  #     xm.div {                          # <div>
+  #       xm.text! "line"; xm.br          #   line<br/>
+  #       xm.text! "another line"; xmbr   #    another line<br/>
+  #     }                                 # </div>
+  #
+  # * The special XML characters <, >, and & are converted to &lt;,
+  #   &gt; and &amp; automatically.  Use the <tt><<</tt> operation to
+  #   insert text without modification.
+  #
+  # * Sometimes tags use special characters not allowed in ruby
+  #   identifiers.  Use the <tt>tag!</tt> method to handle these
+  #   cases.
+  #
+  #   Example:
+  #
+  #     xml.tag!("SOAP:Envelope") { ... }
+  #
+  #   will produce ...
+  #
+  #     <SOAP:Envelope> ... </SOAP:Envelope>"
+  #
+  #   <tt>tag!</tt> will also take text and attribute arguments (after
+  #   the tag name) like normal markup methods.  (But see the next
+  #   bullet item for a better way to handle XML namespaces).
+  #
+  # * Direct support for XML namespaces is now available.  If the
+  #   first argument to a tag call is a symbol, it will be joined to
+  #   the tag to produce a namespace:tag combination.  It is easier to
+  #   show this than describe it.
+  #
+  #     xml.SOAP :Envelope do ... end
+  #
+  #   Just put a space before the colon in a namespace to produce the
+  #   right form for builder (e.g. "<tt>SOAP:Envelope</tt>" =>
+  #   "<tt>xml.SOAP :Envelope</tt>")
+  #
+  # * XmlMarkup builds the markup in any object (called a _target_)
+  #   that accepts the <tt><<</tt> method.  If no target is given,
+  #   then XmlMarkup defaults to a string target.
+  #
+  #   Examples:
+  #
+  #     xm = Builder::XmlMarkup.new
+  #     result = xm.title("yada")
+  #     # result is a string containing the markup.
+  #
+  #     buffer = ""
+  #     xm = Builder::XmlMarkup.new(buffer)
+  #     # The markup is appended to buffer (using <<)
+  #
+  #     xm = Builder::XmlMarkup.new(STDOUT)
+  #     # The markup is written to STDOUT (using <<)
+  #
+  #     xm = Builder::XmlMarkup.new
+  #     x2 = Builder::XmlMarkup.new(:target=>xm)
+  #     # Markup written to +x2+ will be send to +xm+.
+  #
+  # * Indentation is enabled by providing the number of spaces to
+  #   indent for each level as a second argument to XmlBuilder.new.
+  #   Initial indentation may be specified using a third parameter.
+  #
+  #   Example:
+  #
+  #     xm = Builder.new(:indent=>2)
+  #     # xm will produce nicely formatted and indented XML.
+  #
+  #     xm = Builder.new(:indent=>2, :margin=>4)
+  #     # xm will produce nicely formatted and indented XML with 2
+  #     # spaces per indent and an over all indentation level of 4.
+  #
+  #     builder = Builder::XmlMarkup.new(:target=>$stdout, :indent=>2)
+  #     builder.name { |b| b.first("Jim"); b.last("Weirich) }
+  #     # prints:
+  #     #     <name>
+  #     #       <first>Jim</first>
+  #     #       <last>Weirich</last>
+  #     #     </name>
+  #
+  # * The instance_eval implementation which forces self to refer to
+  #   the message receiver as self is now obsolete.  We now use normal
+  #   block calls to execute the markup block.  This means that all
+  #   markup methods must now be explicitly send to the xml builder.
+  #   For instance, instead of
+  #
+  #      xml.div { strong("text") }
+  #
+  #   you need to write:
+  #
+  #      xml.div { xml.strong("text") }
+  #
+  #   Although more verbose, the subtle change in semantics within the
+  #   block was found to be prone to error.  To make this change a
+  #   little less cumbersome, the markup block now gets the markup
+  #   object sent as an argument, allowing you to use a shorter alias
+  #   within the block.
+  #
+  #   For example:
+  #
+  #     xml_builder = Builder::XmlMarkup.new
+  #     xml_builder.div { |xml|
+  #       xml.stong("text")
+  #     }
+  #
+  class XmlMarkup < XmlBase
+    # Create an XML markup builder.  Parameters are specified by an
+    # option hash.
+    #
+    # :target=><em>target_object</em>::
+    #    Object receiving the markup.  +out+ must respond to the
+    #    <tt><<</tt> operator.  The default is a plain string target.
+    #
+    # :indent=><em>indentation</em>::
+    #    Number of spaces used for indentation.  The default is no
+    #    indentation and no line breaks.
+    #
+    # :margin=><em>initial_indentation_level</em>::
+    #    Amount of initial indentation (specified in levels, not
+    #    spaces).
+    #
+    # :escape_attrs=><b>OBSOLETE</em>::
+    #    The :escape_attrs option is no longer supported by builder
+    #    (and will be quietly ignored).  String attribute values are
+    #    now automatically escaped.  If you need unescaped attribute
+    #    values (perhaps you are using entities in the attribute
+    #    values), then give the value as a Symbol.  This allows much
+    #    finer control over escaping attribute values.
+    #
+    def initialize(options={})
+      indent = options[:indent] || 0
+      margin = options[:margin] || 0
+      super(indent, margin)
+      @target = options[:target] || ""
+    end
+    # Return the target of the builder.
+    def target!
+      @target
+    end
+    def comment!(comment_text)
+      _ensure_no_block block_given?
+      _special("<!-- ", " -->", comment_text, nil)
+    end
+    # Insert an XML declaration into the XML markup.
+    #
+    # For example:
+    #
+    #   xml.declare! :ELEMENT, :blah, "yada"
+    #       # => <!ELEMENT blah "yada">
+    def declare!(inst, *args, &block)
+      _indent
+      @target << "<!#{inst}"
+      args.each do |arg|
+        case arg
+        when String
+          @target << %{ "#{arg}"} # " WART
+        when Symbol
+          @target << " #{arg}"
+        end
+      end
+      if block_given?
+        @target << " ["
+        _newline
+        _nested_structures(block)
+        @target << "]"
+      end
+      @target << ">"
+      _newline
+    end
+    # Insert a processing instruction into the XML markup.  E.g.
+    #
+    # For example:
+    #
+    #    xml.instruct!
+    #        #=> <?xml version="1.0" encoding="UTF-8"?>
+    #    xml.instruct! :aaa, :bbb=>"ccc"
+    #        #=> <?aaa bbb="ccc"?>
+    #
+    def instruct!(directive_tag=:xml, attrs={})
+      _ensure_no_block block_given?
+      if directive_tag == :xml
+        a = { :version=>"1.0", :encoding=>"UTF-8" }
+        attrs = a.merge attrs
+      end
+      _special(
+      "<?#{directive_tag}",
+      "?>",
+      nil,
+      attrs,
+      [:version, :encoding, :standalone])
+    end
+    # Insert a CDATA section into the XML markup.
+    #
+    # For example:
+    #
+    #    xml.cdata!("text to be included in cdata")
+    #        #=> <![CDATA[text to be included in cdata]]>
+    #
+    def cdata!(text)
+      _ensure_no_block block_given?
+      _special("<![CDATA[", "]]>", text, nil)
+    end
+    private
+    # NOTE: All private methods of a builder object are prefixed when
+    # a "_" character to avoid possible conflict with XML tag names.
+    # Insert text directly in to the builder's target.
+    def _text(text)
+      @target << text
+    end
+    # Insert special instruction.
+    def _special(open, close, data=nil, attrs=nil, order=[])
+      _indent
+      @target << open
+      @target << data if data
+      _insert_attributes(attrs, order) if attrs
+      @target << close
+      _newline
+    end
+    # Start an XML tag.  If <tt>end_too</tt> is true, then the start
+    # tag is also the end tag (e.g.  <br/>
+    def _start_tag(sym, attrs, end_too=false)
+      @target << "<#{sym}"
+      _insert_attributes(attrs)
+      @target << "/" if end_too
+      @target << ">"
+    end
+    # Insert an ending tag.
+    def _end_tag(sym)
+      @target << "</#{sym}>"
+    end
+    # Insert the attributes (given in the hash).
+    def _insert_attributes(attrs, order=[])
+      return if attrs.nil?
+      order.each do |k|
+        v = attrs[k]
+        @target << %{ #{k}="#{_attr_value(v)}"} if v # " WART
+      end
+      attrs.each do |k, v|
+        @target << %{ #{k}="#{_attr_value(v)}"} unless order.member?(k) # " WART
+      end
+    end
+    def _attr_value(value)
+      case value
+      when Symbol
+        value.to_s
+      else
+        _escape_quote(value.to_s)
+      end
+    end
+    def _ensure_no_block(got_block)
+      if got_block
+        fail IllegalBlockError,
+        "Blocks are not allowed on XML instructions"
+      end
+    end
+  end
+end

data/spec/rails_root/vendor/rails/activesupport/lib/active_support/vendor/memcache-client-1.5.0/memcache.rb ADDED

@@ -0,0 +1,849 @@
+# All original code copyright 2005, 2006, 2007 Bob Cottrell, Eric Hodel,
+# The Robot Co-op.  All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# 1. Redistributions of source code must retain the above copyright
+#    notice, this list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright
+#    notice, this list of conditions and the following disclaimer in the
+#    documentation and/or other materials provided with the distribution.
+# 3. Neither the names of the authors nor the names of their contributors
+#    may be used to endorse or promote products derived from this software
+#    without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS
+# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+# OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+# OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+# BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+# OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+# EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+require 'socket'
+require 'thread'
+require 'timeout'
+require 'rubygems'
+class String
+  ##
+  # Uses the ITU-T polynomial in the CRC32 algorithm.
+  def crc32_ITU_T
+    n = length
+    r = 0xFFFFFFFF
+    n.times do |i|
+      r ^= self[i]
+      8.times do
+        if (r & 1) != 0 then
+          r = (r>>1) ^ 0xEDB88320
+        else
+          r >>= 1
+        end
+      end
+    end
+    r ^ 0xFFFFFFFF
+  end
+end
+##
+# A Ruby client library for memcached.
+#
+# This is intended to provide access to basic memcached functionality.  It
+# does not attempt to be complete implementation of the entire API, but it is
+# approaching a complete implementation.
+class MemCache
+  ##
+  # The version of MemCache you are using.
+  VERSION = '1.5.0'
+  ##
+  # Default options for the cache object.
+  DEFAULT_OPTIONS = {
+    :namespace   => nil,
+    :readonly    => false,
+    :multithread => false,
+  }
+  ##
+  # Default memcached port.
+  DEFAULT_PORT = 11211
+  ##
+  # Default memcached server weight.
+  DEFAULT_WEIGHT = 1
+  ##
+  # The amount of time to wait for a response from a memcached server.  If a
+  # response is not completed within this time, the connection to the server
+  # will be closed and an error will be raised.
+  attr_accessor :request_timeout
+  ##
+  # The namespace for this instance
+  attr_reader :namespace
+  ##
+  # The multithread setting for this instance
+  attr_reader :multithread
+  ##
+  # The servers this client talks to.  Play at your own peril.
+  attr_reader :servers
+  ##
+  # Accepts a list of +servers+ and a list of +opts+.  +servers+ may be
+  # omitted.  See +servers=+ for acceptable server list arguments.
+  #
+  # Valid options for +opts+ are:
+  #
+  #   [:namespace]   Prepends this value to all keys added or retrieved.
+  #   [:readonly]    Raises an exeception on cache writes when true.
+  #   [:multithread] Wraps cache access in a Mutex for thread safety.
+  #
+  # Other options are ignored.
+  def initialize(*args)
+    servers = []
+    opts = {}
+    case args.length
+    when 0 then # NOP
+    when 1 then
+      arg = args.shift
+      case arg
+      when Hash   then opts = arg
+      when Array  then servers = arg
+      when String then servers = [arg]
+      else raise ArgumentError, 'first argument must be Array, Hash or String'
+      end
+    when 2 then
+      servers, opts = args
+    else
+      raise ArgumentError, "wrong number of arguments (#{args.length} for 2)"
+    end
+    opts = DEFAULT_OPTIONS.merge opts
+    @namespace   = opts[:namespace]
+    @readonly    = opts[:readonly]
+    @multithread = opts[:multithread]
+    @mutex       = Mutex.new if @multithread
+    @buckets     = []
+    self.servers = servers
+  end
+  ##
+  # Returns a string representation of the cache object.
+  def inspect
+    "<MemCache: %d servers, %d buckets, ns: %p, ro: %p>" %
+      [@servers.length, @buckets.length, @namespace, @readonly]
+  end
+  ##
+  # Returns whether there is at least one active server for the object.
+  def active?
+    not @servers.empty?
+  end
+  ##
+  # Returns whether or not the cache object was created read only.
+  def readonly?
+    @readonly
+  end
+  ##
+  # Set the servers that the requests will be distributed between.  Entries
+  # can be either strings of the form "hostname:port" or
+  # "hostname:port:weight" or MemCache::Server objects.
+  def servers=(servers)
+    # Create the server objects.
+    @servers = servers.collect do |server|
+      case server
+      when String
+        host, port, weight = server.split ':', 3
+        port ||= DEFAULT_PORT
+        weight ||= DEFAULT_WEIGHT
+        Server.new self, host, port, weight
+      when Server
+        if server.memcache.multithread != @multithread then
+          raise ArgumentError, "can't mix threaded and non-threaded servers"
+        end
+        server
+      else
+        raise TypeError, "cannot convert #{server.class} into MemCache::Server"
+      end
+    end
+    # Create an array of server buckets for weight selection of servers.
+    @buckets = []
+    @servers.each do |server|
+      server.weight.times { @buckets.push(server) }
+    end
+  end
+  ##
+  # Deceremets the value for +key+ by +amount+ and returns the new value.
+  # +key+ must already exist.  If +key+ is not an integer, it is assumed to be
+  # 0.  +key+ can not be decremented below 0.
+  def decr(key, amount = 1)
+    server, cache_key = request_setup key
+    if @multithread then
+      threadsafe_cache_decr server, cache_key, amount
+    else
+      cache_decr server, cache_key, amount
+    end
+  rescue TypeError, SocketError, SystemCallError, IOError => err
+    handle_error server, err
+  end
+  ##
+  # Retrieves +key+ from memcache.  If +raw+ is false, the value will be
+  # unmarshalled.
+  def get(key, raw = false)
+    server, cache_key = request_setup key
+    value = if @multithread then
+              threadsafe_cache_get server, cache_key
+            else
+              cache_get server, cache_key
+            end
+    return nil if value.nil?
+    value = Marshal.load value unless raw
+    return value
+  rescue TypeError, SocketError, SystemCallError, IOError => err
+    handle_error server, err
+  end
+  ##
+  # Retrieves multiple values from memcached in parallel, if possible.
+  #
+  # The memcached protocol supports the ability to retrieve multiple
+  # keys in a single request.  Pass in an array of keys to this method
+  # and it will:
+  #
+  # 1. map the key to the appropriate memcached server
+  # 2. send a single request to each server that has one or more key values
+  #
+  # Returns a hash of values.
+  #
+  #   cache["a"] = 1
+  #   cache["b"] = 2
+  #   cache.get_multi "a", "b" # => { "a" => 1, "b" => 2 }
+  def get_multi(*keys)
+    raise MemCacheError, 'No active servers' unless active?
+    keys.flatten!
+    key_count = keys.length
+    cache_keys = {}
+    server_keys = Hash.new { |h,k| h[k] = [] }
+    # map keys to servers
+    keys.each do |key|
+      server, cache_key = request_setup key
+      cache_keys[cache_key] = key
+      server_keys[server] << cache_key
+    end
+    results = {}
+    server_keys.each do |server, keys_for_server|
+      keys_for_server = keys_for_server.join ' '
+      values = if @multithread then
+                 threadsafe_cache_get_multi server, keys_for_server
+               else
+                 cache_get_multi server, keys_for_server
+               end
+      values.each do |key, value|
+        results[cache_keys[key]] = Marshal.load value
+      end
+    end
+    return results
+  rescue TypeError, SocketError, SystemCallError, IOError => err
+    handle_error server, err
+  end
+  ##
+  # Increments the value for +key+ by +amount+ and retruns the new value.
+  # +key+ must already exist.  If +key+ is not an integer, it is assumed to be
+  # 0.
+  def incr(key, amount = 1)
+    server, cache_key = request_setup key
+    if @multithread then
+      threadsafe_cache_incr server, cache_key, amount
+    else
+      cache_incr server, cache_key, amount
+    end
+  rescue TypeError, SocketError, SystemCallError, IOError => err
+    handle_error server, err
+  end
+  ##
+  # Add +key+ to the cache with value +value+ that expires in +expiry+
+  # seconds.  If +raw+ is true, +value+ will not be Marshalled.
+  #
+  # Warning: Readers should not call this method in the event of a cache miss;
+  # see MemCache#add.
+  def set(key, value, expiry = 0, raw = false)
+    raise MemCacheError, "Update of readonly cache" if @readonly
+    server, cache_key = request_setup key
+    socket = server.socket
+    value = Marshal.dump value unless raw
+    command = "set #{cache_key} 0 #{expiry} #{value.size}\r\n#{value}\r\n"
+    begin
+      @mutex.lock if @multithread
+      socket.write command
+      result = socket.gets
+      raise_on_error_response! result
+      result
+    rescue SocketError, SystemCallError, IOError => err
+      server.close
+      raise MemCacheError, err.message
+    ensure
+      @mutex.unlock if @multithread
+    end
+  end
+  ##
+  # Add +key+ to the cache with value +value+ that expires in +expiry+
+  # seconds, but only if +key+ does not already exist in the cache.
+  # If +raw+ is true, +value+ will not be Marshalled.
+  #
+  # Readers should call this method in the event of a cache miss, not
+  # MemCache#set or MemCache#[]=.
+  def add(key, value, expiry = 0, raw = false)
+    raise MemCacheError, "Update of readonly cache" if @readonly
+    server, cache_key = request_setup key
+    socket = server.socket
+    value = Marshal.dump value unless raw
+    command = "add #{cache_key} 0 #{expiry} #{value.size}\r\n#{value}\r\n"
+    begin
+      @mutex.lock if @multithread
+      socket.write command
+      result = socket.gets
+      raise_on_error_response! result
+      result
+    rescue SocketError, SystemCallError, IOError => err
+      server.close
+      raise MemCacheError, err.message
+    ensure
+      @mutex.unlock if @multithread
+    end
+  end
+  ##
+  # Removes +key+ from the cache in +expiry+ seconds.
+  def delete(key, expiry = 0)
+    @mutex.lock if @multithread
+    raise MemCacheError, "No active servers" unless active?
+    cache_key = make_cache_key key
+    server = get_server_for_key cache_key
+    sock = server.socket
+    raise MemCacheError, "No connection to server" if sock.nil?
+    begin
+      sock.write "delete #{cache_key} #{expiry}\r\n"
+      result = sock.gets
+      raise_on_error_response! result
+      result
+    rescue SocketError, SystemCallError, IOError => err
+      server.close
+      raise MemCacheError, err.message
+    end
+  ensure
+    @mutex.unlock if @multithread
+  end
+  ##
+  # Flush the cache from all memcache servers.
+  def flush_all
+    raise MemCacheError, 'No active servers' unless active?
+    raise MemCacheError, "Update of readonly cache" if @readonly
+    begin
+      @mutex.lock if @multithread
+      @servers.each do |server|
+        begin
+          sock = server.socket
+          raise MemCacheError, "No connection to server" if sock.nil?
+          sock.write "flush_all\r\n"
+          result = sock.gets
+          raise_on_error_response! result
+          result
+        rescue SocketError, SystemCallError, IOError => err
+          server.close
+          raise MemCacheError, err.message
+        end
+      end
+    ensure
+      @mutex.unlock if @multithread
+    end
+  end
+  ##
+  # Reset the connection to all memcache servers.  This should be called if
+  # there is a problem with a cache lookup that might have left the connection
+  # in a corrupted state.
+  def reset
+    @servers.each { |server| server.close }
+  end
+  ##
+  # Returns statistics for each memcached server.  An explanation of the
+  # statistics can be found in the memcached docs:
+  #
+  # http://code.sixapart.com/svn/memcached/trunk/server/doc/protocol.txt
+  #
+  # Example:
+  #
+  #   >> pp CACHE.stats
+  #   {"localhost:11211"=>
+  #     {"bytes"=>4718,
+  #      "pid"=>20188,
+  #      "connection_structures"=>4,
+  #      "time"=>1162278121,
+  #      "pointer_size"=>32,
+  #      "limit_maxbytes"=>67108864,
+  #      "cmd_get"=>14532,
+  #      "version"=>"1.2.0",
+  #      "bytes_written"=>432583,
+  #      "cmd_set"=>32,
+  #      "get_misses"=>0,
+  #      "total_connections"=>19,
+  #      "curr_connections"=>3,
+  #      "curr_items"=>4,
+  #      "uptime"=>1557,
+  #      "get_hits"=>14532,
+  #      "total_items"=>32,
+  #      "rusage_system"=>0.313952,
+  #      "rusage_user"=>0.119981,
+  #      "bytes_read"=>190619}}
+  #   => nil
+  def stats
+    raise MemCacheError, "No active servers" unless active?
+    server_stats = {}
+    @servers.each do |server|
+      sock = server.socket
+      raise MemCacheError, "No connection to server" if sock.nil?
+      value = nil
+      begin
+        sock.write "stats\r\n"
+        stats = {}
+        while line = sock.gets do
+          raise_on_error_response! line
+          break if line == "END\r\n"
+          if line =~ /\ASTAT ([\w]+) ([\w\.\:]+)/ then
+            name, value = $1, $2
+            stats[name] = case name
+                          when 'version'
+                            value
+                          when 'rusage_user', 'rusage_system' then
+                            seconds, microseconds = value.split(/:/, 2)
+                            microseconds ||= 0
+                            Float(seconds) + (Float(microseconds) / 1_000_000)
+                          else
+                            if value =~ /\A\d+\Z/ then
+                              value.to_i
+                            else
+                              value
+                            end
+                          end
+          end
+        end
+        server_stats["#{server.host}:#{server.port}"] = stats
+      rescue SocketError, SystemCallError, IOError => err
+        server.close
+        raise MemCacheError, err.message
+      end
+    end
+    server_stats
+  end
+  ##
+  # Shortcut to get a value from the cache.
+  alias [] get
+  ##
+  # Shortcut to save a value in the cache.  This method does not set an
+  # expiration on the entry.  Use set to specify an explicit expiry.
+  def []=(key, value)
+    set key, value
+  end
+  protected
+  ##
+  # Create a key for the cache, incorporating the namespace qualifier if
+  # requested.
+  def make_cache_key(key)
+    if namespace.nil? then
+      key
+    else
+      "#{@namespace}:#{key}"
+    end
+  end
+  ##
+  # Pick a server to handle the request based on a hash of the key.
+  def get_server_for_key(key)
+    raise ArgumentError, "illegal character in key #{key.inspect}" if
+      key =~ /\s/
+    raise ArgumentError, "key too long #{key.inspect}" if key.length > 250
+    raise MemCacheError, "No servers available" if @servers.empty?
+    return @servers.first if @servers.length == 1
+    hkey = hash_for key
+    20.times do |try|
+      server = @buckets[hkey % @buckets.nitems]
+      return server if server.alive?
+      hkey += hash_for "#{try}#{key}"
+    end
+    raise MemCacheError, "No servers available"
+  end
+  ##
+  # Returns an interoperable hash value for +key+.  (I think, docs are
+  # sketchy for down servers).
+  def hash_for(key)
+    (key.crc32_ITU_T >> 16) & 0x7fff
+  end
+  ##
+  # Performs a raw decr for +cache_key+ from +server+.  Returns nil if not
+  # found.
+  def cache_decr(server, cache_key, amount)
+    socket = server.socket
+    socket.write "decr #{cache_key} #{amount}\r\n"
+    text = socket.gets
+    raise_on_error_response! text
+    return nil if text == "NOT_FOUND\r\n"
+    return text.to_i
+  end
+  ##
+  # Fetches the raw data for +cache_key+ from +server+.  Returns nil on cache
+  # miss.
+  def cache_get(server, cache_key)
+    socket = server.socket
+    socket.write "get #{cache_key}\r\n"
+    keyline = socket.gets # "VALUE <key> <flags> <bytes>\r\n"
+    if keyline.nil? then
+      server.close
+      raise MemCacheError, "lost connection to #{server.host}:#{server.port}"
+    end
+    raise_on_error_response! keyline
+    return nil if keyline == "END\r\n"
+    unless keyline =~ /(\d+)\r/ then
+      server.close
+      raise MemCacheError, "unexpected response #{keyline.inspect}"
+    end
+    value = socket.read $1.to_i
+    socket.read 2 # "\r\n"
+    socket.gets   # "END\r\n"
+    return value
+  end
+  ##
+  # Fetches +cache_keys+ from +server+ using a multi-get.
+  def cache_get_multi(server, cache_keys)
+    values = {}
+    socket = server.socket
+    socket.write "get #{cache_keys}\r\n"
+    while keyline = socket.gets do
+      return values if keyline == "END\r\n"
+      raise_on_error_response! keyline
+      unless keyline =~ /\AVALUE (.+) (.+) (.+)/ then
+        server.close
+        raise MemCacheError, "unexpected response #{keyline.inspect}"
+      end
+      key, data_length = $1, $3
+      values[$1] = socket.read data_length.to_i
+      socket.read(2) # "\r\n"
+    end
+    server.close
+    raise MemCacheError, "lost connection to #{server.host}:#{server.port}"
+  end
+  ##
+  # Performs a raw incr for +cache_key+ from +server+.  Returns nil if not
+  # found.
+  def cache_incr(server, cache_key, amount)
+    socket = server.socket
+    socket.write "incr #{cache_key} #{amount}\r\n"
+    text = socket.gets
+    raise_on_error_response! text
+    return nil if text == "NOT_FOUND\r\n"
+    return text.to_i
+  end
+  ##
+  # Handles +error+ from +server+.
+  def handle_error(server, error)
+    server.close if server
+    new_error = MemCacheError.new error.message
+    new_error.set_backtrace error.backtrace
+    raise new_error
+  end
+  ##
+  # Performs setup for making a request with +key+ from memcached.  Returns
+  # the server to fetch the key from and the complete key to use.
+  def request_setup(key)
+    raise MemCacheError, 'No active servers' unless active?
+    cache_key = make_cache_key key
+    server = get_server_for_key cache_key
+    raise MemCacheError, 'No connection to server' if server.socket.nil?
+    return server, cache_key
+  end
+  def threadsafe_cache_decr(server, cache_key, amount) # :nodoc:
+    @mutex.lock
+    cache_decr server, cache_key, amount
+  ensure
+    @mutex.unlock
+  end
+  def threadsafe_cache_get(server, cache_key) # :nodoc:
+    @mutex.lock
+    cache_get server, cache_key
+  ensure
+    @mutex.unlock
+  end
+  def threadsafe_cache_get_multi(socket, cache_keys) # :nodoc:
+    @mutex.lock
+    cache_get_multi socket, cache_keys
+  ensure
+    @mutex.unlock
+  end
+  def threadsafe_cache_incr(server, cache_key, amount) # :nodoc:
+    @mutex.lock
+    cache_incr server, cache_key, amount
+  ensure
+    @mutex.unlock
+  end
+  def raise_on_error_response!(response)
+    if response =~ /\A(?:CLIENT_|SERVER_)?ERROR (.*)/
+      raise MemCacheError, $1.strip
+    end
+  end
+  ##
+  # This class represents a memcached server instance.
+  class Server
+    ##
+    # The amount of time to wait to establish a connection with a memcached
+    # server.  If a connection cannot be established within this time limit,
+    # the server will be marked as down.
+    CONNECT_TIMEOUT = 0.25
+    ##
+    # The amount of time to wait before attempting to re-establish a
+    # connection with a server that is marked dead.
+    RETRY_DELAY = 30.0
+    ##
+    # The host the memcached server is running on.
+    attr_reader :host
+    ##
+    # The port the memcached server is listening on.
+    attr_reader :port
+    ##
+    # The weight given to the server.
+    attr_reader :weight
+    ##
+    # The time of next retry if the connection is dead.
+    attr_reader :retry
+    ##
+    # A text status string describing the state of the server.
+    attr_reader :status
+    ##
+    # Create a new MemCache::Server object for the memcached instance
+    # listening on the given host and port, weighted by the given weight.
+    def initialize(memcache, host, port = DEFAULT_PORT, weight = DEFAULT_WEIGHT)
+      raise ArgumentError, "No host specified" if host.nil? or host.empty?
+      raise ArgumentError, "No port specified" if port.nil? or port.to_i.zero?
+      @memcache = memcache
+      @host   = host
+      @port   = port.to_i
+      @weight = weight.to_i
+      @multithread = @memcache.multithread
+      @mutex = Mutex.new
+      @sock   = nil
+      @retry  = nil
+      @status = 'NOT CONNECTED'
+    end
+    ##
+    # Return a string representation of the server object.
+    def inspect
+      "<MemCache::Server: %s:%d [%d] (%s)>" % [@host, @port, @weight, @status]
+    end
+    ##
+    # Check whether the server connection is alive.  This will cause the
+    # socket to attempt to connect if it isn't already connected and or if
+    # the server was previously marked as down and the retry time has
+    # been exceeded.
+    def alive?
+      !!socket
+    end
+    ##
+    # Try to connect to the memcached server targeted by this object.
+    # Returns the connected socket object on success or nil on failure.
+    def socket
+      @mutex.lock if @multithread
+      return @sock if @sock and not @sock.closed?
+      @sock = nil
+      # If the host was dead, don't retry for a while.
+      return if @retry and @retry > Time.now
+      # Attempt to connect if not already connected.
+      begin
+        @sock = timeout CONNECT_TIMEOUT do
+          TCPSocket.new @host, @port
+        end
+        if Socket.constants.include? 'TCP_NODELAY' then
+          @sock.setsockopt Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1
+        end
+        @retry  = nil
+        @status = 'CONNECTED'
+      rescue SocketError, SystemCallError, IOError, Timeout::Error => err
+        mark_dead err.message
+      end
+      return @sock
+    ensure
+      @mutex.unlock if @multithread
+    end
+    ##
+    # Close the connection to the memcached server targeted by this
+    # object.  The server is not considered dead.
+    def close
+      @mutex.lock if @multithread
+      @sock.close if @sock && !@sock.closed?
+      @sock   = nil
+      @retry  = nil
+      @status = "NOT CONNECTED"
+    ensure
+      @mutex.unlock if @multithread
+    end
+    private
+    ##
+    # Mark the server as dead and close its socket.
+    def mark_dead(reason = "Unknown error")
+      @sock.close if @sock && !@sock.closed?
+      @sock   = nil
+      @retry  = Time.now + RETRY_DELAY
+      @status = sprintf "DEAD: %s, will retry at %s", reason, @retry
+    end
+  end
+  ##
+  # Base MemCache exception class.
+  class MemCacheError < RuntimeError; end
+end