redis-store 1.0.0.beta2 → 1.0.0.beta3

data/Rakefile

@@ -11,8 +11,8 @@ begin
   require "jeweler"
   Jeweler::Tasks.new do |gemspec|
     gemspec.name        = "#{ENV["GEM_PREFIX"]}redis-store"
-    gemspec.summary     = "Rack::Session, Rack::Cache and cache Redis stores for Ruby web frameworks."
-    gemspec.description = "Rack::Session, Rack::Cache and cache Redis stores for Ruby web frameworks."
+    gemspec.summary     = "Namespaced Rack::Session, Rack::Cache, I18n and cache Redis stores for Ruby web frameworks."
+    gemspec.description = "Namespaced Rack::Session, Rack::Cache, I18n and cache Redis stores for Ruby web frameworks."
     gemspec.email       = "guidi.luca@gmail.com"
     gemspec.homepage    = "http://github.com/jodosha/redis-store"
     gemspec.authors     = [ "Luca Guidi" ]
@@ -27,7 +27,7 @@ end
 
 namespace :spec do
   desc "Run all the examples by starting a detached Redis instance"
-  task :suite do
+  task :suite => :prepare do
     invoke_with_redis_cluster "spec:run"
   end
 
@@ -38,7 +38,7 @@ namespace :spec do
 end
 
 desc "Run all examples with RCov"
-task :rcov do
+task :rcov => :prepare do
   invoke_with_redis_cluster "rcov_run"
 end
 
@@ -47,6 +47,10 @@ Spec::Rake::SpecTask.new(:rcov_run) do |t|
   t.rcov = true
 end
 
+task :prepare do
+  `mkdir -p tmp && rm tmp/*.rdb`
+end
+
 namespace :bundle do
   task :clean do
     system "rm -rf ~/.bundle/ ~/.gem/ .bundle/ Gemfile.lock"

data/VERSION

@@ -1 +1 @@
-1.0.0.beta2
+1.0.0.beta3

data/lib/{rack/session/rails.rb → action_controller/session/redis_session_store.rb}

@@ -1,3 +1,5 @@
+require "redis-store"
+
 module RedisStore
   module Rack
     module Session
@@ -19,10 +21,8 @@ module RedisStore
 
           super
 
