redis-native_hash 0.1.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,15 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+gem "redis", ">= 2.0.0"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "rspec", "~> 2.3.0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.6.2"
+  gem "rcov", ">= 0"
+end
+

data/Gemfile.lock

@@ -0,0 +1,30 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.2)
+    git (1.2.5)
+    jeweler (1.6.2)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+    rake (0.9.2)
+    rcov (0.9.9)
+    redis (2.2.1)
+    rspec (2.3.0)
+      rspec-core (~> 2.3.0)
+      rspec-expectations (~> 2.3.0)
+      rspec-mocks (~> 2.3.0)
+    rspec-core (2.3.1)
+    rspec-expectations (2.3.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.3.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  jeweler (~> 1.6.2)
+  rcov
+  redis (>= 2.0.0)
+  rspec (~> 2.3.0)

data/LICENSE.txt

@@ -0,0 +1,21 @@
+Copyright (c) 2011 Lyconic
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/README.mkd

@@ -0,0 +1,19 @@
+= redis-native_hash
+
+Description goes here.
+
+== Contributing to redis-native_hash
+
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2011 Lyconic. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "redis-native_hash"
+  gem.homepage = "http://github.com/carlzulauf/redis-native_hash"
+  gem.license = "MIT"
+  gem.summary = %Q{ruby-hash-to-redis-hash mapping}
+  gem.description = %Q{ruby-hash-to-redis-hash mapping}
+  gem.email = "czulauf@lyconic.com"
+  gem.authors = ["Carl Zulauf", "Adam Lassek"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "redis-hash #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/core_ext/hash.rb

@@ -0,0 +1,9 @@
+class Hash
+  def stringify_keys!
+    keys.each do |key|
+      self[key.to_s] = delete(key)
+    end
+    self
+  end
+end
+

data/lib/rack/session/redis_hash.rb

@@ -0,0 +1,34 @@
+module Rack
+  module Session
+    class RedisHash < Abstract::ID
+
+      def get_session(env, sid)
+        session = Redis::NativeHash.find session_prefix => sid
+        unless sid and session
+          env['rack.errors'].puts("Session '#{sid.inspect}' not found, initializing...") if $VERBOSE and not sid.nil?
+          session = Redis::NativeHash.new session_prefix
+          sid = session.key
+        end
+        return [sid, session]
+      end
+
+      def set_session(env, session_id, session, options)
+        if options[:drop]
+          session.destroy
+          return false if options[:drop]
+        end
+        if options[:renew]
+          session_id = session.renew_key
+        end
+        session.save
+        return session_id
+      end
+
+      def session_prefix
+        :rack_session
+      end
+
+    end
+  end
+end
+

data/lib/redis/marshal.rb

@@ -0,0 +1,20 @@
+class Redis
+  class Marshal
+    def self.dump(value)
+      case value
+      when String
+        value
+      when Fixnum
+        value
+      else
+        ::Marshal.dump(value)
+      end
+    end
+
+    def self.load(value)
+      return value unless value.start_with?("\004")
+      ::Marshal.load(value) rescue value
+    end
+  end
+end
+

data/lib/redis/native_hash.rb

@@ -0,0 +1,205 @@
+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 'securerandom'
+
+class Redis
+  class NativeHash < TrackedHash
+
+    attr_accessor :namespace
+
+    def initialize(*args)
+      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
+      end
+      data = args.shift
+      update(data) if data.kind_of?(Hash)
+    end
+
+    def []=(key, value)
+      super(convert_key(key), value)
+    end
+    alias_method :store, :[]=
+
+    def fetch(key, *extras)
+      super(convert_key(key),*extras)
+    end
+
+    def [](key)
+       super convert_key(key)
+    end
+
+    def key?(key)
+      super convert_key(key)
+    end
+    alias_method :include?, :key?
+    alias_method :has_key?, :key?
+    alias_method :member?,  :key?
+
+    def delete(key)
+      super convert_key(key)
+    end
+
+    def values_at(*indices)
+      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?
+        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 )
+        end
+      else
+        redis.unwatch
+      end
+    end
+
+    def update(data)
+      v = case data
+        when self.class
+          data.version
+        when ::Hash
+          data.delete("__version")
+        end
+      self.version = v unless v.nil?
+      super(data.stringify_keys!)
+    end
+
+    def reload!
+      self.update( self.class.find( {namespace=>key} ) )
+    end
+    alias_method :reload, :reload!
+
+    def destroy
+      redis.del( redis_key )
+      untrack!
+      clear
+      self.key = nil
+    end
+
+    def renew_key(new_key = nil)
+      unless @key.nil? || @key == new_key
+        redis.del( redis_key )
+        original.clear
+      end
+      @key = new_key
+      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)
+    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)
+          end
+        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
+      end
+    end
+
+    protected
+      def redis; self.class.redis; end
+      def redis_key
+        namespace.nil? ? key : "#{namespace}:#{key}"
+      end
+      def convert_key(key)
+        key.to_s
+      end
+  end
+end
+

