redis-model-extension 0.3.8 → 0.4.0

data/lib/redis-model-extension.rb

@@ -1,341 +1,73 @@
 # -*- encoding : utf-8 -*-
 require 'pp'
 require 'yaml'
+require 'json'
 require 'redis'
+require 'active_model'
 require 'active_support'
 require 'active_support/inflector'
 require 'active_support/inflector/inflections'
 require 'active_support/core_ext/hash/keys'
+require 'active_support/core_ext/hash/indifferent_access'
 require 'active_support/core_ext/object/blank'
 require 'active_support/core_ext/class/inheritable_attributes'
 require 'string_to_bool'
 require 'database'
 
-module RedisModel
-
-  attr_accessor :args, :error, :old_args, :conf
-  
+module RedisModelExtension
+  extend ActiveSupport::Concern
+  #include all needed modules directly into main class
   def self.included(base) 
-    base.send :extend, ClassMethods         
-    base.send :include, InstanceMethods  
-  end
-  
-  module ClassMethods
-    
-    def initialize_redis_model_methods conf
-      @conf = {:reject_nil_values => true}.merge(conf)
-      #take all fields and make methods for them
-      conf[:fields].each do |attr, action|
-        define_method "#{attr}" do
-          if self.args[attr] || self.args[attr] == false #== false is a fi for boolean variable
-            self.args[attr].to_s.send(action)
-          else
-            nil
-          end
-        end
-        
-        define_method "#{attr}=" do |item|
-          self.args[attr] = item
-        end
-        
-        define_method "#{attr}?" do
-          !self.args[attr].nil?
-        end
-      end  
-    end
-    
-    def conf
-      @conf
-    end
-    
-    #Generates redis key for storing object
-    def generate_key(args = {})
-      out = "#{self.name.to_s.underscore.to_sym}:key"
-      @conf[:redis_key].each do |key|
-        if args.has_key?(key)
-          out += ":#{args[key]}"
-        else
-          out += ":*"
-        end
-      end
-      out
-    end
-    
-    #Generates redis key for storing indexes for aliases
-    def generate_alias_key(alias_name, args = {})
-      out = "#{self.name.to_s.underscore.to_sym}:alias:#{alias_name}"
-      @conf[:redis_aliases][alias_name.to_sym].each do |key|
-        if args.has_key?(key)
-          out += ":#{args[key]}"
-        else
-          out += ":*"
-        end
-      end
-      out
-    end
-    
-    #Validates if key by arguments is valid
-    def valid_key?(args = {})
-      full_key = true
-      @conf[:redis_key].each do |key|
-        full_key = false if !args.has_key?(key) || args[key].nil?
-      end
-      full_key
-    end
-
-    #Validates if key by alias name and arguments is valid
-    def valid_alias_key?(alias_name, args = {})
-      full_key = true
-      @conf[:redis_aliases][alias_name.to_sym].each do |key|
-        full_key = false if !args.has_key?(key) || args[key].nil?
-      end
-      full_key
-    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
-
-    #Wrapper around find to get all instances
-    def all
-      self.find({})
-    end
-
-    #Find method for searching in redis
-    def find(args = {})
-      args.symbolize_keys!
-      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)
-          data_args = RedisModelExtension::Database.redis.hgetall(klass.generate_key(args))
-          out << klass.new(args.merge(data_args).merge({:old_args => data_args})) 
-        end
-      else
-        RedisModelExtension::Database.redis.keys(klass.generate_key(args)).each do |key|
-          data_args = RedisModelExtension::Database.redis.hgetall(key)
-          out << klass.new(args.merge(data_args).merge({:old_args => data_args}))
-        end
-      end
-      out
+    base.class_eval do
+      extend ClassInitialize
+      extend ClassOldInitialize
+      extend ClassConfig
+      extend ClassGetFind
+      extend ClassRedisKey  
+      extend ClassCreate
+      extend ClassValidations
+      extend ClassAutoincrementId
+
+      include Initialize
+      include ActiveModelIntegration
+      include Attributes
+      include AutoincrementId
+      include RedisKey
+      include StoreKeys
+      include Config
+      include SaveDestroy
+      include Validations
+      include ValueTransform
     end
