redis_orm 0.6 → 0.6.1

data/CHANGELOG

@@ -1,3 +1,7 @@
+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

data/Gemfile

@@ -0,0 +1,8 @@
+source 'http://rubygems.org'
+
+gem 'activemodel', '>= 3.0.0'
+gem 'activesupport', '>= 3.0.0'
+gem 'redis', '>= 2.2.0'
+gem 'uuid', '>= 2.3.2'
+
+gem 'rspec', '>= 2.5.0'

data/Manifest

@@ -1,8 +1,10 @@
 CHANGELOG
+Gemfile
 LICENSE
 Manifest
 README.md
 Rakefile
+benchmarks/sortable_benchmark.rb
 lib/redis_orm.rb
 lib/redis_orm/active_model_behavior.rb
 lib/redis_orm/associations/belongs_to.rb
@@ -24,9 +26,9 @@ test/exceptions_test.rb
 test/has_one_has_many_test.rb
 test/indices_test.rb
 test/options_test.rb
-test/order_test.rb
 test/polymorphic_test.rb
 test/redis.conf
+test/sortable_test.rb
 test/test_helper.rb
 test/uuid_as_id_test.rb
 test/validations_test.rb

data/README.md

@@ -29,15 +29,25 @@ end
 
 ## Installing redis_orm
 
+stable release:
+
+```sh
 gem install redis_orm
+```
 
-or 
+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
+rake test
+```
 
 ## Setting up a connection to the redis server
 
@@ -84,6 +94,8 @@ Following options are available in property declaration:
 
     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").
+
 ## Searching records by the value
 
 Usually it's done via declaring an index and using *:conditions* hash or dynamic finders. For example:

data/Rakefile

@@ -4,7 +4,7 @@ require 'rake'
 #=begin
 require 'echoe'
 
-Echoe.new('redis_orm', '0.6') do |p|
+Echoe.new('redis_orm', '0.6.1') do |p|
   p.description    = "ORM for Redis (advanced key-value storage) with ActiveRecord API"
   p.url            = "https://github.com/german/redis_orm"
   p.author         = "Dmitrii Samoilov"
@@ -26,13 +26,8 @@ Rake::TestTask.new(:test) do |t|
 end
 =end
 
-#require 'rspec/core/rake_task'
 task :test do |t|
   Dir['test/**/*_test.rb'].each do |file|
     puts `ruby -I./lib #{file}`
   end
 end
-#task :default => :test
-#RSpec::Core::RakeTask.new(:spec) do |t|
-#  t.pattern = 'test/**/*_test.rb'
-#end

data/benchmarks/sortable_benchmark.rb

@@ -0,0 +1,45 @@
+require File.expand_path(File.dirname(__FILE__) + '/../lib/redis_orm')
+require 'benchmark'
+
+class User < RedisOrm::Base
+  property :name, String
+  property :age, Integer
+  property :wage, Float
+  
+  index :name
+  index :age
+end
+
+class SortableUser < RedisOrm::Base
+  property :name, String, :sortable => true
+  property :age, Integer, :sortable => true
+  property :wage, Float, :sortable => true
+  
+  index :name
+  index :age
+end
+
+path_to_conf = File.dirname(File.expand_path(__FILE__)) + "/../test/redis.conf"
+$redis_pid = spawn 'redis-server ' + path_to_conf, :out => "/dev/null"
+sleep(0.3) # must be some delay otherwise "Connection refused - Unable to connect to Redis"
+path_to_socket = File.dirname(File.expand_path(__FILE__)) + "/../redis.sock"
+begin
+  $redis = Redis.new(:host => 'localhost', :path => path_to_socket)
+rescue => e
+  puts 'Unable to create connection to the redis server: ' + e.message.inspect
+  Process.kill 9, $redis_pid.to_i if $redis_pid
+end
+
+n = 100
+Benchmark.bmbm do |x|
+  x.report("creating regular user:") { for i in 1..n; u = User.create(:name => "user#{i}", :age => i, :wage => 100*i); end}
+  x.report("creating user w/ sortable attrs:") { for i in 1..n; u = SortableUser.create(:name => "user#{i}", :age => i, :wage => 100*i); end }
+end
+
+Benchmark.bmbm do |x|
+  x.report("finding regular users:") { User.find(:all, :limit => 5, :offset => 10) }
+  x.report("finding users w/ sortable attrs:") { SortableUser.find(:all, :limit => 5, :offset => 10, :order => [:name, :asc]) }
+end
+
+$redis.flushall if $redis
+Process.kill 9, $redis_pid.to_i if $redis_pid

