redis-objects-legacy 1.6.0

data/lib/redis/objects/counters.rb

@@ -0,0 +1,155 @@
+# This is the class loader, for use as "include Redis::Objects::Counters"
+# For the object itself, see "Redis::Counter"
+require 'redis/counter'
+class Redis
+  module Objects
+    class UndefinedCounter < StandardError; end #:nodoc:
+    class MissingID < StandardError; end #:nodoc:
+
+    module Counters
+      def self.included(klass)
+        klass.instance_variable_set('@initialized_counters', {})
+        klass.send :include, InstanceMethods
+        klass.extend ClassMethods
+      end
+
+      # Class methods that appear in your class when you include Redis::Objects.
+      module ClassMethods
+        attr_reader :initialized_counters
+
+        # Define a new counter.  It will function like a regular instance
+        # method, so it can be used alongside ActiveRecord, DataMapper, etc.
+        def counter(name, options={})
+          options[:start] ||= 0
+          options[:type]  ||= options[:start] == 0 ? :increment : :decrement
+          redis_objects[name.to_sym] = options.merge(:type => :counter)
+          ivar_name = :"@#{name}"
+
+          mod = Module.new do
+            define_method(name) do
+              instance_variable_get(ivar_name) or
+                instance_variable_set(ivar_name,
+                  Redis::Counter.new(
+                    redis_field_key(name), redis_field_redis(name), redis_options(name)
+                  )
+                )
+            end
+          end
+
+          if options[:global]
+            extend mod
+
+            # dispatch to class methods
+            define_method(name) do
+              self.class.public_send(name)
+            end
+          else
+            include mod
+          end
+        end
+
+        # Get the current value of the counter. It is more efficient
+        # to use the instance method if possible.
+        def get_counter(name, id=nil)
+          verify_counter_defined!(name, id)
+          initialize_counter!(name, id)
+          redis.get(redis_field_key(name, id)).to_i
+        end
+
+        # Increment a counter with the specified name and id.  Accepts a block
+        # like the instance method.  See Redis::Objects::Counter for details.
+        def increment_counter(name, id=nil, by=1, &block)
+          name = name.to_sym
+          return super(name, id) unless counter_defined?(name)
+          verify_counter_defined!(name, id)
+          initialize_counter!(name, id)
+          value = redis.incrby(redis_field_key(name, id), by).to_i
+          block_given? ? rewindable_block(:decrement_counter, name, id, by, value, &block) : value
+        end
+
+        # Decrement a counter with the specified name and id.  Accepts a block
+        # like the instance method.  See Redis::Objects::Counter for details.
+        def decrement_counter(name, id=nil, by=1, &block)
+          name = name.to_sym
+          return super(name, id) unless counter_defined?(name)
+          verify_counter_defined!(name, id)
+          initialize_counter!(name, id)
+          value = redis.decrby(redis_field_key(name, id), by).to_i
+          block_given? ? rewindable_block(:increment_counter, name, id, by, value, &block) : value
+        end
+
+        # Reset a counter to its starting value.
+        def reset_counter(name, id=nil, to=nil)
+          verify_counter_defined!(name, id)
+          to = redis_objects[name][:start] if to.nil?
+          redis.set(redis_field_key(name, id), to.to_i)
+          true
+        end
+
+        # Set a counter to its starting value and return the old value.
+        def getset_counter(name, id=nil, to=nil)
+          verify_counter_defined!(name, id)
+          to = redis_objects[name][:start] if to.nil?
+          redis.getset(redis_field_key(name, id), to.to_i).to_i
+        end
+
+        def counter_defined?(name) #:nodoc:
+          redis_objects && redis_objects.has_key?(name.to_sym)
+        end
+
+        private
+
+        def verify_counter_defined!(name, id) #:nodoc:
+          raise NoMethodError, "Undefined counter :#{name} for class #{self.name}" unless counter_defined?(name)
+          if id.nil? and !redis_objects[name][:global]
+            raise Redis::Objects::MissingID, "Missing ID for non-global counter #{self.name}##{name}"
+          end
+        end
+
+        def initialize_counter!(name, id) #:nodoc:
+          key = redis_field_key(name, id)
+          unless @initialized_counters[key]
+            redis.setnx(key, redis_objects[name][:start])
+          end
+          @initialized_counters[key] = true
+        end
+
+        # Implements increment/decrement blocks on a class level
+        def rewindable_block(rewind, name, id, by, value, &block) #:nodoc:
+          # Unfortunately this is almost exactly duplicated from Redis::Counter
+          raise ArgumentError, "Missing block to rewindable_block somehow" unless block_given?
+          ret = nil
+          begin
+            ret = yield value
+          rescue
+            send(rewind, name, id, by)
+            raise
+          end
+          send(rewind, name, id, by) if ret.nil?
+          ret
+        end
+      end
+
+      # Instance methods that appear in your class when you include Redis::Objects.
+      module InstanceMethods
+        # Increment a counter. Called mainly in the context of :counter_cache
+        def increment(name, by=1)
+          if self.class.counter_defined?(name)
+            send(name).increment(by)
+          else
+            super # ActiveRecord
+          end
+        end
+
+        # Decrement a counter. Called mainly in the context of :counter_cache
+        def decrement(name, by=1)
+          if self.class.counter_defined?(name)
+            send(name).decrement(by)
+          else
+            super # ActiveRecord
+          end
+        end
+      end
+    end
+  end
+end

