redis_orm 0.1

data/lib/redis_orm/associations/belongs_to.rb

@@ -0,0 +1,48 @@
+module RedisOrm
+  module Associations
+    module BelongsTo
+      # class Avatar < RedisOrm::Base
+      #   belongs_to :user
+      # end 
+      #
+      # class User < RedisOrm::Base
+      #   has_many :avatars
+      # end 
+      #
+      # avatar.user => avatar:234:user => 1 => User.find(1)
+      def belongs_to(foreign_model, options = {})
+        class_associations = class_variable_get(:"@@associations")
+        class_variable_get(:"@@associations")[model_name] << {:type => :belongs_to, :foreign_model => foreign_model, :options => options}
+
+        foreign_model_name = if options[:as]
+          options[:as].to_sym
+        else
+          foreign_model.to_sym
+        end
+
+        define_method foreign_model_name.to_sym do
+          foreign_model.to_s.camelize.constantize.find($redis.get "#{model_name}:#{@id}:#{foreign_model_name}")
+        end
+
+        # look = Look.create :title => 'test'
+        # look.user = User.find(1) => look:23:user => 1
+        define_method "#{foreign_model_name}=" do |assoc_with_record|
+          if assoc_with_record.model_name == foreign_model.to_s
+            $redis.set("#{model_name}:#{id}:#{foreign_model_name}", assoc_with_record.id)
+          else
+            raise TypeMismatchError
+          end
+
+          # check whether *assoc_with_record* object has *has_many* declaration and TODO it states *self.model_name* in plural and there is no record yet from the *assoc_with_record*'s side (in order not to provoke recursion)
+          if class_associations[assoc_with_record.model_name].detect{|h| h[:type] == :has_many && h[:foreign_models] == model_name.pluralize.to_sym} && !$redis.zrank("#{assoc_with_record.model_name}:#{assoc_with_record.id}:#{model_name.pluralize}", self.id)            
+            assoc_with_record.send(model_name.pluralize.to_sym).send(:"<<", self)
+
+          # check whether *assoc_with_record* object has *has_one* declaration and TODO it states *self.model_name* and there is no record yet from the *assoc_with_record*'s side (in order not to provoke recursion)
+          elsif class_associations[assoc_with_record.model_name].detect{|h| h[:type] == :has_one && h[:foreign_model] == model_name.to_sym} && assoc_with_record.send(model_name.to_sym).nil?
+            assoc_with_record.send("#{model_name}=", self)            
+          end
+        end
+      end
+    end
+  end
+end

data/lib/redis_orm/associations/has_many.rb

@@ -0,0 +1,54 @@
+module RedisOrm
+  module Associations
+    module HasMany
+      # user.avatars => user:1:avatars => [1, 22, 234] => Avatar.find([1, 22, 234])
+      # options
+      #   *:dependant* key: either *destroy* or *nullify* (default)
+      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 = if options[:as]
+          options[:as].to_sym
+        else
+          foreign_models.to_sym
+        end
+
+        define_method foreign_models_name.to_sym do
+          Associations::HasManyProxy.new(model_name, id, foreign_models, options)
+        end
+
+        # user = User.find(1)
+        # user.avatars = Avatar.find(23) => user:1:avatars => [23]
+        define_method "#{foreign_models_name}=" do |records|
+          if !options[:as]
+            # clear old assocs from related models side
+            self.send(foreign_models).to_a.each do |record|
+              $redis.zrem "#{record.model_name}:#{record.id}:#{model_name.pluralize}", id
+            end
+
+            # clear old assocs from this model side
+            $redis.zremrangebyscore "#{model_name}:#{id}:#{records[0].model_name.pluralize}", 0, Time.now.to_f
+          end
+
+          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)
+
+            if !options[:as]
+              # article.comments = [comment1, comment2] 
+              # iterate through the array of comments and create backlink
+              # check whether *record* object has *has_many* declaration and TODO it states *self.model_name* in plural
+              if class_associations[record.model_name].detect{|h| h[:type] == :has_many && h[:foreign_models] == model_name.pluralize.to_sym} #&& !$redis.zrank("#{record.model_name}:#{record.id}:#{model_name.pluralize}", id)#record.model_name.to_s.camelize.constantize.find(id).nil?
+                $redis.zadd("#{record.model_name}:#{record.id}:#{model_name.pluralize}", Time.now.to_f, id)
+              # check whether *record* object has *has_one* declaration and TODO it states *self.model_name*
+              elsif record.get_associations.detect{|h| [:has_one, :belongs_to].include?(h[:type]) && h[:foreign_model] == model_name.to_sym} # 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}:#{model_name}", id)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/redis_orm/associations/has_many_proxy.rb