data/lib/redis_orm/redis_orm.rb

@@ -193,6 +193,8 @@ module RedisOrm
           [options[:offset].to_i, options[:limit].to_i]
         elsif options[:limit]
           [0, options[:limit].to_i]
+        else
+          [0, -1]
         end
         
         order_max_limit = Time.now.to_f
@@ -214,30 +216,66 @@ module RedisOrm
           end
         end
 
+        order_by_property_is_string = false
+        
         # if not array => created_at native order (in which ids were pushed to "#{model_name}:ids" set by default)
         direction = if !options[:order].blank?
-          if options[:order].is_a?(Array)
+          property = {}
+          dir = if options[:order].is_a?(Array)
+            property = @@properties[model_name].detect{|prop| prop[:name].to_s == options[:order].first.to_s}
             # for String values max limit for search key could be 1.0, but for Numeric values there's actually no limit
             order_max_limit = 100_000_000_000
             ids_key = "#{prepared_index}:#{options[:order].first}_ids"
             options[:order].size == 2 ? options[:order].last : 'asc'
           else
+            property = @@properties[model_name].detect{|prop| prop[:name].to_s == options[:order].to_s}
             ids_key = prepared_index
             options[:order]
           end
+          if property && property[:class].eql?("String") && property[:options][:sortable]
+            order_by_property_is_string = true
+          end
+          dir
         else
           ids_key = prepared_index
           'asc'
         end
 
-        if index && index[:options][:unique]
-          id = $redis.get prepared_index
-          model_name.to_s.camelize.constantize.find(id)
-        else
+        if order_by_property_is_string
           if direction.to_s == 'desc'
-            $redis.zrevrangebyscore(ids_key, order_max_limit, 0, :limit => limit).compact.collect{|id| find(id)}
+            ids_length = $redis.llen(ids_key)
+            limit = if options[:offset] && options[:limit]
+              [(ids_length - options[:offset].to_i - options[:limit].to_i), (ids_length - options[:offset].to_i - 1)]
+            elsif options[:limit]
+              [ids_length - options[:limit].to_i, ids_length]
+            elsif options[:offset]
+              [0, (ids_length - options[:offset].to_i - 1)]
+            else
+              [0, -1]
+            end
+            $redis.lrange(ids_key, *limit).reverse.compact.collect{|id| find(id.split(':').last)}
+          else
+            limit = if options[:offset] && options[:limit]
+              [options[:offset].to_i, (options[:offset].to_i + options[:limit].to_i)]
+            elsif options[:limit]
+              [0, options[:limit].to_i - 1]
+            elsif options[:offset]
+              [options[:offset].to_i, -1]
+            else
+              [0, -1]
+            end
+            $redis.lrange(ids_key, *limit).compact.collect{|id| find(id.split(':').last)}
+          end
+        else
+          if index && index[:options][:unique]
+            id = $redis.get prepared_index
+            model_name.to_s.camelize.constantize.find(id)
           else
-            $redis.zrangebyscore(ids_key, 0, order_max_limit, :limit => limit).compact.collect{|id| find(id)}
+            if direction.to_s == 'desc'
+              $redis.zrevrangebyscore(ids_key, order_max_limit, 0, :limit => limit).compact.collect{|id| find(id)}
+            else
+              $redis.zrangebyscore(ids_key, 0, order_max_limit, :limit => limit).compact.collect{|id| find(id)}
+            end
           end
         end
       end
@@ -464,12 +502,20 @@ module RedisOrm
           
           prev_prop_value = instance_variable_get(:"@#{prop[:name]}_changes").first
           prop_value = instance_variable_get(:"@#{prop[:name]}")
-
+          # TODO DRY in destroy also
           if prop[:options][:sortable]
