Module: Redis::Objects::Counters::ClassMethods

Defined in:
lib/redis/objects/counters.rb

Overview

Class methods that appear in your class when you include Redis::Objects.

Instance Attribute Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#initialized_counters ⇒ Object (readonly)

Returns the value of attribute initialized_counters.



18
19
20
 
# File 'lib/redis/objects/counters.rb', line 18

def initialized_counters
  @initialized_counters
end

Instance Method Details

#counter(name, options = {}) ⇒ Object

Define a new counter. It will function like a regular instance method, so it can be used alongside ActiveRecord, DataMapper, etc.



22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
# File 'lib/redis/objects/counters.rb', line 22

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

#counter_defined?(name) ⇒ Boolean

:nodoc:

Returns:

  • (Boolean) 


96
97
98
 
# File 'lib/redis/objects/counters.rb', line 96

def counter_defined?(name) #:nodoc:
  redis_objects && redis_objects.has_key?(name.to_sym)
end

#decrement_counter(name, id = nil, by = 1, &block) ⇒ Object

Decrement a counter with the specified name and id. Accepts a block like the instance method. See Redis::Objects::Counter for details.



72
73
74
75
76
77
78
79
 
# File 'lib/redis/objects/counters.rb', line 72

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

#get_counter(name, id = nil) ⇒ Object

Get the current value of the counter. It is more efficient to use the instance method if possible.



53
54
55
56
57
 
# File 'lib/redis/objects/counters.rb', line 53

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

#getset_counter(name, id = nil, to = nil) ⇒ Object

Set a counter to its starting value and return the old value.



90
91
92
93
94
 
# File 'lib/redis/objects/counters.rb', line 90

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

#increment_counter(name, id = nil, by = 1, &block) ⇒ Object

Increment a counter with the specified name and id. Accepts a block like the instance method. See Redis::Objects::Counter for details.



61
62
63
64
65
66
67
68
 
# File 'lib/redis/objects/counters.rb', line 61

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

#reset_counter(name, id = nil, to = nil) ⇒ Object

Reset a counter to its starting value.



82
83
84
85
86
87
 
# File 'lib/redis/objects/counters.rb', line 82

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