@@ -0,0 +1,118 @@
+module RedisOrm
+  module Associations
+    class HasManyProxy
+      def initialize(reciever_model_name, reciever_id, foreign_models, options)
+        @records = [] #records.to_a
+        @reciever_model_name = reciever_model_name
+        @reciever_id = reciever_id
+        @foreign_models = foreign_models
+        @options = options
+        @fetched = false
+      end
+
+      def fetch
+        @records = @foreign_models.to_s.singularize.camelize.constantize.find($redis.zrevrangebyscore __key__, Time.now.to_f, 0)
+        @fetched = true
+      end
+
+      def [](index)
+        fetch if !@fetched
+        @records[index]
+      end
+
+      # user = User.find(1)
+      # 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)          
+
+          if !@options[:as]
+            record_associations = record.get_associations
+
+            # article.comments << [comment1, comment2] 
+            # iterate through the array of comments and create backlink
+            # check whether *record* object has *has_many* declaration and TODO it states *self.model_name* in plural and there is no record yet from the *record*'s side (in order not to provoke recursion)                    
+            if has_many_assoc = record_associations.detect{|h| h[:type] == :has_many && h[:foreign_models] == @reciever_model_name.pluralize.to_sym}
+              pluralized_reciever_model_name = if has_many_assoc[:options][:as]
+                has_many_assoc[:options][:as].pluralize
+              else
+                @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)
+              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}
+              reciever_model_name = if has_one_assoc[:options][:as]
+                has_one_assoc[:options][:as].to_sym
+              else
+                @reciever_model_name
+              end
+              if record.send(reciever_model_name).nil?
+                $redis.set("#{record.model_name}:#{record.id}:#{reciever_model_name}", @reciever_id)
+              end
+            end
+          end
+        end
+      end
+
+      def all(options = {})
+        if options[:limit] || options[:offset] || options[:order]
+          limit = if options[:limit] && options[:offset]
+            [options[:offset].to_i, options[:limit].to_i]            
+          elsif options[:limit]
+            [0, options[:limit].to_i]
+          end
+
+          record_ids = if options[:order].to_s == 'desc'
+            $redis.zrevrangebyscore(__key__, Time.now.to_f, 0, :limit => limit)
+          else
+            $redis.zrangebyscore(__key__, 0, Time.now.to_f, :limit => limit)
+          end
+          @fetched = true
+          @records = @foreign_models.to_s.singularize.camelize.constantize.find(record_ids)
+        else
+          fetch if !@fetched
+          @records
+        end
+      end
+
+      def find(token = nil, options = {})
+        if token.is_a?(String) || token.is_a?(Integer)
+          record_id = $redis.zrank(__key__, token.to_i)
+          if record_id
+            @fetched = true
+            @records = @foreign_models.to_s.singularize.camelize.constantize.find(token)
+          else
+            nil
+          end
+        elsif token == :all
+          all(options)
+        elsif token == :first
+          all(options.merge({:limit => 1}))
+        end
+      end
+
+      def delete(id)
+        $redis.zrem(__key__, id.to_i)
+      end
+
+      def count
+        $redis.zcard __key__
+      end
+
+      def method_missing(method_name, *args, &block)
+        fetch if !@fetched
+        @records.send(method_name, *args, &block)        
+      end
+
+      protected
+
+        # helper method
+        def __key__
+          @options[:as] ? "#{@reciever_model_name}:#{@reciever_id}:#{@options[:as]}" : "#{@reciever_model_name}:#{@reciever_id}:#{@foreign_models}"
+        end
+    end
+  end
+end

data/lib/redis_orm/associations/has_one.rb

