ruby-redis-portertech 0.0.3

data/lib/redis/sender.rb

@@ -0,0 +1,47 @@
+module Redis
+  module Sender
+
+    def send_redis data
+      collect = []
+      if Symbol === data
+        collect << data
+      elsif NilClass === data
+        collect << :'$-1'
+      elsif FalseClass === data
+        collect << :':0'
+      elsif TrueClass === data
+        collect << :':1'
+      elsif Float === data and data.nan?
+        collect << :':0'
+      elsif Float === data and (data.infinite? || 0) > 0
+        collect << :':inf'
+      elsif Float === data and (data.infinite? || 0) < 0
+        collect << :':-inf'
+      elsif Hash === data
+        collect << "*#{data.size * 2}"
+        data.each do |key, value|
+          key = key.to_s
+          value = value.to_s
+          collect << "$#{key.bytesize}"
+          collect << key
+          collect << "$#{value.bytesize}"
+          collect << value
+        end
+      elsif Enumerable === data and !(String === data)
+        collect << "*#{data.size}"
+        data.each do |element|
+          element = element.to_s
+          collect << "$#{element.bytesize}"
+          collect << element
+        end
+      else
+        data = data.to_s
+        collect << "$#{data.bytesize}"
+        collect << data
+      end
+      collect << ''
+      send_data collect.join "\r\n"
+    end
+    
+  end
+end

data/lib/redis/server.rb

@@ -0,0 +1,60 @@
+module Redis
+  
+  module Server
+    
+    def redis_FLUSHDB
+      @database.clear
+      :'+OK'
+    end
+
+    def redis_FLUSHALL
+      @databases.each do |database|
+        database.clear
+      end
+      :'+OK'
+    end
+    
+    def redis_DBSIZE
+      @database.size
+    end
+    
+    def redis_DEBUG type, key=nil
+      if type.upcase == 'OBJECT'
+        "#{@database[key].class}"
+        value = @database[key]
+        # encoding values are meaningless, they make tcl tests pass
+        # and don't forget they need a trailing space
+        if String === value
+          "Value #{value.class}:#{value.object_id} encoding:raw encoding:int "
+        elsif Numeric === value
+          "Value #{value.class}:#{value.object_id} encoding:int "
+        elsif Array === value
+          "Value #{value.class}:#{value.object_id} encoding:ziplist encoding:linkedlist "
+        elsif Hash === value
+          "Value #{value.class}:#{value.object_id} encoding:zipmap encoding:hashtable "
+        elsif Set === value
+          "Value #{value.class}:#{value.object_id} encoding:intset encoding:hashtable "
+        else
+          "Value #{value.class}:#{value.object_id}"
+        end
+      elsif type.upcase == 'RELOAD'
+        "TODO: what is reload"
+      else
+        raise 'not supported'
+      end
+    end
+    
+    def redis_INFO
+      [
+        "redis_version:%s\r\n",
+        "redis_git_sha1:%s\r\n",
+        "redis_git_dirty:%d\r\n",
+      ].join % [
+        Redis::VERSION,
+        "Ruby",
+        1,
+      ]
+    end
+    
+  end
+end

data/lib/redis/sets.rb

