familia 0.6.1 → 0.6.2

data/lib/familia/redisobject.rb

@@ -47,7 +47,7 @@ module Familia
     end
     
     attr_reader :name, :parent
-    attr_accessor :redis
+    attr_writer :redis
     
     # +name+: If parent is set, this will be used as the suffix 
     # for rediskey. Otherwise this becomes the value of the key.
@@ -55,7 +55,20 @@ module Familia
     # 
     # Options:
     #
-    # :parent: The Familia object that this redis object belongs
+    # :class => A class that responds to Familia.load_method and 
+    # Familia.dump_method. These will be used when loading and
+    # saving data from/to redis to unmarshal/marshal the class. 
+    #
+    # :reference => When true the index of the given value will be
+    # stored rather than the marshaled value. This assumes that 
+    # the marshaled object is stored at a separate key. When read, 
+    # from_redis looks for that separate key and returns the 
+    # unmarshaled object. :class must be specified. Default: false. 
+    #
+    # :extend => Extend this instance with the functionality in an 
+    # other module. Literally: "self.extend opts[:extend]".
+    #
+    # :parent => The Familia object that this redis object belongs
     # to. This can be a class that includes Familia or an instance.
     # 
     # :ttl => the time to live in seconds. When not nil, this will
@@ -64,10 +77,6 @@ module Familia
     #
     # :default => the default value (String-only)
     #
-    # :class => A class that responds to Familia.load_method and 
-    # Familia.dump_method. These will be used when loading and
-    # saving data from/to redis to unmarshal/marshal the class. 
-    #
     # :db => the redis database to use (ignored if :redis is used).
     #
     # :redis => an instance of Redis.
@@ -77,28 +86,60 @@ module Familia
     def initialize name, opts={}
       @name, @opts = name, opts
       @name = @name.join(Familia.delim) if Array === @name
-      @opts[:ttl] ||= self.class.ttl
-      @opts[:db] ||= self.class.db
+      Familia.ld [name, opts, caller[0]].inspect
+      self.extend @opts[:extend] if Module === @opts[:extend]
+      @db = @opts.delete(:db)
+      @ttl = @opts.delete(:ttl) 
       @parent = @opts.delete(:parent)
-      @redis = parent.redis if parent?
-      @redis ||= @opts.delete(:redis) || Familia.redis(@opts[:db])
+      @redis ||= @opts.delete(:redis)
       init if respond_to? :init
     end
     
+    def redis
+      return @redis if @redis
+      parent? ? parent.redis : Familia.redis(db)
+    end
+    
+    def ttl
+      @ttl || self.class.ttl
+    end
+    
+    # Returns the most likely value for db, checking (in this order):
+    #   * the value from :class if it's a Familia object
+    #   * the value from :parent
+    #   * the value self.class.db
+    #   * assumes the db is 0
+    # 
+    # After this is called once, this method will always return the 
+    # same value.
+    def db 
+      return @db if @db
+      # Note it's important that we select this value at the last
+      # possible moment rather than in initialize b/c the value 
+      # could be modified after that but before this is called. 
+      if @opts[:class] && @opts[:class].ancestors.member?(Familia)
+        @db = @opts[:class].db 
+      else
+        @db = parent? ? parent.db : self.class.db
+      end
+      @db ||= 0
+      @db
+    end
+    
     # returns a redis key based on the parent 
     # object so it will include the proper index.
     def rediskey
-      parent? ? parent.rediskey(name) : Familia.rediskey(name)
+      parent? ? parent.rediskey(name) : [name].flatten.compact.join(Familia.delim)
     end
     
     def parent?
-      Class === parent || parent.kind_of?(Familia)
+      Class === parent || Module === parent || parent.kind_of?(Familia)
     end
     
     def update_expiration(ttl=nil)
-      ttl ||= @opts[:ttl]
+      ttl ||= @opts[:ttl] || self.class.ttl
       return unless ttl && ttl.to_i > 0
