lunar 0.4.1 → 0.5.0

data/vendor/redis/lib/redis/hash_ring.rb

@@ -1,131 +0,0 @@
-require 'zlib'
-
-class Redis
-  class HashRing
-
-    POINTS_PER_SERVER = 160 # this is the default in libmemcached
-
-    attr_reader :ring, :sorted_keys, :replicas, :nodes
-
-    # nodes is a list of objects that have a proper to_s representation.
-    # replicas indicates how many virtual points should be used pr. node,
-    # replicas are required to improve the distribution.
-    def initialize(nodes=[], replicas=POINTS_PER_SERVER)
-      @replicas = replicas
-      @ring = {}
-      @nodes = []
-      @sorted_keys = []
-      nodes.each do |node|
-        add_node(node)
-      end
-    end
-
-    # Adds a `node` to the hash ring (including a number of replicas).
-    def add_node(node)
-      @nodes << node
-      @replicas.times do |i|
-        key = Zlib.crc32("#{node.id}:#{i}")
-        @ring[key] = node
-        @sorted_keys << key
-      end
-      @sorted_keys.sort!
-    end
-
-    def remove_node(node)
-      @nodes.reject!{|n| n.id == node.id}
-      @replicas.times do |i|
-        key = Zlib.crc32("#{node.id}:#{i}")
-        @ring.delete(key)
-        @sorted_keys.reject! {|k| k == key}
-      end
-    end
-
-    # get the node in the hash ring for this key
-    def get_node(key)
-      get_node_pos(key)[0]
-    end
-
-    def get_node_pos(key)
-      return [nil,nil] if @ring.size == 0
-      crc = Zlib.crc32(key)
-      idx = HashRing.binary_search(@sorted_keys, crc)
-      return [@ring[@sorted_keys[idx]], idx]
-    end
-
-    def iter_nodes(key)
-      return [nil,nil] if @ring.size == 0
-      node, pos = get_node_pos(key)
-      @sorted_keys[pos..-1].each do |k|
-        yield @ring[k]
-      end
-    end
-
-    class << self
-
-      # gem install RubyInline to use this code
-      # Native extension to perform the binary search within the hashring.
-      # There's a pure ruby version below so this is purely optional
-      # for performance.  In testing 20k gets and sets, the native
-      # binary search shaved about 12% off the runtime (9sec -> 8sec).
-      begin
-        require 'inline'
-        inline do |builder|
-          builder.c <<-EOM
-          int binary_search(VALUE ary, unsigned int r) {
-              int upper = RARRAY_LEN(ary) - 1;
-              int lower = 0;
-              int idx = 0;
-
-              while (lower <= upper) {
-                  idx = (lower + upper) / 2;
-
-                  VALUE continuumValue = RARRAY_PTR(ary)[idx];
-                  unsigned int l = NUM2UINT(continuumValue);
-                  if (l == r) {
-                      return idx;
-                  }
-                  else if (l > r) {
-                      upper = idx - 1;
-                  }
-                  else {
-                      lower = idx + 1;
-                  }
-              }
-              if (upper < 0) {
-                upper = RARRAY_LEN(ary) - 1;
-              }
-              return upper;
-          }
-          EOM
-        end
-      rescue Exception => e
-        # Find the closest index in HashRing with value <= the given value
-        def binary_search(ary, value, &block)
-          upper = ary.size - 1
-          lower = 0
-          idx = 0
-
-          while(lower <= upper) do
-            idx = (lower + upper) / 2
-            comp = ary[idx] <=> value
-
-            if comp == 0
-              return idx
-            elsif comp > 0
-              upper = idx - 1
-            else
-              lower = idx + 1
-            end
-          end
-
-          if upper < 0
-            upper = ary.size - 1
-          end
-          return upper
-        end
-
-      end
-    end
-
-  end
-end

data/vendor/redis/lib/redis/pipeline.rb

@@ -1,13 +0,0 @@
-class Redis
-  class Pipeline
-    attr :commands
-
-    def initialize
-      @commands = []
-    end
-
-    def call(*args)
-      @commands << args
-    end
-  end
-end

data/vendor/redis/lib/redis/raketasks.rb

@@ -1 +0,0 @@
-require File.dirname(__FILE__) + "/../../tasks/redis.tasks"

data/vendor/redis/lib/redis/subscribe.rb

@@ -1,79 +0,0 @@
-class Redis
-  class SubscribedClient
-    def initialize(client)
-      @client = client
-    end
-
-    def call(*args)
-      @client.process(args)
-    end
-
-    def subscribe(*channels, &block)
-      subscription("subscribe", "unsubscribe", channels, block)
-    end
-
-    def psubscribe(*channels, &block)
-      subscription("psubscribe", "punsubscribe", channels, block)
-    end
-
-    def unsubscribe(*channels)
-      call(:unsubscribe, *channels)
-    end
-
-    def punsubscribe(*channels)
-      call(:punsubscribe, *channels)
-    end
-
-  protected
-
-    def subscription(start, stop, channels, block)
-      sub = Subscription.new(&block)
-
-      begin
-        @client.call_loop(start, *channels) do |line|
-          type, *rest = line
-          sub.callbacks[type].call(*rest)
-          break if type == stop && rest.last == 0
-        end
-      ensure
-        send(stop)
-      end
-    end
-  end
-
-  class Subscription
-    attr :callbacks
-
-    def initialize
-      @callbacks = Hash.new do |hash, key|
-        hash[key] = lambda { |*_| }
-      end
-
-      yield(self)
-    end
-
-    def subscribe(&block)
-      @callbacks["subscribe"] = block
-    end
-
-    def unsubscribe(&block)
-      @callbacks["unsubscribe"] = block
-    end
-
-    def message(&block)
-      @callbacks["message"] = block
-    end
-
-    def psubscribe(&block)
-      @callbacks["psubscribe"] = block
-    end
-
-    def punsubscribe(&block)
-      @callbacks["punsubscribe"] = block
-    end
-
-    def pmessage(&block)
-      @callbacks["pmessage"] = block
-    end
-  end
-end

