familia 0.5.3

data/CHANGES.txt

@@ -0,0 +1,6 @@
+FAMILIA, CHANGES
+
+#### 0.5.3 (2010-12-10) ###############################
+
+Initial public release
+

data/LICENSE.txt

@@ -0,0 +1,19 @@
+Copyright (c) 2010-2011 Solutious Inc, Delano Mandelbaum
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,14 @@
+# Familia - 0.5 BETA
+
+**Organize and store ruby objects in Redis**
+
+
+## More Information
+
+* [Codes](http://github.com/delano/familia)
+* [RDocs](http://delano.github.com/familia)
+
+
+## Credits
+
+* [Delano Mandelbaum](http://goldensword.ca)

data/Rakefile

@@ -0,0 +1,70 @@
+require "rubygems"
+require "rake"
+require "rake/clean"
+require 'yaml'
+
+begin
+  require 'hanna/rdoctask'
+rescue LoadError
+  require 'rake/rdoctask'
+end
+ 
+config = YAML.load_file("VERSION.yml")
+task :default => ["build"]
+CLEAN.include [ 'pkg', 'doc' ]
+name = "familia"
+
+begin
+  require "jeweler"
+  Jeweler::Tasks.new do |gem|
+    gem.version = "#{config[:MAJOR]}.#{config[:MINOR]}.#{config[:PATCH]}"
+    gem.name = name
+    gem.rubyforge_project = gem.name
+    gem.summary = "Organize and store ruby objects in Redis"
+    gem.description = gem.summary
+    gem.email = "delano@solutious.com"
+    gem.homepage = "http://github.com/delano/familia"
+    gem.authors = ["Delano Mandelbaum"]
+    gem.add_dependency("redis",      ">= 2.1.0")
+    gem.add_dependency("uri-redis",  ">= 0.4.1")
+    gem.add_dependency("gibbler",    ">= 0.8.4")
+    gem.add_dependency("storable",   ">= 0.8.3")
+    
+    #gem.add_development_dependency("rspec", ">= 1.2.9")
+    #gem.add_development_dependency("mocha", ">= 0.9.8")
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+
+Rake::RDocTask.new do |rdoc|
+  version = "#{config[:MAJOR]}.#{config[:MINOR]}.#{config[:PATCH]}.#{config[:BUILD]}"
+  rdoc.rdoc_dir = "doc"
+  rdoc.title = "#{name} #{version}"
+  rdoc.rdoc_files.include("README*")
+  rdoc.rdoc_files.include("LICENSE.txt")
+  rdoc.rdoc_files.include("bin/*.rb")
+  rdoc.rdoc_files.include("lib/**/*.rb")
+end
+
+
+# Rubyforge Release / Publish Tasks ==================================
+
+#about 'Publish website to rubyforge'
+task 'publish:rdoc' => 'doc/index.html' do
+  #sh "scp -rp doc/* rubyforge.org:/var/www/gforge-projects/#{name}/"
+end
+
+#about 'Public release to rubyforge'
+task 'publish:gem' => [:package] do |t|
+  sh <<-end
+    rubyforge add_release -o Any -a CHANGES.txt -f -n README.md #{name} #{name} #{@spec.version} pkg/#{name}-#{@spec.version}.gem &&
+    rubyforge add_file -o Any -a CHANGES.txt -f -n README.md #{name} #{name} #{@spec.version} pkg/#{name}-#{@spec.version}.tgz 
+  end
+end
+
+
+
+

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:MAJOR: 0
+:MINOR: 5
+:PATCH: 3

data/familia.gemspec

@@ -0,0 +1,57 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{familia}
+  s.version = "0.5.3"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Delano Mandelbaum"]
+  s.date = %q{2010-12-10}
+  s.description = %q{Organize and store ruby objects in Redis}
+  s.email = %q{delano@solutious.com}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+     "README.rdoc"
+  ]
+  s.files = [
+    "CHANGES.txt",
+     "LICENSE.txt",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION.yml",
+     "familia.gemspec",
+     "lib/familia.rb"
+  ]
+  s.homepage = %q{http://github.com/delano/familia}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{familia}
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Organize and store ruby objects in Redis}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<redis>, [">= 2.1.0"])
+      s.add_runtime_dependency(%q<uri-redis>, [">= 0.4.1"])
+      s.add_runtime_dependency(%q<gibbler>, [">= 0.8.4"])
+      s.add_runtime_dependency(%q<storable>, [">= 0.8.3"])
+    else
+      s.add_dependency(%q<redis>, [">= 2.1.0"])
+      s.add_dependency(%q<uri-redis>, [">= 0.4.1"])
+      s.add_dependency(%q<gibbler>, [">= 0.8.4"])
+      s.add_dependency(%q<storable>, [">= 0.8.3"])
+    end
+  else
+    s.add_dependency(%q<redis>, [">= 2.1.0"])
+    s.add_dependency(%q<uri-redis>, [">= 0.4.1"])
+    s.add_dependency(%q<gibbler>, [">= 0.8.4"])
+    s.add_dependency(%q<storable>, [">= 0.8.3"])
+  end
+end
+

data/lib/familia.rb

@@ -0,0 +1,935 @@
+# encoding: utf-8
+FAMILIA_LIB_HOME = File.expand_path File.dirname(__FILE__) unless defined?(FAMILIA_LIB_HOME)
+require 'uri/redis'
+
+module Familia
+  module VERSION
+    def self.to_s
+      load_config
+      [@version[:MAJOR], @version[:MINOR], @version[:PATCH]].join('.')
+    end
+    alias_method :inspect, :to_s
+    def self.load_config
+      require 'yaml'
+      @version ||= YAML.load_file(File.join(FAMILIA_LIB_HOME, '..', 'VERSION.yml'))
+    end
+  end
+end
+
+
+module Familia
+  include Gibbler::Complex
+  @secret = '1-800-AWESOME' # Should be modified via Familia.secret = ''
+  @clients = {}
+  @conf = {}
+  @suffix = :object.freeze
+  @index = :id.freeze
+  @apiversion = nil
+  @uri = URI.parse 'redis://localhost'
+  @debug = false.freeze
+  @classes = []
+  @delim = ':'
+  class << self
+    attr_reader :conf, :classes, :clients
+    attr_accessor :debug, :secret, :delim
+    def debug?() @debug == true end
+  end
+  class Problem < RuntimeError; end
+  class EmptyIndex < Problem; end
+  class NonUniqueKey < Problem; end
+  class NotConnected < Problem
+    attr_reader :uri
+    def initialize uri
+      @uri = uri
+    end
+    def message
+      "No client for #{uri.serverid}"
+    end
+  end
+  def Familia.uri(db=nil)
+    if db.nil?
+      @uri
+    else
+      uri = URI.parse @uri.to_s
+      uri.db = db
+      uri
+    end
+  end
+  def Familia.apiversion(r=nil, &blk)  
+    if blk.nil?
+      @apiversion = r if r; 
+    else
+      tmp = @apiversion
+      @apiversion = r
+      blk.call
+      @apiversion = tmp
+    end
+    @apiversion 
+  end
+  def Familia.apiversion=(r) @apiversion = r; r end
+  def Familia.conf=(conf={})
+    @conf = conf
+    @uri = Redis.uri(@conf).freeze
+    connect @uri
+    @conf
+  end
+  def Familia.redis(uri=nil)
+    uri &&= URI.parse uri if String === uri
+    uri ||= Familia.uri
+    connect(uri) unless @clients[uri.serverid] 
+    #STDERR.puts "REDIS: #{uri} #{caller[0]}" if Familia.debug?
+    @clients[uri.serverid]
+  end
+  def Familia.connect(uri=nil, local_conf={})
+    uri &&= URI.parse uri if String === uri
+    uri ||= Familia.uri
+    local_conf[:thread_safe] = true
+    client = Redis.new local_conf.merge(uri.conf)
+    Familia.trace :CONNECT, client, uri.conf.inspect, caller.first
+    @clients[uri.serverid] = client
+  end
+  def Familia.reconnect_all!
+    Familia.classes.each do |klass|
+      klass.redis.client.reconnect
+      Familia.info "#{klass} ping: #{klass.redis.ping}" if debug?
+    end
+  end
+  def Familia.connected?(uri=nil)
+    uri &&= URI.parse uri if String === uri
+    @clients.has_key?(uri.serverid)
+  end
+  def Familia.default_suffix(a=nil) @suffix = a if a; @suffix end
+  def Familia.default_suffix=(a) @suffix = a end
+  def Familia.index(r=nil)  @index = r if r; @index end
+  def Familia.index=(r) @index = r; r end
+  def Familia.split(r) r.split(Familia.delim) end
+  def Familia.key *args
+    el = args.flatten.compact
+    el.unshift @apiversion unless @apiversion.nil?
+    el.join(Familia.delim)
+  end
+  def Familia.info *msg
+    STDERR.puts *msg
+  end
+  def Familia.ld *msg
+    info *msg if debug?
+  end
+  def Familia.trace label, redis_client, ident, context=nil
+    return unless Familia.debug?
+    info "%s (%d:%s): %s" % [label, Thread.current.object_id, redis_client.object_id, ident] 
+    info "  +-> %s" % [context].flatten[0..3].join("\n      ") if context
+  end
+  def Familia.destroy keyname, uri=nil
+    Familia.redis(uri).del keyname
+  end
+  def Familia.get_any keyname, uri=nil
+    type = Familia.redis(uri).type keyname
+    case type
+    when "string"
+      Familia.redis(uri).get keyname
+    when "list"
+      Familia.redis(uri).lrange(keyname, 0, -1) || []
+    when "set"
+      Familia.redis(uri).smembers( keyname) || []
+    when "zset"
+      Familia.redis(uri).zrange(keyname, 0, -1) || []
+    when "hash"
+      Familia.redis(uri).hgetall(keyname) || {}
+    else
+      nil
+    end
+  end
+  def Familia.exists?(keyname, uri=nil)
+    Familia.redis(uri).exists keyname
+  end
+  
+  def self.included(obj)
+    obj.send :include, Familia::InstanceMethods
+    obj.send :include, Gibbler::Complex
+    obj.extend  Familia::ClassMethods
+    Familia.classes << obj
+  end
+  
+  module InstanceMethods
+    def redisinfo
+      info = {
+        :db   => self.class.db || 0,
+        #:uri  => redisuri,
+        :key  => key,
+        :type => redistype,
+        :ttl  => realttl
+      }
+    end
+    def exists?
+      Familia.redis(self.class.uri).exists self.key
+    end
+    def destroy!(suffix=nil)
+      ret = Familia.redis(self.class.uri).del self.key(suffix)
+      Familia.trace :DELETED, Familia.redis(self.class.uri), "#{key(suffix)}: #{ret}", caller.first
+      ret
+    end
+    def allkeys
+      keynames = [key]
+      self.class.suffixes.each do |sfx| 
+        keynames << key(sfx)
+      end
+      keynames
+    end
+    def key(suffix=nil)
+      raise EmptyIndex, self.class if index.nil? || index.empty?
+      if suffix.nil?
+        suffix = self.class.suffix.kind_of?(Proc) ? 
+                     self.class.suffix.call(self) : 
+                     self.class.suffix
+      end
+      self.class.key self.index, suffix
+    end
+    def save(force=false)
+      Familia.trace :SAVE, Familia.redis(self.class.uri), redisuri, caller.first
+      ## Don't save if there are no changes
+      ##return false unless force || self.gibbled? || self.gibbler_cache.nil?
+      preprocess if respond_to?(:preprocess)
+      self.update_time if self.respond_to?(:update_time)
+      ret = Familia.redis(self.class.uri).set self.key, self.to_json
+      unless self.ttl.nil? || self.ttl <= 0
+        Familia.trace :SET_EXPIRE, Familia.redis(self.class.uri), "#{self.key} to #{self.ttl}"
+        expire(self.ttl) 
+      end
+      ret == "OK"
+    end
+    def index
+      if @index.nil?
+        self.class.index.kind_of?(Proc) ? 
+            self.class.index.call(self) : 
+            self.send(self.class.index)
+      else
+        @index
+      end
+    end
+    def index=(i)
+      @index = i
+    end
+    def expire(ttl=nil)
+      ttl ||= self.class.ttl
+      Familia.redis(self.class.uri).expire self.key, ttl.to_i
+    end
+    def realttl
+      Familia.redis(self.class.uri).ttl self.key
+    end
+    def ttl=(v)
+      @ttl = v.to_i
+    end
+    def ttl
+      @ttl || self.class.ttl
+    end
+    def raw(suffix=nil)
+      suffix ||= :object
+      Familia.redis(self.class.uri).get key(suffix)
+    end
+    def redisuri(suffix=nil)
+      u = URI.parse self.class.uri.to_s
+      u.db ||= self.class.db.to_s
+      u.key = key(suffix)
+      u
+    end
+    def redistype(suffix=nil)
+      Familia.redis(self.class.uri).type key(suffix)
+    end
+    # Finds the shortest available unique key (lower limit of 6)
+    def shortid
+      len = 6
+      loop do
+        begin
+          self.class.expand(@id.shorten(len))
+          break
+        rescue Familia::NonUniqueKey
+          len += 1
+        end
+      end
+      @id.shorten(len) 
+    end
+  end
+  
+  module ClassMethods
+    def inherited(obj)
+      obj.db = self.db
+      Familia.classes << obj
+      super(obj)
+    end
+    def from_redisdump dump
+      dump
+    end
+    def float
+      Proc.new do |v|
+        v.nil? ? 0 : v.to_f
+      end
+    end
+    def extended(obj)
+      obj.db = self.db
+      Familia.classes << obj
+    end
+    def db(db=nil) 
+      @db = db if db; 
+      @db
+    end
+    def db=(db) @db = db end
+    def host(host=nil) @host = host if host; @host end
+    def host=(host) @host = host end
+    def port(port=nil) @port = port if port; @port end
+    def port=(port) @port = port end
+    def uri=(uri)
+      uri = URI.parse uri if String === uri
+      @uri = uri 
+    end
+    def uri(uri=nil) 
+      self.uri = uri unless uri.to_s.empty?
+      return @uri if @uri
+      @uri = URI.parse Familia.uri.to_s
+      @uri.db = @db if @db 
+      Familia.connect @uri #unless Familia.connected?(@uri)
+      @uri
+    end
+    def redis
+      Familia.redis(self.uri)
+    end
+    def flushdb
+      Familia.info "flushing #{uri}"
+      redis.flushdb
+    end
+    def keys(suffix=nil)
+      self.redis.keys(key('*',suffix)) || []
+    end
+    def all(suffix=nil)
+      # objects that could not be parsed will be nil
+      keys(suffix).collect { |k| from_key(k) }.compact 
+    end
+    def any?(filter='*')
+      size(filter) > 0
+    end
+    def size(filter='*')
+      self.redis.keys(key(filter)).compact.size
+    end
+    def suffix=(val)   
+      suffixes << (@suffix = val)
+      val
+    end
+    def suffix(a=nil, &blk) 
+      @suffix = a || blk if a || !blk.nil?
+      val = @suffix || Familia.default_suffix
+      self.suffixes << val
+      val
+    end
+    def prefix=(a)  @prefix = a end
+    def prefix(a=nil) @prefix = a if a; @prefix || self.name.downcase end
+    def index(i=nil, &blk) 
+      @index = i || blk if i || !blk.nil?
+      @index ||= Familia.index
+      @index
+    end
+    def suffixes
+      @suffixes ||= []
+      @suffixes.uniq!
+      @suffixes
+    end
+    def child(opts={})
+      name, klass = opts.keys.first, opts.values.first
+      childs[name] = klass
+      self.suffixes << name
+      define_method :"#{name}_key" do
+        key(name)
+      end
+      define_method :"#{name}?" do
+        #Familia.ld "EXISTS? #{self.class.childs[name]} #{key(name)}"
+        self.class.childs[name].redis.exists key(name)
+      end
+      define_method :"clear_#{name}" do
+        self.class.redis.del key(name)
+      end
+      define_method :"#{name}" do
+        #Familia.ld "#{self.class} Return child #{key(name)}"
+        content = self.class.redis.get key(name)
+        #Familia.ld "TODO: don't reload #{self.class} every time"
+        if !content.nil?
+          begin
+            content = self.class.childs[name].from_json content if klass != String && content.is_a?(String)
+          rescue => ex
+            msg = "Error loading #{name} for #{key}: #{ex.message}"
+            Familia.info "#{msg}: #{$/}#{content}"
+            raise Familia::Problem, msg
+          end
+        else
+          content = self.class.childs[name].new
+        end
+        content
+      end
+      define_method :"#{name}=" do |content|
+        Familia.ld "#{self.class} Modify child #{key(name)} (#{content.class})"
+        self.class.redis.set key(name), (content.is_a?(String) ? content : content.to_json)
+        content
+      end
+    end
+    def child?(name)
+      childs.has_key? :"#{name}"
+    end
+    def childs
+      @childs ||= {}
+      @childs
+    end
+    def hashes
+      @hashes ||= {}
+      @hashes
+    end
+    def hash?(name)
+      @hashes.has_key? :"#{name}"
+    end
+    def hash(opts={}, &blk)
+      if Hash === opts
+        name, klass = opts.keys.first, opts.values.first
+      else
+        name, klass = opts, nil
+      end
+      hashes[name] = klass
+      self.suffixes << name
+      if name.to_s.match(/s$/i)
+        name_plural = name.to_s.clone
+        name_singular = name.to_s[0..-2]
+      else
+        name_plural = "#{name}s"
+        name_singular = name
+      end
+      define_method :"#{name}_key" do
+        key(name)
+      end
+      define_method :"has_#{name}?" do |field|
+        self.class.redis.hexists key(name), field
+      end
+      define_method :"#{name}_size" do 
+        self.class.redis.hlen key(name)
+      end
+      define_method :"clear_#{name}" do
+        self.class.redis.del key(name)
+      end
+      define_method :"#{name}_keys" do 
+        self.class.redis.hkeys key(name)
+      end
+      define_method :"set_#{name}" do |hash|
+        self.class.redis.hmset key(name), *hash.to_a.flatten
+      end
+      define_method :"get_#{name}" do |*fields|
+        ret = self.class.redis.hmget key(name), *fields
+        ret.collect! { |obj| blk.call(obj) } if blk
+        fields.size == 1 ? ret.first : ret
+      end
+      define_method :"del_#{name}" do |field|
+        self.class.redis.hdel key(name), field
+      end
+    end
+    
+    def sets
+      @sets ||= {}
+      @sets
+    end
+    def set?(name)
+      sets.has_key? :"#{name}"
+    end
+    def set(opts={})
+      if Hash === opts
+        name, klass = opts.keys.first, opts.values.first
+      else
+        name, klass = opts, nil
+      end
+      sets[name] = klass
+      self.suffixes << name
+      if name.to_s.match(/s$/i)
+        name_plural = name.to_s.clone
+        name_singular = name.to_s[0..-2]
+      else
+        name_plural = "#{name}s"
+        name_singular = name
+      end
+      define_method :"#{name}_key" do
+        key(name)
+      end
+      define_method :"#{name}_size" do
+        self.class.redis.scard key(name)
+      end
+      # Make the value stored at KEY identical to the given list
+      define_method :"#{name}_sync" do |*latest|
+        latest = latest.flatten.compact
+        # Do nothing if we're given an empty Array. 
+        # Otherwise this would clear all current values
+        if latest.empty?
+          false
+        else
+          # Convert to a list of index values if we got the actual objects
+          latest = latest.collect { |obj| obj.index } if klass === latest.first
+          current = send("#{name_plural}raw")
+          added = latest-current
+          removed = current-latest
+          #Familia.info "#{self.index}: adding: #{added}"
+          added.each { |v| self.send("add_#{name_singular}", v) }
+          #Familia.info "#{self.index}: removing: #{removed}"
+          removed.each { |v| self.send("remove_#{name_singular}", v) }
+          true
+        end
+      end
+      define_method :"#{name}?" do
+        self.send(:"#{name}_size") > 0
+      end
+      define_method :"clear_#{name}" do
+        self.class.redis.del key(name)
+      end
+      define_method :"add_#{name_singular}" do |obj|
+        objid = klass === obj ? obj.index : obj
+        #Familia.ld "#{self.class} Add #{objid} to #{key(name)}"
+        self.class.redis.sadd key(name), objid
+      end
+      define_method :"remove_#{name_singular}" do |obj|
+        objid = klass === obj ? obj.index : obj
+        #Familia.ld "#{self.class} Remove #{objid} from #{key(name)}"
+        self.class.redis.srem key(name), objid
+      end
+      # Example:
+      #
+      #     list = obj.response_time 10, :score => (now-12.hours)..now
+      #
+      define_method :"#{name_plural}raw" do 
+        list = self.class.redis.smembers(key(name)) || []
+      end
+      define_method :"#{name_plural}" do 
+        list = send("#{name_plural}raw")
+        if klass.nil? 
+          list 
+        elsif klass.include?(Familia) 
+          klass.multiget(*list)
+        elsif klass.respond_to?(:from_json)
+          list.collect { |str| klass.from_json(str) }
+        else
+          list
+        end
+      end
+    end
+    def zsets
+      @zsets ||= {}
+      @zsets
+    end
+    def zset?(name)
+      zsets.has_key? :"#{name}"
+    end
+    def zset(opts={})
+      if Hash === opts
+        name, klass = opts.keys.first, opts.values.first
+      else
+        name, klass = opts, nil
+      end
+      zsets[name] = klass
+      self.suffixes << name
+      if name.to_s.match(/s$/i)
+        name_plural = name.to_s.clone
+        name_singular = name.to_s[0..-2]
+      else
+        name_plural = "#{name}s"
+        name_singular = name
+      end
+      define_method :"#{name}_key" do
+        key(name)
+      end
+      define_method :"#{name}_size" do
+        self.class.redis.zcard key(name)
+      end
+      define_method :"clear_#{name}" do
+        self.class.redis.del key(name)
+      end
+      define_method :"#{name}?" do
+        self.send(:"#{name}_size") > 0
+      end
+      define_method :"add_#{name_singular}" do |score,obj|
+        objid = klass === obj ? obj.index : obj
+        #Familia.ld "#{self.class} Add #{objid} (#{score}) to #{key(name)}"
+        self.class.redis.zadd key(name), score, objid
+      end
+      #p "Adding: #{self}#remove_#{name_singular}"
+      define_method :"remove_#{name_singular}" do |obj|
+        objid = klass === obj ? obj.index : obj
+        #Familia.ld "#{self.class} Remove #{objid} from #{key(name)}"
+        self.class.redis.zrem key(name), objid
+      end
+      # Example:
+      #
+      #     list = obj.response_time 10, :score => (now-12.hours)..now
+      #
+      define_method :"#{name_plural}raw" do |*args|
+        
+        count = args.first-1 unless args.empty?
+        count ||= -1
+        
+        opts = args[1] || {}
+        if Range === opts[:score]
+          lo, hi = opts[:score].first, opts[:score].last
+          list = self.class.redis.zrangebyscore(key(name), lo, hi, :limit => [0, count]) || []
+        else                       
+          list = self.class.redis.zrange(key(name), 0, count) || []
+        end
+      end
+      define_method :"#{name_plural}" do |*args|
+        list = send("#{name_plural}raw", *args)
+        if klass.nil? 
+          list 
+        elsif klass.include?(Familia) 
+          klass.multiget(*list)
+        elsif klass.respond_to?(:from_json)
+          list.collect { |str| klass.from_json(str) }
+        else
+          list
+        end
+      end
+      define_method :"#{name_plural}rev" do |*args|
+        
+        count = args.first-1 unless args.empty?
+        count ||= -1
+        
+        opts = args[1] || {}
+        if Range === opts[:score]
+          lo, hi = opts[:score].first, opts[:score].last
+          list = self.class.redis.zrangebyscore(key(name), lo, hi, :limit => [0, count]) || []
+        else                       
+          list = self.class.redis.zrevrange(key(name), 0, count) || []
+        end
+        if klass.nil? 
+          list 
+        elsif klass.include?(Familia) 
+          klass.multiget(*list)
+        elsif klass.respond_to?(:from_json)
+          list.collect { |str| klass.from_json(str) }
+        else
+          list
+        end
+      end
+    end
+
+    def list(opts={})
+      if Hash === opts
+        name, klass = opts.keys.first, opts.values.first
+      else
+        name, klass = opts, nil
+      end
+      lists[name] = klass
+      self.suffixes << name
+      if name.to_s.match(/s$/i)
+        name_plural = name.to_s.clone
+        name_singular = name.to_s[0..-2]
+      else
+        name_plural = "#{name}s"
+        name_singular = name
+      end
+      define_method :"#{name}_key" do
+        key(name)
+      end
+      define_method :"#{name}_size" do
+        self.class.redis.llen key(name)
+      end
+      define_method :"clear_#{name}" do
+        self.class.redis.del key(name)
+      end
+      # Make the value stored at KEY identical to the given list
+      define_method :"#{name}_sync" do |*latest|
+        latest = latest.flatten.compact
+        # Do nothing if we're given an empty Array. 
+        # Otherwise this would clear all current values
+        if latest.empty?
+          false
+        else
+          # Convert to a list of index values if we got the actual objects
+          latest = latest.collect { |obj| obj.index } if klass === latest.first
+          current = send("#{name_plural}raw")
+          added = latest-current
+          removed = current-latest
+          #Familia.info "#{self.index}: adding: #{added}"
+          added.each { |v| self.send("add_#{name_singular}", v) }
+          #Familia.info "#{self.index}: removing: #{removed}"
+          removed.each { |v| self.send("remove_#{name_singular}", v) }
+          true
+        end
+      end
+      define_method :"#{name}?" do
+        self.send(:"#{name}_size") > 0
+      end
+      define_method :"add_#{name_singular}" do |obj|
+        objid = klass === obj ? obj.index : obj
+        #Familia.ld "#{self.class} Add #{objid} to #{key(name)}"
+        ret = self.class.redis.rpush key(name), objid
+        # TODO : copy to zset and set
+        #unless self.ttl.nil? || self.ttl <= 0
+        #  Familia.trace :SET_EXPIRE, Familia.redis(self.class.uri), "#{self.key} to #{self.ttl}"
+        #  Familia.redis(self.class.uri).expire key(name), self.ttl
+        #end
+        ret
+      end
+      define_method :"remove_#{name_singular}" do |obj|
+        objid = klass === obj ? obj.index : obj
+        #Familia.ld "#{self.class} Remove #{objid} from #{key(name)}"
+        self.class.redis.lrem key(name), 0, objid
+      end
+      define_method :"#{name_plural}raw" do |*args|
+        count = args.first-1 unless args.empty?
+        count ||= -1
+        list = self.class.redis.lrange(key(name), 0, count) || []
+      end
+      define_method :"#{name_plural}" do |*args|
+        list = send("#{name_plural}raw", *args)
+        if klass.nil? 
+          list 
+        elsif klass.include?(Familia) 
+          klass.multiget(*list)
+        elsif klass.respond_to?(:from_json)
+          list.collect { |str| klass.from_json(str) }
+        else
+          list
+        end
+      end
+    end
+    def lists
+      @lists ||= {}
+      @lists
+    end
+    def list?(name)
+      lists.has_key? :"#{name}"
+    end
+    def multiget(*ids)
+      ids = rawmultiget(*ids)
+      ids.compact.collect { |json| self.from_json(json) }.compact
+    end
+    def rawmultiget(*ids)
+      ids.collect! { |objid| self.key(objid) }
+      return [] if ids.compact.empty?
+      Familia.trace :MULTIGET, self.redis, "#{ids.size}: #{ids}", caller
+      ids = self.redis.mget *ids
+    end
+    def ttl(sec=nil)
+      @ttl = sec.to_i unless sec.nil? 
+      @ttl
+    end
+    def create(*args)
+      me = new(*args)
+      raise "#{self} exists: #{me.to_json}" if me.exists?
+      me.save
+      me
+    end
+    def load_or_create(id)
+      if exists?(id)
+        from_redis(id)
+      else
+        me = new id
+        me.save
+        me
+      end
+    end
+    def from_key(akey)
+      Familia.trace :LOAD, Familia.redis(self.uri), "#{self.uri}/#{akey}", caller
+      return nil unless Familia.redis(self.uri).exists akey
+      raise Familia::Problem, "Null key" if akey.nil? || akey.empty?    
+      run_json = Familia.redis(self.uri).get akey
+      if run_json.nil? || run_json.empty?
+        Familia.info  "No content @ #{akey}" 
+        return
+      end
+      begin
+        #run_json.force_encoding("ASCII-8BIT") if RUBY_VERSION >= "1.9"
+        obj = self.from_json(run_json)
+        obj
+      rescue => ex
+        STDOUT.puts "Non-fatal error parsing JSON for #{akey}: #{ex.message}"
+        STDOUT.puts run_json
+        STDERR.puts ex.backtrace
+        nil
+      end
+    end
+    def from_redis(objid, suffix=nil)
+      objid &&= objid.to_s
+      return nil if objid.nil? || objid.empty?
+      this_key = key(objid, suffix)
+      #Familia.ld "Reading key: #{this_key}"
+      me = from_key(this_key)
+      me.gibbler  # prime the gibbler cache (used to check for changes)
+      me
+    end
+    def exists?(objid, suffix=nil)
+      objid &&= objid.to_s
+      return false if objid.nil? || objid.empty?
+      ret = Familia.redis(self.uri).exists key(objid, suffix)
+      Familia.trace :EXISTS, Familia.redis(self.uri), "#{key(objid)} #{ret}", caller.first
+      ret
+    end
+    def destroy!(runid, suffix=nil)
+      ret = Familia.redis(self.uri).del key(runid, suffix)
+      Familia.trace :DELETED, Familia.redis(self.uri), "#{key(runid)}: #{ret}", caller.first
+      ret
+    end
+    def find(suffix='*')
+      list = Familia.redis(self.uri).keys(key('*', suffix)) || []
+    end
+    def key(runid, suffix=nil)
+      suffix ||= self.suffix
+      runid ||= ''
+      runid &&= runid.to_s
+      str = Familia.key(prefix, runid, suffix)
+      str
+    end
+    def expand(short_key, suffix=nil)
+      suffix ||= self.suffix
+      expand_key = Familia.key(self.prefix, "#{short_key}*", suffix)
+      Familia.trace :EXPAND, Familia.redis(self.uri), expand_key, caller.first
+      list = Familia.redis(self.uri).keys expand_key
+      case list.size
+      when 0
+        nil
+      when 1 
+        matches = list.first.match(/\A#{Familia.key(prefix)}\:(.+?)\:#{suffix}/) || []
+        matches[1]
+      else
+        raise Familia::NonUniqueKey, "Short key returned more than 1 match" 
+      end
+    end
+  end
+end
+
+module Familia
+  #
+  #     class Example
+  #       include Familia
+  #       field :name
+  #       include Familia::Stamps
+  #     end 
+  #
+  module Stamps
+    def self.included(obj)
+      obj.module_eval do
+        field :created => Integer
+        field :updated => Integer
+        def init_stamps
+          now = Time.now.utc.to_i
+          @created ||= now
+          @updated ||= now 
+        end
+        def created
+          @created ||= Time.now.utc.to_i
+        end
+        def updated
+          @updated ||= Time.now.utc.to_i
+        end
+        def created_age
+          Time.now.utc.to_i-created
+        end
+        def updated_age
+          Time.now.utc.to_i-updated
+        end
+        def update_time
+          @updated = Time.now.utc.to_i
+        end
+        def update_time!
+          update_time
+          save if respond_to? :save
+          @updated
+        end
+      end
+    end
+  end
+  module Status
+    def self.included(obj)
+      obj.module_eval do
+        field :status
+        field :message
+        def  failure?()        status? 'failure'       end
+        def  success?()        status? 'success'       end
+        def  pending?()        status? 'pending'       end
+        def  expired?()        status? 'expired'       end
+        def disabled?()        status? 'disabled'      end
+        def  failure!(msg=nil) status! 'failure',  msg end
+        def  success!(msg=nil) status! 'success',  msg end
+        def  pending!(msg=nil) status! 'pending',  msg end
+        def  expired!(msg=nil) status! 'expired',  msg end
+        def disabled!(msg=nil) status! 'disabled', msg end
+        private
+        def status?(s)
+          status.to_s == s.to_s
+        end
+        def status!(s, msg=nil)
+          @updated = Time.now.utc.to_f
+          @status, @message = s, msg
+          save if respond_to? :save
+        end
+      end
+    end
+  end
+end
+
+module Familia
+  module Tools
+    extend self
+    def move_keys(filter, source_uri, target_uri, &each_key)
+      if target_uri == source_uri
+        raise "Source and target are the same (#{target_uri})"
+      end
+      Familia.connect target_uri
+      source_keys = Familia.redis(source_uri).keys(filter)
+      puts "Moving #{source_keys.size} keys from #{source_uri} to #{target_uri} (filter: #{filter})"
+      source_keys.each_with_index do |key,idx|
+        type = Familia.redis(source_uri).type key
+        ttl = Familia.redis(source_uri).ttl key
+        if source_uri.host == target_uri.host && source_uri.port == target_uri.port
+          Familia.redis(source_uri).move key, target_uri.db
+        else
+          case type
+          when "string"
+            value = Familia.redis(source_uri).get key
+          when "list"
+            value = Familia.redis(source_uri).lrange key, 0, -1
+          when "set"
+            value = Familia.redis(source_uri).smembers key
+          else
+            raise Familia::Problem, "unknown key type: #{type}"
+          end
+          raise "Not implemented"
+        end
+        each_key.call(idx, type, key, ttl) unless each_key.nil?
+      end
+    end
+    # Use the return value from each_key as the new key name
+    def rename(filter, source_uri, target_uri=nil, &each_key)
+      target_uri ||= source_uri
+      move_keys filter, source_uri, target_uri if source_uri != target_uri
+      source_keys = Familia.redis(source_uri).keys(filter)
+      puts "Renaming #{source_keys.size} keys from #{source_uri} (filter: #{filter})"
+      source_keys.each_with_index do |key,idx|
+        Familia.trace :RENAME1, Familia.redis(source_uri), "#{key}", ''
+        type = Familia.redis(source_uri).type key
+        ttl = Familia.redis(source_uri).ttl key
+        newkey = each_key.call(idx, type, key, ttl) unless each_key.nil?
+        Familia.trace :RENAME2, Familia.redis(source_uri), "#{key} -> #{newkey}", caller[0]
+        ret = Familia.redis(source_uri).renamenx key, newkey
+      end
+    end
+  end
+end
+
+
+module Familia
+  module Collector
+    def klasses
+      @klasses ||= []
+      @klasses
+    end
+    def included(obj)
+      self.klasses << obj
+    end
+  end  
+end
+
+class Symbol
+  unless method_defined?(:to_proc)
+    def to_proc
+      proc { |obj, *args| obj.send(self, *args) }
+    end
+  end
+end
+

metadata

@@ -0,0 +1,137 @@
+--- !ruby/object:Gem::Specification 
+name: familia
+version: !ruby/object:Gem::Version 
+  hash: 13
+  prerelease: false
+  segments: 
+  - 0
+  - 5
+  - 3
+  version: 0.5.3
+platform: ruby
+authors: 
+- Delano Mandelbaum
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-12-10 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: redis
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 2
+        - 1
+        - 0
+        version: 2.1.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: uri-redis
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 13
+        segments: 
+        - 0
+        - 4
+        - 1
+        version: 0.4.1
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: gibbler
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 55
+        segments: 
+        - 0
+        - 8
+        - 4
+        version: 0.8.4
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: storable
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 57
+        segments: 
+        - 0
+        - 8
+        - 3
+        version: 0.8.3
+  type: :runtime
+  version_requirements: *id004
+description: Organize and store ruby objects in Redis
+email: delano@solutious.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.rdoc
+files: 
+- CHANGES.txt
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION.yml
+- familia.gemspec
+- lib/familia.rb
+has_rdoc: true
+homepage: http://github.com/delano/familia
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: familia
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Organize and store ruby objects in Redis
+test_files: []
+