-      #Familia.trace :SET_EXPIRE, Familia.redis(self.class.uri), "#{rediskey} to #{self.ttl}"
+      Familia.info "#{rediskey} to #{ttl}"
       expire ttl.to_i
     end
     
@@ -124,10 +165,10 @@ module Familia
     #end
     
     def exists?
-      !size.zero?
+      redis.exists(rediskey) && !size.zero?
     end
     
-    def ttl
+    def realttl
       redis.ttl rediskey
     end
     
@@ -139,17 +180,38 @@ module Familia
       redis.expireat rediskey, unixtime
     end
     
+    def dump_method
+      @opts[:dump_method] || Familia.dump_method
+    end
+    
+    def load_method
+      @opts[:load_method] || Familia.load_method
+    end
+    
     def to_redis v
       return v unless @opts[:class]
-      if v.respond_to? Familia.dump_method
-        v.send Familia.dump_method
-      else
-        Familia.ld "No such method: #{v.class}.#{Familia.dump_method}"
+      case @opts[:class]
+      when String, Fixnum, Float, Gibbler::Digest
         v
+      else
+        if @opts[:reference] == true
+          unless v.respond_to? :index
+            raise Familia::Problem, "#{v.class} does not have an index method"
+          end
+          unless v.kind_of?(Familia)
+            raise Familia::Problem, "#{v.class} is not Familia (#{name})"
+          end
+          v.index
+        elsif v.respond_to? dump_method
+          v.send dump_method
+        else
+          raise Familia::Problem, "No such method: #{v.class}.#{dump_method}"
+        end
       end
     end
     
     def from_redis v
+      return @opts[:default] if v.nil?
       return v unless @opts[:class]
       case @opts[:class]
       when String
@@ -157,13 +219,21 @@ module Familia
       when Fixnum, Float
         @opts[:class].induced_from v
       else
-        if @opts[:class].method_defined? Familia.load_method
-          @opts[:class].send Familia.load_method, v
+        if @opts[:reference] == true
+          @opts[:class].from_redis v
         else
-          Familia.ld "No such method: #{@opts[:class]}##{Familia.load_method}"
-          v
+          if @opts[:class].respond_to? load_method
+            @opts[:class].send load_method, v
+          else
+            raise Familia::Problem, "No such method: #{@opts[:class]}##{load_method}"
+          end
         end
       end
+    rescue => ex
+      Familia.info v
+      Familia.info "Parse error for #{rediskey} (#{load_method}): #{ex.message}"
+      Familia.info ex.backtrace
+      nil
     end 
     
   end
@@ -176,15 +246,22 @@ module Familia
     end
     alias_method :length, :size
     
-    def << v
-      redis.rpush rediskey, to_redis(v)
+    def empty?
+      size == 0
+    end
+    
+    def push *values
+      values.flatten.compact.each { |v| redis.rpush rediskey, to_redis(v) }
       redis.ltrim rediskey, -@opts[:maxlength], -1 if @opts[:maxlength]
       self
     end
-    alias_method :push, :<<
-
-    def unshift v
-      redis.lpush rediskey, to_redis(v)
+    
+    def << v
+      push v
+    end
+    
+    def unshift *values
+      values.flatten.compact.each { |v| redis.lpush rediskey, to_redis(v) }
       # TODO: test maxlength
       redis.ltrim rediskey, 0, @opts[:maxlength] - 1 if @opts[:maxlength]
       self
@@ -195,7 +272,7 @@ module Familia
     end
     
     def shift
-      from_redis redis.lpop(key)
+      from_redis redis.lpop(rediskey)
     end
     
     def [] idx, count=nil
@@ -217,12 +294,40 @@ module Familia
       redis.lrem rediskey, count, to_redis(v)
     end
     alias_method :remove, :delete
+    alias_method :rem, :delete
+    alias_method :del, :delete
     
     def range sidx=0, eidx=-1
