redis 3.3.5 → 4.0.0.rc1

data/lib/redis/client.rb

@@ -1,4 +1,4 @@
-require "redis/errors"
+require_relative "errors"
 require "socket"
 require "cgi"
 
@@ -451,12 +451,12 @@ class Redis
       case options[:tcp_keepalive]
       when Hash
         [:time, :intvl, :probes].each do |key|
-          unless options[:tcp_keepalive][key].is_a?(Integer)
-            raise "Expected the #{key.inspect} key in :tcp_keepalive to be an Integer"
+          unless options[:tcp_keepalive][key].is_a?(Fixnum)
+            raise "Expected the #{key.inspect} key in :tcp_keepalive to be a Fixnum"
           end
         end
 
-      when Integer
+      when Fixnum
         if options[:tcp_keepalive] >= 60
           options[:tcp_keepalive] = {:time => options[:tcp_keepalive] - 20, :intvl => 10, :probes => 2}
 
@@ -478,11 +478,16 @@ class Redis
 
       if driver.kind_of?(String)
         begin
-          require "redis/connection/#{driver}"
-          driver = Connection.const_get(driver.capitalize)
-        rescue LoadError, NameError
-          raise RuntimeError, "Cannot load driver #{driver.inspect}"
+          require_relative "connection/#{driver}"
+        rescue LoadError, NameError => e
+          begin
+            require "connection/#{driver}"
+          rescue LoadError, NameError => e
+            raise RuntimeError, "Cannot load driver #{driver.inspect}: #{e.message}"
+          end
         end
+
+        driver = Connection.const_get(driver.capitalize)
       end
 
       driver

data/lib/redis/connection.rb

@@ -1,4 +1,4 @@
-require "redis/connection/registry"
+require_relative "connection/registry"
 
 # If a connection driver was required before this file, the array
 # Redis::Connection.drivers will contain one or more classes. The last driver
@@ -6,4 +6,4 @@ require "redis/connection/registry"
 # the plain Ruby driver as our default. Another driver can be required at a
 # later point in time, causing it to be the last element of the #drivers array
 # and therefore be chosen by default.
-require "redis/connection/ruby" if Redis::Connection.drivers.empty?
+require_relative "connection/ruby" if Redis::Connection.drivers.empty?

data/lib/redis/connection/command_helper.rb

@@ -30,14 +30,8 @@ class Redis
 
     protected
 
-      if defined?(Encoding::default_external)
-        def encode(string)
-          string.force_encoding(Encoding::default_external)
-        end
-      else
-        def encode(string)
-          string
-        end
+      def encode(string)
+        string.force_encoding(Encoding.default_external)
       end
     end
   end

data/lib/redis/connection/hiredis.rb

@@ -1,5 +1,5 @@
-require "redis/connection/registry"
-require "redis/errors"
+require_relative "registry"
+require_relative "../errors"
 require "hiredis/connection"
 require "timeout"
 

data/lib/redis/connection/ruby.rb

@@ -1,6 +1,6 @@
-require "redis/connection/registry"
-require "redis/connection/command_helper"
-require "redis/errors"
+require_relative "registry"
+require_relative "command_helper"
+require_relative "../errors"
 require "socket"
 require "timeout"
 
@@ -10,31 +10,12 @@ rescue LoadError
   # Not all systems have OpenSSL support
 end
 
-if RUBY_VERSION < "1.9.3"
-  class String
-    # Ruby 1.8.7 does not have byteslice, but it handles encodings differently anyway.
-    # We can simply slice the string, which is a byte array there.
-    def byteslice(*args)
-      slice(*args)
-    end
-  end
-end
-
 class Redis
   module Connection
     module SocketMixin
 
       CRLF = "\r\n".freeze
 
-      # Exceptions raised during non-blocking I/O ops that require retrying the op
-      if RUBY_VERSION >= "1.9.3"
-        NBIO_READ_EXCEPTIONS = [IO::WaitReadable]
-        NBIO_WRITE_EXCEPTIONS = [IO::WaitWritable]
-      else
-        NBIO_READ_EXCEPTIONS = [Errno::EWOULDBLOCK, Errno::EAGAIN]
-        NBIO_WRITE_EXCEPTIONS = [Errno::EWOULDBLOCK, Errno::EAGAIN]
-      end
-
       def initialize(*args)
         super(*args)
 
@@ -83,13 +64,13 @@ class Redis
         begin
           read_nonblock(nbytes)
 
-        rescue *NBIO_READ_EXCEPTIONS
+        rescue IO::WaitReadable
           if IO.select([self], nil, nil, @timeout)
             retry
           else
             raise Redis::TimeoutError
           end
-        rescue *NBIO_WRITE_EXCEPTIONS
+        rescue IO::WaitWritable
           if IO.select(nil, [self], nil, @timeout)
             retry
           else
