redis-objects-legacy 1.6.0

data/lib/redis/value.rb

@@ -0,0 +1,65 @@
+require File.dirname(__FILE__) + '/base_object'
+require 'zlib'
+
+class Redis
+  #
+  # Class representing a simple value.  You can use standard Ruby operations on it.
+  #
+  class Value < BaseObject
+    def value=(val)
+      allow_expiration do
+        if val.nil?
+          delete
+        else
+          redis.set key, marshal(val)
+        end
+      end
+    end
+    alias_method :set, :value=
+
+    def value
+      value = unmarshal(redis.get(key))
+      if value.nil? && !@options[:default].nil?
+        @options[:default]
+      else
+        value
+      end
+    end
+    alias_method :get, :value
+
+    def marshal(value, *args)
+      if !value.nil? && options[:compress]
+        compress(super)
+      else
+        super
+      end
+    end
+
+    def unmarshal(value, *args)
+      if !value.nil? && options[:compress]
+        super(decompress(value), *args)
+      else
+        super
+      end
+    end
+
+    def decompress(value)
+      Zlib::Inflate.inflate(value)
+    end
+
+    def compress(value)
+      Zlib::Deflate.deflate(value)
+    end
+
+    def inspect
+      "#<Redis::Value #{value.inspect}>"
+    end
+
+    def ==(other); value == other end
+    def nil?; value.nil? end
+
+    def method_missing(*args)
+      self.value.send *args
+    end
+  end
+end

data/lib/redis-objects-legacy.rb

@@ -0,0 +1 @@
+require 'redis/objects'

data/spec/redis_autoload_objects_spec.rb

@@ -0,0 +1,46 @@
+
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+# tests whether autoload functionality works correctly; had issues previously
+
+require 'redis/objects'
+# $redis used automatically
+
+describe 'Redis::Objects' do
+  it "should autoload everything" do
+    defined?(::Redis::Counter).should == "constant"
+    x = Redis::Counter.new('x')
+    x.class.name.should == "Redis::Counter"
+    x.redis.should == REDIS_HANDLE
+
+    defined?(::Redis::HashKey).should == "constant"
+    x = Redis::HashKey.new('x')
+    x.class.name.should == "Redis::HashKey"
+    x.redis.should == REDIS_HANDLE
+
+    defined?(::Redis::List).should == "constant"
+    x = Redis::List.new('x')
+    x.class.name.should == "Redis::List"
+    x.redis.should == REDIS_HANDLE
+
+    defined?(::Redis::Lock).should == "constant"
+    x = Redis::Lock.new('x')
+    x.class.name.should == "Redis::Lock"
+    x.redis.should == REDIS_HANDLE
+
+    defined?(::Redis::Set).should == "constant"
+    x = Redis::Set.new('x')
+    x.class.name.should == "Redis::Set"
+    x.redis.should == REDIS_HANDLE
+
+    defined?(::Redis::SortedSet).should == "constant"
+    x = Redis::SortedSet.new('x')
+    x.class.name.should == "Redis::SortedSet"
+    x.redis.should == REDIS_HANDLE
+
+    defined?(::Redis::Value).should == "constant"
+    x = Redis::Value.new('x')
+    x.class.name.should == "Redis::Value"
+    x.redis.should == REDIS_HANDLE
+  end
+end

data/spec/redis_namespace_compat_spec.rb

@@ -0,0 +1,24 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+require 'redis/objects'
+Redis::Objects.redis = REDIS_HANDLE
+
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__) + '/../../redis-namespace/lib')
+begin
+  require 'redis/namespace'
+
+  describe 'Redis::Namespace compat' do
+    it "tests the compatibility of Hash and ::Hash conflicts" do
+      ns = Redis::Namespace.new("resque", :redis => REDIS_HANDLE)
+      ns.instance_eval { rem_namespace({"resque:x" => nil}) }.should == {"x"=>nil}
+      class Foo
+        include Redis::Objects
+      end
+      ns.instance_eval { rem_namespace({"resque:x" => nil}) }.should == {"x"=>nil}
+    end
+  end
+
+rescue LoadError
+  # Redis::Namespace not installed
+  puts "Skipping Redis::Namespace tests as redis-namespace is not installed"
+end

data/spec/redis_objects_active_record_spec.rb

