ruby-redis-portertech 0.0.3

data/lib/redis/config.rb

@@ -0,0 +1,49 @@
+module Redis
+  class Config < Hash
+    
+    INTEGERS = [:port, :timeout, :databases]
+    BOOLEANS = [:daemonize]
+    
+    def initialize argf_or_hash
+
+      # defaults
+      self[:dir] = '.'
+      self[:logfile] = 'stdout'
+      self[:loglevel] = 'verbose'
+      self[:daemonize] = false
+      self[:pidfile] = '/var/run/redis.pid'
+      self[:bind] = '127.0.0.1'
+      self[:port] = 6379
+      self[:timeout] = 300
+      self[:databases] = 16
+
+      this = super()
+      if Hash === argf_or_hash
+        super argf_or_hash
+      else
+        super()
+        # load from ARGF or IO compatible interface
+        argf_or_hash.each do |line|
+          key, val = line.split ' ', 2
+          self[key.downcase.gsub(/-/,'_').to_sym] = val.chomp "\n"
+        end
+      end
+
+      # convert
+      INTEGERS.each do |key|
+        this[key] = this[key].to_i
+      end
+
+      # convert
+      BOOLEANS.each do |key|
+        next unless String===this[key]
+        this[key] = case this[key].downcase
+        when 'yes' then true
+        when 'no' then false
+        else nil
+        end
+      end
+      
+    end
+  end
+end

data/lib/redis/connection.rb

@@ -0,0 +1,30 @@
+module Redis
+  module Connection
+    
+    def redis_AUTH password
+      raise 'invalid password' unless authorized password
+      :'+OK'
+    end
+
+    def redis_SELECT db_index
+      database = @databases[redis_i db_index]
+      raise 'invalid DB index' unless database
+      @database = database
+      :'+OK'
+    end
+    
+    def redis_PING
+      :'+PONG'
+    end
+
+    def redis_ECHO str
+      str
+    end
+
+    def redis_QUIT
+      send_redis :'+OK'
+      :quit
+    end
+    
+  end
+end

data/lib/redis/database.rb

@@ -0,0 +1,133 @@
+module Redis
+  class Database
+    
+    class Watcher
+
+      attr_reader :bound
+
+      def initialize
+        @watched = []
+        @bound = true
+      end
+
+      def bind database, *keys
+        return unless @bound
+        keys.each do |key|
+          entry = [database, key]
+          next if @watched.include? entry
+          @watched << entry
+          (database.watchers[key] ||= []).push self
+        end
+      end
+
+      def unbind
+        return unless @bound
+        @watched.each do |database, key|
+          key_df_list = database.watchers[key]
+          next unless key_df_list
+          key_df_list.delete_if { |e| e == self }
+        end
+        @bound = false
+      end
+
+    end
+    
+    # Redis databases are volatile dictionaries.
+    
+    attr_reader :blocked_pops, :watchers
+    
+    def initialize
+      @dict = {}
+      @expiry = {}
+      @blocked_pops = {}
+      @watchers = {}
+    end
+    
+    def touch key
+      (@watchers[key]||[]).each do |watcher|
+        watcher.unbind
+      end
+    end
+    
+    def expire key, seconds
+      return false unless @dict.has_key? key
+      touch key
+      @expiry[key] = Time.now + seconds
+      return true
+    end
+
+    def expire_at key, unixtime
+      return false unless @dict.has_key? key
+      touch key
+      @expiry[key] = Time.at unixtime
+      return true
+    end
+    
+    def ttl key
+      check_expiry key
+      time = @expiry[key]
+      return -1 unless time
+      (time - Time.now).round
+    end
+    
+    def persist key
+      result = @expiry.has_key? key
+      touch key if result
+      @expiry.delete key
+      result
+    end
+    
+    def random_key
+      @dict.keys[rand @dict.size]
+    end
+    
+    def [] key
+      check_expiry key
+      @dict[key]
+    end
+
+    def []= key, value
+      touch key
+      @expiry.delete key
+      @dict[key] = value
+    end
+    
+    def has_key? key
+      check_expiry key
+      @dict.has_key? key
+    end
+    
+    def delete key
+      touch key
+      @dict.delete key
+      @expiry.delete key
+    end
+    
+    def reduce *args, &block
+      @dict.reduce *args, &block
+    end
+    
+    def size
+      @dict.size
+    end
+    
+    def clear
+      # We don't trigger watchers of unset records
+      @dict.each_key { |key| touch key }
+      @dict.clear
+      @expiry.clear
+    end
+    
+    def empty?
+      @dict.empty?
+    end
+    
+    private
+    
+    def check_expiry key
+      expires_at = @expiry[key]
+      delete key if expires_at and Time.now > expires_at
+    end
+    
+  end
+end

