redis-persistence 0.0.3 → 0.0.4

data/README.markdown

@@ -2,7 +2,7 @@ Redis Persistence
 =================
 
 `Redis::Persistence` is a lightweight object persistence framework,
-fully compatible with ActiveModel and based on Redis[http://redis.io],
+fully compatible with _ActiveModel_, based on [_Redis_](http://redis.io),
 easily used standalone or within Rails applications.
 
 Installation
@@ -20,8 +20,10 @@ Features:
 * Defining default values for properties
 * Casting properties as built-in or custom classes
 * Convenient "dot access" to properties (<tt>article.views.today</tt>)
-* Support for "collections" of embedded objects (eg. article <> comments)
+* Support for "collections" of embedded objects (eg. article » comments)
 * Automatic conversion of UTC-formatted strings to Time objects
+* Small: 1 file, ~ 200 lines of code
+* Fast: ~2000 saves/sec, ~6000 finds/sec
 
 Basic example
 -------------
@@ -47,17 +49,17 @@ Basic example
     # => <Article: {"id"=>1, "title"=>"The Thing", ...}>
 
     article.title
-    # => Hello World!
+    # => The Thing!
 
-    article.created.class
-    # => Time
+    article.created.year
+    # => 2011
 
     article.title = 'The Cabin'
     article.save
     # => <Article: {"id"=>1, "title"=>"The Cabin", ...}>
 ```
 
-See the [`examples/article.rb`](./blob/master/examples/article.rb) for full example.
+See the [`examples/article.rb`](http://github.com/Ataxo/redis-persistence/blob/master/examples/article.rb) for full example.
 
 -----
 

data/examples/article.rb

@@ -8,41 +8,57 @@ Redis::Persistence.config.redis.flushdb
 # => #<Redis client v2.2.2 connected to redis://127.0.0.1:6379/0 (Redis v2.4.1)>
 
 class Comment
-  def initialize(params);                      @attributes = HashWithIndifferentAccess.new(params); end
-  def method_missing(method_name, *arguments); @attributes[method_name];                            end
-  def as_json(*);                              @attributes;                                         end
+  def initialize(params);                      @attributes = HashWithIndifferentAccess.new(params);  end
+  def method_missing(method_name, *arguments); @attributes[method_name];                             end
+  def as_json(*);                              @attributes;                                          end
+end
+
+class Body
+  def initialize(params);                      @body = HashWithIndifferentAccess.new(params)[:body]; end
+  def words
+    @body.split(/\W/).size
+  end
+  def inspect
+    "“#{@body}”"
+  end
 end
 
 class Article
   include Redis::Persistence
 
   property :title
-  property :body
-  property :author, :default  => '(Unknown)'
   property :created
+  property :author, default: '(Unknown)'
+  property :body,   class:   Body
 
-  property :comments, :default => [], :class => [Comment], :family => 'comments'
+  property :comments, default: [], class: [Comment], family: 'comments'
 end
 
-article = Article.new :title   => 'Do Not Blink',
-                      :author  => 'Malcom Gladwell',
-                      :body    => 'Imagine that I asked you ...',
-                      :created => Time.now.utc
-# => #<Article: {"id"=>1, "title"=>"Do Not Blink", ...>
+article = Article.new title:   'I Work For Banks Now!',
+                      author:  'Malcom Gladwell',
+                      body:    'Imagine that I asked you ...',
+                      created: Time.now.utc
+# => #<Article: {"id"=>1, "title"=>"I Work For Banks Now!", ...>
 
 p article.save
-# => #<Article: {"id"=>1, "title"=>"Do Not Blink", ...>
+# => #<Article: {"id"=>1, "title"=>"I Work For Banks Now!", ...>
 
 p article = Article.find(1)
-# => #<Article: {"id"=>1, "title"=>"Do Not Blink", ...>
+# => #<Article: {"id"=>1, "title"=>"I Work For Banks Now!", ...>
 
 p article.title
-# => "Do Not Blink"
+# => "I Work For Banks Now!"
 
 p article.created.year
 # => 2011
 
-article = Article.new :title => 'In the Beginning Was the Command Line'
+p article.body
+# => "“Imagine that I asked you ...”"
+
+p article.body.words
+# => 5
+
+article = Article.new title: 'In the Beginning Was the Command Line'
 p article.save
 # => #<Article: {"id"=>2, "title"=>"In the Beginning Was the Command Line", ... "author"=>"(Unknown)"}>
 
@@ -52,14 +68,14 @@ p article = Article.find(2)
 p article.author
 # => "(Unknown)"
 
-article = Article.create :title => 'OMG BLOG!'
+article = Article.new title: 'OMG BLOG!'
 
-p article.comments
+article.comments
 # => []
 
-article.comments << {:nick => '4chan', :body => 'WHY U NO QUIT?'}
+article.comments << {nick: '4chan', body: 'WHY U NO QUIT?'}
 
-article.comments << Comment.new(:nick => 'h4x0r', :body => 'WHY U NO USE BBS?')
+article.comments << Comment.new(nick: 'h4x0r', body: 'WHY U NO USE BBS?')
 
 p article.comments.size
 # => 2
@@ -68,10 +84,14 @@ p article.save(families: 'comments')
 # => <Article: {"id"=>3, ... "comments"=>[{:nick=>"4chan", :body=>"WHY U NO QUIT?"}]}>
 
 article = Article.find(3)
-p article.comments
-# => []
+begin
+  article.comments
+rescue Exception => e
+  p e
+end
+# => Redis::Persistence::FamilyNotLoaded ...
 
-article = Article.find(3, :families => 'comments')
+article = Article.find(3, families: 'comments')
 p article.comments
 # => [#<Comment @attributes={"nick"=>"4chan", "body"=>"WHY U NO QUIT?"}>, ...]
 

data/examples/benchmark.rb

@@ -1,15 +1,31 @@
 $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
 
+require 'active_record'
+require 'sqlite3'
+
 require 'benchmark'
 require 'redis/persistence'
 require 'active_support/core_ext/hash/indifferent_access'
 
 content = DATA.read
-COUNT   = ENV['COUNT'] || 100_000
+COUNT   = (ENV['COUNT'] || 100_000).to_i
 
 Redis::Persistence.config.redis = Redis.new :db => 14
 Redis::Persistence.config.redis.flushdb
 
+DATABASE_FILE = '/tmp/tire_benchmark_articles.sqlite3'
+File.delete DATABASE_FILE rescue nil
+# ActiveRecord::Base.establish_connection( :adapter => 'sqlite3', :database => ":memory:" )
+ActiveRecord::Base.establish_connection( :adapter => 'sqlite3', :database => DATABASE_FILE )
+ActiveRecord::Migration.verbose = false
+ActiveRecord::Schema.define(:version => 1) do
+  create_table :sql_articles do |t|
+    t.string     :title
+    t.text       :content
+    t.timestamps
+  end
+end
+
 class Article
   include Redis::Persistence
 
@@ -18,6 +34,52 @@ class Article
   property :created, :family => 'extra'
 end
 
+class SQLArticle < ActiveRecord::Base
+end
+
+puts "Beginning the benchmark script (SQLite and Redis)...", "", '='*80
+sleep 5
+
+puts "Saving #{COUNT} records into a SQLite database..."
+
+elapsed = Benchmark.realtime do
+  (1..COUNT).map do |i|
+    SQLArticle.create title: "Document #{i}", content: content
+  end
+end
+
+puts "Duration: #{elapsed} seconds, rate: #{COUNT.to_f/elapsed} docs/sec",
+     '-'*80
+
+puts "Finding all records from SQLite..."
+
+elapsed = Benchmark.realtime do
+  SQLArticle.all
+end
+
+puts "Duration: #{elapsed} seconds, rate: #{COUNT.to_f/elapsed} docs/sec",
+     '-'*80
+
+puts "Finding #{COUNT} records one by one from SQLite..."
+
+elapsed = Benchmark.realtime do
+ (1..COUNT).map { |i| SQLArticle.find(i) }
+end
+
+puts "Duration: #{elapsed} seconds, rate: #{COUNT.to_f/elapsed} docs/sec",
+     '-'*80
+
+puts "Updating all documents in batches of 1000 in SQLite..."
+
+elapsed = Benchmark.realtime do
+  SQLArticle.find_each { |document| document.title += ' (touched)' and document.save }
+end
+
+puts "Duration: #{elapsed} seconds, rate: #{COUNT.to_f/elapsed} docs/sec"
+
+puts "", '='*80, ""
+sleep 5
+
 puts "Saving #{COUNT} documents into Redis..."
 
 elapsed = Benchmark.realtime do
@@ -29,6 +91,15 @@ end
 puts "Duration: #{elapsed} seconds, rate: #{COUNT.to_f/elapsed} docs/sec",
      '-'*80
 
+puts "Finding all documents..."
+
+elapsed = Benchmark.realtime do
+  Article.all
+end
+
+puts "Duration: #{elapsed} seconds, rate: #{COUNT.to_f/elapsed} docs/sec",
+    '-'*80
+
 puts "Finding #{COUNT} documents one by one..."
 
 elapsed = Benchmark.realtime do
@@ -55,8 +126,9 @@ elapsed = Benchmark.realtime do
   Article.find_each { |document| document.title += ' (touched)' and document.save }
 end
 
-puts "Duration: #{elapsed} seconds, rate: #{COUNT.to_f/elapsed} docs/sec",
-     '-'*80
+puts "Duration: #{elapsed} seconds, rate: #{COUNT.to_f/elapsed} docs/sec"
+
+puts '='*80
 
 __END__
 Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.

data/lib/redis/persistence/version.rb

@@ -1,5 +1,5 @@
 class Redis
   module Persistence
-    VERSION = "0.0.3"
+    VERSION = "0.0.4"
   end
 end

data/lib/redis/persistence.rb

@@ -49,6 +49,7 @@ class Redis
     extend  ActiveSupport::Concern
 
     class RedisNotAvailable < StandardError; end
+    class FamilyNotLoaded   < StandardError; end
 
     DEFAULT_FAMILY = 'default'
 
@@ -85,7 +86,7 @@ class Redis
         include ActiveModel::Conversion
 
         extend  ActiveModel::Callbacks
-        define_model_callbacks :save, :destroy
+        define_model_callbacks :save, :destroy, :create
       end
     end
 
@@ -118,14 +119,18 @@ class Redis
       def property(name, options = {})
         # Getter method
         #
-        attr_reader name.to_sym
+        # attr_reader name.to_sym
+        define_method("#{name}") do
+          raise FamilyNotLoaded, "You are accessing the '#{name}' property in the '#{self.class.property_families[name.to_s]}' family which was not loaded.\nTo prevent you from losing data, this exception was raised. Consider loading the model with the family:\n\n  #{self.class.to_s}.find('#{self.id}', families: '#{self.class.property_families[name.to_s]}')\n\n" if self.persisted? and not self.__loaded_families.include?( self.class.property_families[name.to_s] )
+          instance_variable_get(:"@#{name}")
+        end
 
         # Setter method
         #
         define_method("#{name}=") do |value|
           # When changing property, update also loaded family:
           if instance_variable_get(:"@#{name}") != value && self.class.property_defaults[name.to_sym] != value
-            self.__loaded_families |= self.class.property_families.invert.map do |key, value|
+            self.__loaded_families |= self.class.family_properties.invert.map do |key, value|
                                         value.to_s if key.map(&:to_s).include?(name.to_s)
                                       end.compact
           end
@@ -143,8 +148,12 @@ class Redis
         property_types[name.to_sym]    = options[:class]   if options[:class]
 
         # Save the property in corresponding family:
-        if options[:family]; (property_families[options[:family].to_sym] ||= []) << name.to_s
-        else;                (property_families[DEFAULT_FAMILY.to_sym]   ||= []) << name.to_s
+        if options[:family]
+          (family_properties[options[:family].to_sym] ||= []) << name.to_s
+          property_families[name.to_s] = options[:family].to_s
+        else
+          (family_properties[DEFAULT_FAMILY.to_sym]   ||= []) << name.to_s
+          property_families[name.to_s] = DEFAULT_FAMILY.to_s
         end
 
         self
@@ -168,10 +177,16 @@ class Redis
         @property_types ||= {}
       end
 
-      # Returns a Hash mapping families to properties
+      # Returns a Hash mapping properties to families
       #
       def property_families
-        @property_families ||= { DEFAULT_FAMILY.to_sym => ['id'] }
+        @property_families ||= { 'id' => DEFAULT_FAMILY.to_s }
+      end
+
+      # Returns a Hash mapping families to properties
+      #
+      def family_properties
+        @family_properties ||= { DEFAULT_FAMILY.to_sym => ['id'] }
       end
 
       # Find one or multiple records
@@ -205,7 +220,7 @@ class Redis
       end
 
       def __find_one(id, options={})
-        families = options[:families] == 'all' ? property_families.keys : [DEFAULT_FAMILY.to_s] | Array(options[:families])
+        families = options[:families] == 'all' ? family_properties.keys.map(&:to_s) : [DEFAULT_FAMILY.to_s] | Array(options[:families])
         data = __redis.hmget("#{self.model_name.plural}:#{id}", *families)
 
         unless data.compact.empty?
@@ -221,7 +236,7 @@ class Redis
       end
 
       def __find_all(options={})
-        __find_many __all_ids
+        __find_many __all_ids, options
       end
 
       # Find all records in the database:
@@ -246,33 +261,43 @@ class Redis
 
       def initialize(attributes={})
         # Store "loaded_families" based on passed attributes, for using when saving:
-        self.class.property_families.each do |name, properties|
+        self.class.family_properties.each do |name, properties|
           self.__loaded_families |= [name.to_s] if ( properties.map(&:to_s) & attributes.keys.map(&:to_s) ).size > 0
         end
 
         # Make copy of objects in the property defaults hash (so default values are left intact):
-        property_defaults = self.class.property_defaults.inject({}) do |sum, item|
+        property_defaults = self.class.property_defaults.inject({}) do |hash, item|
           key, value = item
-          sum[key] = value.class.respond_to?(:new) ? value.clone : value
-          sum
+          hash[key] = value.class.respond_to?(:new) ? value.clone : value
+          hash
         end
 
+        # Update attributes, respecting defaults:
         __update_attributes property_defaults.merge(attributes)
         self
       end; alias :attributes= :initialize
 
+      # Update record attributes and save it:
+      #
+      #     article.update_attributes title: 'Changed', published: true, ...
+      #
       def update_attributes(attributes={})
         __update_attributes attributes
         save
         self
       end
 
-      # Returns a Hash of attributes for serialization, etc
+      # Returns record attributes as a Hash.
       #
       def attributes
         self.class.
           properties.
-          inject({}) {|attributes, key| attributes[key] = send(key); attributes}
+          inject({}) do |attributes, key|
+            begin
+              attributes[key] = send(key)
+            rescue FamilyNotLoaded; end
+            attributes
+          end
       end
 
       # Saves the record in the database, performing callbacks:
@@ -292,24 +317,51 @@ class Redis
       # Be careful not to overwrite properties with default values.
       #
       def save(options={})
-        run_callbacks :save do
+        perform = lambda do
           self.id ||= self.class.__next_id
-          families  = if options[:families] == 'all'; self.class.property_families.keys
+          families  = if options[:families] == 'all'; self.class.family_properties.keys
                       else;                           self.__loaded_families | Array(options[:families])
                       end
           params    = families.map do |family|
-                        [family.to_s, self.to_json(:only => self.class.property_families[family.to_sym])]
+                        [family.to_s, self.to_json(:only => self.class.family_properties[family.to_sym])]
                       end.flatten
-          __redis.hmset "#{self.class.model_name.plural}:#{self.id}", *params
+          __redis.hmset __redis_key, *params
+        end
+        run_callbacks :save do
+          unless persisted?
+            run_callbacks :create do
+              perform.()
+            end
+          else
+            perform.()
+          end
         end
         self
       end
 
-      # Removes the record from the database, performing callbacks.
+      # Reloads the model, updating its loaded families and attributes,
+      # eg. when you want to access properties in not-loaded families:
+      #
+      #     article.views
+      #     # => FamilyNotLoaded
+      #     article.reload(families: 'counters').views
+      #     # => 100
+      #
+      def reload(options={})
+        families = self.__loaded_families | Array(options[:families])
+        reloaded = self.class.find(self.id, options.merge(families: families))
+        self.attributes        = reloaded.attributes
+        self.__loaded_families = reloaded.__loaded_families
+        self
+      end
+
+      # Removes the record from the database, performing callbacks:
+      #
+      #     article.destroy
       #
       def destroy
         run_callbacks :destroy do
-          __redis.del "#{self.class.model_name.plural}:#{self.id}"
+          __redis.del __redis_key
         end
         self.freeze
       end
@@ -317,37 +369,46 @@ class Redis
       # Returns whether record is saved into database
       #
       def persisted?
-        __redis.exists "#{self.class.model_name.plural}:#{self.id}"
+        __redis.exists __redis_key
       end
 
       def inspect
-        "#<#{self.class}: #{attributes}>"
+        "#<#{self.class}: #{attributes}, loaded_families: #{__loaded_families.join(', ')}>"
+      end
+
+      # Returns the composited key for storing the record in the database
+      #
+      def __redis_key
+        "#{self.class.model_name.plural}:#{self.id}"
       end
 
-      # Updates record properties, taking care of casting to specified classes
-      # (single values or collections), augmenting hashes so you can access them with dot notation,
-      # and automatically converting properly formatted time values to Time classes.
+      # Updates record properties, taking care of casting to custom or built-in classes.
       #
       def __update_attributes(attributes)
-        attributes.each do |name, value|
-          case
-          # Should we cast the value ...
+        attributes.each { |name, value| send "#{name}=", __cast_value(name, value) }
+      end
+
+      # Casts the values according to the <tt>:class</tt> option set when
+      # defining the property, cast Hashes as Hashr[http://rubygems.org/gems/hashr] instances
+      # automatically convert UTC formatted strings to Time.
+      #
+      def __cast_value(name, value)
+        case
+
           when klass = self.class.property_types[name.to_sym]
-            # ... as an Array ...
             if klass.is_a?(Array) && value.is_a?(Array)
-              send "#{name}=", value.map { |v| klass.first.new(v) }
-            # ... or object?
+              value.map { |v| v.class == klass.first ? v : klass.first.new(v) }
             else
-              send "#{name}=", klass.new(value)
+              value.class == klass ? value : klass.new(value)
             end
-          # Should we return augmented Hash?
+
           when value.is_a?(Hash)
-            send "#{name}=", Hashr.new(value)
+            Hashr.new(value)
+
           else
             # Strings formatted as <http://en.wikipedia.org/wiki/ISO8601> are automatically converted to Time
             value = Time.parse(value) if value.is_a?(String) && value =~ /^\d{4}[\/\-]\d{2}[\/\-]\d{2}T\d{2}\:\d{2}\:\d{2}Z$/
-            send "#{name}=", value
-          end
+            value
         end
       end
 

data/test/models.rb

@@ -39,11 +39,15 @@ class ModelWithCallbacks
   before_save    :my_callback_method
   after_save     :my_callback_method
   before_destroy { @hooked = 'YEAH' }
+  before_create  :my_before_create_method
 
   property :title
 
   def my_callback_method
   end
+
+  def my_before_create_method
+  end
 end
 
 class ModelWithValidations
@@ -104,7 +108,7 @@ end
 class ModelWithCastingInFamily
   include Redis::Persistence
   property :pieces, :class => [Piece], :default => [], :family => 'meta'
-  property :parts,  :class => [Piece], :default => [], :family => 'meta'
+  property :parts,  :class => [Piece], :default => [], :family => 'other'
 end
 
 class ModelWithDefaultArray

data/test/redis_persistence_test.rb

@@ -153,7 +153,6 @@ class RedisPersistenceTest < ActiveSupport::TestCase
 
       m = ModelWithFamily.find(1)
       assert_not_nil m.name
-      assert_nil     m.views
 
       m = ModelWithFamily.find(1, :families => ['counters', 'meta'])
       assert_not_nil m.name
@@ -166,19 +165,28 @@ class RedisPersistenceTest < ActiveSupport::TestCase
 
     should "cast the values" do
       m = ModelWithCastingInFamily.create pieces: [ { name: 'One', level: 42 } ]
-      m.save
-
-      m = ModelWithCastingInFamily.find(1)
-      assert_equal [], m.pieces
-      assert_equal [], m.parts
-      assert_nil       m.pieces.first
 
       m = ModelWithCastingInFamily.find(1, :families => 'meta')
-      assert_equal [], m.parts
+      assert_raise(Redis::Persistence::FamilyNotLoaded) { m.parts }
       assert_not_nil   m.pieces.first
       assert_equal 42, m.pieces.first.level
     end
 
+    should "not cas the value if it already has proper class" do
+      m = ModelWithCasting.create thing: {value: 'foo'}
+
+      m.reload
+      assert_equal 'foo', m.thing.value
+    end
+
+    should "not cast the values if it already has proper class" do
+      m = ModelWithCastingInFamily.create pieces: [ { name: 'One', level: 42 }, { name: 'Two', level: 45 } ]
+
+      m.reload(families: 'meta')
+      assert_equal 42, m.pieces.first.level
+      assert_equal 45, m.pieces.last.level
+    end
+
     should "store loaded families on initialization" do
       m = ModelWithCastingInFamily.new pieces: [ { name: 'One', level: 42 } ]
       assert_equal ['default', 'meta'], m.__loaded_families
@@ -239,6 +247,12 @@ class RedisPersistenceTest < ActiveSupport::TestCase
       assert_equal '3', PersistentArticle.all.last.title
     end
 
+    should "return all instances with desired families" do
+      3.times { |i| ModelWithFamily.create name: "#{i+1}", tags: [ 'foo', 'bar' ] }
+      assert_equal 3,   ModelWithFamily.all(families: 'tags').size
+      assert_equal ['foo', 'bar'], ModelWithFamily.all(families: 'tags').last.tags
+    end
+
     should "return instances by IDs" do
       10.times { |i| PersistentArticle.create title: "#{i+1}" }
       assert_equal 10, PersistentArticle.all.size
@@ -266,7 +280,6 @@ class RedisPersistenceTest < ActiveSupport::TestCase
 
       m = ModelWithFamily.find(1)
       assert_equal 1, m.__loaded_families.size
-      assert_nil m.views
 
       m = ModelWithFamily.find(1, families: 'all')
       assert_equal 4, m.__loaded_families.size
@@ -365,6 +378,37 @@ class RedisPersistenceTest < ActiveSupport::TestCase
       assert_equal 'New', a.title
     end
 
+    should "reload itself" do
+      m = ModelWithFamily.create
+      assert_raise(Redis::Persistence::FamilyNotLoaded) { m.views }
+
+      m.reload(families: 'counters')
+      assert m.__loaded_families.include?('counters'), m.__loaded_families.inspect
+      assert_nothing_raised { assert_nil m.views }
+
+      m.views = 100
+      m.save
+
+      assert_equal 100, ModelWithFamily.find(1, families: 'counters').views
+    end
+
+    should "reload itself when casted" do
+      m = ModelWithCastingInFamily.create
+      assert_raise(Redis::Persistence::FamilyNotLoaded) { m.pieces }
+
+      m.reload(families: 'meta')
+      assert_equal [], m.pieces
+    end
+
+    should "reload itself with already loaded families" do
+      m = ModelWithCastingInFamily.create pieces: [{name: 'foo'}], parts: [{name: 'bar'}]
+
+      m = ModelWithCastingInFamily.find(m.id, families: 'meta')
+      m = m.reload
+      assert_equal 'foo', m.pieces.first.name
+      assert m.__loaded_families.include?('meta')
+    end
+
     should "get auto-incrementing ID on save when none is passed" do
       article = PersistentArticle.new title: 'One'
 
@@ -377,6 +421,19 @@ class RedisPersistenceTest < ActiveSupport::TestCase
       assert_equal 2, PersistentArticle.__next_id
     end
 
+    should "fire before_create hooks" do
+      ModelWithCallbacks.any_instance.expects(:my_before_create_method)
+
+      ModelWithCallbacks.create title: 'Hooks'
+    end
+
+    should "fire both before_create and before_save hooks if defined" do
+      ModelWithCallbacks.any_instance.expects(:my_before_create_method)
+      ModelWithCallbacks.any_instance.expects(:my_callback_method).twice
+
+      ModelWithCallbacks.create title: 'Hooks'
+    end
+
     should "fire before_save hooks" do
       article = ModelWithCallbacks.new title: 'Hooks'
       article.expects(:my_callback_method).twice
@@ -418,12 +475,7 @@ class RedisPersistenceTest < ActiveSupport::TestCase
     end
 
     should "not overwrite properties in not-loaded family with defaults" do
-      m = ModelWithDefaultsInFamilies.new :name => 'One'
-      m.save
-
-      # Return defaults
-      m = ModelWithDefaultsInFamilies.find(1)
-      assert_equal [], m.tags
+      m = ModelWithDefaultsInFamilies.create :name => 'One'
 
       # Return defaults
       m = ModelWithDefaultsInFamilies.find(1, families: 'tags')
@@ -438,22 +490,32 @@ class RedisPersistenceTest < ActiveSupport::TestCase
       m = ModelWithDefaultsInFamilies.find(1, :families => 'tags')
       assert_equal ['foo'], m.tags
 
-      # Return defaults
-      m = ModelWithDefaultsInFamilies.find(1)
-      assert_equal [], m.tags
-
       # Change another property
       m = ModelWithDefaultsInFamilies.find(1)
-      m.name = 'Two'
+      m.name = 'Changed'
       m.save
 
-      # Return defaults
-      m = ModelWithDefaultsInFamilies.find(1)
-      assert_equal [], m.tags
-
       # Return data
       m = ModelWithDefaultsInFamilies.find(1, :families => 'tags')
       assert_equal ['foo'], m.tags
+
+      # Return defaults
+      ModelWithDefaultsInFamilies.create :name => 'Two'
+      n = ModelWithDefaultsInFamilies.find(2, :families => 'tags')
+      assert_equal [], n.tags
+    end
+
+    should "raise an exception when accessing not-loaded property on persisted model" do
+      ModelWithFamily.new.save
+      m = ModelWithFamily.find(1)
+      assert_raise(Redis::Persistence::FamilyNotLoaded) { m.lang }
+    end
+
+    should "not raise an exception when accessing property on not-yet-persisted model" do
+      m = ModelWithFamily.new
+      assert_nothing_raised do
+        assert_nil m.lang
+      end
     end
 
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redis-persistence
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -10,11 +10,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-11-20 00:00:00.000000000 Z
+date: 2012-03-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
-  requirement: &70189836581020 !ruby/object:Gem::Requirement
+  requirement: &70133201142020 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -22,10 +22,10 @@ dependencies:
         version: '3.0'
   type: :runtime
   prerelease: false
-  version_requirements: *70189836581020
+  version_requirements: *70133201142020
 - !ruby/object:Gem::Dependency
   name: multi_json
-  requirement: &70189836580520 !ruby/object:Gem::Requirement
+  requirement: &70133201138700 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -33,10 +33,10 @@ dependencies:
         version: '1.0'
   type: :runtime
   prerelease: false
-  version_requirements: *70189836580520
+  version_requirements: *70133201138700
 - !ruby/object:Gem::Dependency
   name: redis
-  requirement: &70189836580060 !ruby/object:Gem::Requirement
+  requirement: &70133201122260 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -44,10 +44,10 @@ dependencies:
         version: 2.2.2
   type: :runtime
   prerelease: false
-  version_requirements: *70189836580060
+  version_requirements: *70133201122260
 - !ruby/object:Gem::Dependency
   name: hashr
-  requirement: &70189836579600 !ruby/object:Gem::Requirement
+  requirement: &70133201117960 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -55,10 +55,10 @@ dependencies:
         version: 0.0.16
   type: :runtime
   prerelease: false
-  version_requirements: *70189836579600
+  version_requirements: *70133201117960
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &70189836579140 !ruby/object:Gem::Requirement
+  requirement: &70133201114180 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -66,10 +66,10 @@ dependencies:
         version: '1.0'
   type: :development
   prerelease: false
-  version_requirements: *70189836579140
+  version_requirements: *70133201114180
 - !ruby/object:Gem::Dependency
   name: yajl-ruby
-  requirement: &70189836578680 !ruby/object:Gem::Requirement
+  requirement: &70133201111840 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -77,10 +77,10 @@ dependencies:
         version: 0.8.0
   type: :development
   prerelease: false
-  version_requirements: *70189836578680
+  version_requirements: *70133201111840
 - !ruby/object:Gem::Dependency
   name: shoulda
-  requirement: &70189836578300 !ruby/object:Gem::Requirement
+  requirement: &70133201109960 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -88,10 +88,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70189836578300
+  version_requirements: *70133201109960
 - !ruby/object:Gem::Dependency
   name: mocha
-  requirement: &70189836577840 !ruby/object:Gem::Requirement
+  requirement: &70133201101720 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -99,10 +99,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70189836577840
+  version_requirements: *70133201101720
 - !ruby/object:Gem::Dependency
   name: turn
-  requirement: &70189836577420 !ruby/object:Gem::Requirement
+  requirement: &70133201100020 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -110,7 +110,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70189836577420
+  version_requirements: *70133201100020
 description: Simple ActiveModel-compatible persistence layer in Redis
 email:
 - karmi@karmi.cz
@@ -160,7 +160,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 1.8.11
 signing_key: 
 specification_version: 3
 summary: Simple ActiveModel-compatible persistence layer in Redis
@@ -169,3 +169,4 @@ test_files:
 - test/active_model_lint_test.rb
 - test/models.rb
 - test/redis_persistence_test.rb
+has_rdoc: