redis 2.0.0.rc2 → 2.0.0.rc3

data/Rakefile

@@ -73,3 +73,87 @@ task :gemspec do
     file.puts spec.to_ruby
   end
 end
+
+desc "Generate YARDoc"
+task :yardoc do
+  require "yard"
+
+  opts = ["--title", "A Ruby client for Redis"]
+
+  YARD::CLI::Yardoc.run(*opts)
+end
+
+namespace :commands do
+  def redis_commands
+    $redis_commands ||= begin
+      require "nokogiri"
+
+      doc = Nokogiri::HTML(open("http://code.google.com/p/redis/wiki/CommandReference"))
+
+      commands = {}
+
+      doc.xpath("//ul/li").each do |node|
+        node.at_xpath("./a").text.split("/").each do |name|
+          if name =~ /^[A-Z]+$/
+            commands[name.downcase] = node.at_xpath("./tt").text
+          end
+        end
+      end
+
+      commands
+    end
+  end
+
+  task :doc do
+    source = File.read("lib/redis.rb")
+
+    redis_commands.each do |name, text|
+      source.sub!(/(?:^ *#.*\n)*^( *)def #{name}(\(|$)/) do
+        indent, extra_args = $1, $2
+        comment = "#{indent}# #{text.strip}"
+
+        IO.popen("par p#{2 + indent.size} 80", "r+") do |io|
+          io.puts comment
+          io.close_write
+          comment = io.read
+        end
+
+        "#{comment}#{indent}def #{name}#{extra_args}"
+      end
+    end
+
+    File.open("lib/redis.rb", "w") { |f| f.write(source) }
+  end
+
+  task :verify do
+    require "redis"
+
+    Dir["test/**/*_test.rb"].each { |f| require f }
+
+    log = StringIO.new
+
+    RedisTest::OPTIONS[:logger] = Logger.new(log)
+
+    redis = Redis.new
+
+    Test::Unit::AutoRunner.run
+
+    report = ["Command", "\033[0mDefined?\033[0m", "\033[0mTested?\033[0m"]
+
+    yes, no = "\033[1;32mYes\033[0m", "\033[1;31mNo\033[0m"
+
+    redis_commands.sort.each do |name, _|
+      defined, tested = redis.respond_to?(name), log.string[">> #{name.upcase}"]
+
+      next if defined && tested
+
+      report << name
+      report << (defined ? yes : no)
+      report << (tested ? yes : no)
+    end
+
+    IO.popen("rs 0 3", "w") do |io|
+      io.puts report.join("\n")
+    end
+  end
+end

data/lib/redis.rb

@@ -1,7 +1,7 @@
 require 'socket'
 
 class Redis
-  VERSION = "2.0.0.rc2"
+  VERSION = "2.0.0.rc3"
 
   class ProtocolError < RuntimeError
     def initialize(reply_type)
@@ -29,7 +29,11 @@ class Redis
   end
 
   def initialize(options = {})
-    @client = Client.new(options)
+    if options[:thread_safe]
+      @client = Client::ThreadSafe.new(options)
+    else
+      @client = Client.new(options)
+    end
   end
 
   def select(db)
@@ -229,24 +233,37 @@ class Redis
     @client.call(:zcard, key)
   end
 
-  def zrange(key, start, stop, with_scores = false)
-    if with_scores
-      @client.call(:zrange, key, start, stop, "WITHSCORES")
-    else
-      @client.call(:zrange, key, start, stop)
+  def zrange(key, start, stop, options = {})
+    command = CommandOptions.new(options) do |c|
+      c.bool :with_scores
     end
+
+    @client.call(:zrange, key, start, stop, *command.to_a)
   end
 
-  def zrangebyscore(key, min, max)
-    @client.call(:zrangebyscore, key, min, max)
+  def zrangebyscore(key, min, max, options = {})
+    command = CommandOptions.new(options) do |c|
+      c.splat :limit
+      c.bool  :with_scores
+    end
+
+    @client.call(:zrangebyscore, key, min, max, *command.to_a)
   end
 
-  def zrevrange(key, start, stop, with_scores = false)
-    if with_scores
-      @client.call(:zrevrange, key, start, stop, "WITHSCORES")
-    else
-      @client.call(:zrevrange, key, start, stop)
+  def zrevrange(key, start, stop, options = {})
+    command = CommandOptions.new(options) do |c|
+      c.bool :with_scores
     end
+
+    @client.call(:zrevrange, key, start, stop, *command.to_a)
+  end
+
+  def zremrangebyscore(key, min, max)
+    @client.call(:zremrangebyscore, key, min, max)
+  end
+
+  def zremrangebyrank(key, start, stop)
+    @client.call(:zremrangebyscore, key, start, stop)
   end
 
   def zscore(key, member)
@@ -257,6 +274,14 @@ class Redis
     _bool @client.call(:zrem, key, member)
   end
 
+  def zinter(destination, keys)
+    @client.call(:zinter, destination, keys.size, *keys)
+  end
+
+  def zunion(destination, keys)
+    @client.call(:zunion, destination, keys.size, *keys)
+  end
+
   def move(key, db)
     _bool @client.call(:move, key, db)
   end
@@ -359,20 +384,15 @@ class Redis
   end
 
   def sort(key, options = {})
-    cmd = []
-    cmd << "SORT"
-    cmd << key
-    cmd += ["BY", options[:by]] if options[:by]
-
-    Array(options[:get]).each do |k|
-      cmd += ["GET", k]
-    end if options[:get]
-
-    cmd += options[:order].split(" ") if options[:order]
-    cmd += ["LIMIT", *options[:limit]] if options[:limit]
-    cmd += ["STORE", options[:store]] if options[:store]
+    command = CommandOptions.new(options) do |c|
+      c.value :by
+      c.splat :limit
+      c.multi :get
+      c.words :order
+      c.value :store
+    end
 
-    @client.call(*cmd)
+    @client.call(:sort, key, *command.to_a)
   end
 
   def incr(key)
@@ -460,6 +480,42 @@ class Redis
     @client.call(command, *args)
   end
 
+  class CommandOptions
+    def initialize(options)
+      @result = []
+      @options = options
+      yield(self)
+    end
+
+    def bool(name)
+      insert(name) { |argument, value| [argument] }
+    end
+
+    def value(name)
+      insert(name) { |argument, value| [argument, value] }
+    end
+
+    def splat(name)
+      insert(name) { |argument, value| [argument, *value] }
+    end
+
+    def multi(name)
+      insert(name) { |argument, value| [argument].product(Array(value)).flatten }
+    end
+
+    def words(name)
+      insert(name) { |argument, value| value.split(" ") }
+    end
+
+    def to_a
+      @result
+    end
+
+    def insert(name)
+      @result += yield(name.to_s.upcase.gsub("_", ""), @options[name]) if @options[name]
+    end
+  end
+
 private
 
   def _bool(value)
@@ -494,3 +550,4 @@ end
 require 'redis/client'
 require 'redis/pipeline'
 require 'redis/subscribe'
+require 'redis/compat'

data/lib/redis/client.rb

@@ -1,5 +1,3 @@
-require "thread"
-
 class Redis
   class Client
     MINUS    = "-".freeze
@@ -17,8 +15,7 @@ class Redis
       @db = (options[:db] || 0).to_i
       @timeout = (options[:timeout] || 5).to_i
       @password = options[:password]
-      @logger  =  options[:logger]
-      @mutex = ::Mutex.new
+      @logger = options[:logger]
       @sock = nil
     end
 
@@ -261,5 +258,24 @@ class Redis
         end
       end
     end
+
+    class ThreadSafe < self
+      def initialize(*args)
+        require "monitor"
+
+        super(*args)
+        @mutex = ::Monitor.new
+      end
+
+      def synchronize(&block)
+        @mutex.synchronize(&block)
+      end
+
+      def ensure_connected(&block)
+        super do
+          synchronize(&block)
+        end
+      end
+    end
   end
 end

data/lib/redis/compat.rb

@@ -0,0 +1,21 @@
+# This file contains core methods that are present in
+# Ruby 1.9 and not in earlier versions.
+
+unless [].respond_to?(:product)
+  class Array
+    def product(*enums)
+      enums.unshift self
+      result = [[]]
+      while [] != enums
+        t, result = result, []
+        b, *enums = enums
+        t.each do |a|
+          b.each do |n|
+            result << a + [n]
+          end
+        end
+      end
+      result
+    end
+  end
+end

data/lib/redis/distributed.rb

@@ -16,9 +16,10 @@ class Redis
     attr_reader :ring
 
     def initialize(urls, options = {})
-      @tag = options.delete(:tag) || /^{(.+?)}/
+      @tag = options.delete(:tag) || /^\{(.+?)\}/
       @default_options = options
       @ring = HashRing.new urls.map { |url| Redis.connect(options.merge(:url => url)) }
+      @subscribed_node = nil
     end
 
     def node_for(key)
@@ -240,7 +241,7 @@ class Redis
     end
 
     def smove(source, destination, member)
-      ensure_same_node(:smove, source, destination, member) do |node|
+      ensure_same_node(:smove, source, destination) do |node|
         node.smove(source, destination, member)
       end
     end
@@ -309,16 +310,32 @@ class Redis
       node_for(key).zincrby(key, increment, member)
     end
 
-    def zrange(key, start, stop, with_scores = false)
-      node_for(key).zrange(key, start, stop, with_scores)
+    def zrange(key, start, stop, options = {})
+      node_for(key).zrange(key, start, stop, options)
     end
 
-    def zrevrange(key, start, stop, with_scores = false)
-      node_for(key).zrevrange(key, start, stop, with_scores)
+    def zrank(key, member)
+      node_for(key).zrank(key, member)
     end
 
-    def zrangebyscore(key, min, max)
-      node_for(key).zrangebyscore(key, min, max)
+    def zrevrank(key, member)
+      node_for(key).zrevrank(key, member)
+    end
+
+    def zrevrange(key, start, stop, options = {})
+      node_for(key).zrevrange(key, start, stop, options)
+    end
+
+    def zremrangebyscore(key, min, max)
+      node_for(key).zremrangebyscore(key, min, max)
+    end
+
+    def zremrangebyrank(key, start, stop)
+      node_for(key).zremrangebyrank(key, start, stop)
+    end
+
+    def zrangebyscore(key, min, max, options = {})
+      node_for(key).zrangebyscore(key, min, max, options)
     end
 
     def zcard(key)
@@ -329,6 +346,18 @@ class Redis
       node_for(key).zscore(key, member)
     end
 
+    def zinter(destination, keys)
+      ensure_same_node(:zinter, destination, *keys) do |node|
+        node.zinter(destination, keys)
+      end
+    end
+
+    def zunion(destination, keys)
+      ensure_same_node(:zunion, destination, *keys) do |node|
+        node.zunion(destination, keys)
+      end
+    end
+
     def hset(key, field, value)
       node_for(key).hset(key, field, value)
     end
@@ -386,15 +415,28 @@ class Redis
     end
 
     def publish(channel, message)
-      raise NotImplementedError
+      node_for(channel).publish(channel, message)
     end
 
-    def unsubscribe(*channels)
-      raise NotImplementedError
+    def subscribed?
+      !! @subscribed_node
     end
 
-    def subscribe(*channels, &block)
-      raise NotImplementedError
+    def unsubscribe(*channels)
+      raise RuntimeError, "Can't unsubscribe if not subscribed." unless subscribed?
+      @subscribed_node.unsubscribe(*channels)
+    end
+
+    def subscribe(channel, *channels, &block)
+      if channels.empty?
+        @subscribed_node = node_for(channel)
+        @subscribed_node.subscribe(channel, &block)
+      else
+        ensure_same_node(:subscribe, channel, *channels) do |node|
+          @subscribed_node = node
+          node.subscribe(channel, *channels, &block)
+        end
+      end
     end
 
     def punsubscribe(*channels)
@@ -452,7 +494,7 @@ class Redis
     def ensure_same_node(command, *keys)
       tags = keys.map { |key| key_tag(key) }
 
-      raise CannotDistribute, command if tags.compact.uniq.size != 1
+      raise CannotDistribute, command if !tags.all? || tags.uniq.size != 1
 
       yield(node_for(keys.first))
     end

metadata

@@ -6,8 +6,8 @@ version: !ruby/object:Gem::Version
   - 2
   - 0
   - 0
-  - rc2
-  version: 2.0.0.rc2
+  - rc3
+  version: 2.0.0.rc3
 platform: ruby
 authors: 
 - Ezra Zygmuntowicz
@@ -20,7 +20,7 @@ autorequire: redis
 bindir: bin
 cert_chain: []
 
-date: 2010-04-28 00:00:00 -03:00
+date: 2010-05-06 00:00:00 -03:00
 default_executable: 
 dependencies: []
 
@@ -38,6 +38,7 @@ files:
 - Rakefile
 - lib/edis.rb
 - lib/redis/client.rb
+- lib/redis/compat.rb
 - lib/redis/distributed.rb
 - lib/redis/hash_ring.rb
 - lib/redis/pipeline.rb