redis 3.0.5 → 3.0.6

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    OWE3ZTkzYTU5MjZkMWY5YmQ0YTM0NmQ1NWY2ZTVmZTljNmZmYzE1Yg==
+    MWU4NjJlZTMzODJmNjI0MTk5ZWQ4Yzk1OGIxNGUwYmQzNzcwZGM0Zg==
   data.tar.gz: !binary |-
-    OTY0NWU0ZTA3YzdiNTdhOTdiMmQzMzk2NWQ1ZjBkN2M2N2MxMGEzYg==
+    ZmQzMjMxMmU2NWRhY2E3NGE1N2I1OWExMjQxMzQ2YmY1MzcxOTM2Mw==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    ZDA2NjI0ZWE0YjM2NDc4MmE0MTZmODIyN2Q5MDgxMDc1NGFiODhiM2M1NGEy
-    MGI1ODA2NzhmMDQ3OGY5ZGJhNzM3MzI0MjMyZGFkM2FjNDM3YzdlNTlkMjFh
-    OTM0ZjQyNTc5OGMwOTkwNGQxZWYyY2E3ODk5Mzc0YmY1ODEzOWE=
+    NTZjYTMwZjU5ZWMwZDI0ZWM4OTZmZGU3YmMzMGJlZmZjMDUxNjUwMzNhZGMy
+    OTZkOWJmNTM5NTQzMWUyZTRjZmMzNWQ5MDY1NDljNzJiNWMzMGE4NGZjMDI0
+    YzM4YTE5MGM5MWVmN2YyYTI3YTViMzljMDg2YzQyYTZlY2M0OTE=
   data.tar.gz: !binary |-
-    MGYyMzA5MDg1YTU1ZTcyYjVkMDljZjU4OGFhMDc1MTg3NzhhMjkzZDQyZjk5
-    MTVmZjJhNmRiZDc0NjE3ODgzMTE5NTMyZGM3YjM0ZjMzMzkyYjA3MjNmYWYx
-    MzZjNTk2NzRiOGMzYmYyODZkYzZjZjE5YWU0OTc2MWUwMTAyODk=
+    Mzk0NmVkMmEwYjc1MzIzOTU4MDEwN2QwNmRhZThkMzA2NzIyOTU5YjlmMzMz
+    Y2NkZjUyZTE5YmI2MjFiZTA4YjNkOWMzZWEwYWRkMjZlNDgzNTc3NDViOTRl
+    ZDMyZDlhYThhZjMxOGM5YzE1NjNkZDQzNjAwODEyNjM3ZmQ3OWE=

data/.gitignore