data/vendor/redis/profile.rb

@@ -1,22 +0,0 @@
-require 'rubygems'
-require 'ruby-prof'
-require "#{File.dirname(__FILE__)}/lib/redis"
-
-
-mode = ARGV.shift || 'process_time'
-n = (ARGV.shift || 200).to_i
-
-r = Redis.new
-RubyProf.measure_mode = RubyProf.const_get(mode.upcase)
-RubyProf.start
-
-n.times do |i|
-  key = "foo#{i}"
-  r[key] = key * 10
-  r[key]
-end
-
-results = RubyProf.stop
-File.open("profile.#{mode}", 'w') do |out|
-  RubyProf::CallTreePrinter.new(results).print(out)
-end

data/vendor/redis/tasks/redis.tasks.rb

@@ -1,140 +0,0 @@
-# Inspired by rabbitmq.rake the Redbox project at http://github.com/rick/redbox/tree/master
-require 'rake'
-require 'fileutils'
-require 'open-uri'
-
-class RedisRunner
-  
-  def self.redisdir
-    "/tmp/redis/"
-  end
-  
-  def self.redisconfdir
-    '/etc/redis.conf'
-  end
-
-  def self.dtach_socket
-    '/tmp/redis.dtach'
-  end
-
-  # Just check for existance of dtach socket
-  def self.running?
-    File.exists? dtach_socket
-  end
-  
-  def self.start
-    puts 'Detach with Ctrl+\  Re-attach with rake redis:attach'
-    sleep 3
-    exec "dtach -A #{dtach_socket} redis-server #{redisconfdir}"
-  end
-  
-  def self.start_detached
-    system "dtach -n #{dtach_socket} redis-server #{redisconfdir}"
-  end
-  
-  def self.attach
-    exec "dtach -a #{dtach_socket}"
-  end
-  
-  def self.stop
-    system 'echo "SHUTDOWN" | nc localhost 6379'
-  end
-
-end
-
-namespace :redis do
-  
-  desc 'About redis'
-  task :about do
-    puts "\nSee http://code.google.com/p/redis/ for information about redis.\n\n"
-  end
-  
-  desc 'Start redis'
-  task :start do
-    RedisRunner.start
-  end
-  
-  desc 'Stop redis'
-  task :stop do
-    RedisRunner.stop
-  end
-  
-  desc 'Restart redis'
-  task :restart do
-    RedisRunner.stop
-    RedisRunner.start
-  end
-
-  desc 'Attach to redis dtach socket'
-  task :attach do
-    RedisRunner.attach
-  end
-  
-  desc 'Install the lastest verison of Redis from Github (requires git, duh)'
-  task :install => [:about, :download, :make] do
-    %w(redis-benchmark redis-cli redis-server).each do |bin|
-      sh "sudo cp /tmp/redis/#{bin} /usr/bin/"
-    end
-
-    puts "Installed redis-benchmark, redis-cli and redis-server to /usr/bin/"
-        
-    unless File.exists?('/etc/redis.conf')
-      sh 'sudo cp /tmp/redis/redis.conf /etc/'
-      puts "Installed redis.conf to /etc/ \n You should look at this file!"
-    end  
-  end
-  
-  task :make do
-    sh "cd #{RedisRunner.redisdir} && make clean"
-    sh "cd #{RedisRunner.redisdir} && make"
-  end
-  
-  desc "Download package"
-  task :download do
-    sh 'rm -rf /tmp/redis/' if File.exists?("#{RedisRunner.redisdir}/.svn")
-    sh 'git clone git://github.com/antirez/redis.git /tmp/redis' unless File.exists?(RedisRunner.redisdir)
-
-    if File.exists?("#{RedisRunner.redisdir}/.git")
-      arguments = ENV['COMMIT'].nil? ? "pull" : "reset --hard #{ENV['COMMIT']}"
-      sh "cd #{RedisRunner.redisdir} && git #{arguments}"
-    end
-  end    
-
-  desc "Open an IRb session"
-  task :console do
-    RedisRunner.start_detached
-    system "irb -I lib -I extra -r redis.rb"
-    RedisRunner.stop
-  end
-end
-
-namespace :dtach do
-  
-  desc 'About dtach'
-  task :about do
-    puts "\nSee http://dtach.sourceforge.net/ for information about dtach.\n\n"
-  end
-  
-  desc 'Install dtach 0.8 from source'
-  task :install => [:about] do
-    
-    Dir.chdir('/tmp/')
-    unless File.exists?('/tmp/dtach-0.8.tar.gz')
-      require 'net/http'
-      
-      url = 'http://downloads.sourceforge.net/project/dtach/dtach/0.8/dtach-0.8.tar.gz'
-      open('/tmp/dtach-0.8.tar.gz', 'wb') do |file| file.write(open(url).read) end
-    end
-
-    unless File.directory?('/tmp/dtach-0.8')    
-      system('tar xzf dtach-0.8.tar.gz')
-    end
-    
-    Dir.chdir('/tmp/dtach-0.8/')
-    sh 'cd /tmp/dtach-0.8/ && ./configure && make'    
-    sh 'sudo cp /tmp/dtach-0.8/dtach /usr/bin/'
-    
-    puts 'Dtach successfully installed to /usr/bin.'
-  end
-end
-  

data/vendor/redis/test/db/.gitignore

@@ -1 +0,0 @@
-redis.pid

data/vendor/redis/test/distributed_test.rb