-      # TODO: handle @opts[:marshal]
-      redis.lrange rediskey, sidx, eidx
+      redis.lrange(rediskey, sidx, eidx).collect do |v|
+        from_redis v
+      end
+    end
+    
+    def members count=-1
+      range 0, count
+    end
+    alias_method :all, :members
+    alias_method :to_a, :members
+    
+    #def revmembers count=1  #TODO
+    #  range -count, 0
+    #end
+    
+    def each &blk
+      range.each &blk
+    end
+    
+    def each_with_index &blk
+      range.each_with_index &blk
+    end
+    
+    def collect &blk
+      range.collect &blk
+    end
+    
+    def select &blk
+      range.select &blk
     end
-    alias_method :to_a, :range
     
     def at idx
       from_redis redis.lindex(rediskey, idx)
@@ -272,19 +377,39 @@ module Familia
       size == 0
     end
     
-    def << v
-      redis.sadd rediskey, to_redis(v)
+    def add *values
+      values.flatten.compact.each { |v| redis.sadd rediskey, to_redis(v) }
       self
     end
-    alias_method :add, :<<
+    
+    def << v
+      add v
+    end
     
     def members
-      # TODO: handle @opts[:marshal]
-      redis.smembers rediskey
+      redis.smembers(rediskey).collect do |v|
+        from_redis v
+      end
     end
     alias_method :all, :members
     alias_method :to_a, :members
     
+    def each &blk
+      members.each &blk
+    end
+    
+    def each_with_index &blk
+      members.each_with_index &blk
+    end
+    
+    def collect &blk
+      members.collect &blk
+    end
+    
+    def select &blk
+      members.select &blk
+    end
+    
     def member? v
       redis.sismember rediskey, to_redis(v)
     end
@@ -309,7 +434,7 @@ module Familia
     end
     
     def random
-      redis.srandmember rediskey
+      from_redis redis.srandmember(rediskey)
     end
     
     ## Make the value stored at KEY identical to the given list
@@ -343,6 +468,10 @@ module Familia
     end
     alias_method :length, :size
     
+    def empty?
+      size == 0
+    end
+    
     # NOTE: The argument order is the reverse of #add
     # e.g. obj.metrics[VALUE] = SCORE
     def []= v, score
@@ -377,29 +506,52 @@ module Familia
       ret.nil? ? nil : ret.to_i
     end
     
-    def members opts={}
-      range 0, -1, opts
+    def members count=-1, opts={}
+      range 0, count, opts
     end
     alias_method :to_a, :members
+    alias_method :all, :members
     
-    def membersrev opts={}
-      rangerev 0, -1, opts
+    def revmembers count=-1, opts={}
+      revrange 0, count, opts
+    end
+    
+    def each &blk
+      members.each &blk
+    end
+
+    def each_with_index &blk
+      members.each_with_index &blk
+    end
+    
+    def collect &blk
+      members.collect &blk
+    end
+    
+    def select &blk
+      members.select &blk
     end
     
     def range sidx, eidx, opts={}
       opts[:with_scores] = true if opts[:withscores]
-      redis.zrange rediskey, sidx, eidx, opts
+      redis.zrange(rediskey, sidx, eidx, opts).collect do |v|
+        from_redis v
+      end
     end
 
-    def rangerev sidx, eidx, opts={}
+    def revrange sidx, eidx, opts={}
       opts[:with_scores] = true if opts[:withscores]
-      redis.zrevrange rediskey, sidx, eidx, opts
+      redis.zrevrange(rediskey, sidx, eidx, opts).collect do |v|
+        from_redis v
+      end
     end
     
     # e.g. obj.metrics.rangebyscore (now-12.hours), now, :limit => [0, 10]
     def rangebyscore sscore, escore, opts={}
       opts[:with_scores] = true if opts[:withscores]
-      redis.zrangebyscore rediskey, sscore, escore, opts
+      redis.zrangebyscore(rediskey, sscore, escore, opts).collect do |v|
+        from_redis v
+      end
     end
     
     def remrangebyrank srank, erank
