redis-model-extension 0.3.8 → 0.4.0

data/lib/redis-model-extension/old_initialize.rb

@@ -0,0 +1,103 @@
+# -*- encoding : utf-8 -*-
+module RedisModelExtension
+
+  # == Old Initialize
+  # port for old initialize method to new structure
+  module ClassOldInitialize
+    TYPE_TRANSLATIONS = { 
+      :integer => :to_i, 
+      :string => :to_s, 
+      :bool => :to_bool, 
+      :symbol => :to_sym, 
+      :array => :to_array, 
+      :hash => :to_hash, 
+      :time => :to_time, 
+      :date => :to_date 
+    }
+    # old method to initialize redis model extenstion
+    # Usage:
+    #  REDIS_MODEL_CONF = {
+    #   :fields => { 
+    #     :integer => :to_i,
+    #     :boolean => :to_bool,
+    #     :string => :to_s,
+    #     :symbol => :to_sym,
+    #    }, 
+    #    :required => [:integer, :string],
+    #    :redis_key => [:string, :symbol],
+    #    :redis_aliases => {
+    #      :token => [:symbol]
+    #    },
+    #    # (default is true) if true all nil values will not be saved into redis,
+    #    # there should be problem when you want to set some value to nil and same
+    #    # it will not be saved (use false to prevent this)
+    #    :reject_nil_values => false 
+    # }
+    # include RedisModel
+    # initialize_redis_model_methods REDIS_MODEL_CONF
+    def initialize_redis_model_methods conf
+      puts "WARNING: This initilization method is deprecated and will be removed in future! \n Please read documentation how to change your model to use new initialization methods"
+
+      @conf = {:reject_nil_values => true}.merge(conf)
+      #take all fields and make methods for them
+      conf[:fields].each do |name, action|
+        redis_fields_config[name] = TYPE_TRANSLATIONS.invert[action]
+        redis_fields_defaults_config[name] = nil
+
+        # define getter method for field
+        define_method "#{name}" do
+          value_get name
+        end
+        
+        # define setter method for field
+        define_method "#{name}=" do |new_value|
+          value_set name, new_value
+        end
+        
+        # define exists? method for field
+        define_method "#{name}?" do
+          value_get(name) && !value_get(name).blank? ? true : false
+        end
+      end
+      
+      # save nil values?
+      redis_save_fields_with_nil false if !conf.has_key?(:reject_nil_values) || conf[:reject_nil_values] == true
+
+      # save into class config about redis key
+      @redis_key_config = conf[:redis_key]
+
+      #validate presence of all fields in key
+      @required_config = (@redis_key_config | conf[:required]) 
+      (@redis_key_config | conf[:required]).each do |field|
+        validates field, :presence => :true
+      end
+
+      # save into class config about redis keys
+      @redis_alias_config = {}
+      conf[:redis_aliases].each do |key, fields|
+        @redis_alias_config[key] = { 
+          main_fields: fields,
+          order_field: nil,
+          args_field: nil,
+        }
+      end
+    end
+    
+    # get config hash
+    def conf
+      fields = {}
+      redis_fields_config.each do |key, type|
+        fields[key] = TYPE_TRANSLATIONS[type] if TYPE_TRANSLATIONS.has_key?(type)
+      end
+      {
+        fields: fields,
+        required: @required_config.sort,
+        redis_key: redis_key_config,
+        redis_aliases: redis_alias_config.inject({}){|o,(k,v)| o[k] = v[:main_fields]; o},
+        reject_nil_values: !redis_save_fields_with_nil_conf,
+      }
+    end
+   
+  end
+
+end

data/lib/redis-model-extension/redis_key.rb