@@ -0,0 +1,104 @@
+require 'set'
+
+module Redis
+  module Sets
+  
+    def redis_SADD key, member
+      record = (@database[key] ||= Set.new)
+      redis_t Set, record
+      return false if record.include? member
+      record.add member
+      true
+    end
+    
+    def redis_SREM key, member
+      record = @database[key] || []
+      return false unless record.include? member
+      record.delete member
+      @database.delete key if record.empty?
+      return true
+    end
+    
+    # Type checks are only to make tests pass
+    def redis_SMOVE source, destination, member
+      source_record = @database[source] || Set.new
+      dest_record = @database[destination]
+      redis_t Set, source_record
+      redis_t NilClass, Set, dest_record
+      return false unless source_record.include? member
+      (@database[destination] ||= Set.new).add member
+      source_record.delete member
+      @database.delete source if source_record.empty?
+      return true
+    end
+      
+    def redis_SCARD key
+      (@database[key] || []).size
+    end
+    
+    def redis_SISMEMBER key, member
+      (@database[key] || []).include? member
+    end
+    
+    def redis_SMEMBERS key
+      (@database[key] || []).to_a
+    end
+    
+    def redis_SINTER *keys
+      keys.each { |key| redis_t NilClass, Array, Set, @database[key] }
+      keys.reduce(nil) do |memo, key| 
+        memo ? memo & (@database[key]||[]) : (@database[key]||Set.new) 
+      end
+    end
+    
+    def redis_SINTERSTORE destination, *keys
+      record = redis_SINTER *keys
+      if record.empty?
+        @database.delete destination 
+      else
+        @database[destination] = record
+      end
+      record.size
+    end
+
+    def redis_SUNION *keys
+      keys.each { |key| redis_t NilClass, Array, Set, @database[key] }
+      keys.reduce(Set.new) { |memo, key| memo | (@database[key]||[]) }
+    end
+
+    def redis_SUNIONSTORE destination, *keys
+      record = redis_SUNION *keys
+      if record.empty?
+        @database.delete destination 
+      else
+        @database[destination] = record
+      end
+      record.size
+    end
+    
+    def redis_SDIFF *keys
+      keys.reduce(nil) { |memo, key| memo ? memo - (@database[key]||[]) : (@database[key]||Set.new) }
+    end
+    
+    def redis_SDIFFSTORE destination, *keys
+      (@database[destination] = redis_SDIFF *keys).size
+    end
+    
+    def redis_SPOP key
+      set = @database[key]
+      return nil unless set
+      rec = rand set.size
+      result = set.to_a[rec]
+      set.delete result
+      @database.delete key if set.empty?
+      result
+    end
+    
+    def redis_SRANDMEMBER key
+      set = (@database[key] || [])
+      return nil if set.empty?
+      set.to_a[rand set.size]
+    end
+    
+  end
+end

data/lib/redis/strict.rb

@@ -0,0 +1,65 @@
+module Redis
+  
+  # This is faster and allows for experimentation with duck-typing.
+  module NotStrict
+
+    def redis_t *args
+    end
+
+    def redis_f val, msg = nil
+      if Numeric === val
+        val
+      else
+        val_downcase = val.downcase
+        if val_downcase == '-inf'
+          -1.0/0
+        elsif val_downcase =~ /^[+]?inf$/
+          1.0/0
+        else
+          val.to_f
+        end
+      end
+    end
+    
+    def redis_i val, msg = nil
+      val.to_i
+    end
+    
+    def redis_pos_i val, msg = 'value is negative'
+      val = redis_i val # may call strict
+      raise msg if val < 0
+      val
+    end
+    
+  end
+  
+  # Strict version allows the ruby-redis server to pass redis tests.
+  module Strict
+    include NotStrict
+
+    def redis_t *args
+      val = args.pop
+      msg = 'Operation against a key holding the wrong kind of value'
+      unless Class === args.last
+        msg = val
+        val = args.pop
+      end
+      args.each do |klass|
+        return if klass === val
+      end
+      raise msg
+    end
+
+    def redis_f val, msg = 'value is not a double'
+      raise msg+val.to_s.dump unless Numeric === val or val =~ /^[ +-]?([0-9.e-]*|inf)$/i
+      super
+    end
+
+    def redis_i val, msg = 'value is not an integer or out of range'
+      raise msg unless Integer === val or val =~ /^[ +-]?[0-9]*$/
+      super
+    end
+    
+  end
+  
+end

data/lib/redis/strings.rb

