redis-objects 0.7.0 → 0.8.0

data/lib/redis/hash_key.rb

@@ -118,7 +118,7 @@ class Redis
 
     # Set keys in bulk if they do not exist. Takes a hash of field/values {'field1' => 'val1'}. Redis: HSETNX
     def fill(pairs={})
-      raise ArgumentErorr, "Arugment to fill must be a hash of key/value pairs" unless pairs.is_a?(::Hash)
+      raise ArgumentError, "Arugment to fill must be a hash of key/value pairs" unless pairs.is_a?(::Hash)
       pairs.each do |field, value|
         redis.hsetnx(key, field, to_redis(value, options[:marshal_keys][field]))
       end

data/lib/redis/list.rb

@@ -20,15 +20,15 @@ class Redis
       push(value)
       self  # for << 'a' << 'b'
     end
-	
+
     # Add a member before or after pivot in the list. Redis: LINSERT
     def insert(where,pivot,value)
       redis.linsert(key,where,to_redis(pivot),to_redis(value))
     end
 
     # Add a member to the end of the list. Redis: RPUSH
-    def push(value)
-      redis.rpush(key, to_redis(value))
+    def push(*values)
+      redis.rpush(key, values.map{|v| to_redis(v) })
       redis.ltrim(key, -options[:maxlength], -1) if options[:maxlength]
     end
 
@@ -50,8 +50,8 @@ class Redis
     end
 
     # Add a member to the start of the list. Redis: LPUSH
-    def unshift(value)
-      redis.lpush(key, to_redis(value))
+    def unshift(*values)
+      redis.lpush(key, values.map{|v| to_redis(v) })
       redis.ltrim(key, 0, options[:maxlength] - 1) if options[:maxlength]
     end
 
@@ -88,7 +88,7 @@ class Redis
 
     # Same functionality as Ruby arrays.
     def []=(index, value)
-      redis.lset(key, index, value)
+      redis.lset(key, index, to_redis(value))
     end
 
     # Delete the element(s) from the list that match name. If count is specified,
@@ -132,16 +132,16 @@ class Redis
       redis.llen(key)
     end
     alias_method :size, :length
-   
+
     # Returns true if there are no elements in the list. Redis: LLEN == 0
     def empty?
       length == 0
     end
- 
+
     def ==(x)
       values == x
     end
-    
+
     def to_s
       values.join(', ')
     end

data/lib/redis/objects.rb

@@ -109,19 +109,24 @@ class Redis
           downcase
       end
 
-      def redis_field_key(name, id=nil) #:nodoc:
+      def redis_field_key(name, id=nil, context=self) #:nodoc:
         klass = first_ancestor_with(name)
         # READ THIS: This can never ever ever ever change or upgrades will corrupt all data
         # I don't think people were using Proc as keys before (that would create a weird key). Should be ok
-        key = klass.redis_objects[name.to_sym][:key]
-        if key && key.respond_to?(:call)
-          key = key.call self
-        end
-        if id.nil? and !klass.redis_objects[name.to_sym][:global]
-          raise NilObjectId,
-            "[#{klass.redis_objects[name.to_sym]}] Attempt to address redis-object :#{name} on class #{klass.name} with nil id (unsaved record?) [object_id=#{object_id}]"
+        if key = klass.redis_objects[name.to_sym][:key]
+          if key.respond_to?(:call)
+            key = key.call context
+          else
+            context.instance_eval "%(#{key})"
+          end
+        else
+          if id.nil? and !klass.redis_objects[name.to_sym][:global]
+            raise NilObjectId,
+              "[#{klass.redis_objects[name.to_sym]}] Attempt to address redis-object " +
+              ":#{name} on class #{klass.name} with nil id (unsaved record?) [object_id=#{object_id}]"
+          end
+          "#{redis_prefix(klass)}:#{id}:#{name}"
         end
-        key || "#{redis_prefix(klass)}:#{id}:#{name}"
       end
 
       def first_ancestor_with(name)