@@ -1,10 +1,11 @@
-nohup.out
-redis/*
-rdsrv
-pkg/*
-coverage/*
-.idea
 *.rdb
 *.swp
-.yardoc
-doc/
+/.idea
+/.yardoc
+/coverage/*
+/doc/
+/nohup.out
+/pkg/*
+/rdsrv
+/redis/*
+/test/db

data/.travis.yml

@@ -16,30 +16,32 @@ gemfile:
   - .travis/Gemfile
 
 env:
-  - conn=ruby
-  - conn=hiredis
-  - conn=synchrony
+  - conn=ruby      REDIS_BRANCH=2.6
+  - conn=hiredis   REDIS_BRANCH=2.6
+  - conn=synchrony REDIS_BRANCH=2.6
+  - conn=ruby      REDIS_BRANCH=2.8
+  - conn=ruby      REDIS_BRANCH=unstable
 
 matrix:
   exclude:
     # hiredis
     - rvm: jruby-18mode
       gemfile: .travis/Gemfile
-      env: conn=hiredis
+      env: conn=hiredis REDIS_BRANCH=2.6
     - rvm: jruby-19mode
       gemfile: .travis/Gemfile
-      env: conn=hiredis
+      env: conn=hiredis REDIS_BRANCH=2.6
 
     # synchrony
     - rvm: 1.8.7
       gemfile: .travis/Gemfile
-      env: conn=synchrony
+      env: conn=synchrony REDIS_BRANCH=2.6
     - rvm: jruby-18mode
       gemfile: .travis/Gemfile
-      env: conn=synchrony
+      env: conn=synchrony REDIS_BRANCH=2.6
     - rvm: jruby-19mode
       gemfile: .travis/Gemfile
-      env: conn=synchrony
+      env: conn=synchrony REDIS_BRANCH=2.6
 
 notifications:
   irc:

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+# 3.0.6
+
+* Added support for `SCAN` and variants.
+
 # 3.0.5
 
 * Fix calling #select from a pipeline (#309).

data/Rakefile

@@ -2,12 +2,15 @@ require 'rubygems'
 require 'rubygems/package_task'
 require 'rake/testtask'
 
+ENV["REDIS_BRANCH"] ||= "unstable"
+
 $:.unshift File.join(File.dirname(__FILE__), 'lib')
 require 'redis/version'
 
 REDIS_DIR = File.expand_path(File.join("..", "test"), __FILE__)
 REDIS_CNF = File.join(REDIS_DIR, "test.conf")
 REDIS_PID = File.join(REDIS_DIR, "db", "redis.pid")
+BINARY = "tmp/redis-#{ENV["REDIS_BRANCH"]}/src/redis-server"
 
 task :default => :run
 
@@ -15,7 +18,9 @@ desc "Run tests and manage server start/stop"
 task :run => [:start, :test, :stop]
 
 desc "Start the Redis server"
-task :start do
+task :start => BINARY do
+  sh "#{BINARY} --version"
+
   redis_running = \
   begin
     File.exists?(REDIS_PID) && Process.kill(0, File.read(REDIS_PID).to_i)
@@ -25,14 +30,8 @@ task :start do
   end
 
   unless redis_running
-    unless system("which redis-server")
-      STDERR.puts "redis-server not in PATH"
-      exit 1
-    end
-
-    unless system("redis-server #{REDIS_CNF}")
-      STDERR.puts "could not start redis-server"
-      exit 1
+    unless system("#{BINARY} #{REDIS_CNF}")
+      abort "could not start redis-server"
     end
   end
 end
@@ -45,9 +44,21 @@ task :stop do
   end
 end
 
+file BINARY do
+  branch = ENV.fetch("REDIS_BRANCH")
+
+  sh <<-SH
+  mkdir -p tmp;
+  cd tmp;
+  wget https://github.com/antirez/redis/archive/#{branch}.tar.gz -O #{branch}.tar.gz;
+  tar xf #{branch}.tar.gz;
+  cd redis-#{branch};
+  make
+  SH
+end
+
 Rake::TestTask.new do |t|
   t.options = "-v"
-  t.libs << "test"
   t.test_files = FileList["test/*_test.rb"]
 end
 

data/lib/redis.rb

@@ -135,7 +135,7 @@ class Redis
     synchronize do |client|
       client.call([:config, action] + args) do |reply|
         if reply.kind_of?(Array) && action == :get
-          Hash[reply.each_slice(2).to_a]
+          Hash[_pairify(reply)]
         else
           reply
         end
@@ -639,9 +639,7 @@ class Redis
   # @return [Float] value after incrementing it
   def incrbyfloat(key, increment)
     synchronize do |client|
-      client.call([:incrbyfloat, key, increment]) do |reply|
-        _floatify(reply) if reply
-      end
+      client.call([:incrbyfloat, key, increment], &_floatify)
     end
   end
 
@@ -1417,9 +1415,7 @@ class Redis
   # @return [Float] score of the member after incrementing it
   def zincrby(key, increment, member)
     synchronize do |client|
-      client.call([:zincrby, key, increment, member]) do |reply|
-        _floatify(reply) if reply
-      end
+      client.call([:zincrby, key, increment, member], &_floatify)
     end
   end
 
@@ -1465,9 +1461,7 @@ class Redis
   # @return [Float] score of the member
   def zscore(key, member)
     synchronize do |client|
-      client.call([:zscore, key, member]) do |reply|
-        _floatify(reply) if reply
-      end
+      client.call([:zscore, key, member], &_floatify)
     end
   end
 
@@ -1493,20 +1487,14 @@ class Redis
     args = []
 
     with_scores = options[:with_scores] || options[:withscores]
-    args << "WITHSCORES" if with_scores
+
+    if with_scores
+      args << "WITHSCORES"
+      block = _floatify_pairs
+    end
 
     synchronize do |client|
-      client.call([:zrange, key, start, stop] + args) do |reply|
-        if with_scores
-          if reply
-            reply.each_slice(2).map do |member, score|
-              [member, _floatify(score)]
-            end
-          end
-        else
-          reply
-        end
-      end
+      client.call([:zrange, key, start, stop] + args, &block)
     end
   end
 
@@ -1525,20 +1513,14 @@ class Redis
     args = []
 
     with_scores = options[:with_scores] || options[:withscores]
-    args << "WITHSCORES" if with_scores
+
+    if with_scores
+      args << "WITHSCORES"
+      block = _floatify_pairs
+    end
 
     synchronize do |client|
-      client.call([:zrevrange, key, start, stop] + args) do |reply|
-        if with_scores
-          if reply
-            reply.each_slice(2).map do |member, score|
-              [member, _floatify(score)]
-            end
-          end
-        else
-          reply
-        end
-      end
+      client.call([:zrevrange, key, start, stop] + args, &block)
     end
   end
 
@@ -1615,23 +1597,17 @@ class Redis
     args = []
 
     with_scores = options[:with_scores] || options[:withscores]
-    args.concat(["WITHSCORES"]) if with_scores
+
+    if with_scores
+      args << "WITHSCORES"
+      block = _floatify_pairs
+    end
 
     limit = options[:limit]
     args.concat(["LIMIT"] + limit) if limit
 
     synchronize do |client|
-      client.call([:zrangebyscore, key, min, max] + args) do |reply|
-        if with_scores
-          if reply
-            reply.each_slice(2).map do |member, score|
-              [member, _floatify(score)]
-            end
-          end
-        else
-          reply
-        end
-      end
+      client.call([:zrangebyscore, key, min, max] + args, &block)
     end
   end
 
@@ -1653,23 +1629,17 @@ class Redis
     args = []
 
     with_scores = options[:with_scores] || options[:withscores]
-    args.concat(["WITHSCORES"]) if with_scores
+
+    if with_scores
+      args << ["WITHSCORES"]
+      block = _floatify_pairs
+    end
 
     limit = options[:limit]
     args.concat(["LIMIT"] + limit) if limit
 
     synchronize do |client|
-      client.call([:zrevrangebyscore, key, max, min] + args) do |reply|
-        if with_scores
-          if reply
-            reply.each_slice(2).map do |member, score|
-              [member, _floatify(score)]
-            end
-          end
-        else
-          reply
-        end
-      end
+      client.call([:zrevrangebyscore, key, max, min] + args, &block)
     end
   end
 
@@ -1931,9 +1901,7 @@ class Redis
   # @return [Float] value of the field after incrementing it
   def hincrbyfloat(key, field, increment)
     synchronize do |client|
-      client.call([:hincrbyfloat, key, field, increment]) do |reply|
-        _floatify(reply) if reply
-      end
+      client.call([:hincrbyfloat, key, field, increment], &_floatify)
     end
   end
 
@@ -2271,18 +2239,189 @@ class Redis
     _eval(:evalsha, args)
   end
 
-  def id
+  def _scan(command, cursor, args, options = {}, &block)
+    # SSCAN/ZSCAN/HSCAN already prepend the key to +args+.
+
+    args << cursor
+
+    if match = options[:match]
+      args.concat(["MATCH", match])
+    end
+
+    if count = options[:count]
+      args.concat(["COUNT", count])
+    end
+
     synchronize do |client|
-      client.id
+      client.call([command] + args, &block)
     end
   end
 
-  def inspect
-    synchronize do |client|
-      "#<Redis client v#{Redis::VERSION} for #{@original_client.id}>"
+  # Scan the keyspace
+  #
+  # @example Retrieve the first batch of keys
+  #   redis.scan(0)
+  #     # => ["4", ["key:21", "key:47", "key:42"]]
+  # @example Retrieve a batch of keys matching a pattern
+  #   redis.scan(4, :match => "key:1?")
+  #     # => ["92", ["key:13", "key:18"]]
+  #
+  # @param [String, Integer] cursor: the cursor of the iteration
+  # @param [Hash] options
+  #   - `:match => String`: only return keys matching the pattern
+  #   - `:count => Integer`: return count keys at most per iteration
+  #
+  # @return [String, Array<String>] the next cursor and all found keys
+  def scan(cursor, options={})
+    _scan(:scan, cursor, [], options)
+  end
+
+  # Scan the keyspace
+  #
+  # @example Retrieve all of the keys (with possible duplicates)
+  #   redis.scan_each.to_a
+  #     # => ["key:21", "key:47", "key:42"]
+  # @example Execute block for each key matching a pattern
+  #   redis.scan_each(:match => "key:1?") {|key| puts key}
+  #     # => key:13
+  #     # => key:18
+  #
+  # @param [Hash] options
+  #   - `:match => String`: only return keys matching the pattern
+  #   - `:count => Integer`: return count keys at most per iteration
+  #
+  # @return [Enumerator] an enumerator for all found keys
+  def scan_each(options={}, &block)
+    return to_enum(:scan_each, options) unless block_given?
+    cursor = 0
+    loop do
+      cursor, keys = scan(cursor, options)
+      keys.each(&block)
+      break if cursor == "0"
+    end
+  end
+
+  # Scan a hash
+  #
+  # @example Retrieve the first batch of key/value pairs in a hash
+  #   redis.hscan("hash", 0)
+  #
+  # @param [String, Integer] cursor: the cursor of the iteration
+  # @param [Hash] options
+  #   - `:match => String`: only return keys matching the pattern
+  #   - `:count => Integer`: return count keys at most per iteration
+  #
+  # @return [String, Array<[String, String]>] the next cursor and all found keys
+  def hscan(key, cursor, options={})
+    _scan(:hscan, cursor, [key], options) do |reply|
+      [reply[0], _pairify(reply[1])]
+    end
+  end
+
+  # Scan a hash
+  #
+  # @example Retrieve all of the key/value pairs in a hash
+  #   redis.hscan_each("hash").to_a
+  #   # => [["key70", "70"], ["key80", "80"]]
+  #
+  # @param [Hash] options
+  #   - `:match => String`: only return keys matching the pattern
+  #   - `:count => Integer`: return count keys at most per iteration
+  #
+  # @return [Enumerator] an enumerator for all found keys
+  def hscan_each(key, options={}, &block)
+    return to_enum(:hscan_each, key, options) unless block_given?
+    cursor = 0
+    loop do
+      cursor, values = hscan(key, cursor, options)
+      values.each(&block)
+      break if cursor == "0"
+    end
+  end
+
+  # Scan a sorted set
+  #
+  # @example Retrieve the first batch of key/value pairs in a hash
+  #   redis.zscan("zset", 0)
+  #
+  # @param [String, Integer] cursor: the cursor of the iteration
+  # @param [Hash] options
+  #   - `:match => String`: only return keys matching the pattern
+  #   - `:count => Integer`: return count keys at most per iteration
+  #
+  # @return [String, Array<[String, Float]>] the next cursor and all found
+  #   members and scores
+  def zscan(key, cursor, options={})
+    _scan(:zscan, cursor, [key], options) do |reply|
+      [reply[0], _floatify_pairs.call(reply[1])]
+    end
+  end
+
+  # Scan a sorted set
+  #
+  # @example Retrieve all of the members/scores in a sorted set
+  #   redis.zscan_each("zset").to_a
+  #   # => [["key70", "70"], ["key80", "80"]]
+  #
+  # @param [Hash] options
+  #   - `:match => String`: only return keys matching the pattern
+  #   - `:count => Integer`: return count keys at most per iteration
+  #
+  # @return [Enumerator] an enumerator for all found scores and members
+  def zscan_each(key, options={}, &block)
+    return to_enum(:zscan_each, key, options) unless block_given?
+    cursor = 0
+    loop do
+      cursor, values = zscan(key, cursor, options)
+      values.each(&block)
+      break if cursor == "0"
+    end
+  end
+
+  # Scan a set
+  #
+  # @example Retrieve the first batch of keys in a set
+  #   redis.sscan("set", 0)
+  #
+  # @param [String, Integer] cursor: the cursor of the iteration
+  # @param [Hash] options
+  #   - `:match => String`: only return keys matching the pattern
+  #   - `:count => Integer`: return count keys at most per iteration
+  #
+  # @return [String, Array<String>] the next cursor and all found members
+  def sscan(key, cursor, options={})
+    _scan(:sscan, cursor, [key], options)
+  end
+
+  # Scan a set
+  #
+  # @example Retrieve all of the keys in a set
+  #   redis.sscan("set").to_a
+  #   # => ["key1", "key2", "key3"]
+  #
+  # @param [Hash] options
+  #   - `:match => String`: only return keys matching the pattern
+  #   - `:count => Integer`: return count keys at most per iteration
+  #
+  # @return [Enumerator] an enumerator for all keys in the set
+  def sscan_each(key, options={}, &block)
+    return to_enum(:sscan_each, key, options) unless block_given?
+    cursor = 0
+    loop do
+      cursor, keys = sscan(key, cursor, options)
+      keys.each(&block)
+      break if cursor == "0"
     end
   end
 
+  def id
+    @original_client.id
+  end
+
+  def inspect
+    "#<Redis client v#{Redis::VERSION} for #{id}>"
+  end
+
   def method_missing(command, *args)
     synchronize do |client|
       client.call([command] + args)
@@ -2320,12 +2459,30 @@ private
     }
   end
 
-  def _floatify(str)
-    if (inf = str.match(/^(-)?inf/i))
-      (inf[1] ? -1.0 : 1.0) / 0.0
-    else
-      Float str
-    end
+  def _floatify
+    lambda { |str|
+      return unless str
+
+      if (inf = str.match(/^(-)?inf/i))
+        (inf[1] ? -1.0 : 1.0) / 0.0
+      else
+        Float(str)
+      end
+    }
+  end
+
+  def _floatify_pairs
+    lambda { |array|
+      return unless array
+
+      array.each_slice(2).map do |member, score|
+        [member, _floatify.call(score)]
+      end
+    }
+  end
+
+  def _pairify(array)
+    array.each_slice(2).to_a
   end
 
   def _subscription(method, channels, block)