-            $redis.zrem "#{model_name}:#{prop[:name]}_ids", @id
-            # remove id from every indexed property
-            @@indices[model_name].each do |index|
-              $redis.zrem "#{construct_prepared_index(index)}:#{prop[:name]}_ids", @id
+            if prop[:class].eql?("String")
+              $redis.lrem "#{model_name}:#{prop[:name]}_ids", 1, "#{prev_prop_value}:#{@id}"
+              # remove id from every indexed property
+              @@indices[model_name].each do |index|
+                $redis.lrem "#{construct_prepared_index(index)}:#{prop[:name]}_ids", 1, "#{prop_value}:#{@id}"
+              end
+            else
+              $redis.zrem "#{model_name}:#{prop[:name]}_ids", @id
+              # remove id from every indexed property
+              @@indices[model_name].each do |index|
+                $redis.zrem "#{construct_prepared_index(index)}:#{prop[:name]}_ids", @id
+              end
             end
           end
 
@@ -571,18 +617,28 @@ module RedisOrm
         
         # if some property need to be sortable add id of the record to the appropriate sorted set
         if prop[:options][:sortable]
-          property_value = instance_variable_get(:"@#{prop[:name]}")
-          score = case prop[:class]
-            when "Integer"; property_value.to_f
-            when "Float"; property_value.to_f
-            when "String"; calculate_key_for_zset(property_value)
-            when "RedisOrm::Boolean"; (property_value == true ? 1.0 : 0.0)
-            when "Time"; property_value.to_f
-          end
-          $redis.zadd "#{model_name}:#{prop[:name]}_ids", score, @id
-          # add to every indexed property
-          @@indices[model_name].each do |index|
-            $redis.zadd "#{construct_prepared_index(index)}:#{prop[:name]}_ids", score, @id
+          property_value = instance_variable_get(:"@#{prop[:name]}").to_s
+          if prop[:class].eql?("String")
+            sortable_key = "#{model_name}:#{prop[:name]}_ids"
+            el_or_position_to_insert = find_position_to_insert(sortable_key, property_value)
+            el_or_position_to_insert == 0 ? $redis.lpush(sortable_key, "#{property_value}:#{@id}") : $redis.linsert(sortable_key, "AFTER", el_or_position_to_insert, "#{property_value}:#{@id}")
+            # add to every indexed property
+            @@indices[model_name].each do |index|
+              sortable_key = "#{construct_prepared_index(index)}:#{prop[:name]}_ids"
+              el_or_position_to_insert == 0 ? $redis.lpush(sortable_key, "#{property_value}:#{@id}") : $redis.linsert(sortable_key, "AFTER", el_or_position_to_insert, "#{property_value}:#{@id}")
+            end
+          else
+            score = case prop[:class]
+              when "Integer"; property_value.to_f
+              when "Float"; property_value.to_f
+              when "RedisOrm::Boolean"; (property_value == true ? 1.0 : 0.0)
+              when "Time"; property_value.to_f
+            end
+            $redis.zadd "#{model_name}:#{prop[:name]}_ids", score, @id
+            # add to every indexed property
+            @@indices[model_name].each do |index|
+              $redis.zadd "#{construct_prepared_index(index)}:#{prop[:name]}_ids", score, @id
+            end
           end
         end
       end
@@ -612,6 +668,47 @@ module RedisOrm
       true # if there were no errors just return true, so *if* conditions would work
     end
 
+    def find_position_to_insert(sortable_key, value)
+      end_index = $redis.llen(sortable_key)
+
+      return 0 if end_index == 0
+      
+      start_index = 0
+      pivot_index = end_index / 2
+
+      start_el = $redis.lindex(sortable_key, start_index)
+      end_el   = $redis.lindex(sortable_key, end_index - 1)
+      pivot_el = $redis.lindex(sortable_key, pivot_index)
+
+      while start_index != end_index
+        # aa..ab..ac..bd <- ad
+        if start_el.split(':').first > value # Michael > Abe
+          return 0
+        elsif end_el.split(':').first < value # Abe < Todd 
+          return end_el
+        elsif start_el.split(':').first == value # Abe == Abe
+          return start_el
+        elsif pivot_el.split(':').first == value # Todd == Todd
+          return pivot_el
+        elsif end_el.split(':').first == value
+          return end_el
+        elsif (start_el.split(':').first < value) && (pivot_el.split(':').first > value)
+          start_index = start_index
+          prev_pivot_index = pivot_index
+          pivot_index = start_index + ((end_index - pivot_index) / 2)
+          end_index   = prev_pivot_index
+        elsif (pivot_el.split(':').first < value) && (end_el.split(':').first > value) # M < V && Y > V
+          start_index = pivot_index
+          pivot_index = pivot_index + ((end_index - pivot_index) / 2)
+          end_index   = end_index          
+        end
+        start_el = $redis.lindex(sortable_key, start_index)
+        end_el   = $redis.lindex(sortable_key, end_index - 1)
+        pivot_el = $redis.lindex(sortable_key, pivot_index)
+      end
+      start_el
+    end
+    
     def update_attributes(attributes)
       if attributes.is_a?(Hash)
         attributes.each do |key, value|
