redis 0.1.2 → 0.2.0

data/lib/redis.rb

@@ -1,373 +1,23 @@
 require 'socket'
-require File.join(File.dirname(__FILE__),'pipeline')
+
+module RedisRb
+  VERSION = "0.2.0"
+end
 
 begin
   if RUBY_VERSION >= '1.9'
     require 'timeout'
-    RedisTimer = Timeout
+    RedisRb::RedisTimer = Timeout
   else
     require 'system_timer'
-    RedisTimer = SystemTimer
+    RedisRb::RedisTimer = SystemTimer
   end
 rescue LoadError
-  RedisTimer = nil
+  RedisRb::RedisTimer = nil
 end
 
-class Redis
-  OK      = "OK".freeze
-  MINUS    = "-".freeze
-  PLUS     = "+".freeze
-  COLON    = ":".freeze
-  DOLLAR   = "$".freeze
-  ASTERISK = "*".freeze
-
-  BULK_COMMANDS = {
-    "set"       => true,
-    "setnx"     => true,
-    "rpush"     => true,
-    "lpush"     => true,
-    "lset"      => true,
-    "lrem"      => true,
-    "sadd"      => true,
-    "srem"      => true,
-    "sismember" => true,
-    "echo"      => true,
-    "getset"    => true,
-    "smove"     => true,
-    "zadd"      => true,
-    "zincrby"   => true,
-    "zrem"      => true,
-    "zscore"    => true
-  }
-  
-  MULTI_BULK_COMMANDS = {
-    "mset"      => true,
-    "msetnx"    => true
-  }
-
-  BOOLEAN_PROCESSOR = lambda{|r| r == 1 }
-
-  REPLY_PROCESSOR = {
-    "exists"    => BOOLEAN_PROCESSOR,
-    "sismember" => BOOLEAN_PROCESSOR,
-    "sadd"      => BOOLEAN_PROCESSOR,
-    "srem"      => BOOLEAN_PROCESSOR,
-    "smove"     => BOOLEAN_PROCESSOR,
-    "zadd"      => BOOLEAN_PROCESSOR,
-    "zrem"      => BOOLEAN_PROCESSOR,
-    "move"      => BOOLEAN_PROCESSOR,
-    "setnx"     => BOOLEAN_PROCESSOR,
-    "del"       => BOOLEAN_PROCESSOR,
-    "renamenx"  => BOOLEAN_PROCESSOR,
-    "expire"    => BOOLEAN_PROCESSOR,
-    "keys"      => lambda{|r| r.split(" ")},
-    "info"      => lambda{|r|
-      info = {}
-      r.each_line {|kv|
-        k,v = kv.split(":",2).map{|x| x.chomp}
-        info[k.to_sym] = v
-      }
-      info
-    }
-  }
-
-  ALIASES = {
-    "flush_db"             => "flushdb",
-    "flush_all"            => "flushall",
-    "last_save"            => "lastsave",
-    "key?"                 => "exists",
-    "delete"               => "del",
-    "randkey"              => "randomkey",
-    "list_length"          => "llen",
-    "push_tail"            => "rpush",
-    "push_head"            => "lpush",
-    "pop_tail"             => "rpop",
-    "pop_head"             => "lpop",
-    "list_set"             => "lset",
-    "list_range"           => "lrange",
-    "list_trim"            => "ltrim",
-    "list_index"           => "lindex",
-    "list_rm"              => "lrem",
-    "set_add"              => "sadd",
-    "set_delete"           => "srem",
-    "set_count"            => "scard",
-    "set_member?"          => "sismember",
-    "set_members"          => "smembers",
-    "set_intersect"        => "sinter",
-    "set_intersect_store"  => "sinterstore",
-    "set_inter_store"      => "sinterstore",
-    "set_union"            => "sunion",
-    "set_union_store"      => "sunionstore",
-    "set_diff"             => "sdiff",
-    "set_diff_store"       => "sdiffstore",
-    "set_move"             => "smove",
-    "set_unless_exists"    => "setnx",
-    "rename_unless_exists" => "renamenx",
-    "type?"                => "type",
-    "zset_add"             => "zadd",
-    "zset_count"           => "zcard",
-    "zset_range_by_score"  => "zrangebyscore",
-    "zset_reverse_range"   => "zrevrange",
-    "zset_range"           => "zrange",
-    "zset_delete"          => "zrem",
-    "zset_score"           => "zscore",
-    "zset_incr_by"         => "zincrby",
-    "zset_increment_by"    => "zincrby"
-  }
-
-  DISABLED_COMMANDS = {
-    "monitor" => true,
-    "sync"    => true
-  }
-
-  def initialize(options = {})
-    @host    =  options[:host]    || '127.0.0.1'
-    @port    = (options[:port]    || 6379).to_i
-    @db      = (options[:db]      || 0).to_i
-    @timeout = (options[:timeout] || 5).to_i
-    @password = options[:password]
-    @logger  =  options[:logger]
-    @thread_safe = options[:thread_safe]
-    @mutex = Mutex.new if @thread_safe
-    @sock = nil
-
-    @logger.info { self.to_s } if @logger
-  end
-
-  def to_s
-    "Redis Client connected to #{server} against DB #{@db}"
-  end
-
-  def server
-    "#{@host}:#{@port}"
-  end
-
-  def connect_to_server
-    @sock = connect_to(@host, @port, @timeout == 0 ? nil : @timeout)
-    call_command(["auth",@password]) if @password
-    call_command(["select",@db]) unless @db == 0
-  end
-
-  def connect_to(host, port, timeout=nil)
-    # We support connect() timeout only if system_timer is availabe
-    # or if we are running against Ruby >= 1.9
-    # Timeout reading from the socket instead will be supported anyway.
-    if @timeout != 0 and RedisTimer
-      begin
-        sock = TCPSocket.new(host, port)
-      rescue Timeout::Error
-        @sock = nil
-        raise Timeout::Error, "Timeout connecting to the server"
-      end
-    else
-      sock = TCPSocket.new(host, port)
-    end
-    sock.setsockopt Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1
-
-    # If the timeout is set we set the low level socket options in order
-    # to make sure a blocking read will return after the specified number
-    # of seconds. This hack is from memcached ruby client.
-    if timeout
-      secs   = Integer(timeout)
-      usecs  = Integer((timeout - secs) * 1_000_000)
-      optval = [secs, usecs].pack("l_2")
-      begin
-        sock.setsockopt Socket::SOL_SOCKET, Socket::SO_RCVTIMEO, optval
-        sock.setsockopt Socket::SOL_SOCKET, Socket::SO_SNDTIMEO, optval
-      rescue Exception => ex
-        # Solaris, for one, does not like/support socket timeouts.
-        @logger.info "Unable to use raw socket timeouts: #{ex.class.name}: #{ex.message}" if @logger
-      end
-    end
-    sock
-  end
-
-  def method_missing(*argv)
-    call_command(argv)
-  end
-
-  def call_command(argv)
-    @logger.debug { argv.inspect } if @logger
-
-    # this wrapper to raw_call_command handle reconnection on socket
-    # error. We try to reconnect just one time, otherwise let the error
-    # araise.
-    connect_to_server if !@sock
-
-    begin
-      raw_call_command(argv.dup)
-    rescue Errno::ECONNRESET, Errno::EPIPE, Errno::ECONNABORTED
-      @sock.close rescue nil
-      @sock = nil
-      connect_to_server
-      raw_call_command(argv.dup)
-    end
-  end
-
-  def raw_call_command(argvp)
-    pipeline = argvp[0].is_a?(Array)
-
-    unless pipeline
-      argvv = [argvp]
-    else
-      argvv = argvp
-    end
-
-    if MULTI_BULK_COMMANDS[argvv.flatten[0].to_s]
-      # TODO improve this code
-      argvp   = argvv.flatten
-      values  = argvp.pop.to_a.flatten
-      argvp   = values.unshift(argvp[0])
-      command = ["*#{argvp.size}"]
-      argvp.each do |v|
-        v = v.to_s
-        command << "$#{get_size(v)}"
-        command << v
-      end
-      command = command.map {|cmd| "#{cmd}\r\n"}.join
-    else
-      command = ""
-      argvv.each do |argv|
-        bulk = nil
-        argv[0] = argv[0].to_s.downcase
-        argv[0] = ALIASES[argv[0]] if ALIASES[argv[0]]
-        raise "#{argv[0]} command is disabled" if DISABLED_COMMANDS[argv[0]]
-        if BULK_COMMANDS[argv[0]] and argv.length > 1
-          bulk = argv[-1].to_s
-          argv[-1] = get_size(bulk)
-        end
-        command << "#{argv.join(' ')}\r\n"
-        command << "#{bulk}\r\n" if bulk
-      end
-    end
-    results = maybe_lock { process_command(command, argvv) }
-    
-    return pipeline ? results : results[0]
-  end
-
-  def process_command(command, argvv)
-    @sock.write(command)
-    argvv.map do |argv|
-      processor = REPLY_PROCESSOR[argv[0]]
-      processor ? processor.call(read_reply) : read_reply
-    end
-  end
-  
-  def maybe_lock(&block)
-    if @thread_safe
-      @mutex.synchronize &block
-    else
-      block.call
-    end
-  end
-
-  def select(*args)
-    raise "SELECT not allowed, use the :db option when creating the object"
-  end
-
-  def [](key)
-    self.get(key)
-  end
-
-  def []=(key,value)
-    set(key,value)
-  end
-
-  def set(key, value, expiry=nil)
-    s = call_command([:set, key, value]) == OK
-    expire(key, expiry) if s && expiry
-    s
-  end
-
-  def sort(key, options = {})
-    cmd = ["SORT"]
-    cmd << key
-    cmd << "BY #{options[:by]}" if options[:by]
-    cmd << "GET #{[options[:get]].flatten * ' GET '}" if options[:get]
-    cmd << "#{options[:order]}" if options[:order]
-    cmd << "LIMIT #{options[:limit].join(' ')}" if options[:limit]
-    call_command(cmd)
-  end
-
-  def incr(key, increment = nil)
-    call_command(increment ? ["incrby",key,increment] : ["incr",key])
-  end
+require 'redis/client'
+require 'redis/pipeline'
 