data/lib/redis/objects/hashes.rb

@@ -0,0 +1,60 @@
+# This is the class loader, for use as "include Redis::Objects::Hashes"
+# For the object itself, see "Redis::Hash"
+require 'redis/hash_key'
+class Redis
+  module Objects
+    module Hashes
+      def self.included(klass)
+        klass.send :include, InstanceMethods
+        klass.extend ClassMethods
+      end
+
+      # Class methods that appear in your class when you include Redis::Objects.
+      module ClassMethods
+        # Define a new hash key.  It will function like a regular instance
+        # method, so it can be used alongside ActiveRecord, DataMapper, etc.
+        def hash_key(name, options={})
+          redis_objects[name.to_sym] = options.merge(:type => :dict)
+          ivar_name = :"@#{name}"
+
+          mod = Module.new do
+            define_method(name) do
+              instance_variable_get(ivar_name) or
+                instance_variable_set(ivar_name,
+                  Redis::HashKey.new(
+                    redis_field_key(name), redis_field_redis(name), redis_options(name)
+                  )
+                )
+            end
+
+            define_method(:"#{name}=") do |values|
+              hash_key = public_send(name)
+
+              redis.pipelined do
+                hash_key.clear
+                hash_key.bulk_set(values)
+              end
+            end
+          end
+
+          if options[:global]
+            extend mod
+
+            # dispatch to class methods
+            define_method(name) do
+              self.class.public_send(name)
+            end
+          else
+            include mod
+          end
+        end
+      end
+
+      # Instance methods that appear in your class when you include Redis::Objects.
+      module InstanceMethods
+      end
+    end
+  end
+end
+
+

data/lib/redis/objects/lists.rb

@@ -0,0 +1,58 @@
+# This is the class loader, for use as "include Redis::Objects::Lists"
+# For the object itself, see "Redis::List"
+require 'redis/list'
+class Redis
+  module Objects
+    module Lists
+      def self.included(klass)
+        klass.send :include, InstanceMethods
+        klass.extend ClassMethods
+      end
+
+      # Class methods that appear in your class when you include Redis::Objects.
+      module ClassMethods
+        # Define a new list.  It will function like a regular instance
+        # method, so it can be used alongside ActiveRecord, DataMapper, etc.
+        def list(name, options={})
+          redis_objects[name.to_sym] = options.merge(:type => :list)
+          ivar_name = :"@#{name}"
+
+          mod = Module.new do
+            define_method(name) do
+              instance_variable_get(ivar_name) or
+                instance_variable_set(ivar_name,
+                  Redis::List.new(
+                    redis_field_key(name), redis_field_redis(name), redis_options(name)
+                  )
+                )
+            end
+
+            define_method(:"#{name}=") do |values|
+              list = public_send(name)
+
+              redis.pipelined do
+                list.clear
+                list.push(*values)
+              end
+            end
+          end
+
+          if options[:global]
+            extend mod
+
+            # dispatch to class methods
+            define_method(name) do
+              self.class.public_send(name)
+            end
+          else
+            include mod
+          end
+        end
+      end
+
+      # Instance methods that appear in your class when you include Redis::Objects.
+      module InstanceMethods
+      end
+    end
+  end
+end

