redis_orm 0.6.2 → 0.7

data/CHANGELOG

@@ -1,10 +1,18 @@
-v0.6.2 [23-05-2011]
-* adds an ability to specify indices on *has_one* assoc
-* adds an ability to create indices on belongs_to association
-* fixed error with updating indices in :belongs_to assoc with :as option; 
-* tests refactoring, now all tests are run with Rake::TestTask, 
-* moved all classes and modules from test cases to special folders
-* fixed bug: :default values should be properly transformed to right classes (if :default values are wrong) so when comparing them to other/stored instances they'll be the same
+v0.7 [03-05-2013]
+FEATURES
+* implemented Array and Hash properties types
+* added ability to specify an *expire* value for the record via method of the class and added inline *expire_in* key that can be used while saving objects (referencial keys in expireable record also expireables)
+* Add model generator [Tatsuya Sato]
+BUGS
+* fixed a bug with Date property implementation
+* refactored *save* method
+
+v0.6.2 [23-05-2012]
+* adds an ability to specify/create indices on *has_one* and *belongs_to* associations
+* fixed error with updating indices in *belongs_to* association with :as option 
+* tests refactoring, now all tests are run with Rake::TestTask 
+* moved all classes and modules from test cases to special folders (test/classes, test/modules)
+* fixed bug: :default values should be properly transformed to the right classes (if :default values are wrong) so when comparing them to other/stored instances they'll be the same
 
 v0.6.1 [05-12-2011]
 * rewritten sortable functionality for attributes which values are strings

data/Gemfile

@@ -1,8 +1,10 @@
 source 'http://rubygems.org'
 
-gem 'activemodel', '>= 3.0.0'
-gem 'activesupport', '>= 3.0.0'
-gem 'redis', '>= 2.2.0'
-gem 'uuid', '>= 2.3.2'
+gemspec
 
-gem 'rspec', '>= 2.5.0'
+group :test do
+  gem 'rspec', '>= 2.5.0'
+  #gem 'linecache19', :git => 'git://github.com/mark-moseley/linecache'
+  #gem 'ruby-debug-base19x', '~> 0.11.30.pre4'
+  #gem 'ruby-debug19'
+end

data/Manifest

@@ -6,6 +6,8 @@ README.md
 Rakefile
 TODO
 benchmarks/sortable_benchmark.rb
+lib/rails/generators/redis_orm/model/model_generator.rb
+lib/rails/generators/redis_orm/model/templates/model.rb.erb
 lib/redis_orm.rb
 lib/redis_orm/active_model_behavior.rb
 lib/redis_orm/associations/belongs_to.rb
@@ -16,6 +18,8 @@ lib/redis_orm/associations/has_one.rb
 lib/redis_orm/redis_orm.rb
 lib/redis_orm/utils.rb
 redis_orm.gemspec
+spec/generators/model_generator_spec.rb
+spec/spec_helper.rb
 test/association_indices_test.rb
 test/associations_test.rb
 test/atomicity_test.rb
@@ -24,6 +28,7 @@ test/callbacks_test.rb
 test/changes_array_test.rb
 test/classes/album.rb
 test/classes/article.rb
+test/classes/article_with_comments.rb
 test/classes/book.rb
 test/classes/catalog_item.rb
 test/classes/category.rb
@@ -36,6 +41,8 @@ test/classes/cutout_aggregator.rb
 test/classes/default_user.rb
 test/classes/dynamic_finder_user.rb
 test/classes/empty_person.rb
+test/classes/expire_user.rb
+test/classes/expire_user_with_predicate.rb
 test/classes/giftcard.rb
 test/classes/jigsaw.rb
 test/classes/location.rb
@@ -53,6 +60,7 @@ test/classes/uuid_timestamp.rb
 test/classes/uuid_user.rb
 test/dynamic_finders_test.rb
 test/exceptions_test.rb
+test/expire_records_test.rb
 test/has_one_has_many_test.rb
 test/indices_test.rb
 test/modules/belongs_to_model_within_module.rb

data/README.md

@@ -82,8 +82,11 @@ Supported property types:
 *  **RedisOrm::Boolean**
     there is no Boolean class in Ruby so it's a special class to store TrueClass or FalseClass objects
 
-*  **Time**
+*  **Time** or **DateTime**
 
+*  **Array** or **Hash**
+  RedisOrm automatically will handle serializing/deserializing arrays and hashes into strings using Marshal class 
+  
 Following options are available in property declaration:
 
 *  **:default**
@@ -96,6 +99,31 @@ Following options are available in property declaration:
 
 *Note* that when you're using :sortable option redis_orm maintains one additional list per attribute. Also note that the #create method could be 3 times slower in some cases (this will be improved in future releases), while the #find performance is basically the same (see the "benchmarks/sortable_benchmark.rb").
 
