redis_buddy 0.1.3 → 0.1.4

data/lib/redis/distributed_marshaled_redis.rb

@@ -1,6 +1,6 @@
 # (c) 2009 Luca Guidi
 
-class DistributedMarshaledRedis < DistRedis
+class DistributedMarshaledRedis < Redis::Distributed
   def initialize(addresses)
     nodes = addresses.map do |address|
       MarshaledRedis.new address

data/lib/redis_buddy.rb

@@ -1,5 +1,5 @@
 require 'redis'
-require 'redis/dist_redis'
+require 'redis/distributed'
 require 'redis/namespace'
 
 require 'redis/redis_factory'

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 1
-  - 3
-  version: 0.1.3
+  - 4
+  version: 0.1.4
 platform: ruby
 authors: 
 - Ole Riesenberg
@@ -25,10 +25,10 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version 
         segments: 
+        - 1
         - 0
-        - 2
-        - 0
-        version: 0.2.0
+        - 6
+        version: 1.0.6
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
@@ -40,9 +40,9 @@ dependencies:
       - !ruby/object:Gem::Version 
         segments: 
         - 0
-        - 3
-        - 0
-        version: 0.3.0
+        - 4
+        - 2
+        version: 0.4.2
   type: :runtime
   version_requirements: *id002
 description: A namespaced Redis Cache Store for Rails 3, based on redis-store
@@ -90,9 +90,5 @@ rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: A namespaced Redis Cache Store for Rails 3
-test_files: 
-- spec/spec_helper.rb
-- spec/redis/distributed_marshaled_redis_spec.rb
-- spec/redis/marshaled_redis_spec.rb
-- spec/redis/redis_factory_spec.rb
-- spec/cache/redis_buddy_store.rb
+test_files: []
+

data/spec/cache/redis_buddy_store.rb

