redis 3.0.0.rc2 → 3.0.0

data/.order

@@ -0,0 +1,169 @@
+{
+  "connection": [
+    "auth",
+    "select",
+    "ping",
+    "echo",
+    "quit"
+  ],
+  "server": [
+    "bgrewriteaof",
+    "bgsave",
+    "config",
+    "dbsize",
+    "debug",
+    "flushall",
+    "flushdb",
+    "info",
+    "lastsave",
+    "monitor",
+    "save",
+    "shutdown",
+    "slaveof",
+    "slowlog",
+    "sync",
+    "time"
+  ],
+  "generic": [
+    "persist",
+    "expire",
+    "expireat",
+    "ttl",
+    "pexpire",
+    "pexpireat",
+    "pttl",
+    "dump",
+    "restore",
+    "del",
+    "exists",
+    "keys",
+    "migrate",
+    "move",
+    "object",
+    "randomkey",
+    "rename",
+    "renamenx",
+    "sort",
+    "type"
+  ],
+  "string": [
+    "decr",
+    "decrby",
+    "incr",
+    "incrby",
+    "incrbyfloat",
+    "set",
+    "setex",
+    "psetex",
+    "setnx",
+    "mset",
+    "mapped_mset",
+    "msetnx",
+    "mapped_msetnx",
+    "get",
+    "mget",
+    "mapped_mget",
+    "setrange",
+    "getrange",
+    "setbit",
+    "getbit",
+    "append",
+    "bitcount",
+    "getset",
+    "strlen"
+  ],
+  "list": [
+    "llen",
+    "lpush",
+    "lpushx",
+    "rpush",
+    "rpushx",
+    "lpop",
+    "rpop",
+    "rpoplpush",
+    "_bpop",
+    "blpop",
+    "brpop",
+    "brpoplpush",
+    "lindex",
+    "linsert",
+    "lrange",
+    "lrem",
+    "lset",
+    "ltrim",
+    "bitop"
+  ],
+  "set": [
+    "scard",
+    "sadd",
+    "srem",
+    "spop",
+    "srandmember",
+    "smove",
+    "sismember",
+    "smembers",
+    "sdiff",
+    "sdiffstore",
+    "sinter",
+    "sinterstore",
+    "sunion",
+    "sunionstore"
+  ],
+  "sorted_set": [
+    "zcard",
+    "zadd",
+    "zincrby",
+    "zrem",
+    "zscore",
+    "zrange",
+    "zrevrange",
+    "zrank",
+    "zrevrank",
+    "zremrangebyrank",
+    "zrangebyscore",
+    "zrevrangebyscore",
+    "zremrangebyscore",
+    "zcount",
+    "zinterstore",
+    "zunionstore"
+  ],
+  "hash": [
+    "hlen",
+    "hset",
+    "hsetnx",
+    "hmset",
+    "mapped_hmset",
+    "hget",
+    "hmget",
+    "mapped_hmget",
+    "hdel",
+    "hexists",
+    "hincrby",
+    "hincrbyfloat",
+    "hkeys",
+    "hvals",
+    "hgetall"
+  ],
+  "pubsub": [
+    "publish",
+    "subscribed?",
+    "subscribe",
+    "unsubscribe",
+    "psubscribe",
+    "punsubscribe"
+  ],
+  "transactions": [
+    "watch",
+    "unwatch",
+    "pipelined",
+    "multi",
+    "exec",
+    "discard"
+  ],
+  "scripting": [
+    "script",
+    "_eval",
+    "eval",
+    "evalsha"
+  ]
+}

data/CHANGELOG.md

