class Redis::NativeHash

Attributes

namespace[RW]
version[W]

Public Class Methods

attr_persist(*attributes) click to toggle source
# File lib/redis/native_hash.rb, line 175
      def attr_persist(*attributes)
        attributes.each do |attr|
          class_eval <<-EOS
            def #{attr}=(value)
              self["#{attr}"] = value
            end

            def #{attr}
              self["#{attr}"]
            end
          EOS
        end
      end
build(namespace, key, values) click to toggle source
# File lib/redis/native_hash.rb, line 162
def build(namespace, key, values)
  h = self.new
  h.namespace = namespace
  h.key = key
  h.populate(values)
  h
end
fetch_values(key) click to toggle source
# File lib/redis/native_hash.rb, line 170
def fetch_values(key)
  results = redis.hgetall(key)
  results.each_pair { |key,value| results[key] = Redis::Marshal.load(value) }
end
find(params) click to toggle source
# File lib/redis/native_hash.rb, line 135
def find(params)
  case params
  when Hash
    hashes = []
    params.each_pair do |namespace, key|
      result = fetch_values( "#{namespace}:#{key}" )
      unless result.empty?
        hashes << build(namespace,key,result)
      end
    end
    unless hashes.empty?
      hashes.size == 1 ? hashes.first : hashes
    else
      nil
    end
  when String,Symbol
    unless self == Redis::NativeHash
      namespace = self.new.namespace.to_s
      namespace = "#{namespace}:" unless namespace.empty?
      result = fetch_values( "#{namespace}#{params}" )
    else
      result = fetch_values(params)
    end
    result.empty? ? nil : build(nil,params,result)
  end
end
new(aargh = nil) click to toggle source
Calls superclass method
# File lib/redis/native_hash.rb, line 12
def initialize(aargh = nil)
  super(nil)
  case aargh
  when String,Symbol
    self.namespace = aargh
  when Hash
    self.namespace = aargh.keys.first
    self.key       = aargh.values.first
  end
  track!
end

Public Instance Methods

[](key) click to toggle source
Calls superclass method
# File lib/redis/native_hash.rb, line 33
def [](key)
   super convert_key(key)
end
[]=(key, value) click to toggle source
Calls superclass method
# File lib/redis/native_hash.rb, line 24
def []=(key, value)
  super(convert_key(key), value)
end
Also aliased as: store
delete(key) click to toggle source
Calls superclass method
# File lib/redis/native_hash.rb, line 44
def delete(key)
  super convert_key(key)
end
destroy() click to toggle source
# File lib/redis/native_hash.rb, line 114
def destroy
  redis.del( redis_key )
  untrack!
  clear
  self.key = nil
end
expire(seconds) click to toggle source
# File lib/redis/native_hash.rb, line 130
def expire(seconds)
  redis.expire(redis_key, seconds)
end
fetch(key, *extras) click to toggle source
Calls superclass method
# File lib/redis/native_hash.rb, line 29
def fetch(key, *extras)
  super(convert_key(key),*extras)
end
has_key?(key)
Alias for: key?
include?(key)
Alias for: key?
key=(new_key) click to toggle source
# File lib/redis/native_hash.rb, line 52
def key=(new_key)
  renew_key(new_key)
end
key?(key) click to toggle source
Calls superclass method
# File lib/redis/native_hash.rb, line 37
def key?(key)
  super convert_key(key)
end
Also aliased as: include?, has_key?, member?
member?(key)
Alias for: key?
reload()
Alias for: reload!
reload!() click to toggle source
# File lib/redis/native_hash.rb, line 108
def reload!
  hash = self.class.find( namespace ? {namespace => key} : key )
  self.update( hash ) if hash
end
Also aliased as: reload
renew_key(new_key = nil) click to toggle source
# File lib/redis/native_hash.rb, line 121
def renew_key(new_key = nil)
  unless @key.nil? || @key == new_key
    redis.del( redis_key )
    original.clear
  end
  @key = new_key
  key
end
replace(other_hash) click to toggle source
# File lib/redis/native_hash.rb, line 103
def replace(other_hash)
  clear
  update(other_hash)
end
save( max_attempts = 5 ) click to toggle source
# File lib/redis/native_hash.rb, line 61
def save( max_attempts = 5 )
  (1..max_attempts).each do |n|
    redis.watch redis_key
    latest_version = redis.hget(redis_key, "__version")
    reload! unless ( latest_version.nil? || latest_version == self.version )
    self.version = nil # generate new version token
    changed_keys = (self.changed + self.added).uniq
    changes = []
    changed_keys.each do |key|
      changes.push( key, Redis::Marshal.dump(self[key]) )
    end
    deleted_keys = self.deleted
    if deleted_keys.empty? and changes.empty?
      redis.unwatch
      return true
    end
    success = redis.multi do
      redis.hmset( redis_key, *changes.push("__version", self.version) ) unless changes.empty?
      deleted_keys.each { |key| redis.hdel( redis_key, key) }
    end
    if success
      untrack!; track! #reset hash
      return true
    end
  end
  raise "Unable to save hash after max attempts (#{max_attempts}). " +
        "Amazing concurrency event may be underway. " +
        "Make some popcorn."
  false
end
store(key, value)
Alias for: []=
update(data) click to toggle source
Calls superclass method
# File lib/redis/native_hash.rb, line 92
def update(data)
  v = case data
    when self.class
      data.version
    when ::Hash
      data.delete("__version")
    end
  self.version = v unless v.nil?
  super(data.stringify_keys!)
end
values_at(*indices) click to toggle source
# File lib/redis/native_hash.rb, line 48
def values_at(*indices)
  indices.collect { |key| self[ convert_key(key) ] }
end
version() click to toggle source
# File lib/redis/native_hash.rb, line 57
def version
  @version ||= generate_key
end