data/lib/redis/objects/locks.rb

@@ -0,0 +1,73 @@
+# This is the class loader, for use as "include Redis::Objects::Locks"
+# For the object itself, see "Redis::Lock"
+require 'redis/lock'
+class Redis
+  module Objects
+    class UndefinedLock < StandardError; end #:nodoc:
+    module Locks
+      def self.included(klass)
+        klass.send :include, InstanceMethods
+        klass.extend ClassMethods
+      end
+
+      # Class methods that appear in your class when you include Redis::Objects.
+      module ClassMethods
+        # Define a new lock.  It will function like a model attribute,
+        # so it can be used alongside ActiveRecord/DataMapper, etc.
+        def lock(name, options={})
+          options[:timeout] ||= 5  # seconds
+          lock_name = "#{name}_lock"
+          redis_objects[lock_name.to_sym] = options.merge(:type => :lock)
+          ivar_name = :"@#{lock_name}"
+
+          mod = Module.new do
+            define_method(lock_name) do |&block|
+              instance_variable_get(ivar_name) or
+                instance_variable_set(ivar_name,
+                  Redis::Lock.new(
+                    redis_field_key(lock_name), redis_field_redis(lock_name), redis_objects[lock_name.to_sym]
+                  )
+                )
+            end
+          end
+
+          if options[:global]
+            extend mod
+
+            # dispatch to class methods
+            define_method(lock_name) do |&block|
+              self.class.public_send(lock_name, &block)
+            end
+          else
+            include mod
+          end
+        end
+
+        # Obtain a lock, and execute the block synchronously.  Any other code
+        # (on any server) will spin waiting for the lock up to the :timeout
+        # that was specified when the lock was defined.
+        def obtain_lock(name, id, &block)
+          verify_lock_defined!(name)
+          raise ArgumentError, "Missing block to #{self.name}.obtain_lock" unless block_given?
+          lock_name = "#{name}_lock"
+          Redis::Lock.new(redis_field_key(lock_name, id), redis_field_redis(lock_name), redis_objects[lock_name.to_sym]).lock(&block)
+        end
+
+        # Clear the lock.  Use with care - usually only in an Admin page to clear
+        # stale locks (a stale lock should only happen if a server crashes.)
+        def clear_lock(name, id)
+          verify_lock_defined!(name)
+          redis.del(redis_field_key("#{name}_lock", id))
+        end
+
+        private
+
+        def verify_lock_defined!(name)
+          unless redis_objects.has_key?("#{name}_lock".to_sym)
+            raise Redis::Objects::UndefinedLock, "Undefined lock :#{name} for class #{self.name}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/redis/objects/sets.rb

