redis-native_hash 0.1.0 → 0.2.1

data/lib/redis/native_hash.rb

@@ -1,30 +1,24 @@
-require 'redis'
-require 'core_ext/hash' unless defined?(ActiveSupport)
-require 'redis/marshal'
-require 'redis/tracked_hash'
-
-if defined?(Rack::Session)
-  require "rack/session/abstract/id"
-  require 'rack/session/redis_hash'
-end
+require_relative "../redis_hash"
 
 require 'securerandom'
 
 class Redis
   class NativeHash < TrackedHash
+    include ClientHelper
+    include KeyHelper
 
     attr_accessor :namespace
 
-    def initialize(*args)
+    def initialize(aargh = nil)
       super(nil)
-      track!
-      if args.first.kind_of?(String) or args.first.kind_of?(Symbol)
-        self.namespace = args.shift
-      elsif !self.instance_of?(NativeHash) # use class name as default namespace for user defined classes
-        self.namespace = self.class.to_s.downcase
+      case aargh
+      when String,Symbol
+        self.namespace = aargh
+      when Hash
+        self.namespace = aargh.keys.first
+        self.key       = aargh.values.first
       end
-      data = args.shift
-      update(data) if data.kind_of?(Hash)
+      track!
     end
 
     def []=(key, value)
@@ -55,44 +49,44 @@ class Redis
       indices.collect { |key| self[ convert_key(key) ] }
     end
 
-    def key
-      @key ||= self.class.generate_key
-    end
-
     def key=(new_key)
       renew_key(new_key)
     end
 
     attr_writer :version
     def version
-      @version ||= self.class.generate_key
-    end
-
-    def save( attempt = 0 )
-      fail "Unable to save Redis::Hash after max attempts." if attempt > 5
-      redis.watch redis_key
-      latest_version = redis.hget(redis_key, "__version")
-      reload! unless ( latest_version.nil? || latest_version == self.version )
-      self.version = nil # generate new version token
-      changed_keys = (self.changed + self.added).uniq
-      changes = []
-      changed_keys.each do |key|
-        changes.push( key, Redis::Marshal.dump(self[key]) )
-      end
-      deleted_keys = self.deleted
-      unless deleted_keys.empty? and changes.empty?
+      @version ||= generate_key
+    end
+
+    def save( max_attempts = 5 )
+      (1..max_attempts).each do |n|
+        redis.watch redis_key
+        latest_version = redis.hget(redis_key, "__version")
+        reload! unless ( latest_version.nil? || latest_version == self.version )
+        self.version = nil # generate new version token
+        changed_keys = (self.changed + self.added).uniq
+        changes = []
+        changed_keys.each do |key|
+          changes.push( key, Redis::Marshal.dump(self[key]) )
+        end
+        deleted_keys = self.deleted
+        if deleted_keys.empty? and changes.empty?
+          redis.unwatch
+          return true
+        end
         success = redis.multi do
           redis.hmset( redis_key, *changes.push("__version", self.version) ) unless changes.empty?
           deleted_keys.each { |key| redis.hdel( redis_key, key) }
         end
         if success
-          untrack!; track! #reset!
-        else
-          save( attempt + 1 )
+          untrack!; track! #reset hash
+          return true
         end
-      else
-        redis.unwatch
       end
+      raise "Unable to save hash after max attempts (#{max_attempts}). " +
+            "Amazing concurrency event may be underway. " +
+            "Make some popcorn."
+      false
     end
 
     def update(data)
@@ -106,8 +100,14 @@ class Redis
       super(data.stringify_keys!)
     end
 
+    def replace(other_hash)
+      clear
+      update(other_hash)
+    end
+
     def reload!
-      self.update( self.class.find( {namespace=>key} ) )
+      hash = self.class.find( namespace ? {namespace => key} : key )
+      self.update( hash ) if hash
     end
     alias_method :reload, :reload!
 
@@ -127,79 +127,66 @@ class Redis
       key
     end
 
-    def self.redis
-      @@redis ||= Redis.new
-    end
-
-    def self.redis=(resource)
-      @@redis = resource
-    end
-
-    def self.generate_key
-      t = Time.now
-      t.strftime('%Y%m%d%H%M%S.') + t.usec.to_s.rjust(6,'0') + '.' + SecureRandom.hex(16)
+    def expire(seconds)
+      redis.expire(redis_key, seconds)
     end
 