@@ -131,27 +136,20 @@ class Redis
           superclass.first_ancestor_with(name)
         end
       end
+
+      def redis_id_field(id=nil)
+        @redis_id_field = id || @redis_id_field || :id
+      end
     end
 
     # Instance methods that appear in your class when you include Redis::Objects.
     module InstanceMethods
-      def redis() self.class.redis end
+      # Map up one level to make modular extend/include approach sane
+      def redis()         self.class.redis end
+      def redis_objects() self.class.redis_objects end
+
       def redis_field_key(name) #:nodoc:
-        klass = self.class.first_ancestor_with(name)
-        if key = klass.redis_objects[name.to_sym][:key]
-          if key.respond_to?(:call)
-            key.call self
-          else
-            eval "%(#{key})"
-          end
-        else
-          if id.nil? and !klass.redis_objects[name.to_sym][:global]
-            raise NilObjectId,
-              "Attempt to address redis-object :#{name} on class #{klass.name} with nil id (unsaved record?) [object_id=#{object_id}]"
-          end
-          # don't try to refactor into class redis_field_key because fucks up eval context
-          "#{klass.redis_prefix}:#{id}:#{name}"
-        end
+        self.class.redis_field_key(name, send(self.class.redis_id_field), self)
       end
     end
   end

data/lib/redis/objects/counters.rb

@@ -23,24 +23,27 @@ class Redis
           options[:start] ||= 0
           options[:type]  ||= options[:start] == 0 ? :increment : :decrement
           redis_objects[name.to_sym] = options.merge(:type => :counter)
-          klass_name = '::' + self.name
+
+          mod = Module.new do
+            define_method(name) do
+              instance_variable_get("@#{name}") or
+                instance_variable_set("@#{name}",
+                  Redis::Counter.new(
+                    redis_field_key(name), redis, redis_objects[name.to_sym]
+                  )
+                )
+            end
+          end
+
           if options[:global]
-            instance_eval <<-EndMethods
-              def #{name}
-                @#{name} ||= Redis::Counter.new(redis_field_key(:#{name}), #{klass_name}.redis, #{klass_name}.redis_objects[:#{name}])
-              end
-            EndMethods
-            class_eval <<-EndMethods
-              def #{name}
-                self.class.#{name}
-              end
-            EndMethods
+            extend mod
+
+            # dispatch to class methods
+            define_method(name) do
+              self.class.public_send(name)
+            end
           else
-            class_eval <<-EndMethods
-              def #{name}
-                @#{name} ||= Redis::Counter.new(redis_field_key(:#{name}), #{klass_name}.redis, #{klass_name}.redis_objects[:#{name}])
-              end
-            EndMethods
+            include mod
           end
         end
 

data/lib/redis/objects/hashes.rb

@@ -15,24 +15,27 @@ class Redis
         # method, so it can be used alongside ActiveRecord, DataMapper, etc.
         def hash_key(name, options={})
           redis_objects[name.to_sym] = options.merge(:type => :dict)
-          klass_name = '::' + self.name
+
+          mod = Module.new do
+            define_method(name) do
+              instance_variable_get("@#{name}") or
+                instance_variable_set("@#{name}",
+                  Redis::HashKey.new(
+                    redis_field_key(name), redis, redis_objects[name.to_sym]
+                  )
+                )
+            end
+          end
+
           if options[:global]
-            instance_eval <<-EndMethods
-              def #{name}
-                @#{name} ||= Redis::HashKey.new(redis_field_key(:#{name}), #{klass_name}.redis, #{klass_name}.redis_objects[:#{name}])
-              end
-            EndMethods
-            class_eval <<-EndMethods
-              def #{name}
-                self.class.#{name}
-              end
-            EndMethods
+            extend mod
+
+            # dispatch to class methods
+            define_method(name) do
+              self.class.public_send(name)
+            end
           else