@@ -0,0 +1,58 @@
+# This is the class loader, for use as "include Redis::Objects::Sets"
+# For the object itself, see "Redis::Set"
+require 'redis/set'
+class Redis
+  module Objects
+    module Sets
+      def self.included(klass)
+        klass.send :include, InstanceMethods
+        klass.extend ClassMethods
+      end
+
+      # Class methods that appear in your class when you include Redis::Objects.
+      module ClassMethods
+        # Define a new list.  It will function like a regular instance
+        # method, so it can be used alongside ActiveRecord, DataMapper, etc.
+        def set(name, options={})
+          redis_objects[name.to_sym] = options.merge(:type => :set)
+          ivar_name = :"@#{name}"
+
+          mod = Module.new do
+            define_method(name) do
+              instance_variable_get(ivar_name) or
+                instance_variable_set(ivar_name,
+                  Redis::Set.new(
+                    redis_field_key(name), redis_field_redis(name), redis_options(name)
+                  )
+                )
+            end
+
+            define_method(:"#{name}=") do |values|
+              set = public_send(name)
+
+              redis.pipelined do
+                set.clear
+                set.merge(*values)
+              end
+            end
+          end
+
+          if options[:global]
+            extend mod
+
+            # dispatch to class methods
+            define_method(name) do
+              self.class.public_send(name)
+            end
+          else
+            include mod
+          end
+        end
+      end
+
+      # Instance methods that appear in your class when you include Redis::Objects.
+      module InstanceMethods
+      end
+    end
+  end
+end

data/lib/redis/objects/sorted_sets.rb

@@ -0,0 +1,49 @@
+# This is the class loader, for use as "include Redis::Objects::Sets"
+# For the object itself, see "Redis::Set"
+require 'redis/sorted_set'
+class Redis
+  module Objects
+    module SortedSets
+      def self.included(klass)
+        klass.send :include, InstanceMethods
+        klass.extend ClassMethods
+      end
+
+      # Class methods that appear in your class when you include Redis::Objects.
+      module ClassMethods
+        # Define a new list.  It will function like a regular instance
+        # 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)
+          ivar_name = :"@#{name}"
+
+          mod = Module.new do
+            define_method(name) do
+              instance_variable_get(ivar_name) or
+                instance_variable_set(ivar_name,
+                  Redis::SortedSet.new(
+                    redis_field_key(name), redis_field_redis(name), redis_options(name)
+                  )
+                )
+            end
+          end
+
+          if options[:global]
+            extend mod
+
+            # dispatch to class methods
+            define_method(name) do
+              self.class.public_send(name)
+            end
+          else
+            include mod
+          end
+        end
+      end
+
+      # Instance methods that appear in your class when you include Redis::Objects.
+      module InstanceMethods
+      end
+    end
+  end
+end

data/lib/redis/objects/values.rb

@@ -0,0 +1,64 @@
+# This is the class loader, for use as "include Redis::Objects::Values"
+# For the object itself, see "Redis::Value"
+require 'redis/value'
+class Redis
+  module Objects
+    module Values
+      def self.included(klass)
+        klass.send :include, InstanceMethods
+        klass.extend ClassMethods
+      end
+
+      # Class methods that appear in your class when you include Redis::Objects.
+      module ClassMethods
+        # Define a new simple value.  It will function like a regular instance
+        # method, so it can be used alongside ActiveRecord, DataMapper, etc.
+        def value(name, options={})
+          redis_objects[name.to_sym] = options.merge(:type => :value)
+          ivar_name = :"@#{name}"
+
+          mod = Module.new do
+            define_method(name) do
+              instance_variable_get(ivar_name) or
+                instance_variable_set(ivar_name,
+                  Redis::Value.new(
+                    redis_field_key(name), redis_field_redis(name), redis_options(name)
+                  )
+                )
+            end
+            define_method("#{name}=") do |value|
+              public_send(name).value = value
+            end
+          end
+
+          if options[:global]
+            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
+            include mod
+          end
+        end
+
+        def mget(name, objects = [])
+          return [] if objects.nil? || objects.empty?
+          raise "Field name Error" if !redis_objects.keys.include?(name.to_sym)
+
+          keys = objects.map{ |obj| obj.redis_field_key name.to_sym }
+
+          self.redis.mget keys
+        end
+      end
+
+      # Instance methods that appear in your class when you include Redis::Objects.
+      module InstanceMethods
+      end
+    end
+  end
+end

data/lib/redis/objects/version.rb

@@ -0,0 +1,5 @@
+class Redis
+  module Objects
+    VERSION = "1.6.0"
+  end
+end