redis-store 0.3.9 → 1.0.0.beta1

data/Gemfile

@@ -1,15 +1,29 @@
 source :gemcutter
-gem "redis", "1.0.5"
+gem "redis", ">= 2.0.0"
 
-# testing gems
-group :testing do
+group :development do
+  gem "jeweler"
+  gem "git"
+end
+
+group :development, :test, :rails3 do
   gem "ruby-debug"
   gem "rspec"
-  gem "rack", "1.0.0"
   gem "rack-cache"
-  gem "activesupport", "2.3.5"
-  gem "actionpack", "2.3.5"
   gem "merb"
-  gem "jeweler"
-  gem "git"
+  gem "methopara" if RUBY_VERSION.match /1\.9/
+end
+
+if ENV["REDIS_STORE_ENV"] == "rails3"
+  group :rails3 do
+    gem "rack", "1.1.0"
+    gem "activesupport", "3.0.0.beta4"
+    gem "actionpack", "3.0.0.beta4"
+  end
+else
+  group :test do
+    gem "rack", "1.0.0"
+    gem "activesupport", "2.3.5"
+    gem "actionpack", "2.3.5"
+  end
 end

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2009-2010 Luca Guidi
+Copyright (c) 2010 Luca Guidi
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -4,29 +4,38 @@
 
 Download and install Redis from [http://code.google.com/p/redis/](http://code.google.com/p/redis/)
 
-    curl -OL http://redis.googlecode.com/files/redis-1.2.5.tar.gz
-    tar -zxvf redis-1.2.5.tar.gz
-    mv redis-1.2.5 redis
+    wget http://redis.googlecode.com/files/redis-2.0.0-rc1.tar.gz
+    tar -zxf redis-2.0.0-rc1.tar.gz
+    mv redis-2.0.0-rc1 redis
     cd redis
     make
 
-Install the gems
+Install the gem
 
-    sudo gem install redis redis-store
+    sudo gem install redis-store
 
 ## Cache store
 
 Provides a cache store for your Ruby web framework of choice.
 
-### Rails
+### Rails 2.x
 
-    config.gem "redis-store", :source => "http://gemcutter.org", :lib => "redis-store"
-    require "redis-store"
+    config.gem "redis-store"
+    config.cache_store = :redis_store
+
+### Rails 3.x
+
+    # Gemfile
+    gem 'rails', '3.0.0.beta4'
+    gem 'redis'
+    gem 'redis-store', '1.0.0.beta1'
+
+    # config/environments/production.rb
     config.cache_store = :redis_store
 
 ### Merb
 
-    dependency "redis-store", "0.3.9"
+    dependency "redis-store", "1.0.0.beta1"
     dependency("merb-cache", merb_gems_version) do
       Merb::Cache.setup do
         register(:redis, Merb::Cache::RedisStore, :servers => ["127.0.0.1:6379"])
@@ -56,14 +65,24 @@ Provides a Redis store for Rack::Session. See [http://rack.rubyforge.org/doc/Rac
     use Rack::Session::Redis
     run Application.new
 
-### Rails
+### Rails 2.x
 
     config.gem "redis-store"
     ActionController::Base.session_store = :redis_session_store
 
+### Rails 3.x
+
+    # Gemfile
+    gem 'rails', '3.0.0.beta4'
+    gem 'redis'
+    gem 'redis-store', '1.0.0.beta1'
+
+    # config/initializers/session_store.rb
+    Rails.application.config.session_store :redis_session_store
+
 ### Merb
 
-    dependency "redis-store", "0.3.9"
+    dependency "redis-store", "1.0.0.beta1"
     Merb::Config.use do |c|
       c[:session_store] = "redis"
     end
@@ -104,9 +123,11 @@ Provides a Redis store for HTTP caching. See [http://github.com/rtomayko/rack-ca
     git clone git://github.com/jodosha/redis-store.git
     cd redis-store
     bundle install
+    REDIS_STORE_ENV=rails3 bundle install # to install Rails 3.x gems
     rake dtach:install
     rake redis:install
     rake
+    REDIS_STORE_ENV=rails3 rake # to test against Rails 3.x
 
 If you are on **Snow Leopard** you have to run `env ARCHFLAGS="-arch x86_64" bundle install`
 

data/Rakefile

@@ -17,6 +17,7 @@ begin
     gemspec.homepage    = "http://github.com/jodosha/redis-store"
     gemspec.authors     = [ "Luca Guidi" ]
     gemspec.executables = [ ]
+    gemspec.add_dependency "redis", ">= 2.0.0"
   end
 
   Jeweler::GemcutterTasks.new
@@ -59,6 +60,12 @@ namespace :redis_cluster do
   end
 end
 
+namespace :bundle do
+  task :clean do
+    system "rm -rf ~/.bundle/ ~/.gem/ .bundle/ Gemfile.lock"
+  end
+end
+
 # courtesy of http://github.com/ezmobius/redis-rb team
 load "tasks/redis.tasks.rb"
 def invoke_with_redis_cluster(task_name)

data/VERSION

@@ -1 +1 @@
-0.3.9
+1.0.0.beta1

data/lib/cache/rails/redis_store.rb

@@ -1,18 +1,6 @@
-module ActiveSupport
+module RedisStore
   module Cache
-    class RedisStore < 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 "localhost:6379/0", "localhost:6380/0" # => instantiate a cluster
-      def initialize(*addresses)
-        @data = Redis::Factory.create(addresses)
-      end
-
+    module Rails2
       def write(key, value, options = nil)
         super
         method = options && options[:unless_exist] ? :marshalled_setnx : :marshalled_set
@@ -28,6 +16,49 @@ module ActiveSupport
         super
         @data.del key
       end
+    end
+
+    module Rails3
+      protected
+        def write_entry(key, entry, options)
+          method = options && options[:unless_exist] ? :marshalled_setnx : :marshalled_set
+          @data.send method, key, entry, options
+        end
+
+        def read_entry(key, options)
+          entry = @data.marshalled_get key, options
+          if entry
+            entry.is_a?(ActiveSupport::Cache::Entry) ? entry : ActiveSupport::Cache::Entry.new(entry)
+          end
+        end
+
+        def delete_entry(key, options)
+          @data.del key
+        end
+    end
+
+    module Store
+      include RedisStore.rails3? ? Rails3 : Rails2
+    end
+  end
+end
+
+module ActiveSupport
+  module Cache
+    class RedisStore < Store
+      include ::RedisStore::Cache::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 "localhost:6379/0", "localhost:6380/0" # => instantiate a cluster
+      def initialize(*addresses)
+        @data = Redis::Factory.create(addresses)
+      end
 
       def exist?(key, options = nil)
         super
@@ -91,7 +122,7 @@ module ActiveSupport
       # Example:
       #   cache.del_matched "rab*"
       def delete_matched(matcher, options = nil)
-        super
+        log "delete_matched", matcher, options
         @data.keys(matcher).each { |key| @data.del key }
       end
 

data/lib/rack/session/rails.rb

@@ -1,61 +1,70 @@
-module ActionController
-  module Session
-# Redis session storage for Rails, and for Rails only. Derived from
-# the MemCacheStore code, simply dropping in Redis instead.
-#
-# Options:
-#  :key     => Same as with the other cookie stores, key name
-#  :secret  => Encryption secret for the key
-#  :host    => Redis host name, default is localhost
-#  :port    => Redis port, default is 6379
-#  :db      => Database number, defaults to 0. Useful to separate your session storage from other data
-#  :key_prefix  => Prefix for keys used in Redis, e.g. myapp-. Useful to separate session storage keys visibly from others
-#  :expire_after => A number in seconds to set the timeout interval for the session. Will map directly to expiry in Redis
+module RedisStore
+  module Rack
+    module Session
+      # Redis session storage for Rails, and for Rails only. Derived from
+      # the MemCacheStore code, simply dropping in Redis instead.
+      #
+      # Options:
+      #  :key     => Same as with the other cookie stores, key name
+      #  :secret  => Encryption secret for the key
+      #  :host    => Redis host name, default is localhost
+      #  :port    => Redis port, default is 6379
+      #  :db      => Database number, defaults to 0. Useful to separate your session storage from other data
+      #  :key_prefix  => Prefix for keys used in Redis, e.g. myapp-. Useful to separate session storage keys visibly from others
+      #  :expire_after => A number in seconds to set the timeout interval for the session. Will map directly to expiry in Redis
+      module Rails
+        def initialize(app, options = {})
+          # Support old :expires option
+          options[:expire_after] ||= options[:expires]
 
-    class RedisSessionStore < ActionController::Session::AbstractStore
+          super
 
-      def initialize(app, options = {})
-        # Support old :expires option
-        options[:expire_after] ||= options[:expires]
+          @options = { :key_prefix => "" }.update(options)
+          servers = [options[:servers]].flatten.compact.map do |server_options|
+            {
+              :namespace => 'rack:session',
+              :host => 'localhost',
+              :port => '6379',
+              :db => 0
+            }.update(Redis::Factory.convert_to_redis_client_options(server_options))
+          end
 
-        super
-
-        @options = { :key_prefix => "" }.update(options)
-        servers = [options[:servers]].flatten.compact.map do |server_options|
-          {
-            :namespace => 'rack:session',
-            :host => 'localhost',
-            :port => '6379',
-            :db => 0
-          }.update(Redis::Factory.convert_to_redis_client_options(server_options))
+          @pool = Redis::Factory.create(*servers)
         end
 
-        @pool = Redis::Factory.create(*servers)
-      end
+        private
+        def prefixed(sid)
+          "#{@options[:key_prefix]}#{sid}"
+        end
 
-      private
-      def prefixed(sid)
-        "#{@options[:key_prefix]}#{sid}"
-      end
+        def get_session(env, sid)
+          sid ||= generate_sid
+          begin
+            session = @pool.marshalled_get(prefixed(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.marshalled_set(prefixed(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
-
     end
   end
 end
+
+unless defined?(ActionDispatch) # rails 2.3.x
+  class ActionController::Session::RedisSessionStore < ActionController::Session::AbstractStore
+    include RedisStore::Rack::Session::Rails
+  end
+else # rails 3.x
+  class ActionDispatch::Session::RedisSessionStore < ActionDispatch::Session::AbstractStore
+    include RedisStore::Rack::Session::Rails
+  end
+end

data/lib/redis/distributed_marshaled.rb

@@ -13,6 +13,16 @@ class Redis
       ring.nodes
     end
 
-    alias_method :flushdb, :delete_cloud! if respond_to?(:delete_cloud!)
+    def marshalled_set(key, val, options = nil)
+      node_for(key).marshalled_set(key, val, options)
+    end
+
+    def marshalled_get(key, options = nil)
+      node_for(key).marshalled_get(key, options)
+    end
+
+    def marshalled_setnx(key, value, options = nil)
+      node_for(key).marshalled_setnx(key, value, options)
+    end
   end
 end

data/lib/redis/marshaled_client.rb

@@ -1,9 +1,9 @@
 class Redis
-  class MarshaledClient < Client
+  class MarshaledClient < self
     def marshalled_set(key, val, options = nil)
       val = marshal_value(val, options)
-      if expires_in = expires_in(options)
-        set_with_expire key, val, expires_in
+      if ttl = expires_in(options)
+        setex key, ttl, val
       else
         set key, val
       end
@@ -26,11 +26,15 @@ class Redis
     end
 
     def marshalled_get(key, options = nil)
-      result = call_command([:get, key])
+      result = @client.call(:get, key)
       result = Marshal.load result if unmarshal?(result, options)
       result
     end
 
+    def to_s
+      "Redis Client connected to #{@client.host}:#{@client.port} against DB #{@client.db}"
+    end
+
     private
       def marshal_value(val, options)
         raw?(options) ? val : Marshal.dump(val)

data/lib/redis-store.rb

@@ -1,8 +1,15 @@
 require "redis"
-require "redis/namespace"
+require "redis/distributed"
 require "redis/factory"
 require "redis/marshaled_client"
 require "redis/distributed_marshaled"
+require "redis_store/version"
+
+module RedisStore
+  def self.rails3? #:nodoc:
+    defined?(::Rails) && ::Rails.version =~ /3\.0\.0/
+  end
+end
 
 # Cache store
 if defined?(Sinatra)

data/lib/redis_store/version.rb

@@ -0,0 +1,10 @@
+module RedisStore
+  module VERSION #:nodoc:
+    MAJOR = 1
+    MINOR = 0
+    TINY  = 0
+    BUILD = "beta1"
+
+    STRING = [MAJOR, MINOR, TINY, BUILD].join('.')
+  end
+end

data/redis-store.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{redis-store}
-  s.version = "0.3.9"
+  s.version = "1.0.0.beta1"
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.required_rubygems_version = Gem::Requirement.new("> 1.3.1") if s.respond_to? :required_rubygems_version=
   s.authors = ["Luca Guidi"]
-  s.date = %q{2010-08-06}
+  s.date = %q{2010-06-09}
   s.description = %q{Rack::Session, Rack::Cache and cache Redis stores for Ruby web frameworks.}
   s.email = %q{guidi.luca@gmail.com}
   s.extra_rdoc_files = [
@@ -18,7 +18,6 @@ Gem::Specification.new do |s|
   s.files = [
     ".gitignore",
      "Gemfile",
-     "Gemfile.lock",
      "MIT-LICENSE",
      "README.md",
      "Rakefile",
@@ -35,7 +34,7 @@ Gem::Specification.new do |s|
      "lib/redis/distributed_marshaled.rb",
      "lib/redis/factory.rb",
      "lib/redis/marshaled_client.rb",
-     "lib/redis/namespace.rb",
+     "lib/redis_store/version.rb",
      "redis-store.gemspec",
      "spec/cache/merb/redis_store_spec.rb",
      "spec/cache/rails/redis_session_store_spec.rb",
@@ -51,6 +50,7 @@ Gem::Specification.new do |s|
      "spec/redis/distributed_marshaled_redis_spec.rb",
      "spec/redis/factory_spec.rb",
      "spec/redis/marshaled_client_spec.rb",
+     "spec/redis_store/version_spec.rb",
      "spec/spec_helper.rb",
      "tasks/redis.tasks.rb"
   ]
@@ -70,6 +70,7 @@ Gem::Specification.new do |s|
      "spec/redis/distributed_marshaled_redis_spec.rb",
      "spec/redis/factory_spec.rb",
      "spec/redis/marshaled_client_spec.rb",
+     "spec/redis_store/version_spec.rb",
      "spec/spec_helper.rb"
   ]
 
@@ -78,9 +79,12 @@ Gem::Specification.new do |s|
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<redis>, [">= 2.0.0"])
     else
+      s.add_dependency(%q<redis>, [">= 2.0.0"])
     end
   else
+    s.add_dependency(%q<redis>, [">= 2.0.0"])
   end
 end
 

data/spec/cache/rails/redis_session_store_spec.rb

@@ -1,77 +1,75 @@
 require File.join(File.dirname(__FILE__), "/../../spec_helper")
+RAILS_SESSION_STORE_CLASS = RedisStore.rails3? ? ActionDispatch::Session::RedisSessionStore : ActionController::Session::RedisSessionStore
 
-module ActionController
-  module Session
-    describe "ActionController::Session::RedisSessionStore" do
-      attr_reader :app
-      before(:each) do
-        @app = Object.new
-        @store  = ActionController::Session::RedisSessionStore.new(app)
-        @dstore = ActionController::Session::RedisSessionStore.new app, :servers => ["localhost:6380/1", "localhost:6381/1"]
-        @rabbit = OpenStruct.new :name => "bunny"
-        @white_rabbit = OpenStruct.new :color => "white"
-        with_store_management do |store|
-          class << store
-            attr_reader :pool
-            public :get_session, :set_session
-          end
-          store.set_session({'rack.session.options' => {}}, "rabbit", @rabbit)
-          store.pool.del "counter"
-          store.pool.del "rub-a-dub"
-        end
+describe RAILS_SESSION_STORE_CLASS do
+  attr_reader :app
+
+  before :each do
+    @app = Object.new
+    @store  = RAILS_SESSION_STORE_CLASS.new(app)
+    @dstore = RAILS_SESSION_STORE_CLASS.new app, :servers => ["localhost:6380/1", "localhost:6381/1"]
+    @rabbit = OpenStruct.new :name => "bunny"
+    @white_rabbit = OpenStruct.new :color => "white"
+    with_store_management do |store|
+      class << store
+        attr_reader :pool
+        public :get_session, :set_session
       end
+      store.set_session({'rack.session.options' => {}}, "rabbit", @rabbit)
+      store.pool.del "counter"
+      store.pool.del "rub-a-dub"
+    end
+  end
 
-      it "should accept connection params" do
-        redis = instantiate_store
-        redis.to_s.should == "Redis Client connected to 127.0.0.1:6379 against DB 0"
+  it "should accept connection params" do
+    redis = instantiate_store
+    redis.to_s.should == "Redis Client connected to 127.0.0.1:6379 against DB 0"
 
-        redis = instantiate_store :servers => "localhost"
-        redis.to_s.should == "Redis Client connected to localhost:6379 against DB 0"
+    redis = instantiate_store :servers => "localhost"
+    redis.to_s.should == "Redis Client connected to localhost:6379 against DB 0"
 
-        redis = instantiate_store :servers => "localhost:6380"
-        redis.to_s.should == "Redis Client connected to localhost:6380 against DB 0"
+    redis = instantiate_store :servers => "localhost:6380"
+    redis.to_s.should == "Redis Client connected to localhost:6380 against DB 0"
 
-        redis = instantiate_store :servers => "localhost:6380/13"
-        redis.to_s.should == "Redis Client connected to localhost:6380 against DB 13"
-      end
+    redis = instantiate_store :servers => "localhost:6380/13"
+    redis.to_s.should == "Redis Client connected to localhost:6380 against DB 13"
+  end
 
-      it "should instantiate a ring" do
-        store = instantiate_store
-        store.should be_kind_of(Redis::MarshaledClient)
-        store = instantiate_store :servers => ["localhost:6379/0", "localhost:6379/1"]
-        store.should be_kind_of(Redis::DistributedMarshaled)
-      end
+  it "should instantiate a ring" do
+    store = instantiate_store
+    store.should be_kind_of(Redis::MarshaledClient)
+    store = instantiate_store :servers => ["localhost:6379/0", "localhost:6379/1"]
+    store.should be_kind_of(Redis::DistributedMarshaled)
+  end
 
-      it "should read the data" do
-        with_store_management do |store|
-          store.get_session({}, "rabbit").should === ["rabbit", @rabbit]
-        end
-      end
+  it "should read the data" do
+    with_store_management do |store|
+      store.get_session({}, "rabbit").should === ["rabbit", @rabbit]
+    end
+  end
 
-      it "should write the data" do
-        with_store_management do |store|
-          store.set_session({"rack.session.options" => {}}, "rabbit", @white_rabbit)
-          store.get_session({}, "rabbit").should === ["rabbit", @white_rabbit]
-        end
-      end
+  it "should write the data" do
+    with_store_management do |store|
+      store.set_session({"rack.session.options" => {}}, "rabbit", @white_rabbit)
+      store.get_session({}, "rabbit").should === ["rabbit", @white_rabbit]
+    end
+  end
 
-      it "should write the data with expiration time" do
-        with_store_management do |store|
-          store.set_session({"rack.session.options" => {:expires_in => 1.second}}, "rabbit", @white_rabbit)
-          store.get_session({}, "rabbit").should === ["rabbit", @white_rabbit]; sleep 2
-          store.get_session({}, "rabbit").should === ["rabbit", {}]
-        end
-      end
+  it "should write the data with expiration time" do
+    with_store_management do |store|
+      store.set_session({"rack.session.options" => {:expires_in => 1.second}}, "rabbit", @white_rabbit)
+      store.get_session({}, "rabbit").should === ["rabbit", @white_rabbit]; sleep 2
+      store.get_session({}, "rabbit").should === ["rabbit", {}]
+    end
+  end
 
-      private
-        def instantiate_store(params={})
-          ActionController::Session::RedisSessionStore.new(app, params).instance_variable_get(:@pool)
-        end
+  private
+    def instantiate_store(params={})
+      RAILS_SESSION_STORE_CLASS.new(app, params).instance_variable_get(:@pool)
+    end
 
-        def with_store_management
-          yield @store
-          yield @dstore
-        end
+    def with_store_management
+      yield @store
+      yield @dstore
     end
-  end
 end