@@ -1,26 +1,89 @@
-# 3.0 (unreleased)
+# 3.0.0
+
+### Upgrading from 2.x to 3.0
+
+The following items are the most important changes to review when
+upgrading from redis-rb 2.x. A full list of changes can be found below.
+
+* The methods for the following commands have changed the arguments they
+  take, their return value, or both.
+
+    * `BLPOP`, `BRPOP`, `BRPOPLPUSH`
+    * `SORT`
+    * `MSETNX`
+    * `ZRANGE`, `ZREVRANGE`, `ZRANGEBYSCORE`, `ZREVRANGEBYSCORE`
+    * `ZINCRBY`, `ZSCORE`
+
+* The return value from `#pipelined` and `#multi` no longer contains
+  unprocessed replies, but the same replies that would be returned if
+  the command had not been executed in these blocks.
+
+* The client raises custom errors on connection errors, instead of
+  `RuntimeError` and errors in the `Errno` family.
+
+### Changes
+
+* Added support for scripting commands (Redis 2.6).
+
+    Scripts can be executed using `#eval` and `#evalsha`. Both can
+    commands can either take two arrays to specify `KEYS` and `ARGV`, or
+    take a hash containing `:keys` and `:argv` to specify `KEYS` and
+    `ARGV`.
+
+    ```ruby
+    redis.eval("return ARGV[1] * ARGV[2]", :argv => [2, 3])
+      # => 6
+    ```
+
+    Subcommands of the `SCRIPT` command can be executed via the
+    `#script` method.
+
+    For example:
+
+    ```ruby
+    redis.script(:load, "return ARGV[1] * ARGV[2]")
+      # => "58db5d365a1922f32e7aa717722141ea9c2b0cf3"
+    redis.script(:exists, "58db5d365a1922f32e7aa717722141ea9c2b0cf3")
+      # => true
+    redis.script(:flush)
+      # => "OK"
+    ```
 
 * The repository now lives at [https://github.com/redis/redis-rb](https://github.com/redis/redis-rb).
   Thanks, Ezra!
 
-* Added support for `PEXPIRE`, `PTTL`, `PEXPIREAT`, `PSETEX`,
+* Added support for `PEXPIRE`, `PEXPIREAT`, `PTTL`, `PSETEX`,
   `INCRYBYFLOAT`, `HINCRYBYFLOAT` and `TIME` (Redis 2.6).
 
 * `Redis.current` is now thread unsafe, because the client itself is thread safe.
 
     In the future you'll be able to do something like:
 
-        Redis.current = Redis::Pool.connect
+    ```ruby
+    Redis.current = Redis::Pool.connect
+    ```
 
     This makes `Redis.current` actually usable in multi-threaded environments,
     while not affecting those running a single thread.
 
-* Change API for `BLPOP`, `BRPOP` and `BRPOPLPUSH`. Both `BLPOP` and
-  `BRPOP` now take a single argument equal to a string key, or an array
-  with string keys, followed by an optional hash with a `:timeout` key.
-  `BRPOPLPUSH` also takes an optional hash with a `:timeout` key as last
-  argument for consistency. By default, these commands use a timeout of
-  `0` to not time out.
+* Change API for `BLPOP`, `BRPOP` and `BRPOPLPUSH`.
+
+    Both `BLPOP` and `BRPOP` now take a single argument equal to a
+    string key, or an array with string keys, followed by an optional
+    hash with a `:timeout` key. When not specified, the timeout defaults
+    to `0` to not time out.
+
+    ```ruby
+    redis.blpop(["list1", "list2"], :timeout => 1.0)
+    ```
+
+    `BRPOPLPUSH` also takes an optional hash with a `:timeout` key as
+    last argument for consistency. When not specified, the timeout
+    defaults to `0` to not time out.
+
+    ```ruby
+    redis.brpoplpush("some_list", "another_list", :timeout => 1.0)
+    ```
 
 * When `SORT` is passed multiple key patterns to get via the `:get`
   option, it now returns an array per result element, holding all `GET`
@@ -32,6 +95,13 @@
   now return an array containing `[String, Float]` pairs when
   `:with_scores => true` is passed.
 
+    For example:
+
+    ```ruby
+    redis.zrange("zset", 0, -1, :with_scores => true)
+      # => [["foo", 1.0], ["bar", 2.0]]
+    ```
+
 * The `ZINCRBY` and `ZSCORE` commands now return a `Float` score instead
   of a string holding a representation of the score.
 

data/README.md

@@ -12,6 +12,13 @@ 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.
 
+## Upgrading from 2.x to 3.0
+
+Please refer to the [CHANGELOG][changelog-3.0.0] for a summary of the
+most important changes, as well as a full list of changes.
+
+[changelog-3.0.0]: https://github.com/redis/redis-rb/blob/master/CHANGELOG.md#300
+
 ## Getting started
 
 As of version 2.0 this client only targets Redis version 2.0 and higher.

data/Rakefile

@@ -148,6 +148,71 @@ namespace :doc do
   end
 end
 
+class Source
+
+  MATCHER = "(?:\\s{%d}#[^\\n]*\\n)*^\\s{%d}def ([a-z_?]+)(?:\(.*?\))?\\n.*?^\\s{%d}end\\n\\n"
+
+  def initialize(data, options = {})
+    @doc = parse(File.read(data), options)
+  end
+
+  def methods
+    @doc.select do |d|
+      d.is_a?(Method)
+    end.map do |d|
+      d.name
+    end
+  end
+
+  def move(a, b)
+    ao = @doc.find { |m| m.is_a?(Method) && m.name == a }
+    bo = @doc.find { |m| m.is_a?(Method) && m.name == b }
+    ai = @doc.index(ao)
+    bi = @doc.index(bo)
+
+    @doc.delete_at(ai)
+    @doc.insert(bi, ao)
+
+    nil
+  end
+
+  def to_s
+    @doc.join
+  end
+
+  protected
+
+  def parse(data, options = {})
+    re = Regexp.new(MATCHER % ([options[:indent]] * 3), Regexp::MULTILINE)
+    tail = data.dup
+    doc = []
+
+    while match = re.match(tail)
+      doc << match.pre_match
+      doc << Method.new(match)
+      tail = match.post_match
+    end
+
+    doc << tail if tail
+    doc
+  end
+
+  class Method
+
+    def initialize(match)
+      @match = match
+    end
+
+    def name
+      @match[1]
+    end
+
+    def to_s
+      @match[0]
+    end
+  end
+end
+
 namespace :commands do
   def redis_commands
     $redis_commands ||= doc.keys.map do |key|
@@ -164,6 +229,108 @@ namespace :commands do
     end
   end
 
+  task :order do
+    require "json"
+
+    reference = if File.exist?(".order")
+                  JSON.parse(File.read(".order"))
+                else
+                  {}
+                end
+
+    buckets = {}
+    doc.each do |k, v|
+      buckets[v["group"]] ||= []
+      buckets[v["group"]] << k.split.first.downcase
+      buckets[v["group"]].uniq!
+    end
+
+    result = (reference.keys + (buckets.keys - reference.keys)).map do |g|
+      [g, reference[g] + (buckets[g] - reference[g])]
+    end
+
+    File.open(".order", "w") do |f|
+      f.write(JSON.pretty_generate(Hash[result]))
+    end
+  end
+
+  def reorder(file, options = {})
+    require "json"
+    require "set"
+
+    STDERR.puts "reordering #{file}..."
+
+    reference = if File.exist?(".order")
+                  JSON.parse(File.read(".order"))
+                else
+                  {}
+                end
+
+    dst = Source.new(file, options)
+
+    src_methods = reference.map { |k, v| v }.flatten
+    dst_methods = dst.methods
+
+    src_set = Set.new(src_methods)
+    dst_set = Set.new(dst_methods)
+
+    intersection = src_set & dst_set
+    intersection.delete("initialize")
+
+    loop do
+      src_methods = reference.map { |k, v| v }.flatten
+      dst_methods = dst.methods
+
+      src_methods = src_methods.select do |m|
+        intersection.include?(m)
+      end
+
+      dst_methods = dst_methods.select do |m|
+        intersection.include?(m)
+      end
+
+      if src_methods == dst_methods
+        break
+      end
+
+      rv = yield(src_methods, dst_methods, dst)
+      break if rv == false
+    end
+
+    File.open(file, "w") do |f|
+      f.write(dst.to_s)
+    end
+  end
+
+  task :reorder do
+    blk = lambda do |src_methods, dst_methods, dst|
+      src_methods.zip(dst_methods).each do |a, b|
+        if a != b
+          dst.move(a, b)
+          break
+        end
+      end
+    end
+
+    reorder "lib/redis.rb", :indent => 2, &blk
+    reorder "lib/redis/distributed.rb", :indent => 4, &blk
+  end
+
+  def missing(file, options = {})
+    src = Source.new(file, options)
+
+    defined_methods = src.methods.map(&:downcase)
+    required_methods = redis_commands.map(&:downcase)
+
+    STDOUT.puts "missing in #{file}:"
+    STDOUT.puts (required_methods - defined_methods).inspect
+  end
+
+  task :missing do
+    missing "lib/redis.rb", :indent => 2
+    missing "lib/redis/distributed.rb", :indent => 4
+  end
+
   def document(file)
     source = File.read(file)