@@ -0,0 +1,52 @@
+module RedisOrm
+  module Associations
+    module HasOne
+      # user.avatars => user:1:avatars => [1, 22, 234] => Avatar.find([1, 22, 234])
+      # *options* is a hash and can hold:
+      #   *:as* key
+      #   *:dependant* key: either *destroy* or *nullify* (default)
+      def has_one(foreign_model, options = {})
+        class_associations = class_variable_get(:"@@associations")
+        class_associations[model_name] << {:type => :has_one, :foreign_model => foreign_model, :options => options}
+
+        foreign_model_name = if options[:as]
+          options[:as].to_sym
+        else
+          foreign_model.to_sym
+        end
+
+        define_method foreign_model_name do
+          foreign_model.to_s.camelize.constantize.find($redis.get "#{model_name}:#{@id}:#{foreign_model_name}")
+        end     
+
+        # profile = Profile.create :title => 'test'
+        # user.profile = profile => user:23:profile => 1
+        define_method "#{foreign_model_name}=" do |assoc_with_record|
+          # we need to store this to clear old associations later
+          old_assoc = self.send(foreign_model_name)
+
+          if assoc_with_record.model_name == foreign_model.to_s
+            $redis.set("#{model_name}:#{id}:#{foreign_model_name}", assoc_with_record.id)
+          else
+            raise TypeMismatchError
+          end
+
+          # check whether *assoc_with_record* object has *belongs_to* declaration and TODO it states *self.model_name* and there is no record yet from the *assoc_with_record*'s side (in order not to provoke recursion)
+          if class_associations[assoc_with_record.model_name].detect{|h| [:belongs_to, :has_one].include?(h[:type]) && h[:foreign_model] == model_name.to_sym} && assoc_with_record.send(model_name.to_sym).nil?
+            assoc_with_record.send("#{model_name}=", self)
+          elsif class_associations[assoc_with_record.model_name].detect{|h| :has_many == h[:type] && h[:foreign_models] == model_name.to_s.pluralize.to_sym} && !$redis.zrank("#{assoc_with_record.model_name}:#{assoc_with_record.id}:#{model_name.pluralize}", self.id)
+            # remove old assoc 
+            # $redis.zrank "city:2:profiles", 12                       
+            if old_assoc
+              #puts 'key - ' + "#{assoc_with_record.model_name}:#{old_assoc.id}:#{model_name.to_s.pluralize}"
+              #puts 'self.id - ' + self.id.to_s
+              $redis.zrem "#{assoc_with_record.model_name}:#{old_assoc.id}:#{model_name.to_s.pluralize}", self.id
+            end
+            # create/add new ones
+            assoc_with_record.send(model_name.pluralize.to_sym).send(:"<<", self)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/redis_orm/redis_orm.rb

