redis-persistence 0.0.1 → 0.0.2

data/README.markdown

@@ -1,50 +1,63 @@
 Redis Persistence
 =================
 
-`Redis::Persistence` is a simple persistence layer for Ruby objects, fully compatible with ActiveModel,
-and thus easily used both standalone or in a Rails project.
+`Redis::Persistence` is a lightweight object persistence framework,
+fully compatible with ActiveModel and based on Redis[http://redis.io],
+easily used standalone or within Rails applications.
 
-## Usage ##
+Installation
+------------
 
-```ruby
-require 'redis/persistence'
+    $ gem install redis-persistence
 
-Redis::Persistence.config.redis = Redis.new
-# => #<Redis client v2.2.2 connected to redis://127.0.0.1:6379/0 (Redis v2.4.1)>
+Features:
+---------
 
-class Article
-  include Redis::Persistence
+* 100% Rails compatibility
+* 100% ActiveModel compatibility: callbacks, validations, serialization, ...
+* No crazy `has_many`-type of semantics
+* Auto-incrementing IDs
+* 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)
+* Automatic conversion of UTC-formatted strings to Time objects
 
-  property :id
-  property :title
-  property :body
-  property :author, :default => '(Unknown)'
-end
+Basic example
+-------------
 
-article = Article.new :id => 1, :title => 'Lorem Ipsum'
-# => #<Article: {"id"=>1, "title"=>"Lorem Ipsum", "body"=>nil, "author"=>"(Unknown)"}>
+```ruby
+    require 'redis/persistence'
 
-article.save
-# => #<Article: {"id"=>1, "title"=>"Lorem Ipsum", "body"=>nil, "author"=>"(Unknown)"}>
+    Redis::Persistence.config.redis = Redis.new
+    # => #<Redis client v2.2.2 connected to redis://127.0.0.1:6379/0 (Redis v2.4.1)>
 
-article = Article.find(1)
-# => #<Article: {"id"=>1, "title"=>"Lorem Ipsum", "body"=>nil, "author"=>"(Unknown)"}>
+    class Article
+      include Redis::Persistence
 
-article.title
-# => "Lorem Ipsum"
+      property :title
+      property :body
+      property :author, :default  => '(Unknown)'
+      property :created
+    end
 
-article.author
-# => "(Unknown)"
-```
+    Article.create title: 'The Thing', body: 'So, in the beginning...', created: Time.now.utc
 
-It comes with the standard feature set of ActiveModel classes: validations, callbacks, serialization,
-Rails DOM helpers compatibility, etc.
+    article = Article.find(1)
+    # => <Article: {"id"=>1, "title"=>"The Thing", ...}>
 
+    article.title
+    # => Hello World!
 
-## Installation ##
+    article.created.class
+    # => Time
+
+    article.title = 'The Cabin'
+    article.save
+    # => <Article: {"id"=>1, "title"=>"The Cabin", ...}>
+```
 
-    git clone git://github.com/Ataxo/redis-persistence.git
-    rake install
+See the [`examples/article.rb`](./blob/master/examples/article.rb) for full example.
 
 -----
 

data/examples/benchmark.rb

@@ -40,7 +40,7 @@ end
 puts "Duration: #{elapsed} seconds, rate: #{COUNT.to_f/elapsed} docs/sec",
      '-'*80
 
-puts "Finding first 1000 documents with only 'data' family..."
+puts "Finding first 1000 documents with only 'default' family..."
 
 elapsed = Benchmark.realtime do
   Article.find (1..1000).to_a

data/examples/rails-template.rb

@@ -54,44 +54,36 @@ puts        '-'*80, ''
 run "bundle install"
 
 puts
-say_status  "Model", "Adding the Article resource...", :yellow
+say_status  "Model", "Generating the Article resource with Redis::Persistence...", :yellow
 puts        '-'*80, ''; sleep 1
 
-generate :scaffold, "Article title:string content:text published:date"
+generate :scaffold, "Article title:string content:text published:boolean --orm=redis_persistence"
 route "root :to => 'articles#index'"
 
 git :add => '.'
-git :commit => "-m 'Added the Article resource'"
+git :commit => "-m 'Generated the Article resource\n\n(Redis::Persistence-based model, scaffolded controller/views/tests)'"
 
 puts
-say_status  "Model", "Adding Redis::Persistence into the Article model...", :yellow
+say_status  "Initializer", "Adding configuration for Redis::Persistence...", :yellow
 puts        '-'*80, ''; sleep 1
 
-run "rm -f app/models/article.rb"
-file 'app/models/article.rb', <<-CODE
-class Article
-  include Redis::Persistence
+# initializer 'redis-persistence.rb', <<-CODE
+# Redis::Persistence.config.redis = Redis.new(:db => 14)
+# CODE
 
-  property :title
-  property :content
-  property :published
-end
-CODE
+generate 'redis_persistence:initializer', "14"
 
-initializer 'redis-persistence.rb', <<-CODE
-Redis::Persistence.config.redis = Redis.new(:db => 14)
-CODE
-
-git :commit => "-a -m 'Added Redis::Persistence into the Article model, added initializer (Redis DB=14)'"
+git :add => 'config/initializers/redis-persistence.rb'
+git :commit => "-a -m 'Added initializer for Redis::Persistence\n\n(Find your data with `redis-cli -n 14 keys articles:*`)'"
 
 puts
 say_status  "Database", "Seeding the database with data...", :yellow
 puts        '-'*80, ''; sleep 0.25
 
-run "rm -rf db/migrate"
-run "redis-cli -n 14 flushdb"
-run "rm -f db/seeds.rb"
-file 'db/seeds.rb', <<-CODE
+remove_file 'db/seeds.rb'
+file        'db/seeds.rb', <<-CODE
+Redis::Persistence.config.redis.flushdb
+
 contents = [
 'Lorem ipsum dolor sit amet.',
 'Consectetur adipisicing elit, sed do eiusmod tempor incididunt.',
@@ -102,7 +94,7 @@ contents = [
 
 puts "Creating articles..."
 %w[ One Two Three Four Five ].each_with_index do |title, i|
-  Article.create title: title, content: contents[i], published: i.days.ago.utc
+  Article.create title: title, content: contents[i], published: (rand > 0.5 ? true : false)
 end
 CODE
 

data/lib/rails/generators/redis_persistence/initializer/initializer_generator.rb

@@ -0,0 +1,18 @@
+module RedisPersistence
+  module Generators
+
+    class InitializerGenerator < Rails::Generators::Base
+
+      desc "Creates initializer file for redis-persistence in config/initializers."
+      argument :database, :type => :string, :default => '14', :optional => true, :banner => "<REDIS DATABASE NUMBER>"
+
+      source_root File.expand_path("../templates", __FILE__)
+
+      def create_initializer_file
+        template "initializer.rb.tt", "config/initializers/redis-persistence.rb"
+      end
+
+    end
+
+  end
+end

data/lib/rails/generators/redis_persistence/initializer/templates/initializer.rb.tt

@@ -0,0 +1 @@
+Redis::Persistence.config.redis = Redis.new(:db => <%= database %>)

data/lib/rails/generators/redis_persistence/model/model_generator.rb

@@ -0,0 +1,26 @@
+module RedisPersistence
+  module Generators
+
+    class ModelGenerator < Rails::Generators::NamedBase
+
+      desc "Creates a Redis::Persistence-based model."
+      argument :attributes, :type => :array, :default => [], :banner => "property:type property:type ..."
+
+      source_root File.expand_path("../templates", __FILE__)
+
+      check_class_collision
+
+      def create_model_file
+        template "model.rb.tt", File.join("app/models", "#{file_name}.rb")
+      end
+
+      hook_for :test_framework
+
+      def module_namespacing(&block)
+        yield if block
+      end unless methods.include?(:module_namespacing)
+
+    end
+
+  end
+end

data/lib/rails/generators/redis_persistence/model/templates/model.rb.tt

@@ -0,0 +1,9 @@
+<% module_namespacing do -%>
+class <%= class_name %>
+  include Redis::Persistence
+
+<% attributes.each do |attribute| -%>
+  property :<%= attribute.name %>
+<% end -%>
+end
+<% end -%>

data/lib/rails/generators/redis_persistence_generator.rb

@@ -0,0 +1,42 @@
+require 'rails/generators/named_base'
+require 'rails/generators/active_model'
+
+module RedisPersistence
+  module Generators
+
+    class ActiveModel < ::Rails::Generators::ActiveModel
+      def self.all(klass)
+        "#{klass}.all"
+      end
+
+      def self.find(klass, params=nil)
+        "#{klass}.find(#{params})"
+      end
+
+      def self.build(klass, params=nil)
+        if params
+          "#{klass}.new(#{params})"
+        else
+          "#{klass}.new"
+        end
+      end
+
+      def save
+        "#{name}.save"
+      end
+
+      def update_attributes(params=nil)
+        "#{name}.update_attributes(#{params})"
+      end
+
+      def errors
+        "#{name}.errors"
+      end
+
+      def destroy
+        "#{name}.destroy"
+      end
+    end
+
+  end
+end

data/lib/redis-persistence.rb

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

data/lib/redis/persistence.rb

@@ -5,11 +5,61 @@ require 'active_model'
 require 'active_support/concern'
 require 'active_support/configurable'
 
+require File.expand_path('../persistence/railtie', __FILE__) if defined?(Rails)
+
 class Redis
+
+  # <b>Redis::Persistence</b> is a lightweight object persistence framework,
+  # fully compatible with ActiveModel and based on Redis[http://redis.io].
+  #
+  # Features:
+  #
+  # * 100% Rails compatibility
+  # * 100% ActiveModel compatibility: callbacks, validations, serialization, ...
+  # * No crazy +has_many+-type of semantics
+  # * Auto-incrementing IDs
+  # * 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)
+  # * Automatic conversion of UTC-formatted strings to Time objects
+  #
+  # Basic example:
+  #
+  #     class Article
+  #       include Redis::Persistence
+  #
+  #       property :title
+  #       property :body
+  #       property :author, :default  => '(Unknown)'
+  #       property :created
+  #     end
+  #
+  #     Article.create title: 'Hello World!', body: 'So, in the beginning...', created: Time.now.utc
+  #     article = Article.find(1)
+  #     # => <Article: {"id"=>1, "title"=>"Hello World!", ...}>
+  #     article.title
+  #     # => Hello World!
+  #     article.created.class
+  #     # => Time
+  #
+  # See the <tt>examples/article.rb</tt> for full example.
+  #
   module Persistence
-    include ActiveSupport::Configurable
     extend  ActiveSupport::Concern
 
+    class RedisNotAvailable < StandardError; end
+
+    DEFAULT_FAMILY = 'default'
+
+    def self.config
+      @__config ||= Hashr.new
+    end
+
+    def self.configure
+      yield config
+    end
+
     included do
       include ActiveModelIntegration
       self.include_root_in_json = false
@@ -21,7 +71,6 @@ class Redis
       def __redis
         self.class.__redis
       end
-
     end
 
     module ActiveModelIntegration
@@ -42,88 +91,175 @@ class Redis
 
     module ClassMethods
 
+      # Create new record in database:
+      #
+      #     Article.create title: 'Lorem Ipsum'
+      #
       def create(attributes={})
         new(attributes).save
       end
 
+      # Define property in the "default" family:
+      #
+      #     property :title
+      #     property :author,   class: Author
+      #     property :comments, default: []
+      #     property :comments, default: [], class: [Comment]
+      #
+      # Specify a custom "family" for this property:
+      #
+      #     property :views, family: 'counters'
+      #
+      # Only the "default" family is loaded... by default,
+      # for performance and limiting used memory.
+      #
+      # See more examples in the <tt>test/models.rb</tt> file.
+      #
       def property(name, options = {})
-        attr_accessor name.to_sym
+        # Getter method
+        #
+        attr_reader name.to_sym
+
+        # 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|
+                                        value.to_s if key.map(&:to_s).include?(name.to_s)
+                                      end.compact
+          end
+          # Store the value in instance variable:
+          instance_variable_set(:"@#{name}", value)
+        end
+
+        # Save the property in properties array:
         properties << name.to_s unless properties.include?(name.to_s)
 
+        # Save property default value (when relevant):
         property_defaults[name.to_sym] = options[:default] if options[:default]
+
+        # Save property casting (when relevant):
         property_types[name.to_sym]    = options[:class]   if options[:class]
-        unless options[:family]
-          (property_families[:data] ||= [])                   << name.to_s
-        else
-          (property_families[options[:family].to_sym] ||= []) << name.to_s
+
+        # 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
         end
+
         self
       end
 
+      # Returns an Array with all properties
+      #
       def properties
         @properties ||= ['id']
       end
 
+      # Returns a Hash with property default values
+      #
       def property_defaults
         @property_defaults ||= {}
       end
 
+      # Returns a Hash with property casting (classes)
+      #
       def property_types
         @property_types ||= {}
       end
 
+      # Returns a Hash mapping families to properties
+      #
       def property_families
-        @property_families ||= { :data => ['id'] }
+        @property_families ||= { DEFAULT_FAMILY.to_sym => ['id'] }
       end
 
+      # Find one or multiple records
+      #
+      #     Article.find 1
+      #     Article.find [1, 2, 3]
+      #
+      # Specify a family (other then "default"):
+      #
+      #     Article.find 1, families: 'counters'
+      #     Article.find 1, families: ['counters', 'meta']
+      #
       def find(args, options={})
         args.is_a?(Array) ? __find_many(args, options) : __find_one(args, options)
       end
 
+      # Yield each record in the database, loading them in batches
+      # specified as +batch_size+:
+      #
+      #     Article.find_each do |article|
+      #       article.title += ' (touched)' and article.save
+      #     end
+      #
+      # This method is conveninent for batch manipulations of your entire database.
+      #
+      def find_each(options={}, &block)
+        batch_size = options.delete(:batch_size) || 1000
+        __all_ids.each_slice batch_size do |batch|
+          __find_many(batch, options).each { |document| yield document }
+        end
+      end
+
       def __find_one(id, options={})
-        families = ['data'] | Array(options[:families])
+        families = options[:families] == 'all' ? property_families.keys : [DEFAULT_FAMILY.to_s] | Array(options[:families])
         data = __redis.hmget("#{self.model_name.plural}:#{id}", *families)
 
         unless data.compact.empty?
-          attributes = data.inject({}) { |hash, item| hash.update( MultiJson.decode(item) ); hash }
-          self.new attributes
+          attributes = data.compact.inject({}) { |hash, item| hash.update( MultiJson.decode(item, :symbolize_keys => true) ); hash }
+          instance   = self.new attributes
+          instance.__loaded_families = families
+          instance
         end
       end
 
-      def __find_all(options={})
-        __find_many __all_ids
-      end
-      alias :all :__find_all
-
       def __find_many(ids, options={})
         ids.map { |id| __find_one(id, options) }.compact
       end
 
-      def find_each(options={}, &block)
-        options = { :batch_size => 1000 }.update(options)
-        __all_ids.each_slice options[:batch_size] do |batch|
-          __find_many(batch).each { |document| yield document }
-        end
+      def __find_all(options={})
+        __find_many __all_ids
       end
 
+      # Find all records in the database:
+      #
+      #     Article.all
+      #
+      alias :all :__find_all
+
       def __next_id
         __redis.incr("#{self.model_name.plural}_ids")
       end
 
       def __all_ids
-        __redis.keys("#{self.model_name.plural}:*").map { |id| id[/:(\d+)$/, 1].to_i }.sort
+        __redis.keys("#{self.model_name.plural}:*").map { |id| id[/:(.+)$/, 1] }.sort
       end
 
     end
 
     module InstanceMethods
       attr_accessor :id
+      attr_writer   :__loaded_families
 
       def initialize(attributes={})
-        __update_attributes self.class.property_defaults.merge(attributes)
+        # Store "loaded_families" based on passed attributes, for using when saving:
+        self.class.property_families.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|
+          key, value = item
+          sum[key] = value.class.respond_to?(:new) ? value.clone : value
+          sum
+        end
+
+        __update_attributes property_defaults.merge(attributes)
         self
-      end
-      alias :attributes= :initialize
+      end; alias :attributes= :initialize
 
       def update_attributes(attributes={})
         __update_attributes attributes
@@ -131,23 +267,44 @@ class Redis
         self
       end
 
+      # Returns a Hash of attributes for serialization, etc
+      #
       def attributes
         self.class.
           properties.
           inject({}) {|attributes, key| attributes[key] = send(key); attributes}
       end
 
-      def save
+      # Saves the record in the database, performing callbacks:
+      #
+      #     Article.new(title: 'Test').save
+      #
+      # Optionally accepts which families to save:
+      #
+      #     article = Article.find(1, families: 'counters')
+      #     article.views += 1
+      #     article.save(families: ['counters', 'meta'])
+      #
+      # You can also save all families:
+      #
+      #     Article.find(1, families: 'all').update_attributes(title: 'Changed').save(families: 'all')
+      #
+      # Be careful not to overwrite properties with default values.
+      #
+      def save(options={})
         run_callbacks :save do
           self.id ||= self.class.__next_id
-          params    = self.class.property_families.keys.map do |family|
-                        [family.to_s, self.to_json(:only => self.class.property_families[family])]
+          families  = options[:families] == 'all' ? self.class.property_families.keys : self.__loaded_families
+          params    = families.map do |family|
+                        [family.to_s, self.to_json(:only => self.class.property_families[family.to_sym])]
                       end.flatten
           __redis.hmset "#{self.class.model_name.plural}:#{self.id}", *params
         end
         self
       end
 
+      # Removes the record from the database, performing callbacks.
+      #
       def destroy
         run_callbacks :destroy do
           __redis.del "#{self.class.model_name.plural}:#{self.id}"
@@ -155,6 +312,8 @@ class Redis
         self.freeze
       end
 
+      # Returns whether record is saved into database
+      #
       def persisted?
         __redis.exists "#{self.class.model_name.plural}:#{self.id}"
       end
@@ -163,25 +322,39 @@ class Redis
         "#<#{self.class}: #{attributes}>"
       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.
+      #
       def __update_attributes(attributes)
         attributes.each do |name, value|
           case
+          # Should we cast the value ...
           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?
             else
               send "#{name}=", klass.new(value)
             end
+          # Should we return augmented Hash?
           when value.is_a?(Hash)
             send "#{name}=", Hashr.new(value)
           else
-            # Automatically convert <http://en.wikipedia.org/wiki/ISO8601> formatted strings to Time
+            # 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
         end
       end
 
+      # Returns which families were loaded in the record lifecycle
+      #
+      def __loaded_families
+        @__loaded_families ||= [DEFAULT_FAMILY.to_s]
+      end
+
     end
 
   end

data/lib/redis/persistence/railtie.rb

@@ -0,0 +1,17 @@
+module RedisPersistence
+  class Railtie < Rails::Railtie
+
+    initializer "warn when configuration is missing" do
+      config.after_initialize do
+        unless ::Redis::Persistence.config.redis
+          puts "\n[ERROR!] Redis::Persistence is not configured!", '='*80,
+               "Please point `Redis::Persistence.config.redis` to a Redis instance, ",
+               "if you actually intend to save some data :)\n\n",
+               "You can create an initializer with:\n\n",
+               "    $ rails generate redis_persistence:initializer\n\n", '-'*80, "\n"
+        end
+      end
+    end
+
+  end
+end

data/lib/redis/persistence/version.rb

@@ -1,5 +1,5 @@
 class Redis
   module Persistence
-    VERSION = "0.0.1"
+    VERSION = "0.0.2"
   end
 end

data/test/models.rb

@@ -103,4 +103,20 @@ end
 class ModelWithCastingInFamily
   include Redis::Persistence
   property :pieces, :class => [Piece], :default => [], :family => 'meta'
+  property :parts,  :class => [Piece], :default => [], :family => 'meta'
+end
+
+class ModelWithDefaultArray
+  include Redis::Persistence
+
+  property :accounts, :default => []
+  property :options,  :default => { :switches => []}
+  property :deep,     :default => { :one => { :two => { :three => [] } } }
+end
+
+class ModelWithDefaultsInFamilies
+  include Redis::Persistence
+
+  property :name
+  property :tags, :default => [], :family => 'tags'
 end

data/test/redis_persistence_test.rb

@@ -8,14 +8,40 @@ class RedisPersistenceTest < ActiveSupport::TestCase
     Redis::Persistence.config.redis
   end
 
-  context "Redis Connection" do
-  
+  context "Configuration" do
+
+    should "be configurable" do
+      assert_respond_to Redis::Persistence, :config
+      assert_nothing_raised do
+        Redis::Persistence.config.foo = 'bar'
+        assert_equal 'bar', Redis::Persistence.config.foo
+      end
+    end
+
+    should "be configurable with a block" do
+      assert_respond_to Redis::Persistence, :configure
+      assert_nothing_raised do
+        Redis::Persistence.configure { |config| config.foo = 'bar' }
+        assert_equal 'bar', Redis::Persistence.config.foo
+      end
+    end
+
+  end
+
+  context "Redis" do
+    teardown { Redis::Persistence.config.redis = Redis.new db: ENV['REDIS_PERSISTENCE_TEST_DATABASE'] || 14 }
+
     should "be set" do
       assert_nothing_raised { in_redis.info }
     end
-  
+
+    should_eventually "raise error when trying to access it when not configured" do
+      Redis::Persistence.config.redis = nil
+      assert_raise(Redis::Persistence::RedisNotAvailable) { Redis::Persistence.config.redis }
+    end
+
   end
-  
+
   context "Defining properties" do
 
     should "define accessors from attributes" do
@@ -108,12 +134,12 @@ class RedisPersistenceTest < ActiveSupport::TestCase
 
   context "Defining properties in families" do
 
-    should "store properties in the 'data' family by default" do
+    should "store properties in the 'default' family by default" do
       m = ModelWithFamily.new name: 'One'
       m.save
 
       assert in_redis.exists('model_with_families:1'), in_redis.keys.to_s
-      assert in_redis.hkeys('model_with_families:1').include?('data')
+      assert in_redis.hkeys('model_with_families:1').include?('default')
     end
 
     should "store properties in the correct family" do
@@ -122,7 +148,7 @@ class RedisPersistenceTest < ActiveSupport::TestCase
 
       assert_equal 1, m.id
       assert in_redis.exists('model_with_families:1'), in_redis.keys.to_s
-      assert in_redis.hkeys('model_with_families:1').include?('data'),     in_redis.hkeys('model_with_families:1').to_s
+      assert in_redis.hkeys('model_with_families:1').include?('default'),  in_redis.hkeys('model_with_families:1').to_s
       assert in_redis.hkeys('model_with_families:1').include?('counters'), in_redis.hkeys('model_with_families:1').to_s
 
       m = ModelWithFamily.find(1)
@@ -144,13 +170,43 @@ class RedisPersistenceTest < ActiveSupport::TestCase
 
       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_not_nil   m.pieces.first
       assert_equal 42, m.pieces.first.level
     end
 
+    should "store loaded families on initialization" do
+      m = ModelWithCastingInFamily.new pieces: [ { name: 'One', level: 42 } ]
+      assert_equal ['default', 'meta'], m.__loaded_families
+
+      m = ModelWithCastingInFamily.new
+      assert_equal ['default'], m.__loaded_families
+    end
+
+    should "store loaded families on find" do
+      ModelWithCastingInFamily.create pieces: [ { name: 'One', level: 42 } ]
+      m = ModelWithCastingInFamily.find(1)
+      assert_equal ['default'], m.__loaded_families
+
+      ModelWithCastingInFamily.create pieces: [ { name: 'One', level: 42 } ]
+      m = ModelWithCastingInFamily.find(1, families: 'meta')
+      assert_equal ['default', 'meta'], m.__loaded_families
+    end
+
+    should "update loaded families on property assignment" do
+      m = ModelWithFamily.new name: 'Test'
+      assert_equal ['default'], m.__loaded_families
+      assert_equal 'Test', m.name
+
+      m.views = 100
+      assert_equal ['default', 'counters'], m.__loaded_families
+      assert_equal 100, m.views
+    end
+
   end
 
   context "Class" do
@@ -205,6 +261,20 @@ class RedisPersistenceTest < ActiveSupport::TestCase
       assert_match /touched/, PersistentArticle.find(1).title
     end
 
+    should "load all families" do
+      ModelWithFamily.create name: 'One', views: 10, lang: 'en'
+
+      m = ModelWithFamily.find(1)
+      assert_equal 1, m.__loaded_families.size
+      assert_nil m.views
+
+      m = ModelWithFamily.find(1, families: 'all')
+      assert_equal 3, m.__loaded_families.size
+      assert_equal 'One', m.name
+      assert_equal 10,    m.views
+      assert_equal 'en',  m.lang
+    end
+
   end
 
   context "Instance" do
@@ -224,24 +294,57 @@ class RedisPersistenceTest < ActiveSupport::TestCase
     end
 
     should "be saved and found in Redis" do
-      article = PersistentArticle.new id: 1, title: 'One'
+      article = PersistentArticle.new title: 'One'
       assert article.save
       assert in_redis.exists("persistent_articles:1")
 
-      assert PersistentArticle.find(1)
+      assert_equal 1, PersistentArticle.all.size
+      assert_not_nil  PersistentArticle.find(1)
       assert in_redis.keys.size > 0, 'Key not saved into Redis?'
       assert_equal 'One', PersistentArticle.find(1).title
     end
 
     should "be deleted from Redis" do
-      article = PersistentArticle.new id: 1, title: 'One'
+      article = PersistentArticle.new title: 'One'
       assert article.save
+      keys_count = in_redis.keys.size
+
       assert_not_nil PersistentArticle.find(1)
-      assert in_redis.keys.size > 0, 'Key not saved into Redis?'
+      assert keys_count > 0, 'Key not saved into Redis?'
 
       article.destroy
       assert_nil PersistentArticle.find(1)
-      assert_equal 0, in_redis.keys.size, 'Key not removed from Redis?'
+      assert in_redis.keys.size < keys_count, 'Key not removed from Redis?'
+    end
+
+    should "be saved, found and deleted with an arbitrary ID" do
+      article = PersistentArticle.new id: 'abc123', title: 'Special'
+      assert article.save
+      keys_count = in_redis.keys.size
+
+      assert_equal 1, PersistentArticle.all.size
+      assert_not_nil  PersistentArticle.find('abc123')
+
+      assert keys_count > 0, 'Key not saved into Redis?'
+      assert_equal 'Special', PersistentArticle.find('abc123').title
+
+      assert article.destroy
+      assert_equal 0, PersistentArticle.all.size
+      assert_nil      PersistentArticle.find('abc123')
+      assert in_redis.keys.size < keys_count, 'Key not removed from Redis?'
+    end
+
+    should "save all families" do
+      m = ModelWithFamily.new name: 'Test'
+      assert m.save
+      assert_equal 1, in_redis.hkeys("model_with_families:1").size
+
+      m = ModelWithFamily.new name: 'Test'
+      assert m.save(families: 'all')
+      assert in_redis.keys.size > 0, 'Key not saved into Redis?'
+
+      # ["default", "counters", "meta"]
+      assert_equal 3, in_redis.hkeys("model_with_families:2").size
     end
 
     should "update attributes" do
@@ -288,6 +391,63 @@ class RedisPersistenceTest < ActiveSupport::TestCase
       assert_equal 1, m.errors.to_a.size
     end
 
+    should "not change default value when assigning property" do
+      m = ModelWithDefaultArray.new
+
+      m.accounts                 << "account_1"
+      m.options[:switches]       << "switch_1"
+      m.deep[:one][:two][:three] << 'foo'
+      m.deep.one.two.three       << 'four'
+
+      assert_equal [], ModelWithDefaultArray.new.accounts
+      assert_equal [], ModelWithDefaultArray.new.options[:switches]
+      assert_equal [], ModelWithDefaultArray.new.deep[:one][:two][:three]
+      assert_equal [], ModelWithDefaultArray.new.deep.one.two.three
+
+      assert_equal [], ModelWithDefaultArray.property_defaults[:accounts]
+      assert_equal [], ModelWithDefaultArray.property_defaults[:options][:switches]
+      assert_equal [], ModelWithDefaultArray.property_defaults[:deep][:one][:two][:three]
+    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
+
+      # Return defaults
+      m = ModelWithDefaultsInFamilies.find(1, families: 'tags')
+      assert_equal [], m.tags
+
+      # Add tag
+      m = ModelWithDefaultsInFamilies.find(1, families: 'tags')
+      m.tags << 'foo'
+      m.save
+
+      # Return data
+      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.save
+
+      # Return defaults
+      m = ModelWithDefaultsInFamilies.find(1)
+      assert_equal [], m.tags
+
+      # Return data
+      m = ModelWithDefaultsInFamilies.find(1, :families => 'tags')
+      assert_equal ['foo'], m.tags
+    end
+
   end
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redis-persistence
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -10,11 +10,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-11-10 00:00:00.000000000 Z
+date: 2011-11-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
-  requirement: &70276358101260 !ruby/object:Gem::Requirement
+  requirement: &70111331651120 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -22,10 +22,10 @@ dependencies:
         version: '3.0'
   type: :runtime
   prerelease: false
-  version_requirements: *70276358101260
+  version_requirements: *70111331651120
 - !ruby/object:Gem::Dependency
   name: multi_json
-  requirement: &70276358100760 !ruby/object:Gem::Requirement
+  requirement: &70111331650560 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -33,10 +33,10 @@ dependencies:
         version: '1.0'
   type: :runtime
   prerelease: false
-  version_requirements: *70276358100760
+  version_requirements: *70111331650560
 - !ruby/object:Gem::Dependency
   name: redis
-  requirement: &70276358100300 !ruby/object:Gem::Requirement
+  requirement: &70111331650040 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -44,10 +44,10 @@ dependencies:
         version: 2.2.2
   type: :runtime
   prerelease: false
-  version_requirements: *70276358100300
+  version_requirements: *70111331650040
 - !ruby/object:Gem::Dependency
   name: hashr
-  requirement: &70276358099840 !ruby/object:Gem::Requirement
+  requirement: &70111331649460 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -55,10 +55,10 @@ dependencies:
         version: 0.0.16
   type: :runtime
   prerelease: false
-  version_requirements: *70276358099840
+  version_requirements: *70111331649460
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &70276358099380 !ruby/object:Gem::Requirement
+  requirement: &70111331648800 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -66,10 +66,10 @@ dependencies:
         version: '1.0'
   type: :development
   prerelease: false
-  version_requirements: *70276358099380
+  version_requirements: *70111331648800
 - !ruby/object:Gem::Dependency
   name: yajl-ruby
-  requirement: &70276358098920 !ruby/object:Gem::Requirement
+  requirement: &70111331647980 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -77,10 +77,10 @@ dependencies:
         version: 0.8.0
   type: :development
   prerelease: false
-  version_requirements: *70276358098920
+  version_requirements: *70111331647980
 - !ruby/object:Gem::Dependency
   name: shoulda
-  requirement: &70276358098540 !ruby/object:Gem::Requirement
+  requirement: &70111331647400 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -88,10 +88,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70276358098540
+  version_requirements: *70111331647400
 - !ruby/object:Gem::Dependency
   name: mocha
-  requirement: &70276352583600 !ruby/object:Gem::Requirement
+  requirement: &70111331646780 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -99,10 +99,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70276352583600
+  version_requirements: *70111331646780
 - !ruby/object:Gem::Dependency
   name: turn
-  requirement: &70276352974040 !ruby/object:Gem::Requirement
+  requirement: &70111331645860 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -110,7 +110,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70276352974040
+  version_requirements: *70111331645860
 description: Simple ActiveModel-compatible persistence layer in Redis
 email:
 - karmi@karmi.cz
@@ -126,7 +126,14 @@ files:
 - examples/article.rb
 - examples/benchmark.rb
 - examples/rails-template.rb
+- lib/rails/generators/redis_persistence/initializer/initializer_generator.rb
+- lib/rails/generators/redis_persistence/initializer/templates/initializer.rb.tt
+- lib/rails/generators/redis_persistence/model/model_generator.rb
+- lib/rails/generators/redis_persistence/model/templates/model.rb.tt
+- lib/rails/generators/redis_persistence_generator.rb
+- lib/redis-persistence.rb
 - lib/redis/persistence.rb
+- lib/redis/persistence/railtie.rb
 - lib/redis/persistence/version.rb
 - redis-persistence.gemspec
 - test/_helper.rb