redis-objects 1.0.1 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 735c34367c9ed2f4bdd4d64e96c22068bb2956b4
-  data.tar.gz: 4e0cac119a34d58e46a2d65c3dfab74bda1394fd
+  metadata.gz: dc70bd55cafac46d93b6dc5dcd24d2e116c00d1e
+  data.tar.gz: d98febd210c47c61f8511f023e09edf86d848f25
 SHA512:
-  metadata.gz: c1f48c5fa92ea83c2dcf0df1368d69d60564c69fdffaa82855ef9b898cfa446afa377bdc7a1590bbc82f0ff4282cdce274a615d99810624b7bbb132ca3636326
-  data.tar.gz: 84ffd1f1185315c8d128c23b598b88b8fca03ede54e794afd8fc42ad2642312d5a086af735f2282e30f734fc83f3c04f011b22be8df2597575ca91bf079ddd29
+  metadata.gz: d854a41164664e2e4dafdf3c25e05ad6281ba305cb4c28fcccbff6777b4f2bcc9f773b96e0c7423552957395ab21aa7c0bef5175d70fe4aae7677c04c457c7d4
+  data.tar.gz: 090c58f4cbe376b4a37b0bd9c1b70894f036c8bc5b94a62c58e1047c0a175f8418659b260ca26daa3a3c21f6e2c9642694f1176f8c8bc390a6914eccd05e90bb

data/CHANGELOG.rdoc

@@ -1,5 +1,23 @@
 = Changelog for Redis::Objects
 
+== 1.1.0 (21 Jan 2015)
+
+* Support connection_pool useage via a proxy object [Jared Jenkins]
+
+* Fix typo on :counter usage [Kevin Bongart]
+
+* Use parent redis_id_field if present [Arnaud Lavrard]
+
+* Fetch the objects options through a redis_options method [Arnaud Lavrard]
+
+== 1.0.1 (14 Oct 2014)
+
+* Array handling for unmarshal [dreyks]
+
+* Test against Ruby 2.1 / 2.2 on Travis CI [tricknotes]
+
+* Redis::Set#randmember method accept count as optional parameter [xeviknal]
+
 == 1.0.0 (25 Jul 2014)
 
 * Fix expiration filter to handle atomic blocks, remove method aliasing [nateware]

data/README.md

@@ -36,10 +36,17 @@ Add it to your Gemfile as:
 gem 'redis-objects'
 ~~~
 
-Redis::Objects needs a handle created by `Redis.new`. The recommended approach
-is to set `Redis.current` to point to your server, which Redis::Objects will
-pick up automatically.
+Redis::Objects needs a handle created by `Redis.new` or a [ConnectionPool](https://github.com/mperham/connection_pool):
 
+The recommended approach is to use a `ConnectionPool` since this guarantees that most timeouts in the `redis` client
+do not pollute your existing connection. However, you need to make sure that both `:timeout` and `:size` are set appropriately
+in a multithreaded environment.
+~~~ruby
+require 'connection_pool'
+Redis::Objects.redis = ConnectionPool.new(size: 5, timeout: 5) { Redis.new(:host => '127.0.0.1', :port => 6379) }
+~~~
+
+Redis::Objects can also default to `Redis.current` if `Redis::Objects.redis` is not set.
 ~~~ruby
 Redis.current = Redis.new(:host => '127.0.0.1', :port => 6379)
 ~~~
@@ -64,6 +71,7 @@ class Post
   include Redis::Objects
 end
 
+# you can also use a ConnectionPool here as well
 User.redis = Redis.new(:host => '1.2.3.4')
 Post.redis = Redis.new(:host => '5.6.7.8')
 ~~~
@@ -97,7 +105,7 @@ user.id  # 1
 user.my_posts.increment
 user.my_posts.increment
 user.my_posts.increment
-puts user.my_posts  # 3
+puts user.my_posts.value # 3
 user.my_posts.reset
 puts user.my_posts.value # 0
 user.my_posts.reset 5

data/Rakefile

@@ -4,6 +4,10 @@ desc "run all the specs"
 task :test do
   sh "bacon spec/*_spec.rb"
 end
-
 task :default => :test
 
+desc "show changelog"
+task :changelog do
+  latest = `git tag |tail -1`.chomp
+  system "git log --pretty=format:'* %s %b [%an]' #{latest}..HEAD"
+end

data/lib/redis/base_object.rb

@@ -4,7 +4,7 @@ class Redis
     def initialize(key, *args)
       @key     = key.is_a?(Array) ? key.flatten.join(':') : key
       @options = args.last.is_a?(Hash) ? args.pop : {}
-      @myredis = args.first
+      @myredis = Objects::ConnectionPoolProxy.proxy_if_needed(args.first)
     end
 
     # Dynamically query the handle to enable resetting midstream

data/lib/redis/objects.rb

@@ -1,6 +1,7 @@
 # Redis::Objects - Lightweight object layer around redis-rb
 # See README.rdoc for usage and approach.
 require 'redis'
+require 'redis/objects/connection_pool_proxy'
 
 class Redis
   autoload :Counter,   'redis/counter'
@@ -60,7 +61,7 @@ class Redis
 
     class << self
       def redis=(conn)
-        @redis = conn
+        @redis = Objects::ConnectionPoolProxy.proxy_if_needed(conn)
       end
       def redis
         @redis || $redis || Redis.current ||
@@ -88,7 +89,10 @@ class Redis
     # Class methods that appear in your class when you include Redis::Objects.
     module ClassMethods
       # Enable per-class connections (eg, User and Post can use diff redis-server)
-      attr_writer :redis
+      def redis=(conn)
+        @redis = Objects::ConnectionPoolProxy.proxy_if_needed(conn)
+      end
+
       def redis
         @redis || Objects.redis
       end
@@ -109,9 +113,19 @@ class Redis
           downcase
       end
 
+      def redis_options(name)
+        klass = first_ancestor_with(name)
+        return klass.redis_objects[name.to_sym] || {}
+      end
+
       def redis_field_redis(name) #:nodoc:
         klass = first_ancestor_with(name)
-        return klass.redis_objects[name.to_sym][:redis] || self.redis
+        override_redis = klass.redis_objects[name.to_sym][:redis]
+        if override_redis
+          Objects::ConnectionPoolProxy.proxy_if_needed(override_redis)
+        else
+          self.redis
+        end
       end
 
       def redis_field_key(name, id=nil, context=self) #:nodoc:
@@ -143,7 +157,13 @@ class Redis
       end
 
       def redis_id_field(id=nil)
-        @redis_id_field = id || @redis_id_field || :id
+        @redis_id_field = id || @redis_id_field
+
+        if superclass && superclass.respond_to?(:redis_id_field)
+          @redis_id_field ||= superclass.redis_id_field
+        end
+
+        @redis_id_field ||= :id
       end
     end
 
@@ -153,6 +173,10 @@ class Redis
       def redis()         self.class.redis end
       def redis_objects() self.class.redis_objects end
 
+      def redis_options(name) #:nodoc:
+        return self.class.redis_options(name)
+      end
+
       def redis_field_redis(name) #:nodoc:
         return self.class.redis_field_redis(name)
       end

data/lib/redis/objects/connection_pool_proxy.rb

@@ -0,0 +1,30 @@
+class Redis
+  module Objects
+    class ConnectionPoolProxy
+      def initialize(pool)
+        raise ArgumentError "Should only proxy ConnectionPool!" unless self.class.should_proxy?(pool)
+        @pool = pool
+      end
+
+      def method_missing(name, *args, &block)
+        @pool.with { |x| x.send(name, *args, &block) }
+      end
+
+      def respond_to_missing?(name, include_all = false)
+        @pool.with { |x| x.respond_to?(name, include_all) }
+      end
+
+      def self.should_proxy?(conn)
+        defined?(::ConnectionPool) && conn.is_a?(::ConnectionPool)
+      end
+
+      def self.proxy_if_needed(conn)
+        if should_proxy?(conn)
+          ConnectionPoolProxy.new(conn)
+        else
+          conn
+        end
+      end
+    end
+  end
+end

data/lib/redis/objects/counters.rb

@@ -29,7 +29,7 @@ class Redis
               instance_variable_get("@#{name}") or
                 instance_variable_set("@#{name}",
                   Redis::Counter.new(
-                    redis_field_key(name), redis_field_redis(name), redis_objects[name.to_sym]
+                    redis_field_key(name), redis_field_redis(name), redis_options(name)
                   )
                 )
             end

data/lib/redis/objects/hashes.rb

@@ -21,7 +21,7 @@ class Redis
               instance_variable_get("@#{name}") or
                 instance_variable_set("@#{name}",
                   Redis::HashKey.new(
-                    redis_field_key(name), redis_field_redis(name), redis_objects[name.to_sym]
+                    redis_field_key(name), redis_field_redis(name), redis_options(name)
                   )
                 )
             end

data/lib/redis/objects/lists.rb

@@ -21,7 +21,7 @@ class Redis
               instance_variable_get("@#{name}") or
                 instance_variable_set("@#{name}",
                   Redis::List.new(
-                    redis_field_key(name), redis_field_redis(name), redis_objects[name.to_sym]
+                    redis_field_key(name), redis_field_redis(name), redis_options(name)
                   )
                 )
             end

data/lib/redis/objects/sets.rb

@@ -21,7 +21,7 @@ class Redis
               instance_variable_get("@#{name}") or
                 instance_variable_set("@#{name}",
                   Redis::Set.new(
-                    redis_field_key(name), redis_field_redis(name), redis_objects[name.to_sym]
+                    redis_field_key(name), redis_field_redis(name), redis_options(name)
                   )
                 )
             end

data/lib/redis/objects/sorted_sets.rb

@@ -21,7 +21,7 @@ class Redis
               instance_variable_get("@#{name}") or
                 instance_variable_set("@#{name}",
                   Redis::SortedSet.new(
-                    redis_field_key(name), redis_field_redis(name), redis_objects[name.to_sym]
+                    redis_field_key(name), redis_field_redis(name), redis_options(name)
                   )
                 )
             end

data/lib/redis/objects/values.rb

@@ -21,7 +21,7 @@ class Redis
               instance_variable_get("@#{name}") or
                 instance_variable_set("@#{name}",
                   Redis::Value.new(
-                    redis_field_key(name), redis_field_redis(name), redis_objects[name.to_sym]
+                    redis_field_key(name), redis_field_redis(name), redis_options(name)
                   )
                 )
             end

data/lib/redis/objects/version.rb

@@ -1,5 +1,5 @@
 class Redis
   module Objects
-    VERSION = "1.0.1"
+    VERSION = "1.1.0"
   end
 end

data/spec/redis_objects_conn_spec.rb

@@ -4,13 +4,13 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 require 'redis/objects'
+require 'connection_pool'
 
 BAD_REDIS = "totally bad bogus redis handle"
 
 # Grab a global handle
 describe 'Connection tests' do
-  it "should support overriding object handles" do
-
+  it "should support overriding object handles with a vanilla redis connection" do
     class CustomConnectionObject
       include Redis::Objects
 
@@ -41,7 +41,38 @@ describe 'Connection tests' do
     obj.default_redis_value.clear
   end
 
-  it "should support local handles" do
+  it "should support overriding object handles with a connection_pool" do
+    class CustomConnectionObject
+      include Redis::Objects
+
+      def id
+        return 1
+      end
+
+      redis_handle = ConnectionPool.new { Redis.new(:host => REDIS_HOST, :port => REDIS_PORT, :db => 31) }
+      value :redis_value, :redis => redis_handle, :key => 'rval'
+      value :default_redis_value, :key => 'rval'
+    end
+
+    obj = CustomConnectionObject.new
+
+    obj.default_redis_value.value.should == nil
+    obj.redis_value.value.should == nil
+
+    obj.default_redis_value.value = 'foo'
+    obj.default_redis_value.value.should == 'foo'
+    obj.redis_value.value.should == nil
+
+    obj.default_redis_value.clear
+    obj.redis_value.value = 'foo'
+    obj.redis_value.value.should == 'foo'
+    obj.default_redis_value.value.should == nil
+
+    obj.redis_value.clear
+    obj.default_redis_value.clear
+  end
+
+  it "should support local handles with a vanilla redis connection" do
     Redis.current = nil  # reset from other tests
     Redis::Objects.redis = nil
     @redis_handle = Redis.new(:host => REDIS_HOST, :port => REDIS_PORT)
@@ -86,6 +117,51 @@ describe 'Connection tests' do
     c.decr(1)
   end
 
+  it "should support local handles with a connection_pool" do
+    Redis.current = nil  # reset from other tests
+    Redis::Objects.redis = nil
+    @redis_handle = ConnectionPool.new { Redis.new(:host => REDIS_HOST, :port => REDIS_PORT) }
+
+    # Redis.current is lazily auto-populated to touch 6379
+    # This why we choose the weird 9212 port to avoid
+    Redis.current.inspect.should == Redis.new.inspect
+    Redis::Objects.redis.inspect.should == Redis.new.inspect
+
+    v = Redis::Value.new('conn/value', @redis_handle)
+    v.clear
+    v.value = 'yay'
+    v.value.should == 'yay'
+
+    h = Redis::HashKey.new('conn/hash', @redis_handle)
+    h.clear
+    h['k'] = 'v'
+
+    l = Redis::List.new('conn/list', @redis_handle)
+    l.clear
+    l << 3
+    l << 4
+    l << 5
+
+    s = Redis::Set.new('conn/set', @redis_handle)
+    s.clear
+    s << 5
+    s << 5
+    s << 6
+    s << 7
+
+    z = Redis::SortedSet.new('conn/zset', @redis_handle)
+    z.clear
+    z['a'] = 8
+    z['b'] = 7
+    z['c'] = 9
+    z['d'] = 6
+
+    c = Redis::Counter.new('conn/counter', @redis_handle)
+    c.reset
+    c.incr(3)
+    c.decr(1)
+  end
+
   it "should support Redis.current" do
     Redis.current = Redis.new(:host => REDIS_HOST, :port => REDIS_PORT)
 
@@ -97,7 +173,41 @@ describe 'Connection tests' do
     Redis::Counter.new('conn/counter').should == 2
   end
 
-  it "should support Redis::Objects.redis=" do
+  it "should support Redis::Objects.redis= with a connection_pool" do
+    @redis_handle = ConnectionPool.new { Redis.new(:host => REDIS_HOST, :port => REDIS_PORT) }
+
+    # Redis.current is lazily auto-populated to touch 6379
+    # This why we choose the weird 9212 port to avoid
+    Redis.current = BAD_REDIS
+    Redis::Objects.redis.should == BAD_REDIS
+
+    # This set of tests sucks, it fucks up the per-data-type handles
+    # because Redis.current is then set to a BS value, and the lazy
+    # init code in redis-rb will keep that value until we clear it.
+    # This ends up fucking any sequential tests.
+    raises_exception{ Redis::Value.new('conn/value').should.be.nil       }
+    raises_exception{ Redis::HashKey.new('conn/hash').keys.should == []  }
+    raises_exception{ Redis::List.new('conn/list').sort.should == []     }
+    raises_exception{ Redis::Set.new('conn/set').sort.should == []       }
+    raises_exception{ Redis::SortedSet.new('conn/zset').should == []     }
+    raises_exception{ Redis::Counter.new('conn/counter').get.should == 0 }
+
+    Redis::Objects.redis = @redis_handle
+    Redis::Value.new('fart').redis.is_a?(Redis::Objects::ConnectionPoolProxy).should == true
+
+    # These should now get the correct handle
+    Redis::Value.new('conn/value').should == 'yay'
+    Redis::HashKey.new('conn/hash').keys.should == ['k']
+    Redis::List.new('conn/list').sort.should  == ['3', '4', '5']
+    Redis::Set.new('conn/set').sort.should    == ['5', '6', '7']
+    Redis::SortedSet.new('conn/zset').should  == ['d', 'b', 'a', 'c']
+    Redis::Counter.new('conn/counter').should == 2
+
+  end
+
+  it "should support Redis::Objects.redis= with a vanilla redis connection" do
+    # reset redis
+    Redis::Objects.redis = nil
     @redis_handle = Redis.new(:host => REDIS_HOST, :port => REDIS_PORT)
 
     # Redis.current is lazily auto-populated to touch 6379
@@ -130,5 +240,4 @@ describe 'Connection tests' do
     # Fix for future tests
     Redis.current = @redis_handle
   end
-
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redis-objects
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.0
 platform: ruby
 authors:
 - Nate Wiger
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-14 00:00:00.000000000 Z
+date: 2015-01-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -66,6 +66,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: connection_pool
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: redis-namespace
   requirement: !ruby/object:Gem::Requirement
@@ -117,6 +131,7 @@ files:
 - lib/redis/list.rb
 - lib/redis/lock.rb
 - lib/redis/objects.rb
+- lib/redis/objects/connection_pool_proxy.rb
 - lib/redis/objects/counters.rb
 - lib/redis/objects/hashes.rb
 - lib/redis/objects/lists.rb