data/lib/redis/tracked_hash.rb

@@ -0,0 +1,56 @@
+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 update(other_hash)
+      if other_hash.kind_of?(TrackedHash)
+        other_original = other_hash.original
+        other_hash.instance_variable_set('@original',original)
+        other_changed = other_hash.changed
+        other_hash.deleted.each { |key| delete(key) }
+        other_hash.instance_variable_set('@original',other_original)
+        updates = Hash[ other_changed.map { |k| [k, other_hash[k]] } ]
+        super( updates )
+      else
+        super
+      end
+    end
+    alias_method :merge!, :update
+  
+  end
+end

data/redis-native_hash.gemspec

@@ -0,0 +1,70 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{redis-native_hash}
+  s.version = "0.1.0"
+
+  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.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.mkd"
+  ]
+  s.files = [
+    ".document",
+    ".rspec",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.mkd",
+    "Rakefile",
+    "VERSION",
+    "lib/core_ext/hash.rb",
+    "lib/rack/session/redis_hash.rb",
+    "lib/redis/marshal.rb",
+    "lib/redis/native_hash.rb",
+    "lib/redis/tracked_hash.rb",
+    "redis-native_hash.gemspec",
+    "spec/redis-hash_spec.rb",
+    "spec/redis/redis_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.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.6.2}
+  s.summary = %q{ruby-hash-to-redis-hash mapping}
+
+  if s.respond_to? :specification_version then
+    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"])
+      s.add_development_dependency(%q<rspec>, ["~> 2.3.0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.6.2"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+    else
+      s.add_dependency(%q<redis>, [">= 2.0.0"])
+      s.add_dependency(%q<rspec>, ["~> 2.3.0"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.6.2"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<redis>, [">= 2.0.0"])
+    s.add_dependency(%q<rspec>, ["~> 2.3.0"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.6.2"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+  end
+end
+

data/spec/redis/redis_hash_spec.rb

@@ -0,0 +1,141 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Redis::NativeHash do
+  before :each do
+    @hash = Redis::NativeHash.new :test, "foo" => "bar"
+    @hash.save
+  end
+
+  describe "#save" do
+    it "should presist changes to existing hash key" do
+      @hash["foo"] = "something else"
+      @hash.save
+      hash = Redis::NativeHash.find :test => @hash.key
+      hash["foo"].should == "something else"
+    end
+    it "should persist new hash keys" do
+      @hash["yin"] = "yang"
+      @hash.save
+      hash = Redis::NativeHash.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::NativeHash.find :test => @hash.key
+      hash["foo"].should == nil
+    end
+    it "should respect changes made since last read from redis" do
+      concurrent_edit = Redis::NativeHash.find :test => @hash.key
+      concurrent_edit["foo"] = "race value"
+      concurrent_edit.save
+      @hash["yin"] = "yang"
+      @hash["foo"] = "bad value"
+      @hash.save
+      hash = Redis::NativeHash.find :test => @hash.key
+      hash["foo"].should == "race value"
+      hash["yin"].should == "yang"
+    end
+    it "should respect removed hash keys since last read" do
+      concurrent_edit = Redis::NativeHash.find :test => @hash.key
+      concurrent_edit["yin"] = "yang"
+      concurrent_edit.delete("foo")
+      concurrent_edit.save
+      @hash["foo"] = "bad value"
+      @hash.save
+      hash = Redis::NativeHash.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
+      concurrent_edit = Redis::NativeHash.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::NativeHash.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::NativeHash.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::NativeHash.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::NativeHash.find namespace => old_key
+      hash.should be_nil
+    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::NativeHash.find :test => key
+      bad_hash.should be_nil
+      @hash.save
+      good_hash = Redis::NativeHash.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::NativeHash.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::NativeHash.find :test => old_key
+      bad_hash.should be_nil
+    end
+  end
+
+  describe ".find" do
+    it "should find an existing redis hash" do
+      hash = Redis::NativeHash.find :test => @hash.key
+      hash["foo"].should == "bar"
+    end
+    it "should return nil when hash not found" do
+      hash = Redis::NativeHash.find :foo => :doesnt_exist
+      hash.should == nil
+    end
+  end
+
+
+  after :each do
+    @hash.destroy
+  end
+end
+

data/spec/redis-hash_spec.rb

@@ -0,0 +1,7 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Redis::NativeHash" do
+  it "should pass" do
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'redis/native_hash'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+
+end
+

data/spec/tracked_hash_spec.rb

@@ -0,0 +1,85 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Redis::TrackedHash do
+  before :each do
+    @hash = Redis::TrackedHash[:a=>33,:b=>34,:c=>35,:d=>36]
+  end
+
+  describe "#added" do
+    it "should track new keys added" do
+      @hash.track!
+      @hash[:dolphin] = "value"
+      @hash.added.should == [:dolphin]
+    end
+    it "should not track additions if #track not called" do
+      @hash[:dolphin] = "mammal"
+      @hash.added.should == []
+    end
+  end
+
+  describe "#changed" do
+    it "tracks changes to existing keys" do
+      @hash.track!
+      @hash[:b] += 2
+      @hash.changed.should == [:b]
+    end
+    it "doesn't track changes if #track has not been called" do
+      @hash[:b] += 3
+      @hash.changed.should == []
+    end
+    it "should track new keys" do
+      @hash.track!
+      @hash[:test] = 47
+      @hash.changed.should == [:test]
+    end
+  end
+
+  describe "#deleted" do
+    it "should track when you delete a key" do
+      @hash.track!
+      @hash.delete(:b)
+      @hash.deleted.should == [:b]
+    end
+    it "should allow you to assign to a key that has been deleted" do
+      @hash.track!
+      @hash.delete(:b)
+      @hash[:b] = "new value"
+      @hash.deleted.should == []
+      @hash[:b].should == "new value"
+    end
+  end
+
+  describe "#merge!" do
+    before :each do
+      @other_hash = @hash.dup
+      @hash.track!; @other_hash.track!
+    end
+    it "maintains change from both Redis::TrackedHash" do
+      @hash[:a] = 64; @other_hash[:c]=96
+      @hash.merge!(@other_hash).should == {:a=>64,:b=>34,:c=>96,:d=>36}
+    end
+    it "gives precedence to changes in other_hash" do
+      @hash[:b] = 14; @other_hash[:b] = 77
+      @hash.merge!(@other_hash)
+      @hash[:b].should == 77
+    end
+    it "always deletes keys deleted in other_hash" do
+      @other_hash.delete(:d)
+      @hash[:d] = "foo"
+      @hash.merge!(@other_hash)
+      @hash.has_key?(:d).should == false
+    end
+    it "allows assignment to a key that has been deleted after a #merge" do
+      @other_hash.delete(:d)
+      @hash.merge!(@other_hash)
+      @hash[:d] = 77
+      @hash.deleted.should == []
+      @hash[:d].should == 77
+    end
+    it "should merge everything from a regular hash" do
+      @hash.merge!( { :c => "bar", :foo => "poo" } )
+      @hash.changed.should include(:c, :foo)
+    end
+  end
+end
+

data/spec/user_defined/user_spec.rb

@@ -0,0 +1,27 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+class User < Redis::NativeHash
+  attr_persist :username, :password, :email
+  #attr_index :username
+end
+
+describe User do
+  before :each do
+    @user = User.new :username => "test", :email => "test@test.com", :random_key => "random value"
+    @user.save
+  end
+
+  describe ".find" do
+    it "should find the user by key" do
+      user = User.find(@user.key)
+      user.username.should      == "test"
+      user.email.should         == "test@test.com"
+      user[:random_key].should  == "random value"
+    end
+  end
+
+  after :each do
+    @user.destroy
+  end
+end
+

metadata

@@ -0,0 +1,127 @@
+--- !ruby/object:Gem::Specification
+name: redis-native_hash
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Carl Zulauf
+- Adam Lassek
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-07-13 00:00:00.000000000 -05:00
+default_executable: 
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: &15185560 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *15185560
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &15168640 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.3.0
+  type: :development
+  prerelease: false
+  version_requirements: *15168640
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &15168040 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *15168040
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: &15167440 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.2
+  type: :development
+  prerelease: false
+  version_requirements: *15167440
+- !ruby/object:Gem::Dependency
+  name: rcov
+  requirement: &15166840 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *15166840
+description: ruby-hash-to-redis-hash mapping
+email: czulauf@lyconic.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.mkd
+files:
+- .document
+- .rspec
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.mkd
+- Rakefile
+- VERSION
+- lib/core_ext/hash.rb
+- lib/rack/session/redis_hash.rb
+- lib/redis/marshal.rb
+- lib/redis/native_hash.rb
+- lib/redis/tracked_hash.rb
+- redis-native_hash.gemspec
+- spec/redis-hash_spec.rb
+- spec/redis/redis_hash_spec.rb
+- spec/spec_helper.rb
+- spec/tracked_hash_spec.rb
+- spec/user_defined/user_spec.rb
+has_rdoc: true
+homepage: http://github.com/carlzulauf/redis-native_hash
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 2729795531866201316
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: ruby-hash-to-redis-hash mapping
+test_files: []