@@ -0,0 +1,119 @@
+# -*- encoding : utf-8 -*-
+module RedisModelExtension
+  
+  # == Class Redis Key
+  # generators of redis keys
+  # used for creating keys for search and save of models & aliases
+  # 
+  module ClassRedisKey
+
+    # Generates redis key for storing object
+    # * will produce something like: your_class:key:field_value1:field_value2... 
+    # (depending on your redis_key setting)
+    def generate_key args = {}, key = "key"
+      #normalize input hash of arguments
+      args = HashWithIndifferentAccess.new(args)
+
+      out = "#{self.name.to_s.underscore.to_sym}:#{key}"
+      redis_key_config.each do |key|
+        out += add_item_to_redis_key args, key
+      end
+      out
+    end
+
+
+    # Generates redis key for storing indexes for dynamic aliases
+    # will produce something like: your_class:dynamic:name_of_your_dynami_alias:field_value2:field_value1... 
+    # (field values are sorted by fields order)
+    # * dynamic_alias_name (Symbol) - name of your dynamic alias
+    # * args (Hash) - arguments of your model
+    # * field_order (Array of symbols) - order of fields (ex. [:field2, :field1]) 
+    # * field_args (Hash) - hash of values for aliasing (ex. {:field1 => "field_value1", :field2 => "field_value2"})
+    def generate_alias_key alias_name, args = {}
+      #check if asked dynamic alias exists
+      raise ArgumentError, "Unknown dynamic alias: '#{alias_name}', use: #{redis_alias_config.keys.join(", ")} " unless redis_alias_config.has_key?(alias_name.to_sym)
+
+      #normalize input hash of arguments
+      args = HashWithIndifferentAccess.new(args)
+
+      # prepare class name + dynamic + alias name
+      out = "#{self.name.to_s.underscore.to_sym}:alias:#{alias_name}"
+
+      #get config 
+      config = redis_alias_config[alias_name.to_sym]
+
+      # use all specified keys
+      config[:main_fields].each do |key|
+        out += add_item_to_redis_key args, key
+      end
+
+      #is alias dynamic?
+      if config[:order_field] && config[:args_field]
+        #check if input arguments has order field
+        if args.has_key?(config[:order_field]) && args[config[:order_field]] && args.has_key?(config[:args_field]) && args[config[:args_field]]
+          #use filed order from defined field in args
+          args[config[:order_field]].each do |key|
+            out += add_item_to_redis_key args[config[:args_field]], key
+          end
+        else 
+          # use global search
+          out += ":*"
+        end
+      end
+
+      out    
+    end
+
+    # Check if key by arguments exists in db
+    def exists? args = {}
+      RedisModelExtension::Database.redis.exists(self.name.constantize.generate_key(args))
+    end
+
+    #Check if key by alias name and arguments exists in db
+    def alias_exists? alias_name, args = {}
+      RedisModelExtension::Database.redis.exists(self.name.constantize.generate_alias_key(alias_name, args))
+    end
+
+    private
+
+    # return one item of redis key (will decide to input value or to add * for search)
+    def add_item_to_redis_key args, key
+      if args.has_key?(key) && !args[key].nil?
+        key = ":#{args[key]}"
+        key = key.mb_chars.downcase if redis_key_normalize_conf.include?(:downcase)
+        key = ActiveSupport::Inflector::transliterate(key) if redis_key_normalize_conf.include?(:transliterate)
+        key 
+      else
+        ":*"
+      end
+    end
+
+  end
+  
+  # == Redis Key
+  # aliases for instance to class generators of redis keys
+  # 
+  module RedisKey
+
+    # get redis key for instance
+    def redis_key
+      self.class.generate_key(to_arg)
+    end
+    
+    # get redis key for instance alias
+    def redis_alias_key alias_name 
+      self.class.generate_alias_key(alias_name, to_arg)
+    end
+  
+    # pointer to exists?
+    def exists?
+      self.class.exists? to_arg
+    end
+
+    # pointer to alias_exists?
+    def alias_exists? alias_name
+      self.class.alias_exists? alias_name, to_arg
+    end
+
+  end
+end

data/lib/redis-model-extension/save_destroy.rb