-
-    #Find method for searching in redis
-    def find_by_alias(alias_name, args = {})
-      args.symbolize_keys!
-      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
-
-    #fastest method to get object from redis by getting it by arguments
-    def get(args = {})
-      args.symbolize_keys!
-      klass = self.name.constantize
-      if klass.valid_key?(args) && klass.exists?(args)
-        data_args = RedisModelExtension::Database.redis.hgetall(klass.generate_key(args))
-        klass.new(args.merge(data_args).merge({:old_args => data_args})) 
-      else
-        nil
-      end
-    end
-
-    #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)
-        unless redis_key.include?("*")
-          data_args = RedisModelExtension::Database.redis.hgetall(redis_key)
-          klass = self.name.constantize
-          klass.new(data_args.merge({:old_args => data_args})) 
-        else
-          raise ArgumentError, "RedisKey for method get_by_redis_key can not contains '*'"
-        end
-      else
-        nil
-      end
-    end 
-
-    #fastest method to get object from redis by getting it by alias and arguments
-    def get_by_alias(alias_name, args = {})
-      args.symbolize_keys!
-      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))
-        if RedisModelExtension::Database.redis.exists(key)
-          data_args = RedisModelExtension::Database.redis.hgetall(key)
-          klass.new(args.merge(data_args).merge({:old_args => data_args})) 
-        else
-          nil
-        end
-      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)
-        if RedisModelExtension::Database.redis.exists(key)
-          klass.new(args.merge(RedisModelExtension::Database.redis.hgetall(key)).merge({:old_args => key}))
-        else
-          nil
-        end
-      else
-        nil
-      end
-    end    
-
   end
-    
-  module InstanceMethods
-    
-    def initialize(args={})
-      args.symbolize_keys!
-      #if old_args is specified, don't usi it in args hash
-      if args[:old_args] && args[:old_args].size > 0 
-        self.old_args = args.delete(:old_args).symbolize_keys
-      end
-      self.args = clear_args(args)
 
-      return self
-    end
-    
-    #Fixing some problems with saving nil into redis and clearing input arguments
-    def clear_args(args)
-      args.symbolize_keys!
-      out_args = {}
-      args.each do |key, value|
-        if self.class.conf[:fields].keys.include?(key) #don't use arguments wich aren't specified in :fields 
-          if value.nil? || value.to_s.size == 0 #change nil and zero length string into nil
-            out_args[key] = nil 
-          else
-            out_args[key] = value
-          end
-        end
-      end
-      out_args
-    end
-    
-    #validates required attributes
-    def valid?
-      @error ||= []
-      self.class.conf[:required].each do |key|
-        if !self.args.has_key?(key) || self.args[key].nil?
-          @error.push("Required #{key}")
-        end
-      end
-      @error.size == 0
-    end
+  module ActiveModelIntegration
+    def self.included(base)
+      base.class_eval do
+        include ActiveModel::AttributeMethods
+        include ActiveModel::Validations
+        include ActiveModel::Naming
+        include ActiveModel::Conversion
 
