lib/ohm.rb in ohm-1.3.0 vs lib/ohm.rb in ohm-1.3.1

@@ -1145,11 +1145,11 @@
     def load!
       update_attributes(db.hgetall(key)) unless new?
       return self
     end
 
-    # Read an attribute remotly from Redis. Useful if you want to get
+    # Read an attribute remotely from Redis. Useful if you want to get
     # the most recent value of the attribute and not rely on locally
     # cached value.
     #
     # Example:
     #
@@ -1303,23 +1303,29 @@
 
         _uniques = nil
         uniques  = nil
         _indices = nil
         indices  = nil
+        existing_indices = nil
+        existing_uniques = nil
 
         t.read do
           _verify_uniques
+          existing_indices = _read_attributes(model.indices) if model.indices.any?
+          existing_uniques = _read_attributes(model.uniques) if model.uniques.any?
           _uniques = db.hgetall(key[:_uniques])
           _indices = db.smembers(key[:_indices])
           uniques  = _read_index_type(:uniques)
           indices  = _read_index_type(:indices)
         end
 
         t.write do
           db.sadd(model.key[:all], id)
-          _delete_uniques(_uniques)
+          _delete_existing_indices(existing_indices)
+          _delete_existing_uniques(existing_uniques)
           _delete_indices(_indices)
+          _delete_uniques(_uniques)
           _save
           _save_indices(indices)
           _save_uniques(uniques)
         end
       end
@@ -1335,25 +1341,28 @@
     #
     def delete
       transaction do |t|
         _uniques = nil
         _indices = nil
+        existing = nil
 
         t.watch(*_unique_keys)
 
         t.watch(key)
         t.watch(key[:_indices]) if model.indices.any?
         t.watch(key[:_uniques]) if model.uniques.any?
 
         t.read do
+          existing = _read_attributes(model.indices) if model.indices.any?
           _uniques = db.hgetall(key[:_uniques])
           _indices = db.smembers(key[:_indices])
         end
 
         t.write do
           _delete_uniques(_uniques)
           _delete_indices(_indices)
+          _delete_existing_indices(existing)
           model.collections.each { |e| db.del(key[e]) }
           db.srem(model.key[:all], id)
           db.del(key[:counters])
           db.del(key)
         end
@@ -1496,37 +1505,62 @@
         end
       end
     end
 
     def _save_uniques(uniques)
+      attrs = model.attributes
+
       uniques.each do |att, val|
         unique = model.key[:uniques][att]
 
         db.hset(unique, val, id)
-        db.hset(key[:_uniques], unique, val)
+        db.hset(key[:_uniques], unique, val) unless attrs.include?(att)
       end
     end
 
     def _delete_uniques(uniques)
       uniques.each do |unique, val|
         db.hdel(unique, val)
         db.hdel(key[:_uniques], unique)
       end
     end
 
+    def _delete_existing_indices(existing)
+      return unless existing
+
+      existing = existing.map { |key, value| model.to_indices(key, value) }
+      existing.flatten!(1)
+
+      _delete_indices(existing)
+    end
+
+    def _delete_existing_uniques(existing)
+      return unless existing
+
+      _delete_uniques(existing.map { |key, value|
+        [model.key[:uniques][key], value]
+      })
+    end
+
     def _delete_indices(indices)
       indices.each do |index|
         db.srem(index, id)
         db.srem(key[:_indices], index)
       end
     end
 
     def _save_indices(indices)
+      attrs = model.attributes
+
       indices.each do |att, val|
         model.to_indices(att, val).each do |index|
           db.sadd(index, id)
-          db.sadd(key[:_indices], index)
+          db.sadd(key[:_indices], index) unless attrs.include?(att)
         end
       end
+    end
+
+    def _read_attributes(attrs)
+      Hash[attrs.zip(db.hmget(key, *attrs))]
     end
   end
 end