@@ -105,13 +86,13 @@ class Redis
         begin
           write_nonblock(data)
 
-        rescue *NBIO_WRITE_EXCEPTIONS
+        rescue IO::WaitWritable
           if IO.select(nil, [self], nil, @write_timeout)
             retry
           else
             raise Redis::TimeoutError
           end
-        rescue *NBIO_READ_EXCEPTIONS
+        rescue IO::WaitReadable
           if IO.select([self], nil, nil, @write_timeout)
             retry
           else
@@ -307,7 +288,6 @@ class Redis
           raise ArgumentError, "SSL incompatible with unix sockets" if config[:ssl]
           sock = UNIXSocket.connect(config[:path], config[:connect_timeout])
         elsif config[:scheme] == "rediss" || config[:ssl]
-          raise ArgumentError, "This library does not support SSL on Ruby < 1.9" if RUBY_VERSION < "1.9.3"
           sock = SSLSocket.connect(config[:host], config[:port], config[:connect_timeout], config[:ssl_params])
         else
           sock = TCPSocket.connect(config[:host], config[:port], config[:connect_timeout])

data/lib/redis/connection/synchrony.rb

@@ -1,6 +1,6 @@
-require "redis/connection/command_helper"
-require "redis/connection/registry"
-require "redis/errors"
+require_relative "command_helper"
+require_relative "registry"
+require_relative "../errors"
 require "em-synchrony"
 require "hiredis/reader"
 

data/lib/redis/pipeline.rb

@@ -1,10 +1,4 @@
 class Redis
-  unless defined?(::BasicObject)
-    class BasicObject
-      instance_methods.each { |meth| undef_method(meth) unless meth =~ /\A(__|instance_eval)/ }
-    end
-  end
-
   class Pipeline
     attr_accessor :db
 

data/lib/redis/version.rb

@@ -1,3 +1,3 @@
 class Redis
-  VERSION = "3.3.5"
+  VERSION = "4.0.0.rc1"
 end

data/makefile

@@ -0,0 +1,42 @@
+TEST_FILES   := $(shell find test -name *_test.rb -type f)
+REDIS_BRANCH := unstable
+TMP          := tmp
+BUILD_DIR    := ${TMP}/redis-${REDIS_BRANCH}
+TARBALL      := ${TMP}/redis-${REDIS_BRANCH}.tar.gz
+BINARY       := ${BUILD_DIR}/src/redis-server
+PID_PATH     := ${BUILD_DIR}/redis.pid
+SOCKET_PATH  := ${BUILD_DIR}/redis.sock
+PORT         := 6381
+
+test: ${TEST_FILES}
+	make start
+	env SOCKET_PATH=${SOCKET_PATH} \
+		ruby -v $$(echo $? | tr ' ' '\n' | awk '{ print "-r./" $$0 }') -e ''
+	make stop
+
+${TMP}:
+	mkdir $@
+
+${TARBALL}: ${TMP}
+	wget https://github.com/antirez/redis/archive/${REDIS_BRANCH}.tar.gz -O $@
+
+${BINARY}: ${TARBALL} ${TMP}
+	rm -rf ${BUILD_DIR}
+	mkdir -p ${BUILD_DIR}
+	tar xf ${TARBALL} -C ${TMP}
+	cd ${BUILD_DIR} && make
+
+stop:
+	(test -f ${PID_PATH} && (kill $$(cat ${PID_PATH}) || true) && rm -f ${PID_PATH}) || true
+
+start: ${BINARY}
+	${BINARY}                     \
+		--daemonize  yes            \
+		--pidfile    ${PID_PATH}    \
+		--port       ${PORT}        \
+		--unixsocket ${SOCKET_PATH}
+
+clean:
+	(test -d ${BUILD_DIR} && cd ${BUILD_DIR}/src && make clean distclean) || true
+
+.PHONY: test start stop

data/redis.gemspec

@@ -1,8 +1,4 @@
-# -*- encoding: utf-8 -*-
-
-$:.unshift File.expand_path("../lib", __FILE__)
-
-require "redis/version"
+require "./lib/redis/version"
 
 Gem::Specification.new do |s|
   s.name = "redis"
@@ -15,8 +11,7 @@ Gem::Specification.new do |s|
 
   s.description = <<-EOS
     A Ruby client that tries to match Redis' API one-to-one, while still
-    providing an idiomatic interface. It features thread-safety,
-    client-side sharding, pipelining, and an obsession for performance.
+    providing an idiomatic interface.
   EOS
 
   s.license = "MIT"
@@ -39,6 +34,7 @@ Gem::Specification.new do |s|
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
 
-  s.add_development_dependency("rake", "<11.0.0")
   s.add_development_dependency("test-unit", "3.1.5")