-  def decr(key,decrement = nil)
-    call_command(decrement ? ["decrby",key,decrement] : ["decr",key])
-  end
-
-  # Similar to memcache.rb's #get_multi, returns a hash mapping
-  # keys to values.
-  def mapped_mget(*keys)
-    result = {}
-    mget(*keys).each do |value|
-      key = keys.shift
-      result.merge!(key => value) unless value.nil?
-    end
-    result
-  end
-
-  # Ruby defines a now deprecated type method so we need to override it here
-  # since it will never hit method_missing
-  def type(key)
-    call_command(['type', key])
-  end
-
-  def quit
-    call_command(['quit'])
-  rescue Errno::ECONNRESET
-  end
-
-  def pipelined(&block)
-    pipeline = Pipeline.new self
-    yield pipeline
-    pipeline.execute
-  end
-
-  def read_reply
-    # We read the first byte using read() mainly because gets() is
-    # immune to raw socket timeouts.
-    begin
-      rtype = @sock.read(1)
-    rescue Errno::EAGAIN
-      # We want to make sure it reconnects on the next command after the
-      # timeout. Otherwise the server may reply in the meantime leaving
-      # the protocol in a desync status.
-      @sock = nil
-      raise Errno::EAGAIN, "Timeout reading from the socket"
-    end
-
-    raise Errno::ECONNRESET,"Connection lost" if !rtype
-    line = @sock.gets
-    case rtype
-    when MINUS
-      raise MINUS + line.strip
-    when PLUS
-      line.strip
-    when COLON
-      line.to_i
-    when DOLLAR
-      bulklen = line.to_i
-      return nil if bulklen == -1
-      data = @sock.read(bulklen)
-      @sock.read(2) # CRLF
-      data
-    when ASTERISK
-      objects = line.to_i
-      return nil if bulklen == -1
-      res = []
-      objects.times {
-        res << read_reply
-      }
-      res
-    else
-      raise "Protocol error, got '#{rtype}' as initial reply byte"
-    end
-  end
-
-  private
-    def get_size(string)
-      string.respond_to?(:bytesize) ? string.bytesize : string.size
-    end
-end
+# For backwards compatibility
+Redis = RedisRb::Client

