redis_orm 0.5.1 → 0.8

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2ca054af9087bbd76a32022f1fee369a5ef0292c15e1b091fddbab2aadb2649f
+  data.tar.gz: 142417a34ecdd550195ec800aff8157d24c5cde06601e69a99c2916d23577e5c
+SHA512:
+  metadata.gz: 7855dfe1ea7f968d17546eb9ff1ade0d9a50b7548f1a297a31cd1ecd1d60329c89dcefedf6affbc107634425b4f0a3828b6b573a5fa46d807c4167e0cea9dbc3
+  data.tar.gz: 2313d1c202ca558573468a93ec4d47beb278069b454e245aaeb65280ce8bc891ac1e89e03df85980c303787ea1e15f4f4220ba61d2f515823b05dcb1a8e939a6

data/CHANGELOG

@@ -1,3 +1,32 @@
+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
+* added Gemfile to the project, improved tests
+
+v0.6 [12-09-2011]
+* added equality operator for object, #to_s method for inspecting objects, #find! which could throw RecordNotFound error
+* added self.descendants class method which returns all inherited from RedisOrm::Base classes
+* introduced :sortable option (in property declaration and #find conditions hash) - rudimentary ability to sort records by any property (not just by default 'created_at')
+* now handling models withing modules definitions (test for this in associations_test.rb)
+* properly handling :as parameter in options for has_many/belongs_to self-references
+* binding related models while creating model instance (like this: Article.create(:comment => comment))
+* bunch of small fixes, updated tests and README.md
+
 v0.5.1 [27-07-2011]
 * added support of uuid as an id/primary key
 * added documentation on uuid support and connection to the redis server

data/README.md

@@ -27,6 +27,28 @@ class User < RedisOrm::Base
 end
 ```
 
+## Installing redis_orm
+
+stable release:
+
+```sh
+gem install redis_orm
+```
+
+or edge version:
+
+```sh
+git clone git://github.com/german/redis_orm.git
+cd redis_orm
+bundle install
+```
+
+To run the tests you should have redis installed already. Please check [Redis download/installation page](http://redis.io/download).
+
+```sh
+rspec
+```
+
 ## Setting up a connection to the redis server
 
 If you are using Rails you should initialize redis and set up global $redis variable in *config/initializers/redis.rb* file:
@@ -60,14 +82,48 @@ 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**
 
     The default value of the attribute when it's getting saved w/o any.
 
+*  **:sortable**
+
+    if *true* is specified then you could sort records by this property later
+
+*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:
@@ -102,7 +158,11 @@ To extract all or part of the associated records you could use 4 options:
 
 * :order
 
-  Either :desc or :asc (default), since records are stored with *Time.now.to_f* scores, by default they could be fetched only in that (or reversed) order. To store them in different order you should *zadd* record's id to some other sorted list manually.
+  Either :desc or :asc (default), since records are stored with *Time.now.to_f* scores, by default they could be fetched only in that (or reversed) order. To order by different property you should:
+  
+  1. specify *:sortable => true* as option in property declaration
+  
+  2. specify the property by which you wish to order *:order => [:name, :desc]* or *:order => [:name]* (:asc order is default)
   
 * :conditions
 
@@ -508,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/TODO

@@ -0,0 +1,5 @@
+* add rake task to create index keys to existing records after the index was added to the column, something like *rake redis_orm:update_index_on zip*
+* add named_scopes
+* Sinatra based admin interface to overview all redis_orm keys in redis
+* ActiveRecord 3.x API
+* refactoring ;)

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.rb

@@ -1,17 +1,14 @@
-# -*- encoding: utf-8 -*-
-
 require 'active_model'
 require 'redis'
 require 'uuid'
-require File.join(File.dirname(File.expand_path(__FILE__)), 'redis_orm', 'active_model_behavior')
-
-require File.join(File.dirname(File.expand_path(__FILE__)), 'redis_orm', 'associations', 'belongs_to')
-
-require File.join(File.dirname(File.expand_path(__FILE__)), 'redis_orm', 'associations', 'has_many_helper')
 
-require File.join(File.dirname(File.expand_path(__FILE__)), 'redis_orm', 'associations', 'has_many_proxy')
-require File.join(File.dirname(File.expand_path(__FILE__)), 'redis_orm', 'associations', 'has_many')
-require File.join(File.dirname(File.expand_path(__FILE__)), 'redis_orm', 'associations', 'has_one')
+require_relative 'redis_orm/active_model_behavior'
+require_relative 'redis_orm/associations/belongs_to'
+require_relative 'redis_orm/associations/has_many_helper'
+require_relative 'redis_orm/associations/has_many_proxy'
+require_relative 'redis_orm/associations/has_many'
+require_relative 'redis_orm/associations/has_one'
+require_relative 'redis_orm/utils'
 
 class String
   def i18n_key
@@ -23,4 +20,4 @@ class String
   end
 end
 
-require File.join(File.dirname(File.expand_path(__FILE__)), 'redis_orm', 'redis_orm')
+require_relative 'redis_orm/redis_orm'

data/lib/redis_orm/active_model_behavior.rb

@@ -1,14 +1,12 @@
 module ActiveModelBehavior 
   module ClassMethods
     def model_name
-      #@_model_name ||= ActiveModel::Name.new(self).to_s.downcase
       @_model_name ||= ActiveModel::Name.new(self).to_s.tableize.singularize
     end
   end
 
   module InstanceMethods
     def model_name
-      #@_model_name ||= ActiveModel::Name.new(self.class).to_s.downcase
       @_model_name ||= ActiveModel::Name.new(self.class).to_s.tableize.singularize
     end
   end

data/lib/redis_orm/associations/belongs_to.rb

@@ -14,28 +14,37 @@ module RedisOrm
         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
+        foreign_model_name = options[:as] ? options[:as].to_sym : foreign_model.to_sym
+        
+        if options[:index]
+          class_variable_get(:"@@indices")[model_name] << {:name => foreign_model_name, :options => {:reference => true}}
         end
-
-        define_method foreign_model_name.to_sym do
+        
+        define_method foreign_model_name do
           if options[:polymorphic]
             model_type = $redis.get("#{model_name}:#{id}:#{foreign_model_name}_type")
             if model_type
               model_type.to_s.camelize.constantize.find($redis.get "#{model_name}:#{@id}:#{foreign_model_name}_id")
             end
           else
-            foreign_model.to_s.camelize.constantize.find($redis.get "#{model_name}:#{@id}:#{foreign_model_name}")
+            # find model even if it's in some module
+            full_model_scope = RedisOrm::Base.descendants.detect{|desc| desc.to_s.split('::').include?(foreign_model.to_s.camelize) }
+            if full_model_scope
+              full_model_scope.find($redis.get "#{model_name}:#{@id}:#{foreign_model_name}")
+            else
+              foreign_model.to_s.camelize.constantize.find($redis.get "#{model_name}:#{@id}:#{foreign_model_name}")
+            end
           end
         end
-
+  
         # look = Look.create :title => 'test'
         # look.user = User.find(1) => look:23:user => 1
         define_method "#{foreign_model_name}=" do |assoc_with_record|
           # we need to store this to clear old association later
           old_assoc = self.send(foreign_model_name)
+
+          # find model even if it's in some module
+          full_model_scope = RedisOrm::Base.descendants.detect{|desc| desc.to_s.split('::').include?(foreign_model.to_s.camelize) }
           
           if options[:polymorphic]
             $redis.set("#{model_name}:#{id}:#{foreign_model_name}_type", assoc_with_record.model_name)
@@ -43,13 +52,42 @@ module RedisOrm
           else
             if assoc_with_record.nil?
               $redis.del("#{model_name}:#{id}:#{foreign_model_name}")
-            elsif assoc_with_record.model_name == foreign_model.to_s
+            elsif [foreign_model.to_s, full_model_scope.model_name].include?(assoc_with_record.model_name)
               $redis.set("#{model_name}:#{id}:#{foreign_model_name}", assoc_with_record.id)
             else
               raise TypeMismatchError
             end
           end
+
+          # handle indices for references
+          self.get_indices.select{|index| index[:options][:reference]}.each do |index|
+            # delete old reference that points to the old associated record
+            if !old_assoc.nil?
+              prepared_index = [self.model_name, index[:name], old_assoc.id].join(':')
+              prepared_index.downcase! if index[:options][:case_insensitive]
+
+              if index[:options][:unique]
+                $redis.del(prepared_index, id)
+              else
+                $redis.zrem(prepared_index, id)
+              end
+            end
+            
+            # if new associated record is nil then skip to next index (since old associated record was already unreferenced)
+            next if assoc_with_record.nil?
+            
+            prepared_index = [self.model_name, index[:name], assoc_with_record.id].join(':')
+
+            prepared_index.downcase! if index[:options][:case_insensitive]
+
+            if index[:options][:unique]
+              $redis.set(prepared_index, id)
+            else
+              $redis.zadd(prepared_index, Time.now.to_f, id)
+            end
+          end
           
+          # we should have an option to delete created earlier associasion (like 'node.owner = nil')
           if assoc_with_record.nil?
             # remove old assoc            
             $redis.zrem("#{old_assoc.model_name}:#{old_assoc.id}:#{model_name.to_s.pluralize}", self.id) if old_assoc
@@ -57,7 +95,7 @@ module RedisOrm
             # 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)
               # remove old assoc
-              $redis.zrem("#{old_assoc.model_name}:#{old_assoc.id}:#{model_name.to_s.pluralize}", self.id) if old_assoc   
+              $redis.zrem("#{old_assoc.model_name}:#{old_assoc.id}:#{model_name.to_s.pluralize}", self.id) if old_assoc
               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)
@@ -70,4 +108,4 @@ module RedisOrm
       end
     end
   end
-end
+end

data/lib/redis_orm/associations/has_many.rb

@@ -7,12 +7,8 @@ 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 = if options[:as]
-          options[:as].to_sym
-        else
-          foreign_models.to_sym
-        end
+        
+        foreign_models_name = options[:as] ? options[:as].to_sym : foreign_models.to_sym
 
         define_method foreign_models_name.to_sym do
           Associations::HasManyProxy.new(model_name, id, foreign_models, options)
@@ -26,9 +22,13 @@ module RedisOrm
             old_records = self.send(foreign_models).to_a
             if !old_records.empty?
               # cache here which association with current model have old record's model
-              has_many_assoc = old_records[0].get_associations.detect{|h| h[:type] == :has_many && h[:foreign_models] == model_name.pluralize.to_sym}
+              has_many_assoc = old_records[0].get_associations.detect do |h|
+                h[:type] == :has_many && h[:foreign_models] == model_name.pluralize.to_sym
+              end
               
-              has_one_or_belongs_to_assoc = old_records[0].get_associations.detect{|h| [:has_one, :belongs_to].include?(h[:type]) && h[:foreign_model] == model_name.to_sym}
+              has_one_or_belongs_to_assoc = old_records[0].get_associations.detect do |h|
+                [:has_one, :belongs_to].include?(h[:type]) && h[:foreign_model] == model_name.to_sym
+              end
               
               old_records.each do |record|
                 if has_many_assoc
@@ -45,23 +45,31 @@ 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
 
-            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
+            # article.comments = [comment1, comment2] 
+            # iterate through the array of comments and create backlink
+            # check whether *record* object has *has_many* declaration and it states *self.model_name* in plural
+            if assoc = 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?
+              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(key, id)              
+              set_expire_on_reference_key(key)
             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
@@ -82,7 +93,7 @@ module RedisOrm
           prepared_index = if options[:conditions] && options[:conditions].is_a?(Hash)
             properties = options[:conditions].collect{|key, value| key}
 
-            index = @foreign_models.to_s.singularize.camelize.constantize.find_index(properties)
+            index = @foreign_models.to_s.singularize.camelize.constantize.find_indices(properties, :first => true)
 
             raise NotIndexFound if !index