@@ -0,0 +1,162 @@
+
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+require 'redis/objects'
+# $redis used automatically
+
+begin
+  require 'active_record'
+  ActiveRecord::Base.establish_connection(
+    :adapter => 'sqlite3',
+    :database => File.expand_path(File.dirname(__FILE__) + '/redis_objects_test.sqlite3')
+  )
+
+  # monkey patch to use migrations both in Rails 4.x and 5.x
+  class ActiveRecord::Migration
+    class << self
+      def [](version)
+        self
+      end
+    end
+  end unless ActiveRecord::Migration.respond_to?(:[])
+
+  class CreateBlogs < ActiveRecord::Migration[4.2]
+    def self.up
+      create_table :blogs do |t|
+        t.string :name
+        # t.integer :num_posts, :default => 0
+        t.timestamps null: true
+      end
+    end
+
+    def self.down
+      drop_table :blogs
+    end
+  end
+
+  class Blog < ActiveRecord::Base
+    include Redis::Objects
+    has_many :posts
+    counter :num_posts
+  end
+
+  class CreatePosts < ActiveRecord::Migration[4.2]
+    def self.up
+      create_table :posts do |t|
+        t.string :title
+        t.string :description, :length => 200
+        t.integer :total
+        t.integer :blog_id
+        t.timestamps null: true
+      end
+    end
+
+    def self.down
+      drop_table :posts
+    end
+  end
+
+  class Post < ActiveRecord::Base
+    include Redis::Objects
+    counter :total
+    counter :num_comments
+    # Unfortunately, counter counter_cache appears to be broken
+    # belongs_to :blog, :counter_cache => :num_posts
+    belongs_to :blog
+    has_many :comments
+  end
+
+  class CreateComments < ActiveRecord::Migration[4.2]
+    def self.up
+      create_table :comments do |t|
+        t.string :body
+        t.integer :post_id
+        t.timestamps null: true
+      end
+    end
+
+   def self.down
+      drop_table :comments
+    end
+  end
+
+  class Comment < ActiveRecord::Base
+    include Redis::Objects
+    belongs_to :post
+    # Unfortunately, counter counter_cache appears to be broken
+    # belongs_to :post, :counter_cache => :num_comments
+  end
+
+  describe ActiveRecord do
+    before do
+      CreateComments.up
+      CreatePosts.up
+      CreateBlogs.up
+    end
+    after do
+      CreateComments.down
+      CreatePosts.down
+      CreateBlogs.down
+    end
+
+    it "exercises ActiveRecord in more detail" do
+      @ar = Post.new
+      should.raise(Redis::Objects::NilObjectId){ @ar.total }
+      @ar.save!
+      @ar.destroy
+
+      # @ar.total.reset
+      @ar2 = Post.new
+      @ar2.save!
+      @ar2.total.reset
+      @ar2.total.increment.should == 1
+      @ar2.id.should == 2
+      @ar2.increment(:total).should == 2
+      @ar2[:total].should == nil  # DB column
+      @ar2.redis.get(@ar2.redis_field_key('total')).to_i.should == 2
+      @ar2[:total] = 3  # DB column
+      @ar2.total.decrement.should == 1
+      @ar2.total.reset
+      @ar2.total.should == 0
+      @ar2.total.reset(55)
+      @ar2.total.should == 55
+      @ar2.total.getset(12).should == 55
+      @ar2.total.should == 12
+      @ar2.destroy
+    end
+
+    it "uses the redis objects counter cache when present" do
+      blog = Blog.create
+      post = Post.create :blog => blog
+      blog.num_posts.incr
+      blog.num_posts.should == 1
+      Post.counter_defined?(:num_comments).should == true
+      post.num_comments.should == 0
+
+      comment = Comment.create :post => post
+      post.num_comments.incr
+      post.comments.count.should == 1
+      post.id.should == 1
+      comment.destroy
+      blog.num_posts.delete
+      blog.destroy
+    end
+
+    it "falls back to ActiveRecord if redis counter is not defined" do
+      blog = Blog.create
+      blog.id.should == 1
+      blog.num_posts.should == 0
+      post = Post.create :blog => blog
+      blog.num_posts.incr
+      blog.num_posts.should == 1
+      blog2 = Blog.create
+      Post.create :blog => blog2
+      Post.create :blog => blog2
+      blog.reload.num_posts.should == 1
+      blog2.num_posts.incr
+      blog2.num_posts.incr
+      blog2.reload.num_posts.should == 2
+      blog.num_posts.should == 1
+    end
+  end
+end

data/spec/redis_objects_conn_spec.rb

@@ -0,0 +1,276 @@
+#
+# Connection tests - a bit ugly but important
+#
+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 with a vanilla redis connection" do
+    class CustomConnectionObject
+      include Redis::Objects
+
+      def id
+        return 1
+      end
+
+      redis_handle = 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 mget" do
+    class CustomConnectionObject
+      include Redis::Objects
+
+      def id
+        return 1
+      end
+
+      redis_handle = Redis.new(:host => REDIS_HOST, :port => REDIS_PORT, :db => 31)
+      value :redis_value, :key => 'rval'
+    end
+
+    obj = CustomConnectionObject.new
+
+    obj.redis_value.value = 'foo'
+
+    obj.class.mget(:redis_value, []).should == []
+    obj.class.mget(:redis_value, [obj]).should == ['foo']
+
+    obj.redis_value.clear
+  end
+
+  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)
+
+    # 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 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)
+
+    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 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
+    # 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.should == @redis_handle
+
+    # 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
+
+    # Fix for future tests
+    Redis.current = @redis_handle
+  end
+
+  it "should support pipelined changes" do
+    list = Redis::List.new('pipelined/list')
+    key = Redis::HashKey.new('pipelined/hash')
+    Redis::Objects.redis.pipelined do
+      key['foo'] = 'bar'
+      list.push 1, 2
+    end
+    key.all.should == { 'foo' => 'bar' }
+    list.values.should == %w[1 2]
+  end
+end