-    def self.find(params)
-      case params
-      when Hash
-        hashes = []
-        params.each_pair do |namespace, key|
-          result = fetch_values( "#{namespace}:#{key}" )
-          unless result.empty?
-            hashes << build(namespace,key,result)
+    class << self
+      def find(params)
+        case params
+        when Hash
+          hashes = []
+          params.each_pair do |namespace, key|
+            result = fetch_values( "#{namespace}:#{key}" )
+            unless result.empty?
+              hashes << build(namespace,key,result)
+            end
           end
+          unless hashes.empty?
+            hashes.size == 1 ? hashes.first : hashes
+          else
+            nil
+          end
+        when String,Symbol
+          unless self == Redis::NativeHash
+            namespace = self.new.namespace.to_s
+            namespace = "#{namespace}:" unless namespace.empty?
+            result = fetch_values( "#{namespace}#{params}" )
+          else
+            result = fetch_values(params)
+          end
+          result.empty? ? nil : build(nil,params,result)
         end
-        unless hashes.empty?
-          hashes.size == 1 ? hashes.first : hashes
-        else
-          nil
-        end
-      when String
-        unless self.instance_of?(NativeHash)
-          result = fetch_values( "#{self.new.namespace}:#{params}" )
-        else
-          result = fetch_values(params)
-        end
-        result.empty? ? nil : build(nil,params,result)
       end
-    end
-
-    def self.build(namespace, key, values)
-      h = self.new
-      h.namespace = namespace
-      h.key = key
-      h.populate(values)
-      h
-    end
-
-    def self.fetch_values(key)
-      results = redis.hgetall(key)
-      results.each_pair { |key,value| results[key] = Redis::Marshal.load(value) }
-    end
 
-    def self.attr_persist(*attributes)
-      attributes.each do |attr|
-        class_eval <<-EOS
-          def #{attr}=(value)
-            self["#{attr}"] = value
-          end
-
-          def #{attr}
-            self["#{attr}"]
-          end
-        EOS
+      def build(namespace, key, values)
+        h = self.new
+        h.namespace = namespace
+        h.key = key
+        h.populate(values)
+        h
       end
-    end
 
-    protected
-      def redis; self.class.redis; end
-      def redis_key
-        namespace.nil? ? key : "#{namespace}:#{key}"
+      def fetch_values(key)
+        results = redis.hgetall(key)
+        results.each_pair { |key,value| results[key] = Redis::Marshal.load(value) }
       end
-      def convert_key(key)
-        key.to_s
+
+      def attr_persist(*attributes)
+        attributes.each do |attr|
+          class_eval <<-EOS
+            def #{attr}=(value)
+              self["#{attr}"] = value
+            end
+
+            def #{attr}
+              self["#{attr}"]
+            end
+          EOS
+        end
       end
+
+    end
   end
 end
 

data/lib/redis/tracked_hash.rb

@@ -1,42 +1,52 @@
 class Redis
   class TrackedHash < Hash
-  
+
     def original
       @original ||= self.dup
     end
     alias_method :track,  :original
     alias_method :track!, :original
-  
+
     def untrack
       @original = nil
     end
     alias_method :untrack!, :untrack
-  
+
     def retrack
       untrack!
       track!
     end
     alias_method :retrack!, :retrack
-  
+
     def changed
       changes = keys.select do |key|
         self[key] != original[key]
       end
     end
-  
+
     def deleted
       original.keys - self.keys
     end
-  
+
     def added
       self.keys - original.keys
     end
-  
+
     def populate(other_hash)
       update(other_hash)
       retrack!
     end
-  
+
+    def dup
+      dupe = super
+      # duplicate a little deeper
+      # otherwise, object references will make it appear a value hasn't changed when it has
+      self.keys.each do |k|
+        dupe[k] = self[k].dup rescue self[k]
+      end
+      dupe
+    end
+
     def update(other_hash)
       if other_hash.kind_of?(TrackedHash)
         other_original = other_hash.original
@@ -51,6 +61,7 @@ class Redis
       end
     end
     alias_method :merge!, :update
-  
+
   end
 end
+