@@ -0,0 +1,104 @@
+# -*- encoding : utf-8 -*-
+module RedisModelExtension
+
+  module ClassCreate
+    
+    # create instance and save it
+    def create args = {}
+      instance = self.new(args)
+      instance.save
+      return instance
+    end
+
+  end
+
+  module SaveDestroy
+
+    # save method - save all attributes (fields) and create aliases
+    def save
+      # can be saved into redis?
+      if valid?
+        perform = lambda do
+          #autoicrement id
+          self.send("id=", increment_id) if redis_key_config.include?(:id) && !self.id?
+
+          #generate key (possibly new)
+          generated_key = redis_key        
+
+          #take care about renaming saved hash in redis (if key changed)
+          if redis_old_keys[:key] && redis_old_keys[:key] !=  generated_key && RedisModelExtension::Database.redis.exists(redis_old_keys[:key])
+            RedisModelExtension::Database.redis.rename(redis_old_keys[:key], generated_key)
+          end
+
+          #ignore nil values for save 
+          args = self.class.redis_save_fields_with_nil_conf ? to_arg : to_arg.reject{|k,v| v.nil?}
+
+          #perform save to redis hash
+          RedisModelExtension::Database.redis.hmset(generated_key, *args.inject([]){ |arr,kv| arr + [kv[0], value_to_redis(kv[0], kv[1])]})
+          
+          #destroy aliases
+          destroy_aliases!
+          create_aliases
+
+          #after save make sure instance remember old key to know if it needs to be ranamed
+          store_keys
+        end
+
+        run_callbacks :save do
+          unless exists?
+            run_callbacks :create do
+              perform.()
+            end
+          else
+            perform.()
+          end
+        end
+        return self
+      else
+        return false
+      end
+    end
+
+    # create aliases (create key value [STRING] key is alias redis key and value is redis key)
+    def create_aliases
+      main_key = redis_key
+      redis_alias_config.each do |alias_name, fields|
+        RedisModelExtension::Database.redis.set(redis_alias_key(alias_name), main_key) if valid_alias_key? alias_name
+      end
+    end
+
+    # update multiple attrubutes at once
+    def update args
+      args.each do |key, value|
+        method = "#{key}=".to_sym 
+        if self.respond_to? method
+          self.send(method, value)
+        end
+      end
+    end
+
+    #remove record form database
+    def destroy!
+      if exists?
+        run_callbacks :destroy do
+          #destroy main object
+          RedisModelExtension::Database.redis.del(redis_key) 
+          destroy_aliases!
+        end
+      end
+    end
+
+    alias :destroy :destroy!
+
+    # remove all aliases
+    def destroy_aliases!
+      #do it only if it is existing object!
+      if redis_old_keys[:aliases].size > 0
+        redis_old_keys[:aliases].each do |alias_key|
+          RedisModelExtension::Database.redis.del alias_key
+        end
+      end
+    end
+    
+  end
+end

data/lib/redis-model-extension/store_keys.rb

@@ -0,0 +1,34 @@
+# -*- encoding : utf-8 -*-
+module RedisModelExtension
+  module StoreKeys
+
+    # store old arguments, need's to be called in find/get initialization
+    # will remember old arguments and remember redis keys
+    # if some fileds in redis key will change, then do rename
+    # without this you can end up with old and new saved object!
+    def store_keys
+      store_redis_keys
+    end
+
+    private 
+
+    # set old arguments
+    def store_redis_keys
+      args = to_arg
+      #store main key
+      redis_old_keys[:key] = self.class.generate_key(args) #store main key
+
+      #store alias keys
+      redis_old_keys[:aliases] = []
+      redis_alias_config.each do |alias_name, fields|
+        redis_old_keys[:aliases] << redis_alias_key(alias_name) if valid_alias_key? alias_name
+      end
+    end
+
+    # get old arguments
+    def redis_old_keys
+      @redis_old_keys ||= {:key => nil, :aliases => []}
+    end
+
+  end
+end

data/lib/redis-model-extension/validation.rb