-            class_eval <<-EndMethods
-              def #{name}
-                @#{name} ||= Redis::HashKey.new(redis_field_key(:#{name}), #{klass_name}.redis, #{klass_name}.redis_objects[:#{name}])
-              end
-            EndMethods
+            include mod
           end
         end
       end

data/lib/redis/objects/lists.rb

@@ -15,24 +15,27 @@ class Redis
         # method, so it can be used alongside ActiveRecord, DataMapper, etc.
         def list(name, options={})
           redis_objects[name.to_sym] = options.merge(:type => :list)
-          klass_name = '::' + self.name
+
+          mod = Module.new do
+            define_method(name) do
+              instance_variable_get("@#{name}") or
+                instance_variable_set("@#{name}",
+                  Redis::List.new(
+                    redis_field_key(name), redis, redis_objects[name.to_sym]
+                  )
+                )
+            end
+          end
+
           if options[:global]
-            instance_eval <<-EndMethods
-              def #{name}
-                @#{name} ||= Redis::List.new(redis_field_key(:#{name}), #{klass_name}.redis, #{klass_name}.redis_objects[:#{name}])
-              end
-            EndMethods
-            class_eval <<-EndMethods
-              def #{name}
-                self.class.#{name}
-              end
-            EndMethods
+            extend mod
+
+            # dispatch to class methods
+            define_method(name) do
+              self.class.public_send(name)
+            end
           else
-            class_eval <<-EndMethods
-              def #{name}
-                @#{name} ||= Redis::List.new(redis_field_key(:#{name}), #{klass_name}.redis, #{klass_name}.redis_objects[:#{name}])
-              end
-            EndMethods
+            include mod
           end
         end
       end

data/lib/redis/objects/locks.rb

@@ -18,24 +18,27 @@ class Redis
           options[:timeout] ||= 5  # seconds
           lock_name = "#{name}_lock"
           redis_objects[lock_name.to_sym] = options.merge(:type => :lock)
-          klass_name = '::' + self.name
+
+          mod = Module.new do
+            define_method(lock_name) do |&block|
+              instance_variable_get("@#{lock_name}") or
+                instance_variable_set("@#{lock_name}",
+                  Redis::Lock.new(
+                    redis_field_key(lock_name), redis, redis_objects[lock_name.to_sym]
+                  )
+                )
+            end
+          end
+
           if options[:global]
-            instance_eval <<-EndMethods
-              def #{lock_name}(&block)
-                @#{lock_name} ||= Redis::Lock.new(redis_field_key(:#{lock_name}), #{klass_name}.redis, #{klass_name}.redis_objects[:#{lock_name}])
-              end
-            EndMethods
-            class_eval <<-EndMethods
-              def #{lock_name}(&block)
-                self.class.#{lock_name}(block)
-              end
-            EndMethods
+            extend mod
+
+            # dispatch to class methods
+            define_method(lock_name) do |&block|
+              self.class.public_send(lock_name, &block)
+            end
           else
-            class_eval <<-EndMethods
-              def #{lock_name}(&block)
-                @#{lock_name} ||= Redis::Lock.new(redis_field_key(:#{lock_name}), #{klass_name}.redis, #{klass_name}.redis_objects[:#{lock_name}])
-              end
-            EndMethods
+            include mod
           end
         end
 

data/lib/redis/objects/sets.rb

@@ -15,26 +15,28 @@ class Redis
         # method, so it can be used alongside ActiveRecord, DataMapper, etc.
         def set(name, options={})
           redis_objects[name.to_sym] = options.merge(:type => :set)
-          klass_name = '::' + self.name
+
+          mod = Module.new do
+            define_method(name) do
+              instance_variable_get("@#{name}") or
+                instance_variable_set("@#{name}",
+                  Redis::Set.new(
+                    redis_field_key(name), redis, redis_objects[name.to_sym]
+                  )
+                )
+            end
+          end
+
           if options[:global]