@@ -426,7 +578,9 @@ module Familia
       redis.zrem rediskey, to_redis(v)
     end
     alias_method :remove, :delete
-    
+    alias_method :rem, :delete
+    alias_method :del, :delete
+      
     def at idx
       range(idx, idx).first
     end
@@ -451,14 +605,20 @@ module Familia
     end
     alias_method :length, :size
     
+    def empty?
+      size == 0
+    end
+    
     def []= n, v
       redis.hset rediskey, n, to_redis(v)
     end
+    alias_method :put, :[]=
     alias_method :store, :[]=
     
     def [] n
-      redis.hget rediskey, n
+      from_redis redis.hget(rediskey, n)
     end
+    alias_method :get, :[]
     
     def fetch n, default=nil
       ret = self[n]
@@ -475,10 +635,13 @@ module Familia
     end
     
     def values
-      redis.hvals rediskey
+      redis.hvals(rediskey).collect do |v|
+        from_redis v
+      end
     end
     
     def all
+      # TODO: from_redis
       redis.hgetall rediskey
     end
     alias_method :to_hash, :all
@@ -516,7 +679,9 @@ module Familia
     alias_method :merge!, :update
     
     def values_at *names
-      redis.hmget rediskey, *names.flatten.compact
+      redis.hmget(rediskey, *names.flatten.compact).collect do |v|
+        from_redis v
+      end
     end
     
     Familia::RedisObject.register self, :hash
@@ -532,10 +697,15 @@ module Familia
     end
     alias_method :length, :size
     
+    def empty?
+      size == 0
+    end
+    
     def value
       redis.setnx rediskey, @opts[:default] if @opts[:default]
-      redis.get rediskey
+      from_redis redis.get(rediskey)
     end
+    alias_method :content, :value
     alias_method :get, :value
     
     def to_s
@@ -605,3 +775,4 @@ module Familia
   end
   
 end
+

data/lib/familia/test_helpers.rb

@@ -12,7 +12,6 @@ class Bone < Storable
   string :value, :default => "GREAT!"
 end
 
-
 class Session < Storable
   include Familia
   index :sessid
@@ -22,7 +21,6 @@ class Session < Storable
   ttl 60 # seconds to live
 end
 
-
 class Customer < Storable
   include Familia
   index :custid

data/lib/familia.rb

@@ -22,20 +22,19 @@ module Familia
   include Gibbler::Complex
   @secret = '1-800-AWESOME' # Should be modified via Familia.secret = ''
   @apiversion = nil
-  @uri = URI.parse 'redis://localhost'
+  @uri = URI.parse 'redis://127.0.0.1'
   @delim = ':'
   @clients = {}
   @classes = []
-  @conf = {}
   @suffix = :object.freeze
   @index = :id.freeze
   @debug = false.freeze
   @dump_method = :to_json
   @load_method = :from_json
   class << self
-    attr_reader :conf, :classes, :clients
+    attr_reader :classes, :clients, :uri
     attr_accessor :debug, :secret, :delim, :dump_method, :load_method
-    attr_writer :apiversion, :uri
+    attr_writer :apiversion
     def debug?() @debug == true end
     def info *msg
       STDERR.puts *msg
@@ -48,49 +47,34 @@ module Familia
       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 uri(db=nil)
-      if db.nil?
-        @uri
-      else
-        uri = URI.parse @uri.to_s
-        uri.db = db
-        uri
-      end
-    end
-    def apiversion(r=nil, &blk)  
-      if blk.nil?
-        @apiversion = r if r; 
-      else
-        tmp = @apiversion
-        @apiversion = r
-        blk.call
-        @apiversion = tmp
-      end
-      @apiversion 
-    end
-    def conf=(conf={})
-      @conf = conf
-      @uri = Redis.uri(@conf).freeze
-      connect @uri
-      @conf
+    def uri= v
+      v = URI.parse v unless URI === v
+      @uri = v
     end
