dumped JsonRedis, (en|de)code where necessary. added push/pop and som…

…e other useful methods. refactored #write

lib/redis/redis_factory.rb

@@ -5,9 +5,9 @@ class << self
     def create(*addresses)
       addresses = extract_addresses(addresses)
       if addresses.size > 1
-        DistributedMarshaledRedis.new addresses
+        Redis::Distributed.new addresses
       else
-        JsonRedis.new addresses.first || {}
+        Redis.new addresses.first || {}
       end
     end
 

lib/redis_buddy.rb

@@ -1,11 +1,3 @@
-require 'redis'
-require 'redis/distributed'
-require 'redis/namespace'
-
-require 'redis/redis_factory'
-require 'redis/json_redis'
-require 'redis/distributed_json_redis'
-require 'redis/marshaled_redis'
-require 'redis/distributed_marshaled_redis'
-
-require 'redis_buddy/cache_store'
+module RedisBuddy
+  # Your code goes here...
+end

lib/redis_buddy/cache_store.rb

@@ -4,60 +4,99 @@ class RedisBuddyStore < Store
       def initialize(*adresses)
         ns = Rails.application.class.to_s.split('::').first.downcase
         @r = RedisFactory.create(adresses)
-        @data = Redis::Namespace.new(ns, :redis => @r)
+        @client = Redis::Namespace.new(ns, :redis => @r)
       end
 
-      def write(key, value, options = nil)
-        method = options && options[:unless_exist] ? :set_unless_exists : :set
+      def write(key, value, options = {})
+        method = :getset if options[:return]
+        method = :setnx if options[:nx]
+        method, ttl = :setex, options[:ttl] if options[:ttl]
+        method = :set unless method
+        value = encode(value)
 
-        if options && options[:expire]
-          if (info.is_a?(Array) ? info.first['redis_version'] : info['redis_version']) <= '1.2.6'
-            @data.send(:set, key, value)
-            @data.send(:expire, key, options[:expire])
-          else
-            @data.send(:setex, key, value,options[:expire])
-          end
-        else
-          @data.send(method, key, value)
-        end
+        ttl ? @client.send(method, key, ttl, value) : @client.send(method, key, value)
+      end
+
+      def push(key, value)
+        @client.lpush(key, encode(value))
+      end
+
+      def increment(key, amount = nil)
+        amount.nil? ? @client.incr(key) : @client.incrby(key, amount)
+      end
+
+      def decrement(key, amount = nil)
+        amount.nil? ? @client.decr(key) : @client.decrby(key, amount)
+      end
+
+      def expire_in(key, ttl)
+        @client.expire(key, ttl)
+      end
+
+      def exipire_at(key, time)
+        @client.exipireat(key, time)
       end
 
       def read(key)
-        @data.get(key)
+        value = @client.get(key)
+        value ? decode(value) : nil
       end
 
-      def ttl(key)
-        @data.ttl(key)
+      def pop(key)
+        value = @client.rpop(key)
+        value ? decode(value) : nil
       end
 
-      def delete(key)
-        @data.del(key)
+      def length(key)
+        @client.llen(key)
       end
 
-      def exist?(key)
-        @data.exists(key)
+      def ttl(key)
+        @client.ttl(key)
       end
 
-      def increment(key, amount = nil)
-        amount.nil? ? @data.incr(key) : @data.incrby(key, amount)
+      def type(key)
+        @client.type(key)
       end
 
-      def decrement(key, amount = nil)
-        amount.nil? ? @data.decr(key) : @data.decrby(key, amount)
+      def exists?(key)
+        @client.exists(key)
       end
 
-      def delete_matched(matcher)
-        super do
-          @data.keys(matcher).each { |key| @data.del(key) }
-        end
+      def delete(key)
+        @client.del(key)
       end
 
       def clear
-        @data.flushdb
+        @client.flushdb
       end
 
       def info
-        @data.info
+        @client.info
+      end
+
+      def keys(pattern = "*")
+        @client.keys(pattern)
+      end
+
+      def client
+        @client
+      end
+
+      private
+      def decode(value)
+        value = Yajl.load(value)
+        value.with_indifferent_access if value.is_a?(Hash)
+        value
+      end
+
+      def encode(value)
+        return value unless encode?(value)
+        Yajl.dump(value)
+      end
+
+      def encode?(value)
+        !value.is_a?(Integer) 
       end
     end
   end

lib/redis_buddy/version.rb

@@ -0,0 +1,3 @@
+module RedisBuddy
+  VERSION = "0.2.1"
+end