@@ -632,7 +729,16 @@ module RedisOrm
       end
 
       @@properties[model_name].each do |prop|
+        property_value = instance_variable_get(:"@#{prop[:name]}").to_s
         $redis.hdel("#{model_name}:#{@id}", prop[:name].to_s)
+        
+        if prop[:options][:sortable]
+          if prop[:class].eql?("String")
+            $redis.lrem "#{model_name}:#{prop[:name]}_ids", 1, "#{property_value}:#{@id}"
+          else
+            $redis.zrem "#{model_name}:#{prop[:name]}_ids", @id
+          end
+        end
       end
 
       $redis.zrem "#{model_name}:ids", @id

data/redis_orm.gemspec

@@ -2,22 +2,22 @@
 
 Gem::Specification.new do |s|
   s.name = %q{redis_orm}
-  s.version = "0.6"
+  s.version = "0.6.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Dmitrii Samoilov"]
-  s.date = %q{2011-09-12}
+  s.authors = [%q{Dmitrii Samoilov}]
+  s.date = %q{2011-12-05}
   s.description = %q{ORM for Redis (advanced key-value storage) with ActiveRecord API}
   s.email = %q{germaninthetown@gmail.com}
-  s.extra_rdoc_files = ["CHANGELOG", "LICENSE", "README.md", "lib/redis_orm.rb", "lib/redis_orm/active_model_behavior.rb", "lib/redis_orm/associations/belongs_to.rb", "lib/redis_orm/associations/has_many.rb", "lib/redis_orm/associations/has_many_helper.rb", "lib/redis_orm/associations/has_many_proxy.rb", "lib/redis_orm/associations/has_one.rb", "lib/redis_orm/redis_orm.rb", "lib/redis_orm/utils.rb"]
-  s.files = ["CHANGELOG", "LICENSE", "Manifest", "README.md", "Rakefile", "lib/redis_orm.rb", "lib/redis_orm/active_model_behavior.rb", "lib/redis_orm/associations/belongs_to.rb", "lib/redis_orm/associations/has_many.rb", "lib/redis_orm/associations/has_many_helper.rb", "lib/redis_orm/associations/has_many_proxy.rb", "lib/redis_orm/associations/has_one.rb", "lib/redis_orm/redis_orm.rb", "lib/redis_orm/utils.rb", "redis_orm.gemspec", "test/association_indices_test.rb", "test/associations_test.rb", "test/atomicity_test.rb", "test/basic_functionality_test.rb", "test/callbacks_test.rb", "test/changes_array_test.rb", "test/dynamic_finders_test.rb", "test/exceptions_test.rb", "test/has_one_has_many_test.rb", "test/indices_test.rb", "test/options_test.rb", "test/order_test.rb", "test/polymorphic_test.rb", "test/redis.conf", "test/test_helper.rb", "test/uuid_as_id_test.rb", "test/validations_test.rb"]
+  s.extra_rdoc_files = [%q{CHANGELOG}, %q{LICENSE}, %q{README.md}, %q{lib/redis_orm.rb}, %q{lib/redis_orm/active_model_behavior.rb}, %q{lib/redis_orm/associations/belongs_to.rb}, %q{lib/redis_orm/associations/has_many.rb}, %q{lib/redis_orm/associations/has_many_helper.rb}, %q{lib/redis_orm/associations/has_many_proxy.rb}, %q{lib/redis_orm/associations/has_one.rb}, %q{lib/redis_orm/redis_orm.rb}, %q{lib/redis_orm/utils.rb}]
+  s.files = [%q{CHANGELOG}, %q{Gemfile}, %q{LICENSE}, %q{Manifest}, %q{README.md}, %q{Rakefile}, %q{benchmarks/sortable_benchmark.rb}, %q{lib/redis_orm.rb}, %q{lib/redis_orm/active_model_behavior.rb}, %q{lib/redis_orm/associations/belongs_to.rb}, %q{lib/redis_orm/associations/has_many.rb}, %q{lib/redis_orm/associations/has_many_helper.rb}, %q{lib/redis_orm/associations/has_many_proxy.rb}, %q{lib/redis_orm/associations/has_one.rb}, %q{lib/redis_orm/redis_orm.rb}, %q{lib/redis_orm/utils.rb}, %q{redis_orm.gemspec}, %q{test/association_indices_test.rb}, %q{test/associations_test.rb}, %q{test/atomicity_test.rb}, %q{test/basic_functionality_test.rb}, %q{test/callbacks_test.rb}, %q{test/changes_array_test.rb}, %q{test/dynamic_finders_test.rb}, %q{test/exceptions_test.rb}, %q{test/has_one_has_many_test.rb}, %q{test/indices_test.rb}, %q{test/options_test.rb}, %q{test/polymorphic_test.rb}, %q{test/redis.conf}, %q{test/sortable_test.rb}, %q{test/test_helper.rb}, %q{test/uuid_as_id_test.rb}, %q{test/validations_test.rb}]
   s.homepage = %q{https://github.com/german/redis_orm}
-  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Redis_orm", "--main", "README.md"]
-  s.require_paths = ["lib"]
+  s.rdoc_options = [%q{--line-numbers}, %q{--inline-source}, %q{--title}, %q{Redis_orm}, %q{--main}, %q{README.md}]
+  s.require_paths = [%q{lib}]
   s.rubyforge_project = %q{redis_orm}
-  s.rubygems_version = %q{1.6.2}
+  s.rubygems_version = %q{1.8.6}
   s.summary = %q{ORM for Redis (advanced key-value storage) with ActiveRecord API}
-  s.test_files = ["test/options_test.rb", "test/dynamic_finders_test.rb", "test/associations_test.rb", "test/validations_test.rb", "test/test_helper.rb", "test/polymorphic_test.rb", "test/uuid_as_id_test.rb", "test/atomicity_test.rb", "test/exceptions_test.rb", "test/association_indices_test.rb", "test/has_one_has_many_test.rb", "test/order_test.rb", "test/indices_test.rb", "test/changes_array_test.rb", "test/callbacks_test.rb", "test/basic_functionality_test.rb"]
+  s.test_files = [%q{test/atomicity_test.rb}, %q{test/indices_test.rb}, %q{test/sortable_test.rb}, %q{test/uuid_as_id_test.rb}, %q{test/test_helper.rb}, %q{test/options_test.rb}, %q{test/callbacks_test.rb}, %q{test/exceptions_test.rb}, %q{test/associations_test.rb}, %q{test/validations_test.rb}, %q{test/basic_functionality_test.rb}, %q{test/dynamic_finders_test.rb}, %q{test/changes_array_test.rb}, %q{test/polymorphic_test.rb}, %q{test/association_indices_test.rb}, %q{test/has_one_has_many_test.rb}]
 
   if s.respond_to? :specification_version then
     s.specification_version = 3

data/test/exceptions_test.rb

@@ -47,4 +47,9 @@ describe "exceptions test" do
     User.find(12).should == nil
     lambda{ User.find! 12 }.should raise_error(RedisOrm::RecordNotFound)
   end
+
+  it "should throw an exception if there was an error while creating object with #create! method" do
+    jigsaw = Jigsaw.create :title => "jigsaw"
+    lambda { User.create!(:name => "John", :age => 44, :profile => jigsaw) }.should raise_error(RedisOrm::TypeMismatchError)
+  end
 end

data/test/options_test.rb

@@ -69,7 +69,7 @@ describe "test options" do
     Album.find(:all, :limit => 1).size.should == 1
     Album.find!(:all, :limit => 1).size.should == 1
   end
-  
+
   it "should return correct array when :limit and :offset options are provided" do
     @album.photos.count.should == 0
 
@@ -88,8 +88,9 @@ describe "test options" do
     @album.photos.find(:all, :limit => 1, :offset => 1).size.should == 1
     
     Photo.find(:all).size.should == 2
-    Photo.find(:first).id.should == @photo1.id
-    Photo.find(:last).id.should == @photo2.id
+
+    Photo.find(:first).should == @photo1
+    Photo.find(:last).should == @photo2
     
     Photo.find(:all, :conditions => {:image => "facepalm.jpg"}).size.should == 1
     Photo.find(:all, :conditions => {:image => "boobs.png"}).size.should == 1
@@ -97,25 +98,25 @@ describe "test options" do
     Photo.find(:all, :conditions => {:image => "facepalm.jpg", :image_type => "jpg"}).size.should == 1
     Photo.find(:all, :conditions => {:image => "boobs.png", :image_type => "png"}).size.should == 1
         
-    Photo.find(:first, :conditions => {:image => "facepalm.jpg"}).id.should == @photo1.id
-    Photo.find(:first, :conditions => {:image => "boobs.png"}).id.should == @photo2.id
+    Photo.find(:first, :conditions => {:image => "facepalm.jpg"}).should == @photo1
+    Photo.find(:first, :conditions => {:image => "boobs.png"}).should == @photo2
     
-    Photo.find(:first, :conditions => {:image => "facepalm.jpg", :image_type => "jpg"}).id.should == @photo1.id
-    Photo.find(:first, :conditions => {:image => "boobs.png", :image_type => "png"}).id.should == @photo2.id
+    Photo.find(:first, :conditions => {:image => "facepalm.jpg", :image_type => "jpg"}).should == @photo1
+    Photo.find(:first, :conditions => {:image => "boobs.png", :image_type => "png"}).should == @photo2
     
-    Photo.find(:last, :conditions => {:image => "facepalm.jpg"}).id.should == @photo1.id
-    Photo.find(:last, :conditions => {:image => "boobs.png"}).id.should == @photo2.id
+    Photo.find(:last, :conditions => {:image => "facepalm.jpg"}).should == @photo1
+    Photo.find(:last, :conditions => {:image => "boobs.png"}).should == @photo2
     
-    Photo.find(:last, :conditions => {:image => "facepalm.jpg", :image_type => "jpg"}).id.should == @photo1.id
-    Photo.find(:last, :conditions => {:image => "boobs.png", :image_type => "png"}).id.should == @photo2.id
+    Photo.find(:last, :conditions => {:image => "facepalm.jpg", :image_type => "jpg"}).should == @photo1
+    Photo.find(:last, :conditions => {:image => "boobs.png", :image_type => "png"}).should == @photo2
   end
 
   it "should accept options for #first and #last methods" do
-    Photo.first(:conditions => {:image => "facepalm.jpg"}).id.should == @photo1.id
-    Photo.first(:conditions => {:image => "boobs.png"}).id.should == @photo2.id
+    Photo.first(:conditions => {:image => "facepalm.jpg"}).should == @photo1
+    Photo.first(:conditions => {:image => "boobs.png"}).should == @photo2
     
-    Photo.last(:conditions => {:image => "facepalm.jpg", :image_type => "jpg"}).id.should == @photo1.id
-    Photo.last(:conditions => {:image => "boobs.png", :image_type => "png"}).id.should == @photo2.id
+    Photo.last(:conditions => {:image => "facepalm.jpg", :image_type => "jpg"}).should == @photo1
+    Photo.last(:conditions => {:image => "boobs.png", :image_type => "png"}).should == @photo2
   end
   
   it "should correctly save boolean values" do

data/test/{order_test.rb → sortable_test.rb}

@@ -11,6 +11,11 @@ class User < RedisOrm::Base
   index :age
 end
 
+class SortableUser < RedisOrm::Base
+  property :name, String, :sortable => true
+  index :name
+end
+
 describe "test options" do
   before(:each) do
     @dan     = User.create :name => "Daniel",   :age => 26, :wage => 40000.0,   :address => "Bellevue"
@@ -18,9 +23,9 @@ describe "test options" do
     @michael = User.create :name => "Michael",  :age => 25, :wage => 60000.0,   :address => "Bellevue"
     @todd    = User.create :name => "Todd",     :age => 22, :wage => 30000.0,   :address => "Bellevue"
   end
-  
+
   it "should return records in specified order" do
-    $redis.zcard("user:name_ids").to_i.should == User.count
+    $redis.llen("user:name_ids").to_i.should == User.count
     $redis.zcard("user:age_ids").to_i.should == User.count
     $redis.zcard("user:wage_ids").to_i.should == User.count
     
@@ -49,11 +54,11 @@ describe "test options" do
     User.find(:all, :conditions => {:name => "Abe"}, :order => [:wage, :desc]).should == [@abe, @abe2]
     User.find(:all, :conditions => {:name => "Abe"}, :order => [:wage, :asc]).should == [@abe2, @abe]
   end
-  
+
   it "should update keys after the persisted object was edited and sort properly" do
     @abe.update_attributes :name => "Zed", :age => 12, :wage => 10.0, :address => "Santa Fe"
 
-    $redis.zcard("user:name_ids").to_i.should == User.count
+    $redis.llen("user:name_ids").to_i.should == User.count
     $redis.zcard("user:age_ids").to_i.should == User.count
     $redis.zcard("user:wage_ids").to_i.should == User.count
 
@@ -66,4 +71,60 @@ describe "test options" do
     User.find(:all, :order => [:wage, :asc]).should == [@abe, @todd, @dan, @michael]
     User.find(:all, :order => [:wage, :desc]).should == [@michael, @dan, @todd, @abe]
   end
+
+  it "should update keys after the persisted object was deleted and sort properly" do
+    user_count = User.count
+    @abe.destroy
+
+    $redis.llen("user:name_ids").to_i.should == user_count - 1
+    $redis.zcard("user:age_ids").to_i.should == user_count - 1
+    $redis.zcard("user:wage_ids").to_i.should == user_count - 1
+
+    User.find(:all, :order => [:name, :asc]).should == [@dan, @michael, @todd]
+    User.find(:all, :order => [:name, :desc]).should == [@todd, @michael, @dan]
+        
+    User.find(:all, :order => [:age, :asc]).should == [@todd, @michael, @dan]
+    User.find(:all, :order => [:age, :desc]).should == [@dan, @michael, @todd]
+    
+    User.find(:all, :order => [:wage, :asc]).should == [@todd, @dan, @michael]
+    User.find(:all, :order => [:wage, :desc]).should == [@michael, @dan, @todd]
+  end
+
+  it "should sort objects with more than 3-4 symbols" do
+    vladislav = User.create :name => "Vladislav", :age => 19, :wage => 120.0
+    vladimir = User.create :name => "Vladimir", :age => 22, :wage => 220.5
+    vlad = User.create :name => "Vlad", :age => 29, :wage => 1200.0
+    
+    User.find(:all, :order => [:name, :desc], :limit => 3).should == [vladislav, vladimir, vlad]
+    User.find(:all, :order => [:name, :desc], :limit => 2, :offset => 4).should == [@michael, @dan]
+    User.find(:all, :order => [:name, :desc], :offset => 3).should == [@todd, @michael, @dan, @abe]
+    User.find(:all, :order => [:name, :desc]).should == [vladislav, vladimir, vlad, @todd, @michael, @dan, @abe]
+
+    User.find(:all, :order => [:name, :asc], :limit => 3, :offset => 4).should == [vlad, vladimir, vladislav]
+    User.find(:all, :order => [:name, :asc], :offset => 3).should == [@todd, vlad, vladimir, vladislav]
+    User.find(:all, :order => [:name, :asc], :limit => 3).should == [@abe, @dan, @michael]
+    User.find(:all, :order => [:name, :asc]).should == [@abe, @dan, @michael, @todd, vlad, vladimir, vladislav]
+  end
+
+  it "should properly handle multiple users with almost the same names" do
+    users = []
+    20.times{|i| users << SortableUser.create(:name => "user#{i}") }
+    SortableUser.all(:order => [:name, :asc]).should == users.sort{|n,m| n.name <=> m.name}
+  end
+
+  it "should properly handle multiple users with almost the same names (descending order)" do
+    rev_users = []
+    20.times{|i| rev_users << SortableUser.create(:name => "user#{i}") }
+    SortableUser.all(:order => [:name, :desc]).should == rev_users.sort{|n,m| n.name <=> m.name}.reverse
+  end
+
+  it "should properly store records with the same names" do
+    users = []
+    users << SortableUser.create(:name => "user#1")
+    users << SortableUser.create(:name => "user#2")
+    users << SortableUser.create(:name => "user#1")
+    users << SortableUser.create(:name => "user#2")
+    SortableUser.all(:order => [:name, :desc]).should == users.sort{|n,m| n.name <=> m.name}.reverse
+    SortableUser.all(:order => [:name, :asc]).should == users.sort{|n,m| n.name <=> m.name}
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redis_orm
 version: !ruby/object:Gem::Version
-  version: '0.6'
+  version: 0.6.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,12 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-09-12 00:00:00.000000000 +03:00
-default_executable: 
+date: 2011-12-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
-  requirement: &74101100 !ruby/object:Gem::Requirement
+  requirement: &17352020 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -22,10 +21,10 @@ dependencies:
         version: 3.0.0
   type: :runtime
   prerelease: false
-  version_requirements: *74101100
+  version_requirements: *17352020
 - !ruby/object:Gem::Dependency
   name: activemodel
-  requirement: &74100700 !ruby/object:Gem::Requirement
+  requirement: &17367880 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -33,10 +32,10 @@ dependencies:
         version: 3.0.0
   type: :runtime
   prerelease: false
-  version_requirements: *74100700
+  version_requirements: *17367880
 - !ruby/object:Gem::Dependency
   name: redis
-  requirement: &74100190 !ruby/object:Gem::Requirement
+  requirement: &17367380 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -44,10 +43,10 @@ dependencies:
         version: 2.2.0
   type: :runtime
   prerelease: false
-  version_requirements: *74100190
+  version_requirements: *17367380
 - !ruby/object:Gem::Dependency
   name: uuid
-  requirement: &74099680 !ruby/object:Gem::Requirement
+  requirement: &17366880 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -55,10 +54,10 @@ dependencies:
         version: 2.3.2
   type: :runtime
   prerelease: false
-  version_requirements: *74099680
+  version_requirements: *17366880
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &74099250 !ruby/object:Gem::Requirement
+  requirement: &17366380 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -66,7 +65,7 @@ dependencies:
         version: 2.5.0
   type: :development
   prerelease: false
-  version_requirements: *74099250
+  version_requirements: *17366380
 description: ORM for Redis (advanced key-value storage) with ActiveRecord API
 email: germaninthetown@gmail.com
 executables: []
@@ -86,10 +85,12 @@ extra_rdoc_files:
 - lib/redis_orm/utils.rb
 files:
 - CHANGELOG
+- Gemfile
 - LICENSE
 - Manifest
 - README.md
 - Rakefile
+- benchmarks/sortable_benchmark.rb
 - lib/redis_orm.rb
 - lib/redis_orm/active_model_behavior.rb
 - lib/redis_orm/associations/belongs_to.rb
@@ -111,13 +112,12 @@ files:
 - test/has_one_has_many_test.rb
 - test/indices_test.rb
 - test/options_test.rb
-- test/order_test.rb
 - test/polymorphic_test.rb
 - test/redis.conf
+- test/sortable_test.rb
 - test/test_helper.rb
 - test/uuid_as_id_test.rb
 - test/validations_test.rb
-has_rdoc: true
 homepage: https://github.com/german/redis_orm
 licenses: []
 post_install_message: 
@@ -144,24 +144,24 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '1.2'
 requirements: []
 rubyforge_project: redis_orm
-rubygems_version: 1.6.2
+rubygems_version: 1.8.6
 signing_key: 
 specification_version: 3
 summary: ORM for Redis (advanced key-value storage) with ActiveRecord API
 test_files:
+- test/atomicity_test.rb
+- test/indices_test.rb
+- test/sortable_test.rb
+- test/uuid_as_id_test.rb
+- test/test_helper.rb
 - test/options_test.rb
-- test/dynamic_finders_test.rb
+- test/callbacks_test.rb
+- test/exceptions_test.rb
 - test/associations_test.rb
 - test/validations_test.rb
-- test/test_helper.rb
+- test/basic_functionality_test.rb
+- test/dynamic_finders_test.rb
+- test/changes_array_test.rb
 - test/polymorphic_test.rb
-- test/uuid_as_id_test.rb
-- test/atomicity_test.rb
-- test/exceptions_test.rb
 - test/association_indices_test.rb
 - test/has_one_has_many_test.rb
-- test/order_test.rb
-- test/indices_test.rb
-- test/changes_array_test.rb
-- test/callbacks_test.rb
-- test/basic_functionality_test.rb