+  s.add_development_dependency("hiredis")
+  s.add_development_dependency("em-synchrony")
 end

data/test/bitpos_test.rb

@@ -1,10 +1,4 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
-
-unless defined?(Enumerator)
-  Enumerator = Enumerable::Enumerator
-end
+require_relative "helper"
 
 class TestBitpos < Test::Unit::TestCase
 
@@ -13,48 +7,48 @@ class TestBitpos < Test::Unit::TestCase
   def test_bitpos_empty_zero
     target_version "2.9.11" do
       r.del "foo"
-      assert_equal 0, r.bitpos("foo", 0)
+      assert_equal(0, r.bitpos("foo", 0))
     end
   end
 
   def test_bitpos_empty_one
     target_version "2.9.11" do
       r.del "foo"
-      assert_equal -1, r.bitpos("foo", 1)
+      assert_equal(-1, r.bitpos("foo", 1))
     end
   end
 
   def test_bitpos_zero
     target_version "2.9.11" do
       r.set "foo", "\xff\xf0\x00"
-      assert_equal 12, r.bitpos("foo", 0)
+      assert_equal(12, r.bitpos("foo", 0))
     end
   end
 
   def test_bitpos_one
     target_version "2.9.11" do
       r.set "foo", "\x00\x0f\x00"
-      assert_equal 12, r.bitpos("foo", 1)
+      assert_equal(12, r.bitpos("foo", 1))
     end
   end
 
   def test_bitpos_zero_end_is_given
     target_version "2.9.11" do
       r.set "foo", "\xff\xff\xff"
-      assert_equal 24, r.bitpos("foo", 0)
-      assert_equal 24, r.bitpos("foo", 0, 0)
-      assert_equal -1, r.bitpos("foo", 0, 0, -1)
+      assert_equal(24, r.bitpos("foo", 0))
+      assert_equal(24, r.bitpos("foo", 0, 0))
+      assert_equal(-1, r.bitpos("foo", 0, 0, -1))
     end
   end
 
   def test_bitpos_one_intervals
     target_version "2.9.11" do
       r.set "foo", "\x00\xff\x00"
-      assert_equal 8,  r.bitpos("foo", 1, 0, -1)
-      assert_equal 8,  r.bitpos("foo", 1, 1, -1)
-      assert_equal -1, r.bitpos("foo", 1, 2, -1)
-      assert_equal -1, r.bitpos("foo", 1, 2, 200)
-      assert_equal 8,  r.bitpos("foo", 1, 1, 1)
+      assert_equal(8,  r.bitpos("foo", 1, 0, -1))
+      assert_equal(8,  r.bitpos("foo", 1, 1, -1))
+      assert_equal(-1, r.bitpos("foo", 1, 2, -1))
+      assert_equal(-1, r.bitpos("foo", 1, 2, 200))
+      assert_equal(8,  r.bitpos("foo", 1, 1, 1))
     end
   end
 

data/test/blocking_commands_test.rb

@@ -1,12 +1,153 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
-require "lint/blocking_commands"
+require_relative "helper"
 
 class TestBlockingCommands < Test::Unit::TestCase
 
   include Helper::Client