-    #return error from validation
-    def error
-      @error ||= []
-    end
-  
-    #return error from validation
-    def errors 
-      @error ||= []
-    end
-  
-    #take all arguments and send them out
-    def to_arg
-      self.args.inject({}) do |output, item|
-        output[item.first] = item.last.send(self.class.conf[:fields][item.first.to_sym])
-        output
-      end
-    end
-  
-    #if this record exists in database
-    def exists?
-      RedisModelExtension::Database.redis.exists(self.class.generate_key(self.args))
-    end
-
-    #remove record form database
-    def destroy!
-      if exists?
-        #destroy main object
-        RedisModelExtension::Database.redis.del(redis_key) 
-        destroy_aliases!
-      end
-    end
-
-    #remove all aliases
-    def destroy_aliases!
-      #do it only if it is existing object!
-      if self.old_args
-        self.class.conf[:redis_aliases].each do |alias_name, fields|
-          if self.class.valid_alias_key?(alias_name, self.old_args) && self.class.alias_exists?(alias_name, self.old_args)
-            RedisModelExtension::Database.redis.del(self.class.generate_alias_key(alias_name, self.old_args)) 
-          end
-        end
-      end
-    end
-    
-    #Method for creating aliases
-    def create_aliases
-      main_key = redis_key
-      self.class.conf[:redis_aliases].each do |alias_name, fields|
-        RedisModelExtension::Database.redis.set(self.class.generate_alias_key(alias_name, self.args), main_key) if self.class.valid_alias_key?(alias_name, self.args)
-      end
-    end
-  
-    #get redis key for instance
-    def redis_key
-      self.class.generate_key(self.args)
-    end
-    
-    #get redis key for instance alias
-    def redis_alias_key(alias_name)
-      self.class.generate_alias_key(alias_name, self.args)
-    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
-
-    #save method
-    def save
-      if valid?
-        #generate key (possibly new)
-        generated_key = redis_key
-        RedisModelExtension::Database.redis.rename(self.class.generate_key(self.old_args), generated_key) if self.old_args && generated_key != self.class.generate_key(self.old_args) && RedisModelExtension::Database.redis.exists(self.class.generate_key(self.old_args))
-        args = self.class.conf[:reject_nil_values] ? self.args.reject{|k,v| v.nil?} : self.args
-        RedisModelExtension::Database.redis.hmset(generated_key, *args.inject([]){ |arr,kv| arr + [kv[0], kv[1].to_s]})
-        
-        #destroy aliases
-        destroy_aliases!
-        create_aliases
-        #after save make new_key -> old_key
-        self.old_args = self.args.clone
-        return self
-      else
-        raise ArgumentError, @error.join(", ")
+        extend  ActiveModel::Callbacks
+        define_model_callbacks :save, :destroy, :create
       end
     end
   end
-end
+
+end
+
+#require all additional modules
+require 'redis-model-extension/config'
+require 'redis-model-extension/initialize'
+require 'redis-model-extension/old_initialize'
+require 'redis-model-extension/value_transform'
+require 'redis-model-extension/redis_key'
+require 'redis-model-extension/get_find'
+require 'redis-model-extension/validation'
+require 'redis-model-extension/attributes'
+require 'redis-model-extension/save_destroy'
+require 'redis-model-extension/store_keys'
+require 'redis-model-extension/autoincrement_id'
+#bad naming in past, will be removed
+require 'redis-model'

data/lib/redis-model.rb

@@ -0,0 +1,14 @@
+# -*- encoding : utf-8 -*-
+
+#bad naming in past, will be removed
+module RedisModel
+
+  #include all needed modules directly into main class
+  def self.included(base) 
+    puts "WARNING: Using include RedisModel is deprecated and will be removed in future! Please use 'include RedisModelExtension'"
+    base.class_eval do  
+      include RedisModelExtension
+    end
+  end
+
+end