@@ -0,0 +1,84 @@
+# -*- encoding : utf-8 -*-
+module RedisModelExtension
+
+  module ClassValidations
+
+    # Validates if key by arguments is valid
+    # (all needed fields are not nil!)
+    def valid_key? args = {}
+      #normalize input hash of arguments
+      args = HashWithIndifferentAccess.new(args)
+
+      redis_key_config.each do |key|
+        return false unless valid_item_for_redis_key? args, key
+      end
+      return true
+    end
+
+
+    # Validates if key by alias name and arguments is valid
+    # (all needed fields are not nil!)
+    def valid_alias_key? alias_name, args = {}
+      raise ArgumentError, "Unknown dynamic alias, use: #{redis_alias_config.keys.join(", ")}" unless redis_alias_config.has_key?(alias_name.to_sym)
+
+      #normalize input hash of arguments
+      args = HashWithIndifferentAccess.new(args)
+
+      config = redis_alias_config[alias_name.to_sym]
+
+
+      # use all specified keys
+      config[:main_fields].each do |key|
+        return false unless valid_item_for_redis_key? args, key
+      end
+
+      # is dynamic alias?
+        if config[:order_field] && config[:args_field]
+        #check if input arguments has order field
+        if args.has_key?(config[:order_field]) && args[config[:order_field]] && args.has_key?(config[:args_field]) && args[config[:args_field]]
+          #use filed order from defined field in args
+          args[config[:order_field]].each do |key|
+            return false unless valid_item_for_redis_key? args[config[:args_field]], key
+          end
+        else 
+          return false
+        end
+      end
+
+      return true
+    end
+
+    # validate one item of redis key
+    def valid_item_for_redis_key? args, key
+      (args.has_key?(key) && !args[key].nil?) || redis_fields_config[key] == :autoincrement
+    end
+
+    private 
+
+    #look for bad cofiguration in redis key and raise argument error
+    def validate_redis_key
+      valid_fields = redis_fields_config.select{|k,v| v != :array && v != :hash  }.keys
+      bad_fields = redis_key_config - valid_fields
+      raise ArgumentError, "Sorry, but you cannot use as redis key [nonexisting | array | hash] fields: [#{bad_fields.join(",")}], availible are: #{valid_fields.join(", ")}" unless bad_fields.size == 0
+    end
+      
+
+  end
+
+  module Validations
+
+    #pointer to validation
+    def valid_key?
+      self.class.valid_key? to_arg
+    end
+
+    #pointer to validation
+    def valid_alias_key? alias_name
+      self.class.valid_alias_key? alias_name, to_arg
+    end
+    
+    def error
+      self.errors
+    end
+  end
+end

data/lib/redis-model-extension/value_transform.rb

@@ -0,0 +1,51 @@
+# -*- encoding : utf-8 -*-
+module RedisModelExtension
+  module ValueTransform
+
+    # choose right type of value and then transform it for redis
+    def value_to_redis name, value
+      if redis_fields_config.has_key?(name)
+        value_transform value, redis_fields_config[name]
+      else
+        value
+      end
+    end
+
+    # convert value for valid format which can be saved in redis
+    def value_transform value, type
+      return nil if value.nil? || value.to_s.size == 0
+      case type
+      when :integer then value.to_i
+      when :autoincrement then value.to_i
+      when :string then value.to_s
+      when :float then value.to_f
+      when :bool then value.to_s
+      when :symbol then value.to_s
+      when :array then value.to_json
+      when :hash then value.to_json
+      when :time then Time.parse(value.to_s).strftime("%Y.%m.%d %H:%M:%S")
+      when :date then Date.parse(value.to_s).strftime("%Y-%m-%d")
+      else value
+      end
+    end
+
+    # convert value from redis into valid format in ruby
+    def value_parse value, type
+      return nil if value.nil? || value.to_s.size == 0
+      case type
+      when :integer then value.to_i
+      when :autoincrement then value.to_i
+      when :string then value.to_s
+      when :float then value.to_f
+      when :bool then value.to_s.to_bool
+      when :symbol then value.to_s.to_sym
+      when :array then value.is_a?(String) ? JSON.parse(value) : value
+      when :hash then value.is_a?(String) ? JSON.parse(value) : value
+      when :time then value.is_a?(String) ? Time.parse(value) : value
+      when :date then value.is_a?(String) ? Date.parse(value) : value
+      else value
+      end
+    end
+
+  end
+end