data/lib/redis_hash.rb

@@ -0,0 +1,22 @@
+require 'redis'
+require 'core_ext/hash' unless defined?(ActiveSupport)
+require 'redis/marshal'
+require 'redis/tracked_hash'
+require 'redis/client_helper'
+require 'redis/key_helper'
+require 'redis/big_hash'
+require 'redis/native_hash'
+require 'redis/lazy_hash'
+
+if defined?(Rack::Session)
+  require "rack/session/abstract/id"
+  require 'rack/session/redis_hash'
+end
+
+if defined?(ActionDispatch::Session)
+  require 'action_dispatch/session/redis_hash'
+end
+
+if defined?(ActiveSupport)
+  require "active_support/cache/redis_store"
+end

data/redis-native_hash.gemspec

@@ -4,14 +4,14 @@
 # -*- encoding: utf-8 -*-
 
 Gem::Specification.new do |s|
-  s.name = %q{redis-native_hash}
-  s.version = "0.1.0"
+  s.name = "redis-native_hash"
+  s.version = "0.2.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Carl Zulauf", "Adam Lassek"]
-  s.date = %q{2011-07-13}
-  s.description = %q{ruby-hash-to-redis-hash mapping}
-  s.email = %q{czulauf@lyconic.com}
+  s.date = "2012-05-13"
+  s.description = "ruby-hash-to-redis-hash mapping"
+  s.email = "czulauf@lyconic.com"
   s.extra_rdoc_files = [
     "LICENSE.txt",
     "README.mkd"
@@ -24,24 +24,35 @@ Gem::Specification.new do |s|
     "LICENSE.txt",
     "README.mkd",
     "Rakefile",
+    "TODO.mkd",
     "VERSION",
+    "lib/action_dispatch/session/redis_hash.rb",
+    "lib/active_support/cache/redis_hash.rb",
+    "lib/active_support/cache/redis_store.rb",
     "lib/core_ext/hash.rb",
     "lib/rack/session/redis_hash.rb",
+    "lib/redis/big_hash.rb",
+    "lib/redis/client_helper.rb",
+    "lib/redis/key_helper.rb",
+    "lib/redis/lazy_hash.rb",
     "lib/redis/marshal.rb",
     "lib/redis/native_hash.rb",
     "lib/redis/tracked_hash.rb",
+    "lib/redis_hash.rb",
     "redis-native_hash.gemspec",
     "spec/redis-hash_spec.rb",
-    "spec/redis/redis_hash_spec.rb",
+    "spec/redis/big_hash_spec.rb",
+    "spec/redis/lazy_hash_spec.rb",
+    "spec/redis/native_hash_spec.rb",
     "spec/spec_helper.rb",
     "spec/tracked_hash_spec.rb",
     "spec/user_defined/user_spec.rb"
   ]