-  include Lint::BlockingCommands
+
+  def setup
+    super
+
+    r.rpush("{zap}foo", "s1")
+    r.rpush("{zap}foo", "s2")
+    r.rpush("{zap}bar", "s1")
+    r.rpush("{zap}bar", "s2")
+  end
+
+  def to_protocol(obj)
+    case obj
+    when String
+      "$#{obj.length}\r\n#{obj}\r\n"
+    when Array
+      "*#{obj.length}\r\n" + obj.map { |e| to_protocol(e) }.join
+    else
+      fail
+    end
+  end
+
+  def mock(options = {}, &blk)
+    commands = {
+      :blpop => lambda do |*args|
+        sleep options[:delay] if options.has_key?(:delay)
+        to_protocol([args.first, args.last])
+      end,
+      :brpop => lambda do |*args|
+        sleep options[:delay] if options.has_key?(:delay)
+        to_protocol([args.first, args.last])
+      end,
+      :brpoplpush => lambda do |*args|
+        sleep options[:delay] if options.has_key?(:delay)
+        to_protocol(args.last)
+      end
+    }
+
+    redis_mock(commands, &blk)
+  end
+
+  def test_blpop
+    assert_equal ["{zap}foo", "s1"], r.blpop("{zap}foo")
+    assert_equal ["{zap}foo", "s2"], r.blpop(["{zap}foo"])
+    assert_equal ["{zap}bar", "s1"], r.blpop(["{zap}bar", "{zap}foo"])
+    assert_equal ["{zap}bar", "s2"], r.blpop(["{zap}foo", "{zap}bar"])
+  end
+
+  def test_blpop_timeout
+    mock do |r|
+      assert_equal ["{zap}foo", "0"], r.blpop("{zap}foo")
+      assert_equal ["{zap}foo", "1"], r.blpop("{zap}foo", :timeout => 1)
+    end
+  end
+
+  def test_blpop_with_old_prototype
+    assert_equal ["{zap}foo", "s1"], r.blpop("{zap}foo", 0)
+    assert_equal ["{zap}foo", "s2"], r.blpop("{zap}foo", 0)
+    assert_equal ["{zap}bar", "s1"], r.blpop("{zap}bar", "{zap}foo", 0)
+    assert_equal ["{zap}bar", "s2"], r.blpop("{zap}foo", "{zap}bar", 0)
+  end
+
+  def test_blpop_timeout_with_old_prototype
+    mock do |r|
+      assert_equal ["{zap}foo", "0"], r.blpop("{zap}foo", 0)
+      assert_equal ["{zap}foo", "1"], r.blpop("{zap}foo", 1)
+    end
+  end
+
+  def test_brpop
+    assert_equal ["{zap}foo", "s2"], r.brpop("{zap}foo")
+    assert_equal ["{zap}foo", "s1"], r.brpop(["{zap}foo"])
+    assert_equal ["{zap}bar", "s2"], r.brpop(["{zap}bar", "{zap}foo"])
+    assert_equal ["{zap}bar", "s1"], r.brpop(["{zap}foo", "{zap}bar"])
+  end
+
+  def test_brpop_timeout
+    mock do |r|
+      assert_equal ["{zap}foo", "0"], r.brpop("{zap}foo")
+      assert_equal ["{zap}foo", "1"], r.brpop("{zap}foo", :timeout => 1)
+    end
+  end
+
+  def test_brpop_with_old_prototype
+    assert_equal ["{zap}foo", "s2"], r.brpop("{zap}foo", 0)
+    assert_equal ["{zap}foo", "s1"], r.brpop("{zap}foo", 0)
+    assert_equal ["{zap}bar", "s2"], r.brpop("{zap}bar", "{zap}foo", 0)
+    assert_equal ["{zap}bar", "s1"], r.brpop("{zap}foo", "{zap}bar", 0)
+  end
+
+  def test_brpop_timeout_with_old_prototype
+    mock do |r|
+      assert_equal ["{zap}foo", "0"], r.brpop("{zap}foo", 0)
+      assert_equal ["{zap}foo", "1"], r.brpop("{zap}foo", 1)
+    end
+  end
+
+  def test_brpoplpush
+    assert_equal "s2", r.brpoplpush("{zap}foo", "{zap}qux")
+    assert_equal ["s2"], r.lrange("{zap}qux", 0, -1)
+  end
+
+  def test_brpoplpush_timeout
+    mock do |r|
+      assert_equal "0", r.brpoplpush("{zap}foo", "{zap}bar")
+      assert_equal "1", r.brpoplpush("{zap}foo", "{zap}bar", :timeout => 1)
+    end
+  end
+
+  def test_brpoplpush_with_old_prototype
+    assert_equal "s2", r.brpoplpush("{zap}foo", "{zap}qux", 0)
+    assert_equal ["s2"], r.lrange("{zap}qux", 0, -1)
+  end
+
+  def test_brpoplpush_timeout_with_old_prototype
+    mock do |r|
+      assert_equal "0", r.brpoplpush("{zap}foo", "{zap}bar", 0)
+      assert_equal "1", r.brpoplpush("{zap}foo", "{zap}bar", 1)
+    end
+  end
+
+  driver(:ruby, :hiredis) do
+    def test_blpop_socket_timeout
+      mock(:delay => 1 + OPTIONS[:timeout] * 2) do |r|
+        assert_raises(Redis::TimeoutError) do
+          r.blpop("{zap}foo", :timeout => 1)
+        end
+      end
+    end
+
+    def test_brpop_socket_timeout
+      mock(:delay => 1 + OPTIONS[:timeout] * 2) do |r|
+        assert_raises(Redis::TimeoutError) do
+          r.brpop("{zap}foo", :timeout => 1)
+        end
+      end
+    end
+
+    def test_brpoplpush_socket_timeout
+      mock(:delay => 1 + OPTIONS[:timeout] * 2) do |r|
+        assert_raises(Redis::TimeoutError) do
+          r.brpoplpush("{zap}foo", "{zap}bar", :timeout => 1)
+        end
+      end
+    end
+  end
 
   def assert_takes_longer_than_client_timeout
     timeout = OPTIONS[:timeout]
@@ -17,7 +158,7 @@ class TestBlockingCommands < Test::Unit::TestCase
       yield(r)
       t2 = Time.now
 
-      assert timeout == r.client.timeout
+      assert timeout == r._client.timeout
       assert delay <= (t2 - t1)
     end
   end