+## Expiring record after certain period of time
+
+You could expire record stored in Redis by specifying TTL in seconds invoking *expire* method of the class like this:
+
+```ruby
+class PhantomUser < RedisOrm::Base
+  property :name, String
+  property :persist, RedisOrm::Boolean, :default => true
+
+  expire 15.minutes.from_now
+end
+```
+
+Also you could specify a condition when *expire* would be set on record's key:
+
+```ruby
+  expire 15.minutes.from_now, :if => Proc.new {|r| !r.persist?}
+```
+
+Also you could override class method *expire* by using *expire_in* key when saving object:
+
+```ruby
+ExpireUser.create :name => "Ghost record", :expire_in => 50.minutes.from_now
+```
+
 ## Searching records by the value
 
 Usually it's done via declaring an index and using *:conditions* hash or dynamic finders. For example:
@@ -540,6 +568,10 @@ end
 
 To run all tests just invoke *rake test*
 
+## Contributors
+
+[Tatsuya Sato](https://github.com/satoryu)
+
 Copyright © 2011 Dmitrii Samoilov, released under the MIT license
 
 Permission is hereby granted, free of charge, to any person obtaining a copy

data/Rakefile

@@ -1,11 +1,11 @@
-require 'rubygems'
+#require 'rubygems'
 require 'rake'
 require 'rake/testtask'
 
 #=begin
 require 'echoe'
 
-Echoe.new('redis_orm', '0.6.2') do |p|
+Echoe.new('redis_orm', '0.7') do |p|
   p.description    = "ORM for Redis (advanced key-value storage) with ActiveRecord API"
   p.url            = "https://github.com/german/redis_orm"
   p.author         = "Dmitrii Samoilov"
@@ -20,6 +20,6 @@ task :default => :test
 desc 'Test the redis_orm functionality'
 Rake::TestTask.new(:test) do |t|
   t.libs << 'lib'
-  t.test_files = FileList['test/*_test.rb']
+  t.test_files = FileList['test/**/*_test.rb', 'spec/**/*_spec.rb']
   t.verbose = true
 end

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

@@ -0,0 +1,21 @@
+require 'rails/generators'
+require 'rails/generators/named_base'
+
+module RedisOrm
+  module Generators
+    class ModelGenerator < ::Rails::Generators::NamedBase
+      source_root File.expand_path('../templates', __FILE__)
+
+      desc "Creates a RedisOrm model"
+      argument :attributes, type: :array, default: [], banner: "field:type field:type"
+
+      check_class_collision
+
+      def create_model_file
+        template "model.rb.erb", File.join('app/models', class_path, "#{file_name}.rb")
+      end
+
+      hook_for :test_framework
+    end
+  end
+end

data/lib/rails/generators/redis_orm/model/templates/model.rb.erb

@@ -0,0 +1,5 @@
+class <%= class_name %> < RedisOrm::Base
+<% attributes.each do |attr| %>
+  property :<%= attr.name %>, <%= attr.type.to_s.camelcase %>
+<% end -%>
+end

data/lib/redis_orm/associations/has_many.rb

@@ -7,7 +7,7 @@ module RedisOrm
       def has_many(foreign_models, options = {})
         class_associations = class_variable_get(:"@@associations")
         class_associations[model_name] << {:type => :has_many, :foreign_models => foreign_models, :options => options}
-
+        
         foreign_models_name = options[:as] ? options[:as].to_sym : foreign_models.to_sym
 
         define_method foreign_models_name.to_sym do
@@ -41,8 +41,10 @@ module RedisOrm
 
           records.to_a.each do |record|
             # we use here *foreign_models_name* not *record.model_name.pluralize* because of the :as option
-            $redis.zadd("#{model_name}:#{id}:#{foreign_models_name}", Time.now.to_f, record.id)
-
+            key = "#{model_name}:#{id}:#{foreign_models_name}"
+            $redis.zadd(key, Time.now.to_f, record.id)
+            set_expire_on_reference_key(key)
+            
             record.get_indices.each do |index|
               save_index_for_associated_record(index, record, [model_name, id, record.model_name.pluralize]) # record.model_name.pluralize => foreign_models_name
             end
@@ -54,17 +56,20 @@ module RedisOrm
               assoc_foreign_models_name = assoc[:options][:as] ? assoc[:options][:as] : model_name.pluralize
               key = "#{record.model_name}:#{record.id}:#{assoc_foreign_models_name}"
               $redis.zadd(key, Time.now.to_f, id) if !$redis.zrank(key, id)
+              set_expire_on_reference_key(key)
             end
               
             # check whether *record* object has *has_one* declaration and it states *self.model_name*
             if assoc = record.get_associations.detect{|h| [:has_one, :belongs_to].include?(h[:type]) && h[:foreign_model] == model_name.to_sym}
               foreign_model_name = assoc[:options][:as] ? assoc[:options][:as] : model_name
+              key = "#{record.model_name}:#{record.id}:#{foreign_model_name}"
               # overwrite assoc anyway so we don't need to check record.send(model_name.to_sym).nil? here
-              $redis.set("#{record.model_name}:#{record.id}:#{foreign_model_name}", id)
+              $redis.set(key, id)              
+              set_expire_on_reference_key(key)
             end
           end
         end
       end
     end
   end
-end
+end

data/lib/redis_orm/associations/has_many_helper.rb

@@ -1,7 +1,7 @@
 module RedisOrm
   module Associations
     module HasManyHelper
-      private
+      private  
       def save_index_for_associated_record(index, record, inception)
         prepared_index = if index[:name].is_a?(Array) # TODO sort alphabetically
           index[:name].inject(inception) do |sum, index_part|

data/lib/redis_orm/associations/has_many_proxy.rb

@@ -3,15 +3,19 @@ module RedisOrm
     class HasManyProxy
       include HasManyHelper
       
-      def initialize(reciever_model_name, reciever_id, foreign_models, options)
+      def initialize(receiver_model_name, reciever_id, foreign_models, options)
         @records = [] #records.to_a
-        @reciever_model_name = reciever_model_name
+        @reciever_model_name = receiver_model_name
         @reciever_id = reciever_id
         @foreign_models = foreign_models
         @options = options
         @fetched = false
       end
 
+      def receiver_instance
+        @receiver_instance ||= @reciever_model_name.camelize.constantize.find(@reciever_id)
+      end
+      
       def fetch
         @records = @foreign_models.to_s.singularize.camelize.constantize.find($redis.zrevrangebyscore __key__, Time.now.to_f, 0)
         @fetched = true
@@ -31,8 +35,10 @@ module RedisOrm
       # user.avatars << Avatar.find(23) => user:1:avatars => [23]
       def <<(new_records)
         new_records.to_a.each do |record|
-          $redis.zadd(__key__, Time.now.to_f, record.id)          
-
+          $redis.zadd(__key__, Time.now.to_f, record.id)
+          
+          receiver_instance.set_expire_on_reference_key(__key__)
+          
           record.get_indices.each do |index|
             save_index_for_associated_record(index, record, [@reciever_model_name, @reciever_id, record.model_name.pluralize]) # record.model_name.pluralize => @foreign_models
           end
@@ -50,8 +56,11 @@ module RedisOrm
                 @reciever_model_name.pluralize
               end
 
-              if !$redis.zrank("#{record.model_name}:#{record.id}:#{pluralized_reciever_model_name}", @reciever_id)
-                $redis.zadd("#{record.model_name}:#{record.id}:#{pluralized_reciever_model_name}", Time.now.to_f, @reciever_id)
+              reference_key = "#{record.model_name}:#{record.id}:#{pluralized_reciever_model_name}"
+              
+              if !$redis.zrank(reference_key, @reciever_id)
+                $redis.zadd(reference_key, Time.now.to_f, @reciever_id)
+                receiver_instance.set_expire_on_reference_key(reference_key)
               end
             # check whether *record* object has *has_one* declaration and TODO it states *self.model_name* and there is no record yet from the *record*'s side (in order not to provoke recursion)
             elsif has_one_assoc = record_associations.detect{|h| [:has_one, :belongs_to].include?(h[:type]) && h[:foreign_model] == @reciever_model_name.to_sym}
@@ -61,7 +70,9 @@ module RedisOrm
                 @reciever_model_name
               end
               if record.send(reciever_model_name).nil?
-                $redis.set("#{record.model_name}:#{record.id}:#{reciever_model_name}", @reciever_id)
+                key = "#{record.model_name}:#{record.id}:#{reciever_model_name}"
+                $redis.set(key, @reciever_id)
+                receiver_instance.set_expire_on_reference_key(key)
               end
             end
           end

data/lib/redis_orm/associations/has_one.rb

@@ -29,10 +29,12 @@ module RedisOrm
           # we need to store this to clear old associations later
           old_assoc = self.send(foreign_model_name)
 
+          reference_key = "#{model_name}:#{id}:#{foreign_model_name}"
           if assoc_with_record.nil?
-            $redis.del("#{model_name}:#{id}:#{foreign_model_name}")
+            $redis.del(reference_key)
           elsif assoc_with_record.model_name == foreign_model.to_s
-            $redis.set("#{model_name}:#{id}:#{foreign_model_name}", assoc_with_record.id)
+            $redis.set(reference_key, assoc_with_record.id)
+            set_expire_on_reference_key(reference_key)
           else
             raise TypeMismatchError
           end

data/lib/redis_orm/redis_orm.rb

@@ -5,6 +5,14 @@ require 'active_support/inflector/transliterate'
 require 'active_support/inflector/methods'
 require 'active_support/inflections'
 require 'active_support/core_ext/string/inflections'
+
+require 'active_support/core_ext/time/acts_like'
+require 'active_support/core_ext/time/calculations'
+require 'active_support/core_ext/time/conversions'
+require 'active_support/core_ext/time/marshal'
+require 'active_support/core_ext/time/zones'
+
+require 'active_support/core_ext/numeric'
 require 'active_support/core_ext/time/calculations' # local_time for to_time(:local)
 require 'active_support/core_ext/string/conversions' # to_time
 
@@ -47,7 +55,8 @@ module RedisOrm
     @@callbacks = Hash.new{|h,k| h[k] = {}}
     @@use_uuid_as_id = {}
     @@descendants = []
-    
+    @@expire = Hash.new{|h,k| h[k] = {}}
+        
     class << self
 
       def inherited(from)
@@ -76,21 +85,18 @@ module RedisOrm
           value = instance_variable_get(:"@#{property_name}")
 
           return nil if value.nil? # we must return nil here so :default option will work when saving, otherwise it'll return "" or 0 or 0.0
-
-          if Time == class_name
-            value = begin
-              value.to_s.to_time(:local)
-            rescue ArgumentError => e
-              nil
-            end
+          if /DateTime|Time/ =~ class_name.to_s            
+            # we're using to_datetime here because to_time doesn't manage timezone correctly
+            value.to_s.to_datetime rescue nil
           elsif Integer == class_name
-            value = value.to_i
+            value.to_i
           elsif Float == class_name
-            value = value.to_f
+            value.to_f
           elsif RedisOrm::Boolean == class_name
-            value = ((value == "false" || value == false) ? false : true)
+            ((value == "false" || value == false) ? false : true)
+          else
+            value
           end
-          value
         end
     
         send(:define_method, "#{property_name}=".to_sym) do |value|
@@ -102,7 +108,6 @@ module RedisOrm
           else
             instance_variable_set(:"@#{property_name}_changes", [value])
           end
-
           instance_variable_set(:"@#{property_name}", value)
         end
   
@@ -127,6 +132,10 @@ module RedisOrm
         end
       end
       
+      def expire(seconds, options = {})
+        @@expire[model_name] = {:seconds => seconds, :options => options}
+      end
+
       def use_uuid_as_id
         @@use_uuid_as_id[model_name] = true
         @@uuid = UUID.new
@@ -251,7 +260,7 @@ module RedisOrm
           ids_key = prepared_index
           'asc'
         end
-
+        
         if order_by_property_is_string
           if direction.to_s == 'desc'
             ids_length = $redis.llen(ids_key)
@@ -367,6 +376,8 @@ module RedisOrm
             obj.send("#{k}=", v)
           end
         end
+        
+        $redis.expire(obj.__redis_record_key, options[:expire_in].to_i) if !options[:expire_in].blank?
 
         obj
       end      
@@ -422,7 +433,27 @@ module RedisOrm
     def to_a
       [self]
     end
-    
+ 
+    def __redis_record_key
+      "#{model_name}:#{id}"
+    end
+   
+    def set_expire_on_reference_key(key)
+      class_expire = @@expire[model_name]
+
+      # if class method *expire* was invoked and number of seconds was specified then set expiry date on the HSET record key
+      if class_expire[:seconds]
+        set_expire = true
+
+        if class_expire[:options][:if] && class_expire[:options][:if].class == Proc
+          # *self* here refers to the instance of class which has_one association
+          set_expire = class_expire[:options][:if][self]  # invoking specified *:if* Proc with current record as *self* 
+        end
+
+        $redis.expire(key, class_expire[:seconds].to_i) if set_expire
+      end
+    end
+   
     # is called from RedisOrm::Associations::HasMany to save backlinks to saved records
     def get_associations
       @@associations[self.model_name]
@@ -450,14 +481,18 @@ module RedisOrm
         end
       end
 
+      # cast all attributes' keys to symbols
+      attributes = attributes.inject({}){|sum, el| sum.merge({el[0].to_sym => el[1]})} if attributes.is_a?(Hash)
+
       # get all names of properties to assign only those attributes from attributes hash whose key are in prop_names 
       # we're not using *self.respond_to?("#{key}=".to_sym)* since *belongs_to* and other assocs could create their own methods 
       # with *key=* name, that in turn will mess up indices
-      prop_names = @@properties[model_name].collect{|m| m[:name]}
-      
       if attributes.is_a?(Hash) && !attributes.empty?        
-        attributes.each do |key, value|
-          self.send("#{key}=".to_sym, value) if prop_names.include?(key.to_sym)
+        @@properties[model_name].each do |property|
+          if !(value = attributes[property[:name]]).nil? # check for nil because we want to pass falses too (and value could be 'false')
+            value = Marshal.load(value) if ["Array", "Hash"].include?(property[:class]) && value.is_a?(String)
+            self.send("#{property[:name]}=".to_sym, value)
+          end
         end
       end
       self
@@ -502,104 +537,20 @@ module RedisOrm
       else
         $redis.incr("#{model_name}:id")
       end
-    end
+    end    
     
     def save
       return false if !valid?
 
-      # store here initial persisted flag so we could invoke :after_create callbacks in the end of the function
+      _check_mismatched_types_for_values
+      
+      # store here initial persisted flag so we could invoke :after_create callbacks in the end of *save* function
       was_persisted = persisted?
 
       if persisted? # then there might be old indices
-        # check whether there's old indices exists and if yes - delete them
-        @@properties[model_name].each do |prop|
-          # if there were no changes for current property skip it (indices remains the same)
-          next if ! self.send(:"#{prop[:name]}_changed?")
-          
-          prev_prop_value = instance_variable_get(:"@#{prop[:name]}_changes").first
-          prop_value = instance_variable_get(:"@#{prop[:name]}")
-          # TODO DRY in destroy also
-          if prop[:options][:sortable]
-            if prop[:class].eql?("String")
-              $redis.lrem "#{model_name}:#{prop[:name]}_ids", 1, "#{prev_prop_value}:#{@id}"
-              # remove id from every indexed property
-              @@indices[model_name].each do |index|
-                $redis.lrem "#{construct_prepared_index(index)}:#{prop[:name]}_ids", 1, "#{prop_value}:#{@id}"
-              end
-            else
-              $redis.zrem "#{model_name}:#{prop[:name]}_ids", @id
-              # remove id from every indexed property
-              @@indices[model_name].each do |index|
-                $redis.zrem "#{construct_prepared_index(index)}:#{prop[:name]}_ids", @id
-              end
-            end
-          end
-
-          indices = @@indices[model_name].inject([]) do |sum, models_index|
-            if models_index[:name].is_a?(Array)
-              if models_index[:name].include?(prop[:name])
-                sum << models_index
-              else
-                sum
-              end
-            else
-              if models_index[:name] == prop[:name]
-                sum << models_index
-              else
-                sum
-              end
-            end
-          end
-
-          if !indices.empty?
-            indices.each do |index|
-              if index[:name].is_a?(Array)
-                keys_to_delete = if index[:name].index(prop) == 0
-                  $redis.keys "#{model_name}:#{prop[:name]}#{prev_prop_value}*"
-                else
-                  $redis.keys "#{model_name}:*#{prop[:name]}:#{prev_prop_value}*"
-                end
-
-                keys_to_delete.each{|key| $redis.del(key)}
-              else
-                key_to_delete = "#{model_name}:#{prop[:name]}:#{prev_prop_value}"
-                $redis.del key_to_delete
-              end
-
-              # also we need to delete associated records *indices*
-              if !@@associations[model_name].empty?
-                @@associations[model_name].each do |assoc|
-                  if :belongs_to == assoc[:type]
-                    # if association has :as option use it, otherwise use standard :foreign_model
-                    foreign_model_name = assoc[:options][:as] ? assoc[:options][:as].to_sym : assoc[:foreign_model].to_sym
-                    if !self.send(foreign_model_name).nil?
-                      if index[:name].is_a?(Array)
-                        keys_to_delete = if index[:name].index(prop) == 0
-                          $redis.keys "#{assoc[:foreign_model]}:#{self.send(assoc[:foreign_model]).id}:#{model_name.to_s.pluralize}:#{prop[:name]}#{prev_prop_value}*"
-                        else
-                          $redis.keys "#{assoc[:foreign_model]}:#{self.send(assoc[:foreign_model]).id}:#{model_name.to_s.pluralize}:*#{prop[:name]}:#{prev_prop_value}*"
-                        end
-
-                        keys_to_delete.each{|key| $redis.del(key)}
-                      else
-                        beginning_of_the_key = "#{assoc[:foreign_model]}:#{self.send(assoc[:foreign_model]).id}:#{model_name.to_s.pluralize}:#{prop[:name]}:"
-
-                        $redis.del(beginning_of_the_key + prev_prop_value.to_s)
-
-                        index[:options][:unique] ? $redis.set((beginning_of_the_key + prop_value.to_s), @id) : $redis.zadd((beginning_of_the_key + prop_value.to_s), Time.now.to_f, @id)
-                      end
-                    end
-                  end
-                end
-              end # deleting associated records *indices*
-
-            end
-          end
-        end
+        _check_indices_for_persisted # remove old indices if needed
       else # !persisted?        
-        @@callbacks[model_name][:before_create].each do |callback|
-          self.send(callback)
-        end
+        @@callbacks[model_name][:before_create].each{ |callback| self.send(callback) }
  
         @id = get_next_id
         $redis.zadd "#{model_name}:ids", Time.now.to_f, @id
@@ -607,103 +558,21 @@ module RedisOrm
         self.created_at = Time.now if respond_to? :created_at
       end
 
-      @@callbacks[model_name][:before_save].each do |callback|
-        self.send(callback)
-      end
+      @@callbacks[model_name][:before_save].each{ |callback| self.send(callback) }
 
       # automatically update *modified_at* property if it was defined
       self.modified_at = Time.now if respond_to? :modified_at
 
-      @@properties[model_name].each do |prop|
-        prop_value = self.send(prop[:name].to_sym)
-        
-        if prop_value.nil? && !prop[:options][:default].nil?
-          prop_value = prop[:options][:default]
-
-          # cast prop_value to proper class if they are not in it
-          # for example 'property :wage, Float, :sortable => true, :default => 20_000' turn 20_000 to 20_000.0
-          if prop[:class] != prop_value.class.to_s
-            prop_value = case prop[:class]
-                         when 'Time'
-                           begin
-                             value.to_s.to_time(:local)
-                           rescue ArgumentError => e
-                             nil
-                           end
-                         when 'Integer'
-                           prop_value.to_i
-                         when 'Float'
-                           prop_value.to_f
-                         when 'RedisOrm::Boolean'
-                           (prop_value == "false" || prop_value == false) ? false : true
-                         end
-          end
+      _save_to_redis # main work done here
+      _save_new_indices
 
-          # set instance variable in order to properly save indexes here
-          self.instance_variable_set(:"@#{prop[:name]}", prop_value)
-          instance_variable_set :"@#{prop[:name]}_changes", [prop_value]
-        end
-
-        $redis.hset("#{model_name}:#{id}", prop[:name].to_s, prop_value)
-
-        # reducing @#{prop[:name]}_changes array to the last value
-        prop_changes = instance_variable_get :"@#{prop[:name]}_changes"
-
-        if prop_changes && prop_changes.size > 2
-          instance_variable_set :"@#{prop[:name]}_changes", [prop_changes.last]
-        end
-        
-        # if some property need to be sortable add id of the record to the appropriate sorted set
-        if prop[:options][:sortable]
-          property_value = instance_variable_get(:"@#{prop[:name]}").to_s
-          if prop[:class].eql?("String")
-            sortable_key = "#{model_name}:#{prop[:name]}_ids"
-            el_or_position_to_insert = find_position_to_insert(sortable_key, property_value)
-            el_or_position_to_insert == 0 ? $redis.lpush(sortable_key, "#{property_value}:#{@id}") : $redis.linsert(sortable_key, "AFTER", el_or_position_to_insert, "#{property_value}:#{@id}")
-            # add to every indexed property
-            @@indices[model_name].each do |index|
-              sortable_key = "#{construct_prepared_index(index)}:#{prop[:name]}_ids"
-              el_or_position_to_insert == 0 ? $redis.lpush(sortable_key, "#{property_value}:#{@id}") : $redis.linsert(sortable_key, "AFTER", el_or_position_to_insert, "#{property_value}:#{@id}")
-            end
-          else
-            score = case prop[:class]
-              when "Integer"; property_value.to_f
-              when "Float"; property_value.to_f
-              when "RedisOrm::Boolean"; (property_value == true ? 1.0 : 0.0)
-              when "Time"; property_value.to_f
-            end
-            $redis.zadd "#{model_name}:#{prop[:name]}_ids", score, @id
-            # add to every indexed property
-            @@indices[model_name].each do |index|
-              $redis.zadd "#{construct_prepared_index(index)}:#{prop[:name]}_ids", score, @id
-            end
-          end
-        end
-      end
-
-      # save new indices (not *reference* onces (for example not these *belongs_to :note, :index => true*)) in order to sort by finders
-      # city:name:Chicago => 1
-      @@indices[model_name].reject{|index| index[:options][:reference]}.each do |index|
-        prepared_index = construct_prepared_index(index) # instance method not class one!
-
-        if index[:options][:unique]
-          $redis.set(prepared_index, @id)
-        else
-          $redis.zadd(prepared_index, Time.now.to_f, @id)
-        end
-      end
-
-      @@callbacks[model_name][:after_save].each do |callback|
-        self.send(callback)
-      end
+      @@callbacks[model_name][:after_save].each{ |callback| self.send(callback) }
 
       if ! was_persisted
-        @@callbacks[model_name][:after_create].each do |callback|
-          self.send(callback)
-        end
+        @@callbacks[model_name][:after_create].each{ |callback| self.send(callback) }
       end
 
-      true # if there were no errors just return true, so *if* conditions would work
+      true # if there were no errors just return true, so *if obj.save* conditions would work
     end
 
     def find_position_to_insert(sortable_key, value)
@@ -875,7 +744,7 @@ module RedisOrm
 
       # remove all associated indices
       @@indices[model_name].each do |index|
-        prepared_index = construct_prepared_index(index) # instance method not class one!
+        prepared_index = _construct_prepared_index(index) # instance method not class one!
 
         if index[:options][:unique]
           $redis.del(prepared_index)
@@ -891,19 +760,208 @@ module RedisOrm
       true # if there were no errors just return true, so *if* conditions would work
     end
     
-    protected
-      def construct_prepared_index(index)
-        prepared_index = if index[:name].is_a?(Array) # TODO sort alphabetically
-          index[:name].inject([model_name]) do |sum, index_part|
-            sum += [index_part, self.instance_variable_get(:"@#{index_part}")]
-          end.join(':')          
-        else
-          [model_name, index[:name], self.instance_variable_get(:"@#{index[:name]}")].join(':')
+  protected
+    def _construct_prepared_index(index)
+      prepared_index = if index[:name].is_a?(Array) # TODO sort alphabetically
+        index[:name].inject([model_name]) do |sum, index_part|
+          sum += [index_part, self.instance_variable_get(:"@#{index_part}")]
+        end.join(':')          
+      else
+        [model_name, index[:name], self.instance_variable_get(:"@#{index[:name]}")].join(':')
+      end
+      
+      prepared_index.downcase! if index[:options][:case_insensitive]
+      
+      prepared_index
+    end
+
+    def _check_mismatched_types_for_values
+      # an exception should be raised before all saving procedures if wrong value type is specified (especcially true for Arrays and Hashes)
+      @@properties[model_name].each do |prop|
+        prop_value = self.send(prop[:name].to_sym)
+        
+        if prop_value && prop[:class] != prop_value.class.to_s && ['Array', 'Hash'].include?(prop[:class].to_s)
+          raise TypeMismatchError 
         end
+      end
+    end
+    
+    def _check_indices_for_persisted
+      # check whether there's old indices exists and if yes - delete them
+      @@properties[model_name].each do |prop|
+        # if there were no changes for current property skip it (indices remains the same)
+        next if ! self.send(:"#{prop[:name]}_changed?")
         
-        prepared_index.downcase! if index[:options][:case_insensitive]
+        prev_prop_value = instance_variable_get(:"@#{prop[:name]}_changes").first
+        prop_value = instance_variable_get(:"@#{prop[:name]}")
+        # TODO DRY in destroy also
+        if prop[:options][:sortable]
+          if prop[:class].eql?("String")
+            $redis.lrem "#{model_name}:#{prop[:name]}_ids", 1, "#{prev_prop_value}:#{@id}"
+            # remove id from every indexed property
+            @@indices[model_name].each do |index|
+              $redis.lrem "#{_construct_prepared_index(index)}:#{prop[:name]}_ids", 1, "#{prop_value}:#{@id}"
+            end
+          else
+            $redis.zrem "#{model_name}:#{prop[:name]}_ids", @id
+            # remove id from every indexed property
+            @@indices[model_name].each do |index|
+              $redis.zrem "#{_construct_prepared_index(index)}:#{prop[:name]}_ids", @id
+            end
+          end
+        end
+
+        indices = @@indices[model_name].inject([]) do |sum, models_index|
+          if models_index[:name].is_a?(Array)
+            if models_index[:name].include?(prop[:name])
+              sum << models_index
+            else
+              sum
+            end
+          else
+            if models_index[:name] == prop[:name]
+              sum << models_index
+            else
+              sum
+            end
+          end
+        end
+
+        if !indices.empty?
+          indices.each do |index|
+            if index[:name].is_a?(Array)
+              keys_to_delete = if index[:name].index(prop) == 0
+                $redis.keys "#{model_name}:#{prop[:name]}#{prev_prop_value}*"
+              else
+                $redis.keys "#{model_name}:*#{prop[:name]}:#{prev_prop_value}*"
+              end
+
+              keys_to_delete.each{|key| $redis.del(key)}
+            else
+              key_to_delete = "#{model_name}:#{prop[:name]}:#{prev_prop_value}"
+              $redis.del key_to_delete
+            end
+
+            # also we need to delete associated records *indices*
+            if !@@associations[model_name].empty?
+              @@associations[model_name].each do |assoc|
+                if :belongs_to == assoc[:type]
+                  # if association has :as option use it, otherwise use standard :foreign_model
+                  foreign_model_name = assoc[:options][:as] ? assoc[:options][:as].to_sym : assoc[:foreign_model].to_sym
+                  if !self.send(foreign_model_name).nil?
+                    if index[:name].is_a?(Array)
+                      keys_to_delete = if index[:name].index(prop) == 0
+                        $redis.keys "#{assoc[:foreign_model]}:#{self.send(assoc[:foreign_model]).id}:#{model_name.to_s.pluralize}:#{prop[:name]}#{prev_prop_value}*"
+                      else
+                        $redis.keys "#{assoc[:foreign_model]}:#{self.send(assoc[:foreign_model]).id}:#{model_name.to_s.pluralize}:*#{prop[:name]}:#{prev_prop_value}*"
+                      end
+
+                      keys_to_delete.each{|key| $redis.del(key)}
+                    else
+                      beginning_of_the_key = "#{assoc[:foreign_model]}:#{self.send(assoc[:foreign_model]).id}:#{model_name.to_s.pluralize}:#{prop[:name]}:"
+
+                      $redis.del(beginning_of_the_key + prev_prop_value.to_s)
+
+                      index[:options][:unique] ? $redis.set((beginning_of_the_key + prop_value.to_s), @id) : $redis.zadd((beginning_of_the_key + prop_value.to_s), Time.now.to_f, @id)
+                    end
+                  end
+                end
+              end
+            end # deleting associated records *indices*
+          end
+        end
+      end
+    end
+      
+    def _save_to_redis
+      @@properties[model_name].each do |prop|
+        prop_value = self.send(prop[:name].to_sym)
         
-        prepared_index
+        if prop_value.nil? && !prop[:options][:default].nil?
+          prop_value = prop[:options][:default]
+
+          # cast prop_value to proper class if they are not in it
+          # for example 'property :wage, Float, :sortable => true, :default => 20_000' turn 20_000 to 20_000.0
+          if prop[:class] != prop_value.class.to_s
+            prop_value = case prop[:class]
+                         when 'Time'
+                           begin
+                             value.to_s.to_time(:local)
+                           rescue ArgumentError => e
+                             nil
+                           end
+                         when 'Integer'
+                           prop_value.to_i
+                         when 'Float'
+                           prop_value.to_f
+                         when 'RedisOrm::Boolean'
+                           (prop_value == "false" || prop_value == false) ? false : true
+                         end
+          end
+
+          # set instance variable in order to properly save indexes here
+          self.instance_variable_set(:"@#{prop[:name]}", prop_value)
+          instance_variable_set :"@#{prop[:name]}_changes", [prop_value]
+        end
+
+        # serialize array- and hash-type properties 
+        if ['Array', 'Hash'].include?(prop[:class]) && !prop_value.is_a?(String)
+          prop_value = Marshal.dump(prop_value)
+        end
+
+        #TODO put out of loop
+        $redis.hset(__redis_record_key, prop[:name].to_s, prop_value)
+
+        set_expire_on_reference_key(__redis_record_key)
+        
+        # reducing @#{prop[:name]}_changes array to the last value
+        prop_changes = instance_variable_get :"@#{prop[:name]}_changes"
+
+        if prop_changes && prop_changes.size > 2
+          instance_variable_set :"@#{prop[:name]}_changes", [prop_changes.last]
+        end
+        
+        # if some property need to be sortable add id of the record to the appropriate sorted set
+        if prop[:options][:sortable]
+          property_value = instance_variable_get(:"@#{prop[:name]}").to_s
+          if prop[:class].eql?("String")
+            sortable_key = "#{model_name}:#{prop[:name]}_ids"
+            el_or_position_to_insert = find_position_to_insert(sortable_key, property_value)
+            el_or_position_to_insert == 0 ? $redis.lpush(sortable_key, "#{property_value}:#{@id}") : $redis.linsert(sortable_key, "AFTER", el_or_position_to_insert, "#{property_value}:#{@id}")
+            # add to every indexed property
+            @@indices[model_name].each do |index|
+              sortable_key = "#{_construct_prepared_index(index)}:#{prop[:name]}_ids"
+              el_or_position_to_insert == 0 ? $redis.lpush(sortable_key, "#{property_value}:#{@id}") : $redis.linsert(sortable_key, "AFTER", el_or_position_to_insert, "#{property_value}:#{@id}")
+            end
+          else
+            score = case prop[:class]
+              when "Integer"; property_value.to_f
+              when "Float"; property_value.to_f
+              when "RedisOrm::Boolean"; (property_value == true ? 1.0 : 0.0)
+              when "Time"; property_value.to_f
+            end
+            $redis.zadd "#{model_name}:#{prop[:name]}_ids", score, @id
+            # add to every indexed property
+            @@indices[model_name].each do |index|
+              $redis.zadd "#{_construct_prepared_index(index)}:#{prop[:name]}_ids", score, @id
+            end
+          end
+        end
       end
+    end
+
+    def _save_new_indices
+      # save new indices (not *reference* onces (for example not these *belongs_to :note, :index => true*)) in order to sort by finders
+      # city:name:Chicago => 1
+      @@indices[model_name].reject{|index| index[:options][:reference]}.each do |index|
+        prepared_index = _construct_prepared_index(index) # instance method not class one!
+
+        if index[:options][:unique]
+          $redis.set(prepared_index, @id)
+        else
+          $redis.zadd(prepared_index, Time.now.to_f, @id)
+        end
+      end
+    end
   end
 end