data/spec/redis_spec.rb

@@ -430,6 +430,15 @@ describe "redis" do
     @r.sort('dogs', :get => ['dog:*:name', 'dog:*:breed'], :limit => [0,1]).should == ['louie', 'mutt']
     @r.sort('dogs', :get => ['dog:*:name', 'dog:*:breed'], :limit => [0,1], :order => 'desc alpha').should == ['taj', 'terrier']
   end
+
+  it "should be able to store a SORT result" do
+    @r.rpush 'colors', 'red'
+    @r.rpush 'colors', 'yellow'
+    @r.rpush 'colors', 'orange'
+    @r.rpush 'colors', 'green'
+    @r.sort('colors', :limit => [1,2], :order => 'desc alpha', :store => 'sorted.colors')
+    @r.lrange('sorted.colors', 0, -1).should == ['red', 'orange']
+  end
   #
   it "should be able count the members of a zset" do
     @r.set_add "set", 'key1'
@@ -439,7 +448,7 @@ describe "redis" do
     @r.delete('set')
     @r.delete('zset')
   end
-  # 
+  #
   it "should be able add members to a zset" do
     @r.set_add "set", 'key1'
     @r.set_add "set", 'key2'
@@ -449,7 +458,7 @@ describe "redis" do
     @r.delete('set')
     @r.delete('zset')
   end
-  # 
+  #
   it "should be able delete members to a zset" do
     @r.set_add "set", 'key1'
     @r.set_add "set", 'key2'
@@ -467,7 +476,7 @@ describe "redis" do
     @r.delete('set2')
     @r.delete('zset')
   end
-  # 
+  #
   it "should be able to get a range of values from a zset" do
     @r.set_add "set", 'key1'
     @r.set_add "set", 'key2'
@@ -487,7 +496,7 @@ describe "redis" do
     @r.delete('set3')
     @r.delete('zset')
   end
-  # 
+  #
   it "should be able to get a reverse range of values from a zset" do
     @r.set_add "set", 'key1'
     @r.set_add "set", 'key2'
@@ -507,7 +516,7 @@ describe "redis" do
     @r.delete('set3')
     @r.delete('zset')
   end
-  # 
+  #
   it "should be able to get a range by score of values from a zset" do
     @r.set_add "set", 'key1'
     @r.set_add "set", 'key2'
@@ -630,7 +639,7 @@ describe "redis" do
   end
 
   it "should handle multiple servers" do
-    require 'dist_redis'
+    require 'redis/dist_redis'
     @r = DistRedis.new(:hosts=> ['localhost:6379', '127.0.0.1:6379'], :db => 15)
 
     100.times do |idx|
@@ -640,6 +649,8 @@ describe "redis" do
     100.times do |idx|
       @r[idx].should == "foo#{idx}"
     end
+
+    @r.keys('*').sort.first.should == "0"
   end
 
   it "should be able to pipeline writes" do
@@ -665,4 +676,77 @@ describe "redis" do
     r.connect_to_server
   end
 
+  it "should run MULTI without a block" do
+    @r.multi
+    @r.get("key1").should == "QUEUED"
+    @r.discard
+  end
+
+  it "should run MULTI/EXEC with a block" do
+    @r.multi do
+      @r.set "key1", "value1"
+    end
+
+    @r.get("key1").should == "value1"
+
+    begin
+      @r.multi do
+        @r.set "key2", "value2"
+        raise "Some error"
+        @r.set "key3", "value3"
+      end
+    rescue
+    end
+
+    @r.get("key2").should be_nil
+    @r.get("key3").should be_nil
+  end
+
+  it "should yield the Redis object when using #multi with a block" do
+    @r.multi do |multi|
+      multi.set "key1", "value1"
+    end
+
+    @r.get("key1").should == "value1"
+  end
+
+  it "can set and get hash values" do
+    @r.hset("rush", "signals", "1982").should be_true
+    @r.hexists("rush", "signals").should be_true
+    @r.hget("rush", "signals").should == "1982"
+  end
+
+  it "can delete hash values" do
+    @r.hset("rush", "YYZ", "1981")
+    @r.hdel("rush", "YYZ").should be_true
+    @r.hexists("rush", "YYZ").should be_false
+  end
+
+  describe "with some hash values" do
+    before(:each) do
+      @r.hset("rush", "permanent waves", "1980")
+      @r.hset("rush", "moving pictures", "1981")
+      @r.hset("rush", "signals", "1982")
+    end
+
+    it "can get the length of the hash" do
+      @r.hlen("rush").should == 3
+      @r.hlen("yyz").should be_zero
+    end
+
+    it "can get the keys and values of the hash" do
+      @r.hkeys("rush").should == ["permanent waves", "moving pictures", "signals"]
+      @r.hvals("rush").should == %w[1980 1981 1982]
+      @r.hvals("yyz").should be_empty
+    end
+
+    it "returns a hash for HGETALL" do
+      @r.hgetall("rush").should == {
+        "permanent waves" => "1980",
+        "moving pictures" => "1981",
+        "signals"         => "1982"
+      }
+      @r.hgetall("yyz").should == {}
+    end
+  end
 end

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: redis
 version: !ruby/object:Gem::Version 
-  version: 0.1.2
+  prerelease: false
+  segments: 
+  - 0
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Ezra Zygmuntowicz
@@ -14,19 +19,21 @@ autorequire: redis
 bindir: bin
 cert_chain: []
 
-date: 2010-01-27 00:00:00 -08:00
+date: 2010-03-23 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rspec
-  type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+        - 0
         version: "0"
-    version: 
+  type: :development
+  version_requirements: *id001
 description: Ruby client library for redis key value storage server
 email: ez@engineyard.com
 executables: []
@@ -39,9 +46,11 @@ files:
 - LICENSE
 - README.markdown
 - Rakefile
-- lib/dist_redis.rb
-- lib/hash_ring.rb
-- lib/pipeline.rb
+- lib/edis.rb
+- lib/redis/client.rb
+- lib/redis/dist_redis.rb
+- lib/redis/hash_ring.rb
+- lib/redis/pipeline.rb
 - lib/redis/raketasks.rb
 - lib/redis.rb
 - tasks/redis.tasks.rb
@@ -60,18 +69,20 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: Ruby client library for redis key value storage server