redis-model-extension 0.3.8 → 0.4.0

data/Gemfile

@@ -3,13 +3,16 @@ source "http://rubygems.org"
 gem "redis"
 gem "i18n"
 gem "activesupport"
+gem "activemodel"
 
 group :development do
   gem "shoulda", ">= 0"
   gem 'shoulda-context'
+  gem 'mocha'
+  gem "simplecov", "~> 0.6.4"
   gem "rake"
   gem "rack"
-  gem "rdoc", "~> 3.12"
+  gem "sdoc" # sdoc -N .
   gem "bundler"
   gem "jeweler", "~> 1.8.3"
   gem "turn", "~> 0.8.2"

data/README.markdown

@@ -2,6 +2,25 @@
 
 Redis model is basic implementation of few methods for creating model which store data in Redis
 
+## Instalation
+
+Just in console
+
+``` ruby
+gem install redis-model-extension
+```
+
+Or put into Gemfile
+
+``` ruby
+gem "redis-model-extension"
+```
+
+and somewhere before use (not rails - they will require gem automaticaly)
+``` ruby
+require "redis-model-extension"
+```
+
 ## Initialization
 
 You can use yml config file `redis_config.yml` in `config` directory:
@@ -33,27 +52,43 @@ RedisModelExtension::Database.redis_config(:host => "127.0.0.1", :port => 6379,
 
 ## Usage
 
+Your class needs to include RedisModel and there is your testing configuration:
+([old initialization - still working :)](https://github.com/ondrejbartas/redis-model-extension/wiki/Old-initialization))
+
 ``` ruby
 class TestRedisModel
-  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
+  include RedisModelExtension
+
+  #REQUIRED:
+  #redis_field :name_of_field, :filed_type, (:default_value - optional)
+  redis_field :field1,    :integer
+  redis_field :field2,    :bool
+  redis_field :field3,    :string, "Default string"
+  redis_field :field4,    :symbol
+  redis_field :field5,    :array
+  redis_field :field6,    :hash
+  redis_field :field7,    :time
+  redis_field :field8,    :date
+  
+  # which columns are used for generating redis key - name_of_your_class:key:field1:field2...
+  redis_key :field1, :field2
+
+  #OPTIONALS:
+
+  # redis_validate :field1, :field2... #test your model, if all specified variables are not nil
+  redis_validate :field1, :field3 
+
+  # reddis_key_normalize - when assembling redis key you can specify normalization actions for values
+  # :downcase - your_class:key:Value:FoO -> your_class:key:value:foo (find - case insensitive)
+  # :transliterate - your_class:key:VašíČek:FoO -> your_class:key:VasiCek:FoO (find - without á,č etc.)
+  # :downcase & :transliterate - your_class:key:VašíČek:FoO -> your_class:key:vasicek:foo
+  # this is crucial for find method
+  reddis_key_normalize :transliterate, :downcase
+
+  # redis alias is working as redis key, but it will only create alias to your main hash in redis
+  # specified is by combination of uniq value (you specify which fields to use)
+  # redis_alias :name_of_alias, <array of field names>
+  redis_alias :token, [:field4]
 end
 
 foo = TestRedisModel.new()
@@ -68,7 +103,7 @@ end
 
 # custom errors in initialize etc.
 #class declaration
-def initialize args = {}
+def initialize args = {}
   error << "My custom error"
   super args
 end
@@ -76,9 +111,9 @@ end
 
 
 #you can update more attributes at once
-foo.update(:integer => 234, :string => "bar")
+foo.update(:field1 => 234, :field3 => "bar")
 
-# !!! if you try to save invalid object you will get ArgumentError execption !!!
+# !!! if you try to save invalid object you will get ArgumentError exception !!!
 
 # after save you can find and get object find_by_alias
 
@@ -86,24 +121,24 @@ foo.update(:integer => 234, :string => "bar")
 #you can perfor find only with keys which are in redis key
 #this is slow variant for redis but compared to other databases super fast :-)
 #if you specify all keys from redis key it will perform faster method get
-TestRedisModel.find(:string => "foo") 
+TestRedisModel.find(:field3 => "foo") 
 
 #you can use get method if you know all keys used in redis key
 #this variant is super fast
-TestRedisModel.get(:string => "foo", :symbol=> true) 
+TestRedisModel.get(:field3 => "foo", :field4=> true) 
 
 #you can ask redis if this item exists
-TestRedisModel.exists?(:string => "foo", :symbol=> true) 
+TestRedisModel.exists?(:field3 => "foo", :field4=> true) 
 
 #you can try to find by alias - alias needs to be uniq 
 #use alias only for uniq combination of keys
-TestRedisModel.find_by_alias(:token, :symbol=> true) 
+TestRedisModel.find_by_alias(:token, :field4=> true) 
 
 ```
 
 Now you can easily access all attributes from TestRedisModel by `foo.integer` or exists? `foo.integer?` or set value by `foo.integer = 1234` 
 
-You can initialize model by `foo = TestRedisModel.new(:integer => 123, :string => "bar")` and then access it same as above.
+You can initialize model by `foo = TestRedisModel.new(:field1 => 123, :field3 => "bar")` and then access it same as above.
 
 Saving is easy too: `foo.save` -> It will raise exception if :required attributes aren't filled. Error message says what is missing.
 

data/Rakefile

@@ -58,12 +58,6 @@ task :startup => [:'redis:start']
 desc "Teardown databases"
 task :teardown => [:'redis:stop']
 
-Rake::TestTask.new(:test) do |t|
-  t.test_files = FileList['test/functional/*_test.rb', 'test/unit/*_test.rb','test/integration/*_test.rb']
-  t.warning = false
-  t.verbose = false
-end
-
 namespace :redis do
   desc "Start the Redis server"
   task :start do

data/VERSION

@@ -1 +1 @@
-0.3.8
+0.4.0

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

@@ -0,0 +1,38 @@
+# -*- encoding : utf-8 -*-
+module RedisModelExtension
+
+  # == Attribues
+  # modul for easier getting all attributes
+  # also for setting ang getting value instance variable
+  module Attributes
+
+    #take all arguments and send them out
+    def to_arg
+      redis_fields_config.inject({}) do |args, (key, type)|
+        args[key] = self.send(key)
+        args
+      end
+    end
+
+    alias :args :to_arg
+    
+    #put arguments into json
+    def to_json
+      to_arg.to_json
+    end
+    
+
+    private 
+
+    # get value from instance variable
+    def value_get name
+      instance_variable_get(:"@#{name}")
+    end
+
+    # set value into instance variable
+    def value_set name, value
+      instance_variable_set(:"@#{name}", value)
+    end
+
+  end
+end

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

@@ -0,0 +1,38 @@
+# -*- encoding : utf-8 -*-
+module RedisModelExtension
+
+  # == Class Autoincrement Id
+  # get last id
+  # generate autoincrement key
+  module ClassAutoincrementId
+
+    # get last id from redis
+    def get_last_id
+      Database.redis.get generate_autoincrement_key
+    end
+
+    #generate autoincrement key
+    def generate_autoincrement_key
+      "#{self.name.to_s.underscore.to_sym}:autoincrement_id"
+    end
+
+  end
+
+  # == Autoincrement Id
+  # increment id
+  module AutoincrementId
+
+    private
+
+    # get auto incremented id from redis
+    def increment_id
+      Database.redis.incr self.class.generate_autoincrement_key
+    end
+
+    # get last id from redis
+    def get_last_id
+      self.class.get_last_id
+    end
+
+  end
+end

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

@@ -0,0 +1,67 @@
+# -*- encoding : utf-8 -*-
+module RedisModelExtension
+  # == Config
+  # set private methods for accessing & storing class configurations
+  module ClassConfig
+
+    #store informations about saving nil values
+    def redis_save_fields_with_nil_conf
+      @redis_save_fields_with_nil_conf.nil? ? @redis_save_fields_with_nil_conf = true : @redis_save_fields_with_nil_conf
+    end
+
+    #store informations about current class fields settings
+    def redis_fields_config
+      @redis_model_config ||= {}
+    end
+
+    #store informations about current class fields defaults settings
+    def redis_fields_defaults_config
+      @redis_model_defaults_config ||= {}
+    end
+
+    #store informations about current class redis key fields
+    def redis_key_config
+      @redis_key_config ||= []
+    end
+
+    #store informations about current class aliases settings
+    def redis_alias_config
+      @redis_alias_config ||= {}
+    end
+
+    private
+
+    #store informations about all user defined fields settings
+    def redis_user_field_config
+      @redis_user_field_config ||= []
+    end
+
+  end
+
+  # == Config
+  # set private methods for accessing class configurations form instance
+  module Config
+    private 
+
+    # pointer to class settings
+    def redis_key_config
+      self.class.redis_key_config
+    end
+
+    # pointer to class settings
+    def redis_fields_config
+      self.class.redis_fields_config
+    end
+
+    # pointer to class settings
+    def redis_fields_defaults_config
+      self.class.redis_fields_defaults_config
+    end
+
+    # pointer to class settings
+    def redis_alias_config
+      self.class.redis_alias_config
+    end
+
+  end
+end

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

@@ -0,0 +1,146 @@
+# -*- encoding : utf-8 -*-
+module RedisModelExtension
+
+  # == Get & Find
+  # * Model.all => Array of all instances
+  # * Model.find(1) => Array of one instance with id 1
+  # * Model.get(1) => Array of one instance with id 1
+  # * Model.find( id: 1 ) => Array of one instance with id 1
+  # * Model.find( field: "test" ) => Array of all instances with field == test [field must be in redis key]
+  module ClassGetFind
+
+    ######################################
+    #  FIND METHODS
+    ######################################
+
+    #Find method for searching in redis
+    # * args (Integer) - search by id
+    # * args (Hash) - search by arguments in redis_key
+    def find(args = {})
+      # when argument is integer - search by id 
+      args = { id: args } if args.is_a?(Integer)
+      #normalize input hash of arguments
+      args = HashWithIndifferentAccess.new(args)
+
+      out = []
+      klass = self.name.constantize
+      
+      #is key specified directly? -> no needs of looking for other keys! -> faster
+      if klass.valid_key?(args)
+        if klass.exists?(args)
+          out << klass.new_by_key(klass.generate_key(args)) 
+        end
+      else
+        RedisModelExtension::Database.redis.keys(klass.generate_key(args)).each do |key|
+          out << klass.new_by_key(key) 
+        end
+      end
+      out
+    end
+    alias :all :find
+
+    #Find method for searching in redis
+    def find_by_alias(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)
+
+      out = []
+      klass = self.name.constantize
+      #is key specified directly? -> no needs of looking for other keys! -> faster
+      if klass.valid_alias_key?(alias_name, args)
+        out << klass.get_by_alias(alias_name, args) if klass.alias_exists?(alias_name, args)
+      else
+        RedisModelExtension::Database.redis.keys(klass.generate_alias_key(alias_name, args)).each do |key|
+          out << klass.get_by_alias_key(key)
+        end
+      end
+      out
+    end
+
+    ######################################
+    #  GET BY ARGUMENTS
+    ######################################
+
+    #fastest method to get object from redis by getting it by arguments
+    # * args (Integer) - search by id
+    # * args (Hash) - search by arguments in redis_key
+    def get(args = {})
+      # when argument is integer - search by id 
+      args = { id: args } if args.is_a?(Integer)
+
+      #normalize input hash of arguments
+      args = HashWithIndifferentAccess.new(args)
+
+      klass = self.name.constantize
+      if klass.valid_key?(args) && klass.exists?(args)
+        klass.new_by_key(klass.generate_key(args)) 
+      else
+        nil
+      end
+    end
+
+    ######################################
+    #  GET BY REDIS KEYS
+    ######################################
+
+    #fastest method to get object from redis by getting it by dynamic alias and arguments
+    def get_by_alias(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)
+
+      klass = self.name.constantize
+      if klass.valid_alias_key?(alias_name, args) && klass.alias_exists?(alias_name, args)
+        key = RedisModelExtension::Database.redis.get(klass.generate_alias_key(alias_name, args))
+        return klass.new_by_key(key) if RedisModelExtension::Database.redis.exists(key)
+      end
+      nil
+    end    
+
+
+    ######################################
+    #  GET BY REDIS KEYS
+    ######################################
+
+    #if you know redis key and would like to get object
+    def get_by_redis_key(redis_key)
+      if redis_key.is_a?(String) && RedisModelExtension::Database.redis.exists(redis_key)
+        klass = self.name.constantize
+        klass.new_by_key(redis_key)
+      else
+        nil
+      end
+    end 
+
+    #fastest method to get object from redis by getting it by alias and arguments
+    def get_by_alias_key(alias_key)
+      klass = self.name.constantize
+      if RedisModelExtension::Database.redis.exists(alias_key)
+        key = RedisModelExtension::Database.redis.get(alias_key)
+        return klass.new_by_key(key) if RedisModelExtension::Database.redis.exists(key)
+      end
+      nil
+    end 
+
+
+    ######################################
+    #  CREATE NEW OBJECT BY HASH VALUES
+    ######################################
+        
+    # read all data from redis and create new instance (used for Find & Get method)
+    def new_by_key(key)
+      args = HashWithIndifferentAccess.new(RedisModelExtension::Database.redis.hgetall(key))
+
+      new_instance = self.name.constantize.new(args)
+      new_instance.store_keys
+
+      return new_instance
+    end
+
+  end
+end

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

@@ -0,0 +1,179 @@
+# -*- encoding : utf-8 -*-
+module RedisModelExtension
+
+  # == Class Initialize
+  # redis_field - defines fields to be stored into redis
+  # redis_alias - defines aliases for finding models 
+  # redis_key - defines wich fields will be in redis key
+  # redis_key_normalize - normalization of redis key (downcase, transliterate)
+  # redis_save_fields_with_nil - enable/disable save of nil fields into redis
+  module ClassInitialize
+    VALID_NORMALIZATIONS = [:downcase, :transliterate]
+
+    #add new field which will be saved into redis
+    # * name - name of your variable
+    # * type - type of your variable (:integer, :float, :string, :array, :hash)
+    # * (default) - default value of your variable
+    def redis_field name, type, default = nil
+      redis_user_field_config << name
+
+      # remember field to save into redis
+      redis_fields_config[name] = type
+      # remember field default value
+      redis_fields_defaults_config[name] = default
+
+      # get value
+      define_method name do
+        value_get name  
+      end
+
+      # assign new value
+      define_method "#{name}=" do |new_value|
+        value_set name, new_value
+      end
+
+      # value exists? (not nil and not blank?)
+      define_method "#{name}?" do 
+        value_get(name) && !value_get(name).blank? ? true : false
+      end
+
+      # default saving nil values to redis
+      redis_save_fields_with_nil true
+
+      #set default key to autoincrement id
+      set_redis_autoincrement_key
+    end
+
+    def set_redis_autoincrement_key
+      @redis_key_config = [:id]
+
+      # get value
+      define_method :id do
+        value_get :id 
+      end
+
+      # value exists? (not nil and not blank?)
+      define_method "id?" do 
+        value_get(:id) && !value_get(:id).blank? ? true : false
+      end
+
+      # set value
+      define_method "id=" do |new_value|
+        value_set :id, new_value
+      end
+      private :id= #set it as private
+
+      redis_fields_config[:id] = :autoincrement
+
+    end
+
+    def remove_redis_autoincrement_key
+
+      puts "#{self.name} : remove"
+      # remove get value
+      remove_method :id
+
+      # remove value exists? (not nil and not blank?)
+      remove_method "id?"
+
+      # remove set value
+      remove_method "id="
+
+      redis_fields_config.delete(:id)
+    end
+
+
+    # set redis key which will be used for storing model
+    def redis_key *fields
+      @redis_key_config = fields.flatten
+      
+      validate_redis_key
+      
+      #own specification of redis key - delete autoincrement
+      remove_redis_autoincrement_key unless redis_user_field_config.include?(:id) || @redis_key_config.include?(:id)
+
+      # automaticaly add all fields from key to validation
+      # if any of fields in redis key is nil
+      # then prevent to save it
+      @redis_key_config.each do |field|
+        validates field, :presence => :true if field != :id
+      end
+    end
+    
+    # set redis model to normalize redis keys
+    def redis_key_normalize *metrics
+      @redis_key_normalize_conf ||= []
+      metrics.each do |metric|
+        raise ArgumentError, "Please provide valid normalization: #{VALID_NORMALIZATIONS.join(", ")}" unless VALID_NORMALIZATIONS.include?(metric)
+        @redis_key_normalize_conf << metric
+      end
+    end
+
+    # store informations about redis aliases
+    def redis_alias name, main_fields, name_of_field_for_order = nil, name_of_field_for_args = nil
+      #set fields if they are not allready set!
+      if name_of_field_for_order && name_of_field_for_args
+        redis_field name_of_field_for_order, :array, [] unless redis_fields_config.has_key?(name_of_field_for_order)
+        redis_field name_of_field_for_args, :hash, {} unless redis_fields_config.has_key?(name_of_field_for_args)
+      end
+
+      @redis_alias_config ||= {}
+      #add specification of dynamic alias
+      @redis_alias_config[name] = { 
+        main_fields: main_fields,
+        order_field: name_of_field_for_order,
+        args_field: name_of_field_for_args,
+      }
+
+      #create alias methods for find and get (find_by_name, get_by_name)
+      create_class_alias_method(name)
+    end
+
+    # store informations about saving nil values
+    def redis_save_fields_with_nil store
+      @redis_save_fields_with_nil_conf = store
+    end
+
+    # store informations about redis key normalization
+    def redis_key_normalize_conf
+      @redis_key_normalize_conf ||= []
+    end
+
+    private
+    
+    def create_class_alias_method(name)
+      self.class.instance_eval do
+        define_method("find_by_#{name}") do |args|
+          find_by_alias(name, args)
+        end
+        define_method("get_by_#{name}") do |args|
+          get_by_alias(name, args)
+        end
+      end
+    end
+
+  end
+
+  module Initialize
+
+    # initialize instance    
+    def initialize(args={})
+      args = HashWithIndifferentAccess.new(args)
+      # look for fields in input hash
+      redis_fields_config.each do |key, type|
+        # disable to set nonexisting ID!
+        raise ArgumentError, "You cannot specify #{key} (it is auto incremented)" if args[key] && type == :autoincrement && get_last_id.to_i < args[key].to_i
+
+        # input hash has known field
+        if args.has_key?(key) 
+          value_set key, value_parse(args[key], type)
+        else #there is no value set default valued
+          value_set key, redis_fields_defaults_config[key]
+        end
+      end
+
+      return self
+    end
+
+  end
+end