-          @options = { :key_prefix => "" }.update(options)
           servers = [options[:servers]].flatten.compact.map do |server_options|
             {
-              :namespace => 'rack:session',
               :host => 'localhost',
               :port => '6379',
               :db => 0
@@ -33,33 +33,37 @@ module RedisStore
         end
 
         private
-        def prefixed(sid)
-          "#{@options[:key_prefix]}#{sid}"
-        end
+          def get_session(env, sid)
+            sid ||= generate_sid
+            begin
+              session = @pool.get(sid) || {}
+            rescue Errno::ECONNREFUSED
+              session = {}
+            end
+            [sid, session]
+          end
 
-        def get_session(env, sid)
-          sid ||= generate_sid
-          begin
-            session = @pool.marshalled_get(prefixed(sid)) || {}
+          def set_session(env, sid, session_data)
+            options = env['rack.session.options']
+            @pool.set(sid, session_data, options)
+            return true
           rescue Errno::ECONNREFUSED
-            session = {}
+            return false
           end
-          [sid, session]
-        end
 
-        def set_session(env, sid, session_data)
-          options = env['rack.session.options']
-          @pool.marshalled_set(prefixed(sid), session_data, options)
-          return true
-        rescue Errno::ECONNREFUSED
-          return false
-        end
+          def destroy(env)
+            if sid = current_session_id(env)
+              @pool.del(sid)
+            end
+          rescue Errno::ECONNREFUSED
+            false
+          end
       end
     end
   end
 end
 
-if ::RedisStore.rails3?
+if ::Redis::Store.rails3?
   class ActionDispatch::Session::RedisSessionStore < ActionDispatch::Session::AbstractStore
     include RedisStore::Rack::Session::Rails
   end

data/lib/{cache/rails → active_support/cache}/redis_store.rb

@@ -1,15 +1,17 @@
+require "redis-store"
+
 module ::RedisStore
   module Cache
     module Rails2
       def write(key, value, options = nil)
         super
-        method = options && options[:unless_exist] ? :marshalled_setnx : :marshalled_set
+        method = options && options[:unless_exist] ? :setnx : :set
         @data.send method, key, value, options
       end
 
       def read(key, options = nil)
         super
-        @data.marshalled_get key, options
+        @data.get key, options
       end
 
       def delete(key, options = nil)
@@ -22,6 +24,16 @@ module ::RedisStore
         @data.exists key
       end
 
+      # Delete objects for matched keys.
+      #
+      # Example:
+      #   cache.del_matched "rab*"
+      def delete_matched(matcher, options = nil)
+        instrument(:delete_matched, matcher, options) do
+          @data.keys(matcher).each { |key| @data.del key }
+        end
+      end
+
       private
         def instrument(operation, key, options = nil)
           log(operation.to_s, key, options)
@@ -30,14 +42,26 @@ module ::RedisStore
     end
 
     module Rails3
+      # Delete objects for matched keys.
+      #
+      # Example:
+      #   cache.del_matched "rab*"
+      def delete_matched(matcher, options = nil)
+        options = merged_options(options)
+        instrument(:delete_matched, matcher.inspect) do
+          matcher = key_matcher(matcher, options)
+          @data.keys(matcher).each { |key| delete_entry(key, options) }
+        end
+      end
+
       protected
         def write_entry(key, entry, options)
-          method = options && options[:unless_exist] ? :marshalled_setnx : :marshalled_set
+          method = options && options[:unless_exist] ? :setnx : :set
           @data.send method, key, entry, options
         end
 
         def read_entry(key, options)
-          entry = @data.marshalled_get key, options
+          entry = @data.get key, options
           if entry
             entry.is_a?(ActiveSupport::Cache::Entry) ? entry : ActiveSupport::Cache::Entry.new(entry)
           end
@@ -46,10 +70,25 @@ module ::RedisStore
         def delete_entry(key, options)
           @data.del key
         end
+
+        # Add the namespace defined in the options to a pattern designed to match keys.
+        #
+        # This implementation is __different__ than ActiveSupport:
+        # __it doesn't accept Regular expressions__, because the Redis matcher is designed
+        # only for strings with wildcards.
+        def key_matcher(pattern, options)
+          prefix = options[:namespace].is_a?(Proc) ? options[:namespace].call : options[:namespace]
+          if prefix
+            raise "Regexps aren't supported, please use string with wildcards." if pattern.is_a?(Regexp)
+            "#{prefix}:#{pattern}"
+          else
+            pattern
+          end
+        end
     end
 
     module Store
-      include ::RedisStore.rails3? ? Rails3 : Rails2
+      include ::Redis::Store.rails3? ? Rails3 : Rails2
     end
   end
 end
@@ -62,23 +101,26 @@ module ActiveSupport
       # Instantiate the store.
       #
       # Example:
-      #   RedisStore.new                       # => host: localhost,   port: 6379,  db: 0
-      #   RedisStore.new "example.com"         # => host: example.com, port: 6379,  db: 0
-      #   RedisStore.new "example.com:23682"   # => host: example.com, port: 23682, db: 0
-      #   RedisStore.new "example.com:23682/1" # => host: example.com, port: 23682, db: 1
-      #   RedisStore.new "localhost:6379/0", "localhost:6380/0" # => instantiate a cluster
-      def initialize(*addresses)
-        @data = Redis::Factory.create(addresses)
-      end
-
-      # Delete objects for matched keys.
+      #   RedisStore.new
+      #     # => host: localhost,   port: 6379,  db: 0
       #
-      # Example:
-      #   cache.del_matched "rab*"
-      def delete_matched(matcher, options = nil)
-        instrument(:delete_matched, matcher, options) do
-          @data.keys(matcher).each { |key| @data.del key }
-        end
+      #   RedisStore.new "example.com"
+      #     # => host: example.com, port: 6379,  db: 0
+      #
+      #   RedisStore.new "example.com:23682"
+      #     # => host: example.com, port: 23682, db: 0
+      #
+      #   RedisStore.new "example.com:23682/1"
+      #     # => host: example.com, port: 23682, db: 1
+      #
+      #   RedisStore.new "example.com:23682/1/theplaylist"
+      #     # => host: example.com, port: 23682, db: 1, namespace: theplaylist
+      #
+      #   RedisStore.new "localhost:6379/0", "localhost:6380/0"
+      #     # => instantiate a cluster
+      def initialize(*addresses)
+        @data = ::Redis::Factory.create(addresses)
+        super(addresses.extract_options!)
       end
 
       # Reads multiple keys from the cache using a single call to the
@@ -88,7 +130,7 @@ module ActiveSupport
       #   cache.read_multi "rabbit", "white-rabbit"
       #   cache.read_multi "rabbit", "white-rabbit", :raw => true
       def read_multi(*names)
-        @data.marshalled_mget *names
+        @data.mget *names
       end
 
       # Increment a key in the store.

data/lib/cache/merb/redis_store.rb

@@ -4,12 +4,24 @@ module Merb
       # Instantiate the store.
       #
       # Example:
-      #   RedisStore.new                                     # => host: localhost,   port: 6379,  db: 0
-      #   RedisStore.new :servers => ["example.com"]         # => host: example.com, port: 6379,  db: 0
-      #   RedisStore.new :servers => ["example.com:23682"]   # => host: example.com, port: 23682, db: 0
-      #   RedisStore.new :servers => ["example.com:23682/1"] # => host: example.com, port: 23682, db: 1
-      #   RedisStore.new :servers => ["localhost:6379/0", "localhost:6380/0"] # => instantiate a cluster
-      def initialize(config = {})
+      #   RedisStore.new
+      #     # => host: localhost,   port: 6379,  db: 0
+      #
+      #   RedisStore.new :servers => ["example.com"]
+      #     # => host: example.com, port: 6379,  db: 0
+      #
+      #   RedisStore.new :servers => ["example.com:23682"]
+      #     # => host: example.com, port: 23682, db: 0
+      #
+      #   RedisStore.new :servers => ["example.com:23682/1"]
+      #     # => host: example.com, port: 23682, db: 1
+      #
+      #   RedisStore.new :servers => ["example.com:23682/1/theplaylist"]
+      #     # => host: example.com, port: 23682, db: 1, namespace: theplaylist
+      #
+      #   RedisStore.new :servers => ["localhost:6379/0", "localhost:6380/0"]
+      #     # => instantiate a cluster
+      def initialize(config = { })
         @data = Redis::Factory.create config[:servers]
       end
 
@@ -18,12 +30,12 @@ module Merb
       end
 
       def read(key, parameters = {}, conditions = {})
-        @data.marshalled_get normalize(key, parameters), conditions
+        @data.get normalize(key, parameters), conditions
       end
 
       def write(key, data = nil, parameters = {}, conditions = {})
         if writable?(key, parameters, conditions)
-          method = conditions && conditions[:unless_exist] ? :marshalled_setnx : :marshalled_set
+          method = conditions && conditions[:unless_exist] ? :setnx : :set
           @data.send method, normalize(key, parameters), data, conditions
         end
       end

data/lib/cache/sinatra/redis_store.rb

@@ -10,25 +10,37 @@ module Sinatra
       # Instantiate the store.
       #
       # Example:
-      #   RedisStore.new                       # => host: localhost,   port: 6379,  db: 0
-      #   RedisStore.new "example.com"         # => host: example.com, port: 6379,  db: 0
-      #   RedisStore.new "example.com:23682"   # => host: example.com, port: 23682, db: 0
-      #   RedisStore.new "example.com:23682/1" # => host: example.com, port: 23682, db: 1
-      #   RedisStore.new "localhost:6379/0", "localhost:6380/0" # => instantiate a cluster
+      #   RedisStore.new
+      #     # => host: localhost,   port: 6379,  db: 0
+      #
+      #   RedisStore.new "example.com"
+      #     # => host: example.com, port: 6379,  db: 0
+      #
+      #   RedisStore.new "example.com:23682"
+      #     # => host: example.com, port: 23682, db: 0
+      #
+      #   RedisStore.new "example.com:23682/1"
+      #     # => host: example.com, port: 23682, db: 1
+      #
+      #   RedisStore.new "example.com:23682/1/theplaylist"
+      #     # => host: example.com, port: 23682, db: 1, namespace: theplaylist
+      #
+      #   RedisStore.new "localhost:6379/0", "localhost:6380/0"
+      #     # => instantiate a cluster
       def initialize(*addresses)
         @data = Redis::Factory.create addresses
       end
 
       def write(key, value, options = nil)
         if options && options[:unless_exist]
-          @data.marshalled_setnx key, value, options
+          @data.setnx key, value, options
         else
-          @data.marshalled_set key, value, options
+          @data.set key, value, options
         end
       end
 
       def read(key, options = nil)
-        @data.marshalled_get(key, options)
+        @data.get(key, options)
       end
 
       def delete(key, options = nil)

data/lib/i18n/backend/redis.rb

@@ -0,0 +1,67 @@
+module I18n
+  module Backend
+    class Redis
+      include Base, Flatten
+      attr_accessor :store
+
+      # Instantiate the store.
+      #
+      # Example:
+      #   RedisStore.new
+      #     # => host: localhost,   port: 6379,  db: 0
+      #
+      #   RedisStore.new "example.com"
+      #     # => host: example.com, port: 6379,  db: 0
+      #
+      #   RedisStore.new "example.com:23682"
+      #     # => host: example.com, port: 23682, db: 0
+      #
+      #   RedisStore.new "example.com:23682/1"
+      #     # => host: example.com, port: 23682, db: 1
+      #
+      #   RedisStore.new "example.com:23682/1/theplaylist"
+      #     # => host: example.com, port: 23682, db: 1, namespace: theplaylist
+      #
+      #   RedisStore.new "localhost:6379/0", "localhost:6380/0"
+      #     # => instantiate a cluster
+      def initialize(*addresses)
+        @store = ::Redis::Factory.create(addresses)
+      end
+
+      def translate(locale, key, options = {})
+        options[:resolve] ||= false
+        super locale, key, options
+      end
+
+      def store_translations(locale, data, options = {})
+        escape = options.fetch(:escape, true)
+        flatten_translations(locale, data, escape, false).each do |key, value|
+          case value
+          when Proc
+            raise "Key-value stores cannot handle procs"
+          else
+            @store.set "#{locale}.#{key}", value
+          end
+        end
+      end
+
+      def available_locales
+        locales = @store.keys.map { |k| k =~ /\./; $` }
+        locales.uniq!
+        locales.compact!
+        locales.map! { |k| k.to_sym }
+        locales
+      end
+
+      protected
+        def lookup(locale, key, scope = [], options = {})
+          key = normalize_flat_keys(locale, key, scope, options[:separator])
+          @store.get "#{locale}.#{key}"
+        end
+
+        def resolve_link(locale, key)
+          key
+        end
+    end
+  end
+end

data/lib/rack/cache/redis_metastore.rb

@@ -4,7 +4,7 @@ module Rack
       class RedisBase < MetaStore
         extend Rack::Utils
 
-        # The Redis::MarshaledClient object used to communicate with the Redis daemon.
+        # The Redis::Store object used to communicate with the Redis daemon.
         attr_reader :cache
 
         def self.resolve(uri)
@@ -17,17 +17,17 @@ module Rack
 
       class Redis < RedisBase
         def initialize(server, options = {})
-          @cache = ::Redis::MarshaledClient.new server
+          @cache = ::Redis::Factory.create server
         end
 
         def read(key)
           key = hexdigest(key)
-          cache.marshalled_get(key) || []
+          cache.get(key) || []
         end
 
         def write(key, entries)
           key = hexdigest(key)
-          cache.marshalled_set(key, entries)
+          cache.set(key, entries)
         end
 
         def purge(key)