@@ -0,0 +1,502 @@
+require 'active_support/inflector/inflections'
+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/calculations' # local_time for to_time(:local)
+require 'active_support/core_ext/string/conversions' # to_time
+
+require 'active_model/validator'
+require 'active_model/validations'
+
+module RedisOrm
+  # there is no Boolean class in Ruby so defining a special class to specify TrueClass or FalseClass objects
+  class Boolean
+  end
+
+  # it's raised when found request was initiated on the property/properties which have no index on it
+  class NotIndexFound < StandardError
+  end
+
+  class TypeMismatchError < StandardError
+  end
+
+  class ArgumentsMismatch < StandardError
+  end
+  
+  class Base
+    include ActiveModel::Validations
+    include ActiveModelBehavior
+
+    extend Associations::BelongsTo
+    extend Associations::HasMany
+    extend Associations::HasOne
+
+    attr_accessor :persisted
+
+    @@properties = Hash.new{|h,k| h[k] = []}
+    @@indices = Hash.new{|h,k| h[k] = []} # compound indices are available too   
+    @@associations = Hash.new{|h,k| h[k] = []}
+    @@callbacks = Hash.new{|h,k| h[k] = {}}    
+
+    class << self
+
+      def inherited(from)
+        [:after_save, :before_save, :after_create, :before_create, :after_destroy, :before_destroy].each do |callback_name|
+          @@callbacks[from.model_name][callback_name] = []
+        end
+      end
+     
+      # *options* currently supports
+      #   *unique* Boolean
+      #   *case_insensitive* Boolean TODO 
+      def index(name, options = {})
+        @@indices[model_name] << {:name => name, :options => options}
+      end
+
+      def property(property_name, class_name, options = {})
+        @@properties[model_name] << {:name => property_name, :class => class_name.to_s, :options => options}
+
+        send(:define_method, property_name) do
+          value = instance_variable_get(:"@#{property_name}")
+
+          return value 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
+          elsif Integer == class_name
+            value = value.to_i
+          elsif Float == class_name
+            value = value.to_f
+          elsif RedisOrm::Boolean == class_name
+            value = (value == "false" ? false : true)
+          end
+          value
+        end
+    
+        send(:define_method, :"#{property_name}=") do |value|
+          if instance_variable_get(:"@#{property_name}_changes") && !instance_variable_get(:"@#{property_name}_changes").empty?
+            initial_value = instance_variable_get(:"@#{property_name}_changes")[0]
+            instance_variable_set(:"@#{property_name}_changes", [initial_value, value])
+          elsif instance_variable_get(:"@#{property_name}")
+            instance_variable_set(:"@#{property_name}_changes", [self.send(property_name), value])
+          else
+            instance_variable_set(:"@#{property_name}_changes", [value])
+          end
+
+          instance_variable_set(:"@#{property_name}", value)
+        end
+  
+        send(:define_method, :"#{property_name}_changes") do
+          instance_variable_get(:"@#{property_name}_changes")
+        end
+      end
+
+      def count
+        $redis.zcard("#{model_name}:ids").to_i
+      end
+
+      def first
+        id = $redis.zrangebyscore("#{model_name}:ids", 0, Time.now.to_f, :limit => [0, 1])
+        id.empty? ? nil : find(id[0])
+      end
+
+      def last
+        id = $redis.zrevrangebyscore("#{model_name}:ids", Time.now.to_f, 0, :limit => [0, 1])
+        id.empty? ? nil : find(id[0])
+      end
+
+      def all(options = {})
+        limit = if options[:limit] && options[:offset]
+          [options[:offset].to_i, options[:limit].to_i]
+        elsif options[:limit]
+          [0, options[:limit].to_i]
+        end
+
+        if options[:order].to_s == 'desc'
+          $redis.zrevrangebyscore("#{model_name}:ids", Time.now.to_f, 0, :limit => limit).compact.collect{|id| find(id)}
+        else
+          $redis.zrangebyscore("#{model_name}:ids", 0, Time.now.to_f, :limit => limit).compact.collect{|id| find(id)}
+        end
+      end
+
+      def find(ids)
+        if ids.is_a?(Hash)
+          all(ids)
+        elsif ids.is_a?(Array)
+          return [] if ids.empty?
+          ids.inject([]) do |array, id|
+            record = $redis.hgetall "#{model_name}:#{id}"
+            if record && !record.empty?
+              array << new(record, id, true)
+            end
+          end
+        else
+          return nil if ids.nil?
+          id = ids
+          record = $redis.hgetall "#{model_name}:#{id}"
+          if record && record.empty?
+            nil
+          else
+            new(record, id, true)
+          end
+        end        
+      end
+
+      def after_save(callback)        
+        @@callbacks[model_name][:after_save] << callback
+      end
+
+      def before_save(callback)        
+        @@callbacks[model_name][:before_save] << callback
+      end
+
+      def after_create(callback)        
+        @@callbacks[model_name][:after_create] << callback
+      end
+
+      def before_create(callback)
+        @@callbacks[model_name][:before_create] << callback
+      end
+
+      def after_destroy(callback)
+        @@callbacks[model_name][:after_destroy] << callback
+      end
+      
+      def before_destroy(callback)        
+        @@callbacks[model_name][:before_destroy] << callback
+      end
+
+      def create(options = {})
+        obj = new(options, nil, false)
+        obj.save
+        obj
+      end
+
+      # dynamic finders
+      def method_missing(method_name, *args, &block)
+        if method_name =~ /^find_(all_)?by_(\w*)/
+          prepared_index = model_name.to_s
+          index = if $2
+            properties = $2.split('_and_')
+            raise ArgumentsMismatch if properties.size != args.size
+            
+            properties.each_with_index do |prop, i|
+              # raise if User.find_by_firstname_and_castname => there's no *castname* in User's properties
+              raise ArgumentsMismatch if !@@properties[model_name].detect{|p| p[:name] == prop.to_sym}
+              prepared_index += ":#{prop}:#{args[i].to_s}"
+            end
+
+            @@indices[model_name].detect do |models_index|
+              if models_index[:name].is_a?(Array) && models_index[:name].size == properties.size
+                models_index[:name] == properties.map{|p| p.to_sym}
+              elsif !models_index[:name].is_a?(Array) && properties.size == 1
+                models_index[:name] == properties[0].to_sym
+              end
+            end
+          end
+
+          raise NotIndexFound if !index
+
+          if method_name =~ /^find_by_(\w*)/                      
+            id = if index[:options][:unique]            
+              $redis.get prepared_index
+            else
+              $redis.zrangebyscore(prepared_index, 0, Time.now.to_f, :limit => [0, 1])[0]
+            end
+            model_name.to_s.camelize.constantize.find(id)
+          elsif method_name =~ /^find_all_by_(\w*)/
+            records = []          
+
+            if index[:options][:unique]            
+              id = $redis.get prepared_index
+              records << model_name.to_s.camelize.constantize.find(id)
+            else
+              ids = $redis.zrangebyscore(prepared_index, 0, Time.now.to_f)
+              records += model_name.to_s.camelize.constantize.find(ids)
+            end          
+
+            records
+          else
+            nil
+          end
+        end
+      end
+
+    end
+
+    # could be invoked from has_many module (<< method)
+    def to_a
+      [self]
+    end
+
+    # is called from RedisOrm::Associations::HasMany to save backlinks to saved records
+    def get_associations
+      @@associations[self.model_name]
+    end
+
+    def initialize(attributes = {}, id = nil, persisted = false)
+      @persisted = persisted
+      
+      instance_variable_set(:"@id", id.to_i) if id
+
+      # when object is created with empty attribute set @#{prop[:name]}_changes array properly
+      @@properties[model_name].each do |prop|
+        if prop[:options][:default]
+          instance_variable_set :"@#{prop[:name]}_changes", [prop[:options][:default]]
+        else
+          instance_variable_set :"@#{prop[:name]}_changes", []
+        end
+      end
+ 
+      if attributes.is_a?(Hash) && !attributes.empty?        
+        attributes.each do |key, value|
+          self.send("#{key}=".to_sym, value) if self.respond_to?("#{key}=".to_sym)
+        end
+      end
+      self
+    end
+
+    def id
+      @id
+    end
+
+    def persisted?
+      @persisted
+    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
+      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|
+          prop_changes = instance_variable_get :"@#{prop[:name]}_changes" 
+
+          next if prop_changes.size < 2
+          prev_prop_value = prop_changes.first
+
+          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
+            end
+          end
+        end
+      else # !persisted?        
+        @@callbacks[model_name][:before_create].each do |callback|
+          self.send(callback)
+        end
+ 
+        @id = $redis.incr("#{model_name}:id")
+        $redis.zadd "#{model_name}:ids", Time.now.to_f, @id
+        @persisted = true
+
+        if @@properties[model_name].detect{|p| p[:name] == :created_at }
+          self.created_at = Time.now
+        end
+      end
+
+      @@callbacks[model_name][:before_save].each do |callback|
+        self.send(callback)
+      end
+
+      # automatically update *modified_at* property if it was defined
+      if @@properties[model_name].detect{|p| p[:name] == :modified_at }
+        self.modified_at = Time.now
+      end
+
+      @@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]
+          # set instance variable in order to properly save indexes here
+          self.instance_variable_set(:"@#{prop[:name]}", prop[:options][:default]) 
+        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
+      end
+
+      # save new indices in order to sort by finders
+      # city:name:Харьков => 1
+      @@indices[model_name].each do |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}").to_s]
+          end.join(':')
+        else
+          [model_name, index[:name], self.instance_variable_get(:"@#{index[:name]}").to_s].join(':')
+        end
+
+        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
+
+      if ! was_persisted
+        @@callbacks[model_name][:after_create].each do |callback|
+          self.send(callback)
+        end
+      end
+
+      true # if there were no errors just return true, so *if* conditions would work
+    end
+
+    def update_attributes(attributes)
+      if attributes.is_a?(Hash)
+        attributes.each do |key, value|
+          self.send("#{key}=".to_sym, value) if self.respond_to?("#{key}=".to_sym)
+        end
+      end
+      save
+    end
+
+    def update_attribute(attribute_name, attribute_value)
+      self.send("#{attribute_name}=".to_sym, attribute_value) if self.respond_to?("#{attribute_name}=".to_sym)
+      save
+    end
+
+    def destroy
+      @@callbacks[model_name][:before_destroy].each do |callback|
+        self.send(callback)
+      end
+
+      @@properties[model_name].each do |prop|
+        $redis.hdel("#{model_name}:#{@id}", prop.to_s)
+      end
+
+      $redis.zrem "#{model_name}:ids", @id
+
+      # also we need to delete *links* to associated records
+      if !@@associations[model_name].empty?
+        @@associations[model_name].each do |assoc|
+
+          foreign_model  = ""
+          records = []
+
+          case assoc[:type]
+            when :belongs_to
+              foreign_model = assoc[:foreign_model].to_s
+              foreign_model_name = assoc[:options][:as] ? assoc[:options][:as] : assoc[:foreign_model]
+              records << self.send(foreign_model_name)
+
+              $redis.del "#{model_name}:#{@id}:#{assoc[:foreign_model]}"
+            when :has_one
+              foreign_model = assoc[:foreign_model].to_s
+              foreign_model_name = assoc[:options][:as] ? assoc[:options][:as] : assoc[:foreign_model]
+              records << self.send(foreign_model_name)
+
+              $redis.del "#{model_name}:#{@id}:#{assoc[:foreign_model]}"
+            when :has_many
+              foreign_model = assoc[:foreign_models].to_s.singularize
+              foreign_models_name = assoc[:options][:as] ? assoc[:options][:as] : assoc[:foreign_models]
+              records += self.send(foreign_models_name)
+
+              # delete all members             
+              $redis.zremrangebyscore "#{model_name}:#{@id}:#{assoc[:foreign_models]}", 0, Time.now.to_f
+          end
+
+          # check whether foreign_model also has an assoc to the destroying record
+          # and remove an id of destroing record from each of associated sets
+          if !records.compact.empty?
+            records.compact.each do |record|
+              # we make 3 different checks rather then 1 with elsif to ensure that all associations will be processed
+              # it's covered in test/option_test in "should delete link to associated record when record was deleted" scenario
+              # for if class Album; has_one :photo, :as => :front_photo; has_many :photos; end
+              # end some photo from the album will be deleted w/o these checks only first has_one will be triggered
+              if @@associations[foreign_model].detect{|h| h[:type] == :belongs_to && h[:foreign_model] == model_name.to_sym}
+                #puts 'from destr :belongs_to - ' + "#{foreign_model}:#{record.id}:#{model_name}"
+                $redis.del "#{foreign_model}:#{record.id}:#{model_name}"
+              end
+              
+              if @@associations[foreign_model].detect{|h| h[:type] == :has_one && h[:foreign_model] == model_name.to_sym}
+                #puts 'from destr :has_one - ' + "#{foreign_model}:#{record.id}:#{model_name}"
+                $redis.del "#{foreign_model}:#{record.id}:#{model_name}"
+              end
+
+              if @@associations[foreign_model].detect{|h| h[:type] == :has_many && h[:foreign_models] == model_name.pluralize.to_sym}
+                #puts "from destr :has_many - " + "#{foreign_model}:#{record.id}:#{model_name.pluralize}"
+                $redis.zrem "#{foreign_model}:#{record.id}:#{model_name.pluralize}", @id
+              end
+            end
+          end
+
+          if assoc[:options][:dependant] == :destroy
+            records.each do |r|
+              r.destroy
+            end
+          end
+        end
+      end      
+
+      # we need to ensure that smembers are correct after removal of the record
+      @@indices[model_name].each do |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
+
+        if index[:options][:unique]
+          $redis.del(prepared_index)
+        else
+          $redis.zremrangebyscore(prepared_index, 0, Time.now.to_f)
+        end
+      end
+      
+      @@callbacks[model_name][:after_destroy].each do |callback|
+        self.send(callback)
+      end
+
+      true # if there were no errors just return true, so *if* conditions would work
+    end    
+  end
+end