@@ -1,173 +0,0 @@
-require File.join(File.dirname(__FILE__), "/../spec_helper")
-
-module ActiveSupport
-  module Cache
-    describe "ActiveSupport::Cache::RedisBuddyStore" do
-      before(:each) do
-        @store  = ActiveSupport::Cache::RedisBuddyStore.new
-        @dstore = ActiveSupport::Cache::RedisBuddyStore.new "localhost:6380/1", "localhost:6381/1"
-        @rabbit = OpenStruct.new :name => "bunny"
-        @white_rabbit = OpenStruct.new :color => "white"
-        with_store_management do |store|
-          store.write  "rabbit", @rabbit
-          store.delete "counter"
-          store.delete "rub-a-dub"
-        end
-      end
-
-      it "should accept connection params" do
-        redis = instantiate_store
-        redis.host.should == "127.0.0.1"
-        redis.port.should == 6379
-        redis.db.should == 0
-
-        redis = instantiate_store "localhost"
-        redis.host.should == "localhost"
-
-        redis = instantiate_store "localhost:6380"
-        redis.host.should == "localhost"
-        redis.port.should == 6380
-
-        redis = instantiate_store "localhost:6380/13"
-        redis.host.should == "localhost"
-        redis.port.should == 6380
-        redis.db.should == 13
-      end
-
-      it "should instantiate a ring" do
-        store = instantiate_store
-        store.should be_kind_of(MarshaledRedis)
-        store = instantiate_store ["localhost:6379/0", "localhost:6379/1"]
-        store.should be_kind_of(DistributedMarshaledRedis)
-      end
-
-      it "should read the data" do
-        with_store_management do |store|
-          store.read("rabbit").should === @rabbit
-        end
-      end
-
-      it "should write the data" do
-        with_store_management do |store|
-          store.write "rabbit", @white_rabbit
-          store.read("rabbit").should === @white_rabbit
-        end
-      end
-
-      it "should write the data with expiration time" do
-        with_store_management do |store|
-          store.write "rabbit", @white_rabbit, :expires_in => 1.second
-          store.read("rabbit").should === @white_rabbit ; sleep 2
-          store.read("rabbit").should be_nil
-        end
-      end
-
-      it "should not write data if :unless_exist option is true" do
-        with_store_management do |store|
-          store.write "rabbit", @white_rabbit, :unless_exist => true
-          store.read("rabbit").should === @rabbit
-        end
-      end
-
-      it "should read raw data" do
-        with_store_management do |store|
-          store.read("rabbit", :raw => true).should == "\004\bU:\017OpenStruct{\006:\tname\"\nbunny"
-        end
-      end
-
-      it "should write raw data" do
-        with_store_management do |store|
-          store.write "rabbit", @white_rabbit, :raw => true
-          store.read("rabbit", :raw => true).should == %(#<OpenStruct color="white">)
-        end
-      end
-
-      it "should delete data" do
-        with_store_management do |store|
-          store.delete "rabbit"
-          store.read("rabbit").should be_nil
-        end
-      end
-
-      it "should delete matched data" do
-        with_store_management do |store|
-          store.delete_matched "rabb*"
-          store.read("rabbit").should be_nil
-        end
-      end
-
-      it "should verify existence of an object in the store" do
-        with_store_management do |store|
-          store.exist?("rabbit").should be_true
-          store.exist?("rab-a-dub").should be_false
-        end
-      end
-
-      it "should increment a key" do
-        with_store_management do |store|
-          3.times { store.increment "counter" }
-          store.read("counter", :raw => true).to_i.should == 3
-        end
-      end
-
-      it "should decrement a key" do
-        with_store_management do |store|
-          3.times { store.increment "counter" }
-          2.times { store.decrement "counter" }
-          store.read("counter", :raw => true).to_i.should == 1
-        end
-      end
-
-      it "should increment a key by given value" do
-        with_store_management do |store|
-          store.increment "counter", 3
-          store.read("counter", :raw => true).to_i.should == 3
-        end
-      end
-
-      it "should decrement a key by given value" do
-        with_store_management do |store|
-          3.times { store.increment "counter" }
-          store.decrement "counter", 2
-          store.read("counter", :raw => true).to_i.should == 1
-        end
-      end
-
-      it "should clear the store" do
-        with_store_management do |store|
-          store.clear
-          store.instance_variable_get(:@data).keys("*").flatten.should be_empty
-        end
-      end
-
-      it "should return store stats" do
-        with_store_management do |store|
-          store.stats.should_not be_empty
-        end
-      end
-
-      it "should fetch data" do
-        with_store_management do |store|
-          store.fetch("rabbit").should == @rabbit
-          store.fetch("rub-a-dub").should be_nil
-          store.fetch("rub-a-dub") { "Flora de Cana" }
-          store.fetch("rub-a-dub").should === "Flora de Cana"
-          store.fetch("rabbit", :force => true).should be_nil # force cache miss
-          store.fetch("rabbit", :force => true, :expires_in => 1.second) { @white_rabbit }
-          store.fetch("rabbit").should === @white_rabbit ; sleep 2
-          store.fetch("rabbit").should be_nil
-        end
-      end
-
-      private
-        def instantiate_store(addresses = nil)
-          ActiveSupport::Cache::RedisBuddyStore.new(addresses).instance_variable_get(:@data)
-        end
-
-        def with_store_management
-          yield @store
-          yield @dstore
-        end
-    end
-  end
-end

data/spec/redis/distributed_marshaled_redis_spec.rb

@@ -1,35 +0,0 @@
-require File.join(File.dirname(__FILE__), "/../spec_helper")
-
-describe "DistributedMarshaledRedis" do
-  before(:each) do
-    @dmr = DistributedMarshaledRedis.new [
-      {:host => "localhost", :port => "6380", :db => 0},
-      {:host => "localhost", :port => "6381", :db => 0}
-    ]
-    @rabbit = OpenStruct.new :name => "bunny"
-    @white_rabbit = OpenStruct.new :color => "white"
-    @dmr.set "rabbit", @rabbit
-  end
-
-  after(:all) do
-    @dmr.ring.nodes.each { |server| server.flush_db }
-  end
-
-  it "should accept connection params" do
-    dmr = DistributedMarshaledRedis.new [ :host => "localhost", :port => "6380", :db => "1" ]
-    dmr.ring.should have(1).node
-    mr = dmr.ring.nodes.first
-    mr.host.should == "localhost"
-    mr.port.should == 6380
-    mr.db.should == 1
-  end
-
-  it "should set an object" do
-    @dmr.set "rabbit", @white_rabbit
-    @dmr.get("rabbit").should == @white_rabbit
-  end
-
-  it "should get an object" do
-    @dmr.get("rabbit").should == @rabbit
-  end
-end

data/spec/redis/marshaled_redis_spec.rb

@@ -1,54 +0,0 @@
-require File.join(File.dirname(__FILE__), "/../spec_helper")
-
-describe "MarshaledRedis" do
-  before(:each) do
-    @store = MarshaledRedis.new
-    @rabbit = OpenStruct.new :name => "bunny"
-    @white_rabbit = OpenStruct.new :color => "white"
-    @store.set    "rabbit", @rabbit
-    @store.delete "rabbit2"
-  end
-
-  after :each do
-    @store.quit
-  end
-
-  it "should unmarshal an object on get" do
-    @store.get("rabbit").should === @rabbit
-  end
-
-  it "should marshal object on set" do
-    @store.set "rabbit", @white_rabbit
-    @store.get("rabbit").should === @white_rabbit
-  end
-
-  it "should not unmarshal object on get if raw option is true" do
-    @store.get("rabbit", :raw => true).should == "\004\bU:\017OpenStruct{\006:\tname\"\nbunny"
-  end
-
-  it "should not marshal object on set if raw option is true" do
-    @store.set "rabbit", @white_rabbit, :raw => true
-    @store.get("rabbit", :raw => true).should == %(#<OpenStruct color="white">)
-  end
-
-  it "should not unmarshal object if getting an empty string" do
-    @store.set "empty_string", ""
-    lambda { @store.get("empty_string").should == "" }.should_not raise_error
-  end
-
-  it "should not set an object if already exist" do
-    @store.set_unless_exists "rabbit", @white_rabbit
-    @store.get("rabbit").should === @rabbit
-  end
-
-  it "should marshal object on set_unless_exists" do
-    @store.set_unless_exists "rabbit2", @white_rabbit
-    @store.get("rabbit2").should === @white_rabbit
-  end
-
-  it "should not marshal object on set_unless_exists if raw option is true" do
-    @store.set_unless_exists "rabbit2", @white_rabbit, :raw => true
-    @store.get("rabbit2", :raw => true).should == %(#<OpenStruct color="white">)
-  end
-end
-

data/spec/redis/redis_factory_spec.rb

@@ -1,34 +0,0 @@
-require File.join(File.dirname(__FILE__), "/../spec_helper")
-
-describe "RedisFactory" do
-  it "should instantiate a MarshaledRedis store" do
-    store = RedisFactory.create
-    store.should be_kind_of(MarshaledRedis)
-    store.host.should == "127.0.0.1"
-    store.port.should == 6379
-    store.db.should == 0
-  end
-
-  it "should allow to specify host" do
-    store = RedisFactory.create "localhost"
-    store.host.should == "localhost"
-  end
-
-  it "should allow to specify port" do
-    store = RedisFactory.create "localhost:6380"
-    store.host.should == "localhost"
-    store.port.should == 6380
-  end
-
-  it "should allow to specify db" do
-    store = RedisFactory.create "localhost:6380/13"
-    store.host.should == "localhost"
-    store.port.should == 6380
-    store.db.should == 13
-  end
-
-  it "should instantiate a DistributedMarshaledRedis store" do
-    store = RedisFactory.create "localhost:6379", "localhost:6380"
-    store.should be_kind_of(DistributedMarshaledRedis)
-  end
-end

data/spec/spec_helper.rb

@@ -1,14 +0,0 @@
-$: << File.join(File.dirname(__FILE__), "/../lib")
-require 'bundler'
-Bundler.setup :testing
-require "ostruct"
-require "spec"
-require "redis"
-require "rails"
-require "redis_buddy"
-
-require "cache/redis_buddy_store"
-
-class Redis; attr_reader :host, :port, :db end
-$DEBUG = ENV["DEBUG"] === "true"
-