@@ -1,1131 +0,0 @@
-require File.join(File.dirname(__FILE__), "test_helper")
-
-require "redis/distributed"
-
-class RedisDistributedTest < Test::Unit::TestCase
-  NODES = ["redis://127.0.0.1:6379/15"]
-
-  setup do
-    @log = StringIO.new
-    @r = Redis::Distributed.new NODES, :logger => ::Logger.new(@log)
-    ensure_redis_running(@r)
-    @r.flushdb
-  end
-
-  context "Internals" do
-    test "Logger" do
-      @r.ping
-
-      assert_match(/Redis >> PING/, @log.string)
-    end
-
-    test "Recovers from failed commands" do
-      # See http://github.com/ezmobius/redis-rb/issues#issue/28
-
-      assert_raises ArgumentError do
-        @r.srem "foo"
-      end
-
-      assert_nothing_raised do
-        @r.info
-      end
-    end
-  end
-
-  context "Connection handling" do
-    test "PING" do
-      assert_equal ["PONG"], @r.ping
-    end
-
-    test "SELECT" do
-      @r.set "foo", "bar"
-
-      @r.select 14
-      assert_equal nil, @r.get("foo")
-
-      @r.select 15
-
-      assert_equal "bar", @r.get("foo")
-    end
-  end
-
-  context "Commands operating on all the kind of values" do
-    test "EXISTS" do
-      assert_equal false, @r.exists("foo")
-
-      @r.set("foo", "s1")
-
-      assert_equal true,  @r.exists("foo")
-    end
-
-    test "DEL" do
-      @r.set "foo", "s1"
-      @r.set "bar", "s2"
-      @r.set "baz", "s3"
-
-      assert_equal ["bar", "baz", "foo"], @r.keys("*").sort
-
-      @r.del "foo"
-
-      assert_equal ["bar", "baz"], @r.keys("*").sort
-
-      @r.del "bar", "baz"
-
-      assert_equal [], @r.keys("*").sort
-    end
-
-    test "TYPE" do
-      assert_equal "none", @r.type("foo")
-
-      @r.set("foo", "s1")
-
-      assert_equal "string", @r.type("foo")
-    end
-
-    test "KEYS" do
-      @r.set("f", "s1")
-      @r.set("fo", "s2")
-      @r.set("foo", "s3")
-
-      assert_equal ["f","fo", "foo"], @r.keys("f*").sort
-    end
-
-    test "RANDOMKEY" do
-      assert_raises Redis::Distributed::CannotDistribute do
-        @r.randomkey
-      end
-    end
-
-    test "RENAME" do
-      assert_raises Redis::Distributed::CannotDistribute do
-        @r.set("foo", "s1")
-        @r.rename "foo", "bar"
-      end
-
-      assert_equal "s1", @r.get("foo")
-      assert_equal nil, @r.get("bar")
-    end
-
-    test "RENAMENX" do
-      assert_raises Redis::Distributed::CannotDistribute do
-        @r.set("foo", "s1")
-        @r.rename "foo", "bar"
-      end
-
-      assert_equal "s1", @r.get("foo")
-      assert_equal nil, @r.get("bar")
-    end
-
-    test "DBSIZE" do
-      assert_equal [0], @r.dbsize
-
-      @r.set("foo", "s1")
-
-      assert_equal [1], @r.dbsize
-    end
-
-    test "EXPIRE" do
-      @r.set("foo", "s1")
-      @r.expire("foo", 1)
-
-      assert_equal "s1", @r.get("foo")
-
-      sleep 2
-
-      assert_equal nil, @r.get("foo")
-    end
-
-    test "EXPIREAT" do
-      @r.set("foo", "s1")
-      @r.expireat("foo", Time.now.to_i + 1)
-
-      assert_equal "s1", @r.get("foo")
-
-      sleep 2
-
-      assert_equal nil, @r.get("foo")
-    end
-
-    test "TTL" do
-      @r.set("foo", "s1")
-      @r.expire("foo", 1)
-
-      assert_equal 1, @r.ttl("foo")
-    end
-
-    test "MOVE"
-
-    test "FLUSHDB" do
-      @r.set("foo", "s1")
-      @r.set("bar", "s2")
-
-      assert_equal [2], @r.dbsize
-
-      @r.flushdb
-
-      assert_equal [0], @r.dbsize
-    end
-  end
-
-  context "Commands requiring clustering" do
-    test "RENAME" do
-      @r.set("{qux}foo", "s1")
-      @r.rename "{qux}foo", "{qux}bar"
-
-      assert_equal "s1", @r.get("{qux}bar")
-      assert_equal nil, @r.get("{qux}foo")
-    end
-
-    test "RENAMENX" do
-      @r.set("{qux}foo", "s1")
-      @r.set("{qux}bar", "s2")
-
-      assert_equal false, @r.renamenx("{qux}foo", "{qux}bar")
-
-      assert_equal "s1", @r.get("{qux}foo")
-      assert_equal "s2", @r.get("{qux}bar")
-    end
-
-    test "RPOPLPUSH" do
-      @r.rpush "{qux}foo", "s1"
-      @r.rpush "{qux}foo", "s2"
-
-      assert_equal "s2", @r.rpoplpush("{qux}foo", "{qux}bar")
-      assert_equal ["s2"], @r.lrange("{qux}bar", 0, -1)
-      assert_equal "s1", @r.rpoplpush("{qux}foo", "{qux}bar")
-      assert_equal ["s1", "s2"], @r.lrange("{qux}bar", 0, -1)
-    end
-
-    test "SMOVE" do
-      @r.sadd "{qux}foo", "s1"
-      @r.sadd "{qux}bar", "s2"
-
-      assert @r.smove("{qux}foo", "{qux}bar", "s1")
-      assert @r.sismember("{qux}bar", "s1")
-    end
-
-    test "SINTER" do
-      @r.sadd "{qux}foo", "s1"
-      @r.sadd "{qux}foo", "s2"
-      @r.sadd "{qux}bar", "s2"
-
-      assert_equal ["s2"], @r.sinter("{qux}foo", "{qux}bar")
-    end
-
-    test "SINTERSTORE" do
-      @r.sadd "{qux}foo", "s1"
-      @r.sadd "{qux}foo", "s2"
-      @r.sadd "{qux}bar", "s2"
-
-      @r.sinterstore("{qux}baz", "{qux}foo", "{qux}bar")
-
-      assert_equal ["s2"], @r.smembers("{qux}baz")
-    end
-
-    test "SUNION" do
-      @r.sadd "{qux}foo", "s1"
-      @r.sadd "{qux}foo", "s2"
-      @r.sadd "{qux}bar", "s2"
-      @r.sadd "{qux}bar", "s3"
-
-      assert_equal ["s1", "s2", "s3"], @r.sunion("{qux}foo", "{qux}bar").sort
-    end
-
-    test "SUNIONSTORE" do
-      @r.sadd "{qux}foo", "s1"
-      @r.sadd "{qux}foo", "s2"
-      @r.sadd "{qux}bar", "s2"
-      @r.sadd "{qux}bar", "s3"
-
-      @r.sunionstore("{qux}baz", "{qux}foo", "{qux}bar")
-
-      assert_equal ["s1", "s2", "s3"], @r.smembers("{qux}baz").sort
-    end
-
-    test "SDIFF" do
-      @r.sadd "{qux}foo", "s1"
-      @r.sadd "{qux}foo", "s2"
-      @r.sadd "{qux}bar", "s2"
-      @r.sadd "{qux}bar", "s3"
-
-      assert_equal ["s1"], @r.sdiff("{qux}foo", "{qux}bar")
-      assert_equal ["s3"], @r.sdiff("{qux}bar", "{qux}foo")
-    end
-
-    test "SDIFFSTORE" do
-      @r.sadd "{qux}foo", "s1"
-      @r.sadd "{qux}foo", "s2"
-      @r.sadd "{qux}bar", "s2"
-      @r.sadd "{qux}bar", "s3"
-
-      @r.sdiffstore("{qux}baz", "{qux}foo", "{qux}bar")
-
-      assert_equal ["s1"], @r.smembers("{qux}baz")
-    end
-
-    test "SORT" do
-      @r.set("foo:1", "s1")
-      @r.set("foo:2", "s2")
-
-      @r.rpush("{qux}bar", "1")
-      @r.rpush("{qux}bar", "2")
-
-      assert_equal ["s1"], @r.sort("{qux}bar", :get => "foo:*", :limit => [0, 1])
-      assert_equal ["s2"], @r.sort("{qux}bar", :get => "foo:*", :limit => [0, 1], :order => "desc alpha")
-    end
-
-    test "SORT with an array of GETs" do
-      @r.set("foo:1:a", "s1a")
-      @r.set("foo:1:b", "s1b")
-
-      @r.set("foo:2:a", "s2a")
-      @r.set("foo:2:b", "s2b")
-
-      @r.rpush("{qux}bar", "1")
-      @r.rpush("{qux}bar", "2")
-
-      assert_equal ["s1a", "s1b"], @r.sort("{qux}bar", :get => ["foo:*:a", "foo:*:b"], :limit => [0, 1])
-      assert_equal ["s2a", "s2b"], @r.sort("{qux}bar", :get => ["foo:*:a", "foo:*:b"], :limit => [0, 1], :order => "desc alpha")
-    end
-
-    test "SORT with STORE" do
-      @r.set("foo:1", "s1")
-      @r.set("foo:2", "s2")
-
-      @r.rpush("{qux}bar", "1")
-      @r.rpush("{qux}bar", "2")
-
-      @r.sort("{qux}bar", :get => "foo:*", :store => "{qux}baz")
-      assert_equal ["s1", "s2"], @r.lrange("{qux}baz", 0, -1)
-    end
-  end
-
-  context "Commands operating on string values" do
-    test "SET and GET" do
-      @r.set("foo", "s1")
-
-      assert_equal "s1", @r.get("foo")
-    end
-
-    test "SET and GET with brackets" do
-      @r["foo"] = "s1"
-
-      assert_equal "s1", @r["foo"]
-    end
-
-    test "SET and GET with newline characters" do
-      @r.set("foo", "1\n")
-
-      assert_equal "1\n", @r.get("foo")
-    end
-
-    test "SET and GET with ASCII characters" do
-      (0..255).each do |i|
-        str = "#{i.chr}---#{i.chr}"
-        @r.set("foo", str)
-
-        assert_equal str, @r.get("foo")
-      end
-    end
-
-    test "SETEX" do
-      @r.setex("foo", 1, "s1")
-
-      assert_equal "s1", @r.get("foo")
-
-      sleep 2
-
-      assert_equal nil, @r.get("foo")
-    end
-
-    test "GETSET" do
-      @r.set("foo", "bar")
-
-      assert_equal "bar", @r.getset("foo", "baz")
-      assert_equal "baz", @r.get("foo")
-    end
-
-    test "MGET" do
-      assert_raises Redis::Distributed::CannotDistribute do
-        @r.mget("foo", "bar")
-      end
-    end
-
-    test "MGET mapped" do
-      assert_raises Redis::Distributed::CannotDistribute do
-        @r.mapped_mget("foo", "bar")
-      end
-    end
-
-    test "SETNX" do
-      @r.set("foo", "s1")
-
-      assert_equal "s1", @r.get("foo")
-
-      @r.setnx("foo", "s2")
-
-      assert_equal "s1", @r.get("foo")
-    end
-
-    test "MSET" do
-      assert_raises Redis::Distributed::CannotDistribute do
-        @r.mset(:foo, "s1", :bar, "s2")
-      end
-    end
-
-    test "MSET mapped" do
-      assert_raises Redis::Distributed::CannotDistribute do
-        @r.mapped_mset(:foo => "s1", :bar => "s2")
-      end
-    end
-
-    test "MSETNX" do
-      assert_raises Redis::Distributed::CannotDistribute do
-        @r.set("foo", "s1")
-        @r.msetnx(:foo, "s2", :bar, "s3")
-      end
-    end
-
-    test "MSETNX mapped" do
-      assert_raises Redis::Distributed::CannotDistribute do
-        @r.set("foo", "s1")
-        @r.mapped_msetnx(:foo => "s2", :bar => "s3")
-      end
-    end
-
-    test "INCR" do
-      assert_equal 1, @r.incr("foo")
-      assert_equal 2, @r.incr("foo")
-      assert_equal 3, @r.incr("foo")
-    end
-
-    test "INCRBY" do
-      assert_equal 1, @r.incrby("foo", 1)
-      assert_equal 3, @r.incrby("foo", 2)
-      assert_equal 6, @r.incrby("foo", 3)
-    end
-
-    test "DECR" do
-      @r.set("foo", 3)
-
-      assert_equal 2, @r.decr("foo")
-      assert_equal 1, @r.decr("foo")
-      assert_equal 0, @r.decr("foo")
-    end
-
-    test "DECRBY" do
-      @r.set("foo", 6)
-
-      assert_equal 3, @r.decrby("foo", 3)
-      assert_equal 1, @r.decrby("foo", 2)
-      assert_equal 0, @r.decrby("foo", 1)
-    end
-  end
-
-  context "Commands operating on lists" do
-    test "RPUSH" do
-      @r.rpush "foo", "s1"
-      @r.rpush "foo", "s2"
-
-      assert_equal 2, @r.llen("foo")
-      assert_equal "s2", @r.rpop("foo")
-    end
-
-    test "LPUSH" do
-      @r.lpush "foo", "s1"
-      @r.lpush "foo", "s2"
-
-      assert_equal 2, @r.llen("foo")
-      assert_equal "s2", @r.lpop("foo")
-    end
-
-    test "LLEN" do
-      @r.rpush "foo", "s1"
-      @r.rpush "foo", "s2"
-
-      assert_equal 2, @r.llen("foo")
-    end
-
-    test "LRANGE" do
-      @r.rpush "foo", "s1"
-      @r.rpush "foo", "s2"
-      @r.rpush "foo", "s3"
-
-      assert_equal ["s2", "s3"], @r.lrange("foo", 1, -1)
-      assert_equal ["s1", "s2"], @r.lrange("foo", 0, 1)
-    end
-
-    test "LTRIM" do
-      @r.rpush "foo", "s1"
-      @r.rpush "foo", "s2"
-      @r.rpush "foo", "s3"
-
-      @r.ltrim "foo", 0, 1
-
-      assert_equal 2, @r.llen("foo")
-      assert_equal ["s1", "s2"], @r.lrange("foo", 0, -1)
-    end
-
-    test "LINDEX" do
-      @r.rpush "foo", "s1"
-      @r.rpush "foo", "s2"
-
-      assert_equal "s1", @r.lindex("foo", 0)
-      assert_equal "s2", @r.lindex("foo", 1)
-    end
-
-    test "LSET" do
-      @r.rpush "foo", "s1"
-      @r.rpush "foo", "s2"
-
-      assert_equal "s2", @r.lindex("foo", 1)
-      assert @r.lset("foo", 1, "s3")
-      assert_equal "s3", @r.lindex("foo", 1)
-
-      assert_raises RuntimeError do
-        @r.lset("foo", 4, "s3")
-      end
-    end
-
-    test "LREM" do
-      @r.rpush "foo", "s1"
-      @r.rpush "foo", "s2"
-
-      assert_equal 1, @r.lrem("foo", 1, "s1")
-      assert_equal ["s2"], @r.lrange("foo", 0, -1)
-    end
-
-    test "LPOP" do
-      @r.rpush "foo", "s1"
-      @r.rpush "foo", "s2"
-
-      assert_equal 2, @r.llen("foo")
-      assert_equal "s1", @r.lpop("foo")
-      assert_equal 1, @r.llen("foo")
-    end
-
-    test "RPOP" do
-      @r.rpush "foo", "s1"
-      @r.rpush "foo", "s2"
-
-      assert_equal 2, @r.llen("foo")
-      assert_equal "s2", @r.rpop("foo")
-      assert_equal 1, @r.llen("foo")
-    end
-
-    test "RPOPLPUSH" do
-      assert_raises Redis::Distributed::CannotDistribute do
-        @r.rpoplpush("foo", "bar")
-      end
-    end
-  end
-
-  context "Blocking commands" do
-    test "BLPOP" do
-      @r.lpush("foo", "s1")
-      @r.lpush("foo", "s2")
-
-      thread = Thread.new do
-        redis = Redis::Distributed.new(NODES)
-        sleep 0.3
-        redis.lpush("foo", "s3")
-      end
-
-      assert_equal @r.blpop("foo", 0.1), ["foo", "s2"]
-      assert_equal @r.blpop("foo", 0.1), ["foo", "s1"]
-      assert_equal @r.blpop("foo", 0.4), ["foo", "s3"]
-
-      thread.join
-    end
-
-    test "BRPOP" do
-      @r.rpush("foo", "s1")
-      @r.rpush("foo", "s2")
-
-      t = Thread.new do
-        redis = Redis::Distributed.new(NODES)
-        sleep 0.3
-        redis.rpush("foo", "s3")
-      end
-
-      assert_equal @r.brpop("foo", 0.1), ["foo", "s2"]
-      assert_equal @r.brpop("foo", 0.1), ["foo", "s1"]
-      assert_equal @r.brpop("foo", 0.4), ["foo", "s3"]
-
-      t.join
-    end
-
-    test "BRPOP should unset a configured socket timeout" do
-      @r = Redis::Distributed.new(NODES, :timeout => 1)
-      assert_nothing_raised do
-        @r.brpop("foo", 2)
-      end # Errno::EAGAIN raised if socket times out before redis command times out
-    end
-
-    test "BRPOP should restore the timeout after the command is run"
-
-    test "BRPOP should restore the timeout even if the command fails"
-  end
-
-  context "Commands operating on sets" do
-    test "SADD" do
-      @r.sadd "foo", "s1"
-      @r.sadd "foo", "s2"
-
-      assert_equal ["s1", "s2"], @r.smembers("foo").sort
-    end
-
-    test "SREM" do
-      @r.sadd "foo", "s1"
-      @r.sadd "foo", "s2"
-
-      @r.srem("foo", "s1")
-
-      assert_equal ["s2"], @r.smembers("foo")
-    end
-
-    test "SPOP" do
-      @r.sadd "foo", "s1"
-      @r.sadd "foo", "s2"
-
-      assert ["s1", "s2"].include?(@r.spop("foo"))
-      assert ["s1", "s2"].include?(@r.spop("foo"))
-      assert_nil @r.spop("foo")
-    end
-
-    test "SMOVE" do
-      assert_raises Redis::Distributed::CannotDistribute do
-        @r.sadd "foo", "s1"
-        @r.sadd "bar", "s2"
-
-        @r.smove("foo", "bar", "s1")
-      end
-    end
-
-    test "SCARD" do
-      assert_equal 0, @r.scard("foo")
-
-      @r.sadd "foo", "s1"
-
-      assert_equal 1, @r.scard("foo")
-
-      @r.sadd "foo", "s2"
-
-      assert_equal 2, @r.scard("foo")
-    end
-
-    test "SISMEMBER" do
-      assert_equal false, @r.sismember("foo", "s1")
-
-      @r.sadd "foo", "s1"
-
-      assert_equal true,  @r.sismember("foo", "s1")
-      assert_equal false, @r.sismember("foo", "s2")
-    end
-
-    test "SINTER" do
-      assert_raises Redis::Distributed::CannotDistribute do
-        @r.sadd "foo", "s1"
-        @r.sadd "foo", "s2"
-        @r.sadd "bar", "s2"
-
-        @r.sinter("foo", "bar")
-      end
-    end
-
-    test "SINTERSTORE" do
-      assert_raises Redis::Distributed::CannotDistribute do
-        @r.sadd "foo", "s1"
-        @r.sadd "foo", "s2"
-        @r.sadd "bar", "s2"
-
-        @r.sinterstore("baz", "foo", "bar")
-      end
-    end
-
-    test "SUNION" do
-      assert_raises Redis::Distributed::CannotDistribute do
-        @r.sadd "foo", "s1"
-        @r.sadd "foo", "s2"
-        @r.sadd "bar", "s2"
-        @r.sadd "bar", "s3"
-
-        @r.sunion("foo", "bar")
-      end
-    end
-
-    test "SUNIONSTORE" do
-      assert_raises Redis::Distributed::CannotDistribute do
-        @r.sadd "foo", "s1"
-        @r.sadd "foo", "s2"
-        @r.sadd "bar", "s2"
-        @r.sadd "bar", "s3"
-
-        @r.sunionstore("baz", "foo", "bar")
-      end
-    end
-
-    test "SDIFF" do
-      assert_raises Redis::Distributed::CannotDistribute do
-        @r.sadd "foo", "s1"
-        @r.sadd "foo", "s2"
-        @r.sadd "bar", "s2"
-        @r.sadd "bar", "s3"
-
-        @r.sdiff("foo", "bar")
-      end
-    end
-
-    test "SDIFFSTORE" do
-      assert_raises Redis::Distributed::CannotDistribute do
-        @r.sadd "foo", "s1"
-        @r.sadd "foo", "s2"
-        @r.sadd "bar", "s2"
-        @r.sadd "bar", "s3"
-
-        @r.sdiffstore("baz", "foo", "bar")
-      end
-    end
-
-    test "SMEMBERS" do
-      assert_equal [], @r.smembers("foo")
-
-      @r.sadd "foo", "s1"
-      @r.sadd "foo", "s2"
-
-      assert_equal ["s1", "s2"], @r.smembers("foo").sort
-    end
-
-    test "SRANDMEMBER" do
-      @r.sadd "foo", "s1"
-      @r.sadd "foo", "s2"
-
-      4.times do
-        assert ["s1", "s2"].include?(@r.srandmember("foo"))
-      end
-
-      assert_equal 2, @r.scard("foo")
-    end
-  end
-
-  context "Commands operating on sorted sets" do
-    test "ZADD" do
-      assert_equal 0, @r.zcard("foo")
-
-      @r.zadd "foo", 1, "s1"
-
-      assert_equal 1, @r.zcard("foo")
-    end
-
-    test "ZREM" do
-      @r.zadd "foo", 1, "s1"
-
-      assert_equal 1, @r.zcard("foo")
-
-      @r.zadd "foo", 2, "s2"
-
-      assert_equal 2, @r.zcard("foo")
-
-      @r.zrem "foo", "s1"
-
-      assert_equal 1, @r.zcard("foo")
-    end
-
-    test "ZINCRBY" do
-      @r.zincrby "foo", 1, "s1"
-
-      assert_equal "1", @r.zscore("foo", "s1")
-
-      @r.zincrby "foo", 10, "s1"
-
-      assert_equal "11", @r.zscore("foo", "s1")
-    end
-
-    test "ZRANK"
-
-    test "ZREVRANK"
-
-    test "ZRANGE" do
-      @r.zadd "foo", 1, "s1"
-      @r.zadd "foo", 2, "s2"
-      @r.zadd "foo", 3, "s3"
-
-      assert_equal ["s1", "s2"], @r.zrange("foo", 0, 1)
-      assert_equal ["s1", "1", "s2", "2"], @r.zrange("foo", 0, 1, true)
-    end
-
-    test "ZREVRANGE" do
-      @r.zadd "foo", 1, "s1"
-      @r.zadd "foo", 2, "s2"
-      @r.zadd "foo", 3, "s3"
-
-      assert_equal ["s3", "s2"], @r.zrevrange("foo", 0, 1)
-      assert_equal ["s3", "3", "s2", "2"], @r.zrevrange("foo", 0, 1, true)
-    end
-
-    test "ZRANGEBYSCORE" do
-      @r.zadd "foo", 1, "s1"
-      @r.zadd "foo", 2, "s2"
-      @r.zadd "foo", 3, "s3"
-
-      assert_equal ["s2", "s3"], @r.zrangebyscore("foo", 2, 3)
-    end
-
-    test "ZRANGEBYSCORE with LIMIT"
-    test "ZRANGEBYSCORE with WITHSCORES"
-
-    test "ZCARD" do
-      assert_equal 0, @r.zcard("foo")
-
-      @r.zadd "foo", 1, "s1"
-
-      assert_equal 1, @r.zcard("foo")
-    end
-
-    test "ZSCORE" do
-      @r.zadd "foo", 1, "s1"
-
-      assert_equal "1", @r.zscore("foo", "s1")
-
-      assert_nil @r.zscore("foo", "s2")
-      assert_nil @r.zscore("bar", "s1")
-    end
-
-    test "ZREMRANGEBYRANK"
-
-    test "ZREMRANGEBYSCORE"
-
-    test "ZUNION"
-
-    test "ZINTER"
-  end
-
-  context "Commands operating on hashes" do
-    test "HSET and HGET" do
-      @r.hset("foo", "f1", "s1")
-
-      assert_equal "s1", @r.hget("foo", "f1")
-    end
-
-    test "HDEL" do
-      @r.hset("foo", "f1", "s1")
-
-      assert_equal "s1", @r.hget("foo", "f1")
-
-      @r.hdel("foo", "f1")
-
-      assert_equal nil, @r.hget("foo", "f1")
-    end
-
-    test "HEXISTS" do
-      assert_equal false, @r.hexists("foo", "f1")
-
-      @r.hset("foo", "f1", "s1")
-
-      assert @r.hexists("foo", "f1")
-    end
-
-    test "HLEN" do
-      assert_equal 0, @r.hlen("foo")
-
-      @r.hset("foo", "f1", "s1")
-
-      assert_equal 1, @r.hlen("foo")
-
-      @r.hset("foo", "f2", "s2")
-
-      assert_equal 2, @r.hlen("foo")
-    end
-
-    test "HKEYS" do
-      assert_equal [], @r.hkeys("foo")
-
-      @r.hset("foo", "f1", "s1")
-      @r.hset("foo", "f2", "s2")
-
-      assert_equal ["f1", "f2"], @r.hkeys("foo")
-    end
-
-    test "HVALS" do
-      assert_equal [], @r.hvals("foo")
-
-      @r.hset("foo", "f1", "s1")
-      @r.hset("foo", "f2", "s2")
-
-      assert_equal ["s1", "s2"], @r.hvals("foo")
-    end
-
-    test "HGETALL" do
-      assert_equal({}, @r.hgetall("foo"))
-
-      @r.hset("foo", "f1", "s1")
-      @r.hset("foo", "f2", "s2")
-
-      assert_equal({"f1" => "s1", "f2" => "s2"}, @r.hgetall("foo"))
-    end
-
-    test "HMSET" do
-      @r.hmset("hash", "foo1", "bar1", "foo2", "bar2")
-
-      assert_equal "bar1", @r.hget("hash", "foo1")
-      assert_equal "bar2", @r.hget("hash", "foo2")
-    end
-
-    test "HMSET with invalid arguments" do
-      assert_raises RuntimeError do
-        @r.hmset("hash", "foo1", "bar1", "foo2", "bar2", "foo3")
-      end
-    end
-  end
-
-  context "Sorting" do
-    test "SORT" do
-      assert_raises Redis::Distributed::CannotDistribute do
-        @r.set("foo:1", "s1")
-        @r.set("foo:2", "s2")
-
-        @r.rpush("bar", "1")
-        @r.rpush("bar", "2")
-
-        @r.sort("bar", :get => "foo:*", :limit => [0, 1])
-      end
-    end
-  end
-
-  context "Transactions" do
-    test "MULTI/DISCARD" do
-      @foo = nil
-
-      assert_raises Redis::Distributed::CannotDistribute do
-        @r.multi { @foo = 1 }
-      end
-
-      assert_nil @foo
-
-      assert_raises Redis::Distributed::CannotDistribute do
-        @r.discard
-      end
-    end
-  end
-
-  context "Publish/Subscribe" do
-
-    test "SUBSCRIBE and UNSUBSCRIBE"
-    # do
-    #   thread = Thread.new do
-    #     @r.subscribe("foo") do |on|
-    #       on.subscribe do |channel, total|
-    #         @subscribed = true
-    #         @t1 = total
-    #       end
-
-    #       on.message do |channel, message|
-    #         if message == "s1"
-    #           @r.unsubscribe
-    #           @message = message
-    #         end
-    #       end
-
-    #       on.unsubscribe do |channel, total|
-    #         @unsubscribed = true
-    #         @t2 = total
-    #       end
-    #     end
-    #   end
-
-    #   Redis::Distributed.new(NODES).publish("foo", "s1")
-
-    #   thread.join
-
-    #   assert @subscribed
-    #   assert_equal 1, @t1
-    #   assert @unsubscribed
-    #   assert_equal 0, @t2
-    #   assert_equal "s1", @message
-    # end
-
-    test "SUBSCRIBE within SUBSCRIBE"
-    # do
-    #   @channels = []
-
-    #   thread = Thread.new do
-    #     @r.subscribe("foo") do |on|
-    #       on.subscribe do |channel, total|
-    #         @channels << channel
-
-    #         @r.subscribe("bar") if channel == "foo"
-    #         @r.unsubscribe if channel == "bar"
-    #       end
-    #     end
-    #   end
-
-    #   Redis::Distributed.new(NODES).publish("foo", "s1")
-
-    #   thread.join
-
-    #   assert_equal ["foo", "bar"], @channels
-    # end
-
-    test "other commands within a SUBSCRIBE"
-    # do
-    #   assert_raises RuntimeError do
-    #     @r.subscribe("foo") do |on|
-    #       on.subscribe do |channel, total|
-    #         @r.set("bar", "s2")
-    #       end
-    #     end
-    #   end
-    # end
-
-    test "SUBSCRIBE without a block"
-    # do
-    #   assert_raises LocalJumpError do
-    #     @r.subscribe("foo")
-    #   end
-    # end
-
-    test "SUBSCRIBE timeout"
-
-  end
-
-  context "Persistence control commands" do
-    test "SAVE and BGSAVE" do
-      assert_nothing_raised do
-        @r.save
-      end
-
-      assert_nothing_raised do
-        @r.bgsave
-      end
-    end
-
-    test "LASTSAVE" do
-      assert @r.lastsave.all? { |t| Time.at(t) <= Time.now }
-    end
-  end
-
-  context "Remote server control commands" do
-    test "INFO" do
-      %w(last_save_time redis_version total_connections_received connected_clients total_commands_processed connected_slaves uptime_in_seconds used_memory uptime_in_days changes_since_last_save).each do |x|
-        @r.info.each do |info|
-          assert info.keys.include?(x)
-        end
-      end
-    end
-
-    test "MONITOR" do
-      assert_raises NotImplementedError do
-        @r.monitor
-      end
-    end
-
-    test "ECHO" do
-      assert_equal ["foo bar baz\n"], @r.echo("foo bar baz\n")
-    end
-  end
-
-  context "Distributed" do
-    test "handle multiple servers" do
-      @r = Redis::Distributed.new ["redis://localhost:6379/15", *NODES]
-
-      100.times do |idx|
-        @r.set(idx.to_s, "foo#{idx}")
-      end
-
-      100.times do |idx|
-        assert_equal "foo#{idx}", @r.get(idx.to_s)
-      end
-
-      assert_equal "0", @r.keys("*").sort.first
-      assert_equal "string", @r.type("1")
-    end
-
-    test "add nodes" do
-      logger = Logger.new("/dev/null")
-
-      @r = Redis::Distributed.new NODES, :logger => logger, :timeout => 10
-
-      assert_equal "127.0.0.1", @r.nodes[0].client.host
-      assert_equal 6379, @r.nodes[0].client.port
-      assert_equal 15, @r.nodes[0].client.db
-      assert_equal 10, @r.nodes[0].client.timeout
-      assert_equal logger, @r.nodes[0].client.logger
-
-      @r.add_node("redis://localhost:6380/14")
-
-      assert_equal "localhost", @r.nodes[1].client.host
-      assert_equal 6380, @r.nodes[1].client.port
-      assert_equal 14, @r.nodes[1].client.db
-      assert_equal 10, @r.nodes[1].client.timeout
-      assert_equal logger, @r.nodes[1].client.logger
-    end
-  end
-
-  context "Pipelining commands" do
-    test "cannot be distributed" do
-      assert_raises Redis::Distributed::CannotDistribute do
-        @r.pipelined do
-          @r.lpush "foo", "s1"
-          @r.lpush "foo", "s2"
-        end
-      end
-    end
-  end
-
-  context "Unknown commands" do
-    should "not work by default" do
-      assert_raises NoMethodError do
-        @r.not_yet_implemented_command
-      end
-    end
-  end
-
-  context "Key tags" do
-    should "hash consistently" do
-      r1 = Redis::Distributed.new ["redis://localhost:6379/15", *NODES]
-      r2 = Redis::Distributed.new ["redis://localhost:6379/15", *NODES]
-      r3 = Redis::Distributed.new ["redis://localhost:6379/15", *NODES]
-
-      assert r1.node_for("foo").id == r2.node_for("foo").id
-      assert r1.node_for("foo").id == r3.node_for("foo").id
-    end
-
-    should "allow clustering of keys" do
-      @r = Redis::Distributed.new(NODES)
-      @r.add_node("redis://localhost:6379/14")
-      @r.flushdb
-
-      100.times do |i|
-        @r.set "{foo}users:#{i}", i
-      end
-
-      assert_equal [0, 100], @r.nodes.map { |node| node.keys.size }
-    end
-
-    should "distribute keys if no clustering is used" do
-      @r.add_node("redis://localhost:6379/14")
-      @r.flushdb
-
-      @r.set "users:1", 1
-      @r.set "users:4", 4
-
-      assert_equal [1, 1], @r.nodes.map { |node| node.keys.size }
-    end
-
-    should "allow passing a custom tag extractor" do
-      @r = Redis::Distributed.new(NODES, :tag => /^(.+?):/)
-      @r.add_node("redis://localhost:6379/14")
-      @r.flushdb
-
-      100.times do |i|
-        @r.set "foo:users:#{i}", i
-      end
-
-      assert_equal [0, 100], @r.nodes.map { |node| node.keys.size }
-    end
-  end
-
-  teardown do
-    @r.nodes.each { |node| node.client.disconnect }
-  end
-end