-            instance_eval <<-EndMethods
-              def #{name}
-                @#{name} ||= Redis::Set.new(redis_field_key(:#{name}), #{klass_name}.redis, #{klass_name}.redis_objects[:#{name}])
-              end
-            EndMethods
-            class_eval <<-EndMethods
-              def #{name}
-                self.class.#{name}
-              end
-            EndMethods
+            extend mod
+
+            # dispatch to class methods
+            define_method(name) do
+              self.class.public_send(name)
+            end
           else
-            class_eval <<-EndMethods
-              def #{name}
-                @#{name} ||= Redis::Set.new(redis_field_key(:#{name}), #{klass_name}.redis, #{klass_name}.redis_objects[:#{name}])
-              end
-            EndMethods
+            include mod
           end
-
         end
       end
 

data/lib/redis/objects/sorted_sets.rb

@@ -15,24 +15,27 @@ class Redis
         # method, so it can be used alongside ActiveRecord, DataMapper, etc.
         def sorted_set(name, options={})
           redis_objects[name.to_sym] = options.merge(:type => :sorted_set)
-          klass_name = '::' + self.name
+
+          mod = Module.new do
+            define_method(name) do
+              instance_variable_get("@#{name}") or
+                instance_variable_set("@#{name}",
+                  Redis::SortedSet.new(
+                    redis_field_key(name), redis, redis_objects[name.to_sym]
+                  )
+                )
+            end
+          end
+
           if options[:global]
-            instance_eval <<-EndMethods
-              def #{name}
-                @#{name} ||= Redis::SortedSet.new(redis_field_key(:#{name}), #{klass_name}.redis, #{klass_name}.redis_objects[:#{name}])
-              end
-            EndMethods
-            class_eval <<-EndMethods
-              def #{name}
-                self.class.#{name}
-              end
-            EndMethods
+            extend mod
+
+            # dispatch to class methods
+            define_method(name) do
+              self.class.public_send(name)
+            end
           else
-            class_eval <<-EndMethods
-              def #{name}
-                @#{name} ||= Redis::SortedSet.new(redis_field_key(:#{name}), #{klass_name}.redis, #{klass_name}.redis_objects[:#{name}])
-              end
-            EndMethods
+            include mod
           end
         end
       end

data/lib/redis/objects/values.rb

@@ -15,35 +15,34 @@ class Redis
         # method, so it can be used alongside ActiveRecord, DataMapper, etc.
         def value(name, options={})
           redis_objects[name.to_sym] = options.merge(:type => :value)
-          klass_name = '::' + self.name
+
+          mod = Module.new do
+            define_method(name) do
+              instance_variable_get("@#{name}") or
+                instance_variable_set("@#{name}",
+                  Redis::Value.new(
+                    redis_field_key(name), redis, redis_objects[name.to_sym]
+                  )
+                )
+            end
+            define_method("#{name}=") do |value|
+              public_send(name).value = value
+            end
+          end
+
           if options[:global]
-            instance_eval <<-EndMethods
-              def #{name}
-                @#{name} ||= Redis::Value.new(redis_field_key(:#{name}), #{klass_name}.redis, #{klass_name}.redis_objects[:#{name}])
-              end
-              def #{name}=(value)
-                #{name}.value = value
-              end
-            EndMethods
-            class_eval <<-EndMethods
-              def #{name}
-                self.class.#{name}
-              end
-              def #{name}=(value)
-                self.class.#{name} = value
-              end
-            EndMethods
+            extend mod
+
+            # dispatch to class methods
+            define_method(name) do
+              self.class.public_send(name)
+            end
+            define_method("#{name}=") do |value|
+              self.class.public_send("#{name}=", value)
+            end
           else
-            class_eval <<-EndMethods
-              def #{name}
-                @#{name} ||= Redis::Value.new(redis_field_key(:#{name}), #{klass_name}.redis, #{klass_name}.redis_objects[:#{name}])
-              end
-              def #{name}=(value)
-                #{name}.value = value
-              end
-            EndMethods
+            include mod
           end
-
         end
       end