data/lib/redis/hashes.rb

@@ -0,0 +1,70 @@
+module Redis
+  module Hashes
+    
+    def redis_HSET key, field, value
+      hash = @database[key] ||= {}
+      result = !hash.has_key?(field)
+      hash[field] = value
+      result
+    end
+    
+    def redis_HEXISTS key, field
+      (@database[key] || {}).has_key? field
+    end
+
+    def redis_HSETNX key, field, value
+      hash = @database[key] || {}
+      return false if hash.has_key? field
+      redis_HSET key, field, value
+      return true
+    end
+    
+    def redis_HKEYS key
+      (@database[key] || {}).keys
+    end
+    
+    def redis_HVALS key
+      (@database[key] || {}).values
+    end
+    
+    def redis_HMSET key, *args
+      (@database[key] ||= {}).merge! Hash[*args]
+      :'+OK'
+    end
+      
+    def redis_HMGET key, *fields
+      hash = (@database[key] || {})
+      redis_t Hash, hash
+      fields.collect do |field|
+        hash[field]
+      end
+    end
+      
+    def redis_HLEN key
+      (@database[key] || {}).size
+    end
+
+    def redis_HGET key, field
+      (@database[key] || {})[field]
+    end
+    
+    def redis_HGETALL key
+      @database[key] || {}
+    end
+
+    def redis_HDEL key, field
+      hash = @database[key] || {}
+      result = hash.has_key? field
+      hash.delete field
+      result
+    end
+    
+    def redis_HINCRBY key, field, increment
+      hash = @database[key] ||= {}
+      value = redis_i(hash[field] ||= 0)
+      value += redis_i increment
+      hash[field] = value
+    end
+    
+  end
+end

data/lib/redis/keys.rb