data/redis-model-extension.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "redis-model-extension"
-  s.version = "0.3.8"
+  s.version = "0.4.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Ondrej Bartas"]
-  s.date = "2012-08-09"
+  s.date = "2012-08-13"
   s.description = "It provides functions as find, find_by_alias, get, exists?, validate, save etc."
   s.email = "ondrej@bartas.cz"
   s.extra_rdoc_files = [
@@ -27,12 +27,37 @@ Gem::Specification.new do |s|
     "config/redis_setup.conf",
     "lib/database.rb",
     "lib/redis-model-extension.rb",
+    "lib/redis-model-extension/attributes.rb",
+    "lib/redis-model-extension/autoincrement_id.rb",
+    "lib/redis-model-extension/config.rb",
+    "lib/redis-model-extension/get_find.rb",
+    "lib/redis-model-extension/initialize.rb",
+    "lib/redis-model-extension/old_initialize.rb",
+    "lib/redis-model-extension/redis_key.rb",
+    "lib/redis-model-extension/save_destroy.rb",
+    "lib/redis-model-extension/store_keys.rb",
+    "lib/redis-model-extension/validation.rb",
+    "lib/redis-model-extension/value_transform.rb",
+    "lib/redis-model.rb",
     "lib/string_to_bool.rb",
     "redis-model-extension.gemspec",
     "redis-model.gemspec",
     "test/helper.rb",
+    "test/models.rb",
+    "test/redis_model_old/test_redis_model_old_config.rb",
+    "test/redis_model_parts/test_attributes.rb",
+    "test/redis_model_parts/test_autoincrement_id.rb",
+    "test/redis_model_parts/test_dynamic_alias.rb",
+    "test/redis_model_parts/test_get_find.rb",
+    "test/redis_model_parts/test_hooks.rb",
+    "test/redis_model_parts/test_initialize.rb",
+    "test/redis_model_parts/test_redis_key.rb",
+    "test/redis_model_parts/test_save_destroy.rb",
+    "test/redis_model_parts/test_validation.rb",
+    "test/redis_model_parts/test_variable_types.rb",
     "test/test_database_module.rb",
-    "test/test_redis-model-extension.rb"
+    "test/test_redis-model-extension.rb",
+    "test/test_string_to_bool.rb"
   ]
   s.homepage = "http://github.com/ondrejbartas/redis-model-extension"
   s.licenses = ["MIT"]
@@ -47,11 +72,14 @@ Gem::Specification.new do |s|
       s.add_runtime_dependency(%q<redis>, [">= 0"])
       s.add_runtime_dependency(%q<i18n>, [">= 0"])
       s.add_runtime_dependency(%q<activesupport>, [">= 0"])
+      s.add_runtime_dependency(%q<activemodel>, [">= 0"])
       s.add_development_dependency(%q<shoulda>, [">= 0"])
       s.add_development_dependency(%q<shoulda-context>, [">= 0"])
+      s.add_development_dependency(%q<mocha>, [">= 0"])
+      s.add_development_dependency(%q<simplecov>, ["~> 0.6.4"])
       s.add_development_dependency(%q<rake>, [">= 0"])
       s.add_development_dependency(%q<rack>, [">= 0"])
-      s.add_development_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_development_dependency(%q<sdoc>, [">= 0"])
       s.add_development_dependency(%q<bundler>, [">= 0"])
       s.add_development_dependency(%q<jeweler>, ["~> 1.8.3"])
       s.add_development_dependency(%q<turn>, ["~> 0.8.2"])
@@ -61,11 +89,14 @@ Gem::Specification.new do |s|
       s.add_dependency(%q<redis>, [">= 0"])
       s.add_dependency(%q<i18n>, [">= 0"])
       s.add_dependency(%q<activesupport>, [">= 0"])
+      s.add_dependency(%q<activemodel>, [">= 0"])
       s.add_dependency(%q<shoulda>, [">= 0"])
       s.add_dependency(%q<shoulda-context>, [">= 0"])
+      s.add_dependency(%q<mocha>, [">= 0"])
+      s.add_dependency(%q<simplecov>, ["~> 0.6.4"])
       s.add_dependency(%q<rake>, [">= 0"])
       s.add_dependency(%q<rack>, [">= 0"])
-      s.add_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_dependency(%q<sdoc>, [">= 0"])
       s.add_dependency(%q<bundler>, [">= 0"])
       s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
       s.add_dependency(%q<turn>, ["~> 0.8.2"])
@@ -76,11 +107,14 @@ Gem::Specification.new do |s|
     s.add_dependency(%q<redis>, [">= 0"])
     s.add_dependency(%q<i18n>, [">= 0"])
     s.add_dependency(%q<activesupport>, [">= 0"])