+    # A convenience method for returning the appropriate Redis
+    # connection. If +uri+ is an Integer, we'll treat it as a
+    # database number. If it's a String, we'll treat it as a 
+    # full URI (e.g. redis://1.2.3.4/15).
+    # Otherwise we'll return the default connection. 
     def redis(uri=nil)
       if Integer === uri
-        uri = Familia.uri(uri)
-      else
-        uri &&= URI.parse uri if String === uri
+        tmp = Familia.uri
+        tmp.db = uri
+        uri = tmp
+      elsif String === uri
+        uri &&= URI.parse uri
       end
       uri ||= Familia.uri
       connect(uri) unless @clients[uri.serverid] 
-      #STDERR.puts "REDIS: #{uri} #{caller[0]}" if Familia.debug?
       @clients[uri.serverid]
     end
-    def connect(uri=nil, local_conf={})
+    def connect(uri=nil)
       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
+      conf = uri.conf
+      conf[:thread_safe] = true
+      client = Redis.new conf
+      Familia.trace :CONNECT, client, conf.inspect, caller[0..3] if Familia.debug
       @clients[uri.serverid] = client
     end
     def reconnect_all!
@@ -107,17 +91,23 @@ module Familia
     def default_suffix=(a) @suffix = a end
     def index(r=nil)  @index = r if r; @index end
     def index=(r) @index = r; r end
+    def join(*r) r.join(Familia.delim) end
     def split(r) r.split(Familia.delim) end
     def rediskey *args
       el = args.flatten.compact
       el.unshift @apiversion unless @apiversion.nil?
       el.join(Familia.delim)
     end
-    def destroy keyname, uri=nil
-      Familia.redis(uri).del keyname
-    end
-    def exists? keyname, uri=nil
-      Familia.redis(uri).exists keyname
+    def apiversion(r=nil, &blk)  
+      if blk.nil?
+        @apiversion = r if r; 
+      else
+        tmp = @apiversion
+        @apiversion = r
+        blk.call
+        @apiversion = tmp
+      end
+      @apiversion 
     end
   end
   
@@ -138,7 +128,12 @@ module Familia
     obj.send :include, Familia::InstanceMethods
     obj.send :include, Gibbler::Complex
     obj.extend Familia::ClassMethods
-    obj.class_set :instances
+    obj.class_zset :instances, :class => obj, :reference => true
+    # :object is a special redis object because its reserved
+    # for storing the marshaled instance data (e.g. to_json).
+    # When it isn't defined explicitly we define it here b/c
+    # it's assumed to exist in other places (see #save).
+    obj.string :object, :class => obj unless obj.redis_object? :object
     Familia.classes << obj
   end
   

data/try/21_redis_object_zset_try.rb

@@ -16,7 +16,7 @@ require 'familia/test_helpers'
 #=> ['metric0', 'metric1', 'metric2', 'metric3', 'metric4']
 
 ## Familia::SortedSet#members
-@a.metrics.membersrev
+@a.metrics.revmembers
 #=> ['metric4', 'metric3', 'metric2', 'metric1', 'metric0']
 
 ## Familia::SortedSet#rank

data/try/24_redis_object_string_try.rb

@@ -28,7 +28,7 @@ Familia.apiversion = 'v1'
 ## Familia::String.new
 @ret = Familia::String.new 'arbitrary:key'
 @ret.rediskey
-#=> 'v1:arbitrary:key'
+#=> 'arbitrary:key'
 
 ## instance set
 @ret.value = '1000'

data/try/30_familia_object_try.rb

@@ -30,8 +30,8 @@ Bone.suffix
 #=> true
 
 ## Customer.instances
-Customer.instances.all
-#=> ['delano']
+Customer.instances.all.collect(&:custid)
+#=> [:delano]
 
 ## Familia.from_redis
 obj = Customer.from_redis :delano