@@ -0,0 +1,155 @@
+module Redis
+  module Keys
+    
+    def redis_RANDOMKEY
+      return nil if @database.empty?
+      @database.random_key
+    end
+  
+    def redis_KEYS pattern
+      @database.reduce([]) do |memo, key_val|
+        key = key_val[0]
+        memo.push key if File.fnmatch(pattern, key)
+        memo
+      end
+    end
+    
+    def redis_SORT key, *args
+      record = @database[key] || []
+      sort = 'ASC'
+      gets = []
+      alpha = false
+      by = by_hash = offset = count = store = nil
+      until args.empty?
+        arg = args.shift
+        case arg.upcase
+        when 'LIMIT'
+          offset = args.shift.to_i
+          count = args.shift.to_i
+        when 'ASC'
+          sort = 'ASC'
+        when 'DESC'
+          sort = 'DESC'
+        when 'ALPHA'
+          alpha = true
+        when 'STORE'
+          store = args.shift
+        when 'GET'
+          gets << args.shift
+        when 'BY'
+          by, by_hash = args.shift.split '->', 2
+        else
+          raise "#{arg} bad argument"
+        end
+      end
+      result = record.sort do |a, b|
+        if by
+          a = @database[by.sub /\*/, a]
+          a = a[by_hash] if by_hash
+          b = @database[by.sub /\*/, b]
+          b = b[by_hash] if by_hash
+        end
+        if alpha
+          a = a.to_s
+          b = b.to_s
+        else
+          a = a.to_f
+          b = b.to_f
+        end
+        if sort == 'DESC'
+          b <=> a
+        else
+          a <=> b
+        end
+      end
+      unless gets.empty?
+        original = result
+        result = []
+        original.each do |r|
+          gets.each do |g|
+            get, get_hash = g.split('->', 2)
+            r = @database[get.sub /\*/, r] unless get == '#'
+            r = r[get_hash] if get_hash
+            result << r
+          end
+        end
+      end
+      if count and offset
+        result = result[offset,count]
+      elsif count
+        result = result[0,count]
+      elsif offset
+        result = result[offset..-1]
+      end
+      if Array === result[0]
+        result = result.collect {|r| r.first}
+      end
+      @database[store] = result if store
+      result
+    end
+    
+    def redis_DEL *keys
+      count = 0
+      keys.each do |key|
+        count += 1  if @database.has_key? key
+        @database.delete key
+      end
+      count
+    end
+    
+    def redis_TYPE key
+      case @database[key]
+      when String, Numeric; 'string'
+      when Array; 'list'
+      when Set; 'set'
+      when ZSet; 'zset'
+      when Hash; 'hash'
+      else 'unknown'
+      end
+    end
+
+    def redis_EXISTS key
+      @database.has_key? key
+    end
+    
+    def redis_EXPIRE key, seconds
+      @database.expire key, redis_pos_i(seconds)
+    end
+
+    def redis_EXPIREAT key, timestamp
+      @database.expire_at key, redis_pos_i(timestamp)
+    end
+    
+    def redis_PERSIST key
+      @database.persist key
+    end
+
+    def redis_TTL key
+      @database.ttl key
+    end
+    
+    def redis_RENAME key, newkey
+      raise 'key and newkey are identical' if key == newkey
+      raise 'key not found' unless @database.has_key? key
+      @database[newkey] = @database[key]
+      @database.delete key
+    end
+    
+    def redis_RENAMENX key, newkey
+      return false if @database.has_key? newkey
+      redis_RENAME key, newkey
+      true
+    end
+    
+    def redis_MOVE key, db
+      raise unless @database.has_key? key
+      raise if @databases[redis_i db].has_key? key
+      @databases[redis_i db][key] = @database[key]
+      @database.delete key
+      true
+    rescue
+      false
+    end
+      
+  end
+end

data/lib/redis/lists.rb