+    s.add_dependency(%q<activemodel>, [">= 0"])
     s.add_dependency(%q<shoulda>, [">= 0"])
     s.add_dependency(%q<shoulda-context>, [">= 0"])
+    s.add_dependency(%q<mocha>, [">= 0"])
+    s.add_dependency(%q<simplecov>, ["~> 0.6.4"])
     s.add_dependency(%q<rake>, [">= 0"])
     s.add_dependency(%q<rack>, [">= 0"])
-    s.add_dependency(%q<rdoc>, ["~> 3.12"])
+    s.add_dependency(%q<sdoc>, [">= 0"])
     s.add_dependency(%q<bundler>, [">= 0"])
     s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
     s.add_dependency(%q<turn>, ["~> 0.8.2"])

data/test/helper.rb

@@ -1,5 +1,16 @@
+# -*- encoding : utf-8 -*-
+require 'simplecov'
+SimpleCov.start do 
+  add_filter "/test/"
+  add_filter "/config/"
+  add_filter "database"
+  
+  add_group 'Lib', 'lib/'
+end
+
 require 'rubygems'
 require 'bundler'
+
 begin
   Bundler.setup(:default, :development)
 rescue Bundler::BundlerError => e
@@ -7,7 +18,9 @@ rescue Bundler::BundlerError => e
   $stderr.puts "Run `bundle install` to install missing gems"
   exit e.status_code
 end
+
 require 'test/unit'
+require 'mocha'
 require 'turn'
 require 'shoulda-context'
 
@@ -15,5 +28,7 @@ $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'redis-model-extension'
 
-class Test::Unit::TestCase
-end
+require File.expand_path(File.join(File.dirname(__FILE__),'models.rb'))
+
+#clear database connection
+RedisModelExtension::Database.redis = nil

data/test/models.rb

@@ -0,0 +1,83 @@
+# -*- encoding : utf-8 -*-
+
+class TestOldRedisModel
+  REDIS_MODEL_CONF = {
+     :fields => { 
+       :integer => :to_i,
+       :boolean => :to_bool,
+       :string => :to_s,
+       :symbol => :to_sym,
+       :array => :to_array,
+       :hash => :to_hash,
+      }, 
+      :required => [:integer, :string],
+      :redis_key => [:string],
+      :redis_aliases => {
+        :token => [:symbol]
+      },
+      :reject_nil_values => true,
+   }
+   include RedisModel
+   initialize_redis_model_methods REDIS_MODEL_CONF
+end
+
+class TestRedisModel
+  include RedisModelExtension
+  redis_field :integer, :integer
+  redis_field :boolean, :bool
+  redis_field :string,  :string
+  redis_field :symbol,  :symbol, :default
+  redis_field :array,   :array
+  redis_field :hash,    :hash
+  redis_field :time,    :time
+  redis_field :date,    :date
+  redis_field :float,   :float
+
+  validates :integer, :presence => true
+    
+  redis_key :string
+
+  redis_alias :token, [:symbol]
+
+end
+
+class AutoincrementNotSet
+  include RedisModelExtension
+  redis_field :name, :string
+  redis_field :email, :string
+end
+
+class AutoincrementSetRedisKey
+  include RedisModelExtension
+  redis_field :name, :string
+  redis_field :email, :string
+  redis_key [:id]
+end
+
+class DynamicAlias
+  include RedisModelExtension
+  redis_field :name,  :string
+  redis_field :items, :hash
+  redis_key :name
+  redis_alias :items_with_name, [:name], :items_order, :items
+end
+
+class WithCallbacks
+  include RedisModelExtension
+
+  before_save    :before_save_method
+  after_save     :after_save_method
+  before_destroy { @destroyed_flag = true }
+  before_create  :before_create_method
+
+  redis_field :name, :string
+
+  def before_save_method
+  end
+
+  def after_save_method
+  end
+
+  def before_create_method
+  end
+end