-  s.homepage = %q{http://github.com/carlzulauf/redis-native_hash}
+  s.homepage = "http://github.com/carlzulauf/redis-native_hash"
   s.licenses = ["MIT"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.6.2}
-  s.summary = %q{ruby-hash-to-redis-hash mapping}
+  s.rubygems_version = "1.8.15"
+  s.summary = "ruby-hash-to-redis-hash mapping"
 
   if s.respond_to? :specification_version then
     s.specification_version = 3

data/spec/redis/big_hash_spec.rb

@@ -0,0 +1,118 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Redis::BigHash do
+  before :each do
+    @hash = Redis::BigHash.new
+    @hash[:foo] = "bar"
+    @hash[:yin] = "yang"
+  end
+
+  describe "#[]" do
+    it "should read an existing value" do
+      @hash[:foo].should == "bar"
+    end
+    it "should get nil for a value that doesn't exist" do
+      @hash[:bad_key].should be_nil
+    end
+    it "should allow lookup of multiple keys, returning an array" do
+      @hash[:foo, :yin, :bad_key].should == ["bar", "yang", nil]
+    end
+  end
+
+  describe "#[]=" do
+    it "should store string values" do
+      str = "This is a test string"
+      @hash[:test] = str
+      @hash[:test].should == str
+    end
+    it "should store arbitrary objects" do
+      t = Time.now
+      @hash[:test] = t
+      @hash[:test].should == t
+    end
+  end
+
+  describe "#add" do
+    it "should not overwrite an existing value" do
+      @hash.add(:foo, "bad value")
+      @hash[:foo].should == "bar"
+    end
+    it "should set a value when it doesn't exist" do
+      @hash.add(:new_key, "good value")
+      @hash[:new_key].should == "good value"
+    end
+  end
+
+  describe "#key=" do
+    it "should change the key used" do
+      @hash[:testing] = "key change"
+      @hash.key = "some_new_key"
+      @hash.key.should == "some_new_key"
+    end
+    it "should move all hash data to a new key" do
+      @hash[:testing] = "hash migration"
+      @hash.key = "some_new_key"
+      @hash[:foo].should == "bar"
+    end
+    it "should not whine when the hash is empty" do
+      hash = Redis::BigHash.new :frequent => :plyer
+      hash.key = :flyer
+      hash.key.should == :flyer
+    end
+  end
+
+  describe "#keys" do
+    it "should return a list of all keys" do
+      @hash.keys.should == ["foo", "yin"]
+    end
+  end
+
+  describe "#key?" do
+    it "should return true when a key is present" do
+      @hash.key?(:foo).should be_true
+    end
+    it "should return false when a key is not present" do
+      @hash.key?(:fubar).should be_false
+    end
+  end
+
+  describe "#update" do
+    it "should update BigHash with values from another hash" do
+      @hash.update :test1 => "value1", :test2 => "value2"
+      @hash[:test1].should == "value1"
+      @hash[:test2].should == "value2"
+    end
+    it "should allow values to be arbitrary ruby objects" do
+      t = Time.now; r = Rational(22,7)
+      @hash.update :test1 => t, :test2 => r
+      @hash[:test1].should == t
+      @hash[:test2].to_s.should == "22/7"
+    end
+  end
+
+  describe "#delete" do
+    it "should return the current value" do
+      @hash.delete(:foo).should == "bar"
+    end
+    it "should remove the value" do
+      @hash.delete(:foo)
+      @hash[:foo].should be_nil
+    end
+  end
+
+  describe "#namespace" do
+    it "should prepend the namespace onto the key" do
+      @hash.namespace = "test_namespace"
+      @hash.redis_key.should =~ /^test_namespace:/
+    end
+    it "should migrate existing values over" do
+      @hash.namespace = "test_namespace"
+      @hash[:foo].should == "bar"
+    end
+  end
+
+  after :each do
+    @hash.destroy
+  end
+end
+

data/spec/redis/lazy_hash_spec.rb

@@ -0,0 +1,160 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+# MOST OF THIS COPIED FROM native_hash_spec !!!!
+# Redis::LazyHash should behave pretty much the same as Redis::LazyHash
+# only, lazier...
+
+describe Redis::LazyHash do
+  before :each do
+    @hash = Redis::LazyHash.new :test
+    @hash.update("foo" => "bar")
+    @hash.save
+    @hash = Redis::LazyHash.new :test => @hash.key
+  end
+
+  describe "#loaded?" do
+    it "should not be loaded when no read/write has occurred" do
+      @hash.loaded?.should be_false
+    end
+    it "should be loaded after a read occurs" do
+      @hash[:foo]
+      @hash.loaded?.should be_true
+    end
+  end
+
+  describe "#save" do
+    it "should presist changes to existing hash key" do
+      @hash["foo"] = "something else"
+      @hash.save
+      hash = Redis::LazyHash.find :test => @hash.key
+      hash["foo"].should == "something else"
+    end
+    it "should persist new hash keys" do
+      @hash["yin"] = "yang"
+      @hash.save
+      hash = Redis::LazyHash.find :test => @hash.key
+      hash["yin"].should == "yang"
+    end
+    it "should remove deleted keys from redis" do
+      @hash["yin"] = "yang"
+      @hash.delete("foo")
+      @hash["foo"].should == nil
+      @hash.save
+      hash = Redis::LazyHash.find :test => @hash.key
+      hash["foo"].should == nil
+    end
+    it "should respect changes made since last read from redis" do
+      @hash.inspect # have to touch the hash first
+      concurrent_edit = Redis::LazyHash.find :test => @hash.key
+      concurrent_edit["foo"] = "race value"
+      concurrent_edit.save
+      @hash["yin"] = "yang"
+      @hash["foo"] = "bad value"
+      @hash.save
+      hash = Redis::LazyHash.find :test => @hash.key
+      hash["foo"].should == "race value"
+      hash["yin"].should == "yang"
+    end
+    it "should respect removed hash keys since last read" do
+      @hash.inspect
+      concurrent_edit = Redis::LazyHash.find :test => @hash.key
+      concurrent_edit["yin"] = "yang"
+      concurrent_edit.delete("foo")
+      concurrent_edit.save
+      @hash["foo"] = "bad value"
+      @hash.save
+      hash = Redis::LazyHash.find :test => @hash.key
+      hash["foo"].should == nil
+      hash["yin"].should == "yang"
+    end
+    it "should allow overwrite of concurrent edit after #reload! is called" do
+      @hash.inspect
+      concurrent_edit = Redis::LazyHash.find :test => @hash.key
+      concurrent_edit["yin"] = "yang"
+      concurrent_edit.delete("foo")
+      concurrent_edit.save
+      @hash.reload!
+      @hash["foo"].should == nil
+      @hash["foo"] = "good value"
+      @hash.save
+      hash = Redis::LazyHash.find :test => @hash.key
+      hash["foo"].should == "good value"
+    end
+    it "should treat string and symbolic keys the same" do
+      @hash[:foo].should == "bar"
+      @hash[:test] = "good value"
+      @hash["test"].should == "good value"
+      @hash.save
+      hash = Redis::LazyHash.find :test => @hash.key
+      hash[:test].should == "good value"
+      hash["test"].should == "good value"
+    end
+    it "should properly store nested hashes" do
+      @hash[:test] = { :foo => :bar, :x => { :y => "z" } }
+      @hash[:test][:x][:y].should == "z"
+      @hash.save
+      hash = Redis::LazyHash.find :test => @hash.key
+      hash[:test][:foo].should == :bar
+      hash[:test][:x][:y].should == "z"
+    end
+  end
+
+  describe "#renew" do
+    it "should generate a new key" do
+      old_key = @hash.key
+      new_key = @hash.renew_key
+      @hash.key.should eq(new_key)
+      @hash.key.should_not eq(old_key)
+    end
+    it "should remove the old hash from redis" do
+      old_key   = @hash.key
+      namespace = @hash.namespace
+      @hash.renew_key
+      hash = Redis::LazyHash.find namespace => old_key
+      hash.inspect
+      hash.size.should == 0
+    end
+    it "should not persist the hash under the new key until #save is called" do
+      @hash["good key"] = "good value"
+      key = @hash.renew_key
+      bad_hash = Redis::LazyHash.find :test => key
+      bad_hash.size.should == 0
+      @hash.save
+      good_hash = Redis::LazyHash.find :test => key
+      good_hash["good key"].should eq("good value")
+      good_hash["foo"].should      eq("bar")
+    end
+  end
+
+  describe "#key=" do
+    it "should allow an arbitrary key to be used" do
+      @hash.key = "blah@blah.com"
+      @hash.save
+      a_hash = Redis::LazyHash.find :test => "blah@blah.com"
+      a_hash["foo"].should eq('bar')
+    end
+    it "should not leave the old hash behind when the key is changed" do
+      old_key = @hash.key
+      @hash.key = "carl@linkleaf.com"
+      @hash.save
+      bad_hash = Redis::LazyHash.find :test => old_key
+      bad_hash.size.should == 0
+    end
+  end
+
+  describe ".find" do
+    it "should find an existing redis hash" do
+      hash = Redis::LazyHash.find :test => @hash.key
+      hash["foo"].should == "bar"
+    end
+    it "should return an empty hash when hash not found" do
+      hash = Redis::LazyHash.find :foo => :doesnt_exist
+      hash.size.should == 0
+    end
+  end
+
+
+  after :each do
+    @hash.destroy
+  end
+end

data/spec/redis/{redis_hash_spec.rb → native_hash_spec.rb}

@@ -2,7 +2,8 @@ require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
 describe Redis::NativeHash do
   before :each do
-    @hash = Redis::NativeHash.new :test, "foo" => "bar"
+    @hash = Redis::NativeHash.new :test
+    @hash.update("foo" => "bar")
     @hash.save
   end