@@ -0,0 +1,225 @@
+require 'eventmachine'
+
+module Redis
+  module Lists
+    
+    class DeferredPop
+      include EventMachine::Deferrable
+      
+      attr_reader :bound
+      
+      def initialize database, timeout_secs, *keys
+        @database = database
+        @keys = keys
+        timeout timeout_secs if timeout_secs > 0
+        errback { unbind }
+        callback { unbind }
+        keys.each do |key|
+          (@database.blocked_pops[key] ||= []).push self
+        end
+        @bound = true
+      end
+      
+      def unbind
+        return unless @bound
+        @keys.each do |key|
+          key_df_list = @database.blocked_pops[key]
+          next unless key_df_list
+          key_df_list.delete_if { |e| e == self }
+        end
+        @bound = false
+      end
+      
+    end
+    
+    def redis_LRANGE key, first, last
+      first = redis_i first
+      last = redis_i last
+      list = @database[key] || []
+      first = 0 if first < -list.size
+      list[first..last]
+    end
+    
+    def redis_LTRIM key, start, stop
+      @database[key] = redis_LRANGE key, start, stop
+    end
+    
+    def redis_BRPOP *args
+      timeout = redis_pos_i args.pop
+      args.each do |key|
+        list = @database[key]
+        if list and list.size > 0
+          value = list.pop
+          @database.delete key if list.empty?
+          return [key, value]
+        end
+      end
+      df = DeferredPop.new(@database, timeout, *args)
+      df.errback { send_redis :'*-1' }
+      df.callback { |key, value| send_redis [key, value] }
+      df
+    end
+    
+    def redis_BLPOP *args
+      timeout = redis_pos_i args.pop
+      args.each do |key|
+        list = @database[key]
+        if list and list.size > 0
+          value = list.shift
+          @database.delete key if list.empty?
+          return [key, value]
+        end
+      end
+      df = DeferredPop.new(@database, timeout, *args)
+      df.errback { send_redis :'*-1' }
+      df.callback { |key, value| send_redis [key, value] }
+      df
+    end
+
+    def redis_RPOPLPUSH source, destination
+      source_list = @database[source]
+      return nil unless source_list
+      redis_t Array, source_list
+      redis_t NilClass, Array, @database[destination]
+      value = source_list.pop
+      @database.delete source if source_list.empty?
+      redis_LPUSH destination, value
+      return value
+    end
+    
+    def redis_BRPOPLPUSH source, destination, timeout
+      source_list = @database[source]
+      if source_list
+        redis_t Array, source_list
+        value = source_list.pop
+        @database.delete source if source_list.empty?
+        redis_LPUSH destination, value
+        return value
+      end
+      redis_t NilClass, Array, @database[destination]
+      df = DeferredPop.new @database, redis_pos_i(timeout), source
+      df.errback {send_redis :'*-1'}
+      df.callback do |key, value|
+        redis_LPUSH destination, value
+        send_redis value
+      end
+      df
+    end
+    
+    def redis_RPUSH key, value
+      list = @database[key]
+      redis_t NilClass, Array, list
+      (@database.blocked_pops[key] ||= []).each do |deferrable|
+        deferrable.succeed key, value
+        return 0
+      end
+      list = @database[key] = [] unless list
+      list.push(value).size
+    end
+
+    def redis_LPUSH key, value
+      list = @database[key]
+      redis_t NilClass, Array, list
+      (@database.blocked_pops[key] ||= []).each do |deferrable|
+        deferrable.succeed key, value
+        return 0
+      end
+      list = @database[key] = [] unless list
+      list.unshift(value).size
+    end
+
+    def redis_LPUSHX key, value
+      list = @database[key]
+      return 0 unless Array === list and list.size > 0
+      redis_LPUSH key, value
+      list.size
+    end
+
+    def redis_RPUSHX key, value
+      list = @database[key]
+      return 0 unless Array === list and list.size > 0
+      redis_RPUSH key, value
+      list.size
+    end
+    
+    def redis_LINSERT key, mode, pivot, value
+      list = @database[key]
+      index = list.find_index pivot
+      return -1 unless index
+      case mode.upcase
+      when 'BEFORE'
+        list[index,0] = value
+      when 'AFTER'
+        list[index+1,0] = value
+      else
+        raise 'only BEFORE|AFTER supported'
+      end
+      list.size
+    end
+    
+    def redis_RPOP key
+      list = @database[key]
+      return nil unless list
+      value = list.pop
+      @database.delete key if list.empty?
+      value
+    end
+
+    def redis_LPOP key
+      list = @database[key]
+      return nil unless list
+      value = list.shift
+      @database.delete key if list.empty?
+      value
+    end
+
+    def redis_LLEN key
+      list = @database[key] || []
+      redis_t Array, list
+      list.size
+    end
+
+    def redis_LINDEX key, index
+      list = @database[key] || []
+      redis_t Array, list
+      list[redis_i index]
+    end
+
+    def redis_LSET key, index, value
+      list = @database[key] || []
+      redis_t Array, list
+      raise 'out of range' unless list.size > redis_i(index).abs
+      list[redis_i index] = value
+    end
+    
+    def redis_LREM key, count, value
+      list = @database[key] || []
+      count = redis_i count
+      size = list.size
+      if count == 0
+        list.delete value
+      elsif count < 0
+        i = list.size
+        while i > 0 and count < 0
+          i -= 1
+          if list[i] == value
+            list.delete_at i
+            count += 1
+          end
+        end
+      else # count > 0
+        i = 0
+        while i < list.size and count > 0
+          if list[i] == value
+            list.delete_at i 
+            count -= 1
+          else
+            i += 1
+          end
+        end
+      end
+      size - list.size
+    end
+      
+  end
+end