@@ -0,0 +1,142 @@
+module Redis
+  
+  # Note: Redis does not have a dedicated integer type.
+  # Integer operations will convert values to integers.
+  
+  module Strings
+    
+    def redis_GET key
+      value = @database[key]
+      redis_t NilClass, String, Numeric, value
+      value
+    end
+    
+    def redis_APPEND key, value
+      new_value = redis_GET(key).to_s + value
+      @database[key] = new_value
+      new_value.size
+    end
+    
+    def redis_SETRANGE key, offset, value
+      data = (redis_GET(key)||'').to_s
+      return data.size if value.empty?
+      offset = redis_pos_i offset, 'out of range'
+      raise 'maximum allowed size' if offset + value.size > 512*1024*1024
+      if data.size <= offset
+        data.concat 0.chr * (offset - data.size + value.size)
+      end
+      data[offset,value.size] = value
+      @database[key] = data
+      data.size
+    end
+    
+    def redis_GETRANGE key, first, last
+      first = redis_i first
+      last = redis_i last
+      value = redis_GET(key) || ''
+      first = 0 if first < -value.size
+      value[first..last]
+    end
+    
+    def redis_GETBIT key, offset
+      data = redis_GET key
+      return 0 unless data
+      data = data.to_s
+      offset = redis_pos_i offset
+      byte = offset / 8
+      bit = 0x80 >> offset % 8
+      return 0 if data.size <= byte
+      original_byte = data[byte].ord
+      original_bit = original_byte & bit
+      original_bit != 0
+    end
+    
+    def redis_SETBIT key, offset, value
+      data = (redis_GET(key)||'').to_s
+      offset = redis_pos_i offset, 'out of range'
+      raise 'out of range' if offset >= 4*1024*1024*1024
+      byte = offset / 8
+      bit = 0x80 >> offset % 8
+      if data.size <= byte
+        data += 0.chr * (byte - data.size + 1)
+      end
+      original_byte = data[byte].ord
+      original_bit = original_byte & bit
+      if value == '0'
+        data[byte] = (original_byte & ~bit).chr
+      elsif value == '1'
+        data[byte] = (original_byte | bit).chr
+      else
+        raise 'out of range'
+      end
+      @database[key] = data
+      original_bit != 0
+    end
+  
+    def redis_STRLEN key
+      value = redis_GET key
+      value ? value.size : 0
+    end
+
+    def redis_MGET *keys
+      keys.collect do |key|
+        value = @database[key]
+        (String === value) ? value : nil
+      end
+    end
+    
+    def redis_GETSET key, value
+      old = redis_GET key
+      @database[key] = value
+      old
+    end
+    
+    def redis_SET key, value
+      @database[key] = value
+      :'+OK'
+    end
+
+    def redis_SETEX key, seconds, value
+      @database[key] = value
+      @database.expire key, redis_pos_i(seconds, 'invalid expire time in SETEX')
+      :'+OK'
+    end
+    
+    def redis_MSET *args
+      Hash[*args].each do |key, value|
+        @database[key] = value
+      end
+      :'+OK'
+    end
+    
+    def redis_MSETNX *args
+      hash = Hash[*args]
+      hash.each do |key, value|
+        return false if @database.has_key? key
+      end
+      hash.each do |key, value|
+        @database[key] = value
+      end
+      true
+    end
+
+    def redis_SETNX key, value
+      return false if @database.has_key? key
+      @database[key] = value
+      true
+    end
+    
+    def redis_INCR key
+      @database[key] = redis_i(@database[key] || 0) + 1
+    end
+
+    def redis_INCRBY key, value
+      @database[key] = redis_i(@database[key] || 0) + redis_i(value)
+    end
+
+    def redis_DECRBY key, value
+      @database[key] = redis_i(@database[key] || 0) - redis_i(value)
+    end
+      
+  end
+end

data/lib/redis/synchrony.rb

@@ -0,0 +1,51 @@
+require 'fiber'
+require File.expand_path 'client', File.dirname(__FILE__)
+
+module Redis
+  
+  # Compatible with em-synchrony
+  
+  def self.synchrony blk=nil, tail=nil, &block
+    blk ||= block
+    context = Proc.new { Fiber.new { blk.call }.resume }
+    EventMachine.run(context, tail)
+  end
+
+  class Synchrony
+    def self.sync(df)
+      f = Fiber.current
+      xback = proc {|r|
+        if f == Fiber.current
+          return r
+        else
+          f.resume r
+        end
+      }
+      df.callback &xback
+      df.errback &xback
+      Fiber.yield
+    end
+    def initialize redis
+      @redis = redis
+    end
+    def method_missing method, *args, &block
+      raise 'synchrony not allowed in multi' if @redis.in_multi? and method != :exec
+      result = @redis.send method, *args, &block
+      if result.respond_to? :callback and result.respond_to? :errback
+        result = Synchrony.sync result
+        raise result if Exception === result
+      end
+      result
+    end
+  end
+
+  class Client
+
+    def synchrony
+      raise 'you probably want Redis.synchrony instead' if block_given?
+      @synchrony ||= Synchrony.new self
+    end
+  
+  end
+
+end