familia 0.6.1 → 0.6.2

data/CHANGES.txt

@@ -1,5 +1,20 @@
 FAMILIA, CHANGES
 
+#### 0.6.2 (2010-12-29) ###############################
+
+* FIXED: Familia::ClassMethods.ttl=
+* FIXED: Familia.class_lists (etc) methods. 
+* FIXED: Redis objects check if parent is a Module
+* CHANGE: redis_objects, class_redis_objects maintain order they're defined in. (See Bluth::Queue)
+* CHANGE: Depends on Storable 0.8.4
+* CHANGE: FamiliaObject.instances is now a sorted set
+* ADDED: InstanceMethods#initialize calls init if available
+* ADDED: Can set index values via InstanceMethods#index=
+* ADDED: empty? method for List, Set, et al
+* ADDED: :extend option for RedisObject instances
+* ADDED: :reference option for storing the index value instead of the marshaled value
+
+
 #### 0.6.1 (2010-12-18) ###############################
 
 * CHANGE: Default initialize method calls initialize_redis_objects before super

data/Rakefile

@@ -26,9 +26,9 @@ begin
     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_dependency("uri-redis",  ">= 0.4.2")
+    gem.add_dependency("gibbler",    ">= 0.8.6")
+    gem.add_dependency("storable",   ">= 0.8.5")
     
     #gem.add_development_dependency("rspec", ">= 1.2.9")
     #gem.add_development_dependency("mocha", ">= 0.9.8")

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
 :MAJOR: 0
 :MINOR: 6
-:PATCH: 1
+:PATCH: 2

data/familia.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{familia}
-  s.version = "0.6.1"
+  s.version = "0.6.2"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Delano Mandelbaum"]
-  s.date = %q{2010-12-18}
+  s.date = %q{2010-12-30}
   s.description = %q{Organize and store ruby objects in Redis}
   s.email = %q{delano@solutious.com}
   s.extra_rdoc_files = [
@@ -53,20 +53,20 @@ Gem::Specification.new do |s|
 
     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"])
+      s.add_runtime_dependency(%q<uri-redis>, [">= 0.4.2"])
+      s.add_runtime_dependency(%q<gibbler>, [">= 0.8.6"])
+      s.add_runtime_dependency(%q<storable>, [">= 0.8.5"])
     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"])
+      s.add_dependency(%q<uri-redis>, [">= 0.4.2"])
+      s.add_dependency(%q<gibbler>, [">= 0.8.6"])
+      s.add_dependency(%q<storable>, [">= 0.8.5"])
     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"])
+    s.add_dependency(%q<uri-redis>, [">= 0.4.2"])
+    s.add_dependency(%q<gibbler>, [">= 0.8.6"])
+    s.add_dependency(%q<storable>, [">= 0.8.5"])
   end
 end
 

data/lib/familia/core_ext.rb

@@ -17,102 +17,103 @@ class String
   end
 end
 
-class Time
-  module Units
-    PER_MICROSECOND = 0.000001.freeze
-    PER_MILLISECOND = 0.001.freeze
-    PER_MINUTE = 60.0.freeze
-    PER_HOUR = 3600.0.freeze
-    PER_DAY = 86400.0.freeze
+unless defined?(Time::Units)
+  class Time
+    module Units
+      PER_MICROSECOND = 0.000001.freeze
+      PER_MILLISECOND = 0.001.freeze
+      PER_MINUTE = 60.0.freeze
+      PER_HOUR = 3600.0.freeze
+      PER_DAY = 86400.0.freeze
     
-    def microseconds()    seconds * PER_MICROSECOND     end
-    def milliseconds()    seconds * PER_MILLISECOND    end
-    def seconds()         self                         end
-    def minutes()         seconds * PER_MINUTE          end
-    def hours()           seconds * PER_HOUR             end
-    def days()            seconds * PER_DAY               end
-    def weeks()           seconds * PER_DAY * 7           end
-    def years()           seconds * PER_DAY * 365        end 
+      def microseconds()    seconds * PER_MICROSECOND     end
+      def milliseconds()    seconds * PER_MILLISECOND    end
+      def seconds()         self                         end
+      def minutes()         seconds * PER_MINUTE          end
+      def hours()           seconds * PER_HOUR             end
+      def days()            seconds * PER_DAY               end
+      def weeks()           seconds * PER_DAY * 7           end
+      def years()           seconds * PER_DAY * 365        end 
             
-    def in_years()        seconds / PER_DAY / 365      end
-    def in_weeks()        seconds / PER_DAY / 7       end
-    def in_days()         seconds / PER_DAY          end
-    def in_hours()        seconds / PER_HOUR          end
-    def in_minutes()      seconds / PER_MINUTE         end
-    def in_milliseconds() seconds / PER_MILLISECOND    end
-    def in_microseconds() seconds / PER_MICROSECOND   end
+      def in_years()        seconds / PER_DAY / 365      end
+      def in_weeks()        seconds / PER_DAY / 7       end
+      def in_days()         seconds / PER_DAY          end
+      def in_hours()        seconds / PER_HOUR          end
+      def in_minutes()      seconds / PER_MINUTE         end
+      def in_milliseconds() seconds / PER_MILLISECOND    end
+      def in_microseconds() seconds / PER_MICROSECOND   end
     
-    def in_time
-      Time.at(self).utc
-    end
+      def in_time
+        Time.at(self).utc
+      end
     
-    def in_seconds(u=nil)
-      case u.to_s
-      when /\A(y)|(years?)\z/
-        years
-      when /\A(w)|(weeks?)\z/
-        weeks
-      when /\A(d)|(days?)\z/
-        days
-      when /\A(h)|(hours?)\z/
-        hours
-      when /\A(m)|(minutes?)\z/
-        minutes
-      when /\A(ms)|(milliseconds?)\z/
-        milliseconds
-      when /\A(us)|(microseconds?)|(μs)\z/
-        microseconds
-      else
-        self
+      def in_seconds(u=nil)
+        case u.to_s
+        when /\A(y)|(years?)\z/
+          years
+        when /\A(w)|(weeks?)\z/
+          weeks
+        when /\A(d)|(days?)\z/
+          days
+        when /\A(h)|(hours?)\z/
+          hours
+        when /\A(m)|(minutes?)\z/
+          minutes
+        when /\A(ms)|(milliseconds?)\z/
+          milliseconds
+        when /\A(us)|(microseconds?)|(μs)\z/
+          microseconds
+        else
+          self
+        end
       end
-    end
     
-    ## JRuby doesn't like using instance_methods.select here. 
-    ## It could be a bug or something quirky with Attic 
-    ## (although it works in 1.8 and 1.9). The error:
-    ##  
-    ##  lib/attic.rb:32:in `select': yield called out of block (LocalJumpError)
-    ##  lib/stella/mixins/numeric.rb:24
-    ##
-    ## Create singular methods, like hour and day. 
-    # instance_methods.select.each do |plural|
-    #   singular = plural.to_s.chop
-    #   alias_method singular, plural
-    # end
+      ## JRuby doesn't like using instance_methods.select here. 
+      ## It could be a bug or something quirky with Attic 
+      ## (although it works in 1.8 and 1.9). The error:
+      ##  
+      ##  lib/attic.rb:32:in `select': yield called out of block (LocalJumpError)
+      ##  lib/stella/mixins/numeric.rb:24
+      ##
+      ## Create singular methods, like hour and day. 
+      # instance_methods.select.each do |plural|
+      #   singular = plural.to_s.chop
+      #   alias_method singular, plural
+      # end
     
-    alias_method :ms, :milliseconds
-    alias_method :'μs', :microseconds
-    alias_method :second, :seconds
-    alias_method :minute, :minutes
-    alias_method :hour, :hours
-    alias_method :day, :days
-    alias_method :week, :weeks
-    alias_method :year, :years
+      alias_method :ms, :milliseconds
+      alias_method :'μs', :microseconds
+      alias_method :second, :seconds
+      alias_method :minute, :minutes
+      alias_method :hour, :hours
+      alias_method :day, :days
+      alias_method :week, :weeks
+      alias_method :year, :years
 
+    end
   end
-end
 
-class Numeric
-  include Time::Units
+  class Numeric
+    include Time::Units
 
-  def to_ms
-    (self*1000.to_f)
-  end
+    def to_ms
+      (self*1000.to_f)
+    end
   
-  # TODO: Use 1024?
-  def to_bytes
-    args = case self.abs.to_i
-    when (1000)..(1000**2)
-      '%3.2f%s' % [(self / 1000.to_f).to_s, 'KB']
-    when (1000**2)..(1000**3)
-      '%3.2f%s' % [(self / (1000**2).to_f).to_s, 'MB']
-    when (1000**3)..(1000**4)
-      '%3.2f%s' % [(self / (1000**3).to_f).to_s, 'GB']
-    when (1000**4)..(1000**6)
-      '%3.2f%s' % [(self / (1000**4).to_f).to_s, 'TB']
-    else
-      [self.to_i, 'B'].join
+    # TODO: Use 1024?
+    def to_bytes
+      args = case self.abs.to_i
+      when (1000)..(1000**2)
+        '%3.2f%s' % [(self / 1000.to_f).to_s, 'KB']
+      when (1000**2)..(1000**3)
+        '%3.2f%s' % [(self / (1000**2).to_f).to_s, 'MB']
+      when (1000**3)..(1000**4)
+        '%3.2f%s' % [(self / (1000**3).to_f).to_s, 'GB']
+      when (1000**4)..(1000**6)
+        '%3.2f%s' % [(self / (1000**4).to_f).to_s, 'TB']
+      else
+        [self.to_i, 'B'].join
+      end
     end
   end
 end
-

data/lib/familia/object.rb

@@ -23,7 +23,7 @@ module Familia
         !obj.nil? && klass == obj.klass
       end
       define_method :"#{kind}s" do 
-        names = redis_objects.keys.select { |name| send(:"#{kind}?", name) }
+        names = redis_objects_order.select { |name| send(:"#{kind}?", name) }
         names.collect! { |name| redis_objects[name] }
         names
       end
@@ -42,7 +42,12 @@ module Familia
         !obj.nil? && klass == obj.klass
       end
       define_method :"class_#{kind}s" do 
-        names = class_redis_objects.keys.select { |name| send(:"#{kind}?", name) }
+        names = class_redis_objects_order.select { |name| ret = send(:"class_#{kind}?", name) }
+        # TODO: This returns instances of the RedisObject class which
+        # also contain the options. This is different from the instance
+        # RedisObjects defined above which returns the OpenStruct of name, klass, and opts. 
+        #names.collect! { |name| self.send name }
+        # OR NOT:
         names.collect! { |name| class_redis_objects[name] }
         names
       end
@@ -50,10 +55,15 @@ module Familia
     
     def inherited(obj)
       obj.db = self.db
-      obj.ttl = self.ttl
       obj.uri = self.uri
+      obj.ttl = self.ttl
       obj.parent = self
-      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
       super(obj)
     end
@@ -62,15 +72,17 @@ module Familia
       obj.ttl = self.ttl
       obj.uri = self.uri
       obj.parent = self
-      obj.class_set :instances
+      obj.class_zset :instances, :class => obj, :reference => true
       Familia.classes << obj
     end
     
     # Creates an instance method called +name+ that
     # returns an instance of the RedisObject +klass+ 
     def install_redis_object name, klass, opts
+      raise ArgumentError, "Name is blank" if name.to_s.empty?
       name = name.to_s.to_sym
       opts ||= {}
+      redis_objects_order << name
       redis_objects[name] = OpenStruct.new
       redis_objects[name].name = name
       redis_objects[name].klass = klass
@@ -79,17 +91,22 @@ module Familia
       define_method "#{name}=" do |v|
         self.send(name).replace v
       end
+      define_method "#{name}?" do
+        !self.send(name).empty?
+      end
       redis_objects[name]
     end
     
     # Creates a class method called +name+ that
     # returns an instance of the RedisObject +klass+ 
     def install_class_redis_object name, klass, opts
+      raise ArgumentError, "Name is blank" if name.to_s.empty?
       name = name.to_s.to_sym
       opts ||= {}
       opts[:suffix] ||= nil
       opts[:parent] ||= self
-      # TODO: investigate metaclass.redis_objects
+      # TODO: investigate using metaclass.redis_objects
+      class_redis_objects_order << name
       class_redis_objects[name] = OpenStruct.new
       class_redis_objects[name].name = name
       class_redis_objects[name].klass = klass
@@ -100,6 +117,9 @@ module Familia
       metaclass.send :define_method, "#{name}=" do |v|
         send(name).replace v
       end
+      metaclass.send :define_method, "#{name}?" do
+        !send(name).empty?
+      end
       redis_object = klass.new name, opts
       redis_object.freeze
       self.instance_variable_set("@#{name}", redis_object)
@@ -114,6 +134,7 @@ module Familia
       @ttl = v unless v.nil?
       @ttl || (parent ? parent.ttl : nil)
     end
+    def ttl=(v) @ttl = v end
     def db v=nil
       @db = v unless v.nil?
       @db || (parent ? parent.db : nil)
@@ -128,15 +149,13 @@ module Familia
       @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 || (parent ? parent.uri : Familia.uri)
+      self.uri = uri if !uri.to_s.empty?
+      @uri ||= (parent ? parent.uri : Familia.uri)
+      @uri.db = @db if @db && @uri.db.to_s != @db.to_s
+      @uri
     end
     def redis
-      Familia.redis(self.uri)
+      Familia.redis uri
     end
     def flushdb
       Familia.info "flushing #{uri}"
@@ -145,7 +164,7 @@ module Familia
     def keys(suffix=nil)
       self.redis.keys(rediskey('*',suffix)) || []
     end
-    def all(suffix=nil)
+    def all(suffix=:object)
       # objects that could not be parsed will be nil
       keys(suffix).collect { |k| from_key(k) }.compact 
     end
@@ -170,6 +189,10 @@ module Familia
     def suffixes
       redis_objects.keys.uniq
     end
+    def class_redis_objects_order
+      @class_redis_objects_order ||= []
+      @class_redis_objects_order
+    end
     def class_redis_objects
       @class_redis_objects ||= {}
       @class_redis_objects
@@ -180,26 +203,20 @@ module Familia
     def redis_object? name
       redis_objects.has_key? name.to_s.to_sym
     end
+    def redis_objects_order
+      @redis_objects_order ||= []
+      @redis_objects_order
+    end
     def redis_objects
       @redis_objects ||= {}
       @redis_objects
     end
-    def create(*args)
-      me = new(*args)
-      raise "#{self} exists: #{me.to_json}" if me.exists?
+    def create *args
+      me = from_array *args
+      raise "#{self} exists: #{me.rediskey}" 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 multiget(*ids)
       ids = rawmultiget(*ids)
       ids.compact.collect { |json| self.from_json(json) }.compact
@@ -211,49 +228,56 @@ module Familia
       ids = self.redis.mget *ids
     end
     
-    def from_key(akey)
-      raise ArgumentError, "Null key" if akey.nil? || akey.empty?    
-      Familia.trace :LOAD, redis, "#{self.uri}/#{akey}", caller if Familia.debug?
-      return unless redis.exists akey
-      v = redis.get akey
-      begin
-        if v.to_s.empty?
-          Familia.info  "No content @ #{akey}"
-          nil
-        else
-          self.send Familia.load_method, v
-        end
-      rescue => ex
-        Familia.info v
-        Familia.info "Non-fatal error parsing JSON for #{akey}: #{ex.message}"
-        Familia.info ex.backtrace
-        nil
-      end
-    end
-    def from_redis(objid)
-      objid &&= objid.to_s
-      return nil if objid.nil? || objid.empty?
-      this_key = rediskey(objid, self.suffix)
-      me = from_key(this_key)
+    # Returns an instance based on +idx+ otherwise it
+    # creates and saves a new instance base on +idx+. 
+    # See from_index
+    def load_or_create idx
+      return from_redis(idx) if exists?(idx)
+      obj = from_index idx
+      obj.save
+      obj
+    end
+    # Note +idx+ needs to be an appropriate index for 
+    # the given class. If the index is multi-value it
+    # must be passed as an Array in the proper order.
+    # Does not call save.
+    def from_index idx
+      obj = new 
+      obj.index = idx
+      obj
+    end
+    def from_key objkey
+      raise ArgumentError, "Null key" if objkey.to_s.empty?    
+      Familia.trace :LOAD, redis, "#{self.uri}/#{objkey}", caller if Familia.debug?
+      obj = Familia::String.new objkey, :class => self
+      obj.exists? ? obj.value : nil
+    end
+    def from_redis idx, suffix=:object
+      return nil if idx.to_s.empty?
+      objkey = rediskey idx, suffix
+      Familia.trace :FROMREDIS, Familia.redis(self.uri), objkey, caller.first
+      me = from_key objkey
       me
     end
-    def exists?(objid, suffix=nil)
-      objid &&= objid.to_s
-      return false if objid.nil? || objid.empty?
-      ret = Familia.redis(self.uri).exists rediskey(objid, suffix)
-      Familia.trace :EXISTS, Familia.redis(self.uri), "#{rediskey(objid)} #{ret}", caller.first
+    def exists? idx, suffix=:object
+      return false if idx.to_s.empty?
+      objkey = rediskey idx, suffix
+      ret = Familia.redis(self.uri).exists objkey
+      Familia.trace :EXISTS, Familia.redis(self.uri), "#{rediskey(obj.index, suffix)} #{ret}", caller.first
       ret
     end
-    def destroy!(idx, suffix=nil)  # TODO: remove suffix arg
-      ret = Familia.redis(self.uri).del rediskey(runid, suffix)
-      Familia.trace :DELETED, Familia.redis(self.uri), "#{rediskey(runid)}: #{ret}", caller.first
+    def destroy! idx, suffix=:object
+      ret = Familia.redis(self.uri).del rediskey(idx, suffix)
+      Familia.trace :DELETED, Familia.redis(self.uri), "#{rediskey(idx, suffix)}: #{ret}", caller.first
       ret
     end
-    def find(suffix='*')
+    def find suffix='*'
       list = Familia.redis(self.uri).keys(rediskey('*', suffix)) || []
     end
-    def rediskey(idx, suffix=nil)
+    # idx can be a value or an Array of values used to create the index. 
+    def rediskey idx, suffix=nil
       raise RuntimeError, "No index for #{self}" if idx.to_s.empty?
+      idx = Familia.join *idx if Array === idx
       idx &&= idx.to_s
       Familia.rediskey(prefix, idx, suffix)
     end
@@ -271,12 +295,6 @@ module Familia
         raise Familia::NonUniqueKey, "Short key returned more than 1 match" 
       end
     end
-    ## TODO: Investigate
-    ##def float
-    ##  Proc.new do |v|
-    ##    v.nil? ? 0 : v.to_f
-    ##  end
-    ##end
   end
 
   
@@ -288,23 +306,17 @@ module Familia
     # must call initialize_redis_objects.
     def initialize *args
       initialize_redis_objects
-      super   # call Storable#initialize or equivalent
+      from_array *args if respond_to? :from_array
+      init *args if respond_to? :init
     end
     
     # This needs to be called in the initialize method of
     # any class that includes Familia. 
     def initialize_redis_objects
-      # :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).
-      unless self.class.redis_object? :object
-        self.class.string :object, :class => self.class
-      end
-      
       # Generate instances of each RedisObject. These need to be
       # unique for each instance of this class so they can refer
-      # to the index of this specific instance. 
+      # to the index of this specific instance.
+      #
       # i.e. 
       #     familia_object.rediskey              == v1:bone:INDEXVALUE:object
       #     familia_object.redis_object.rediskey == v1:bone:INDEXVALUE:name
@@ -326,7 +338,8 @@ module Familia
     
     def redisinfo
       info = {
-        :db   => self.class.db || 0,
+        :uri  => self.class.uri,
+        :db   => self.class.db,
         :key  => rediskey,
         :type => redistype,
         :ttl  => realttl
@@ -363,9 +376,11 @@ module Familia
       #Familia.trace :SAVE, Familia.redis(self.class.uri), redisuri, caller.first
       preprocess if respond_to?(:preprocess)
       self.update_time if self.respond_to?(:update_time)
+      # TODO: Check here (run checkup)
       ret = self.object.set self               # object is a name reserved by Familia
       unless ret.nil?
-        self.class.instances.add index         # use this set instead of Klass.keys
+        now = Time.now.utc.to_i
+        self.class.instances.add now, self     # use this set instead of Klass.keys
         self.object.update_expiration self.ttl # does nothing unless if not specified
       end
       true
@@ -375,7 +390,7 @@ module Familia
       if Familia.debug?
         Familia.trace :DELETED, Familia.redis(self.class.uri), "#{rediskey}: #{ret}", caller.first
       end
-      self.class.instances.rem index if ret > 0
+      self.class.instances.rem self if ret > 0
       ret
     end
     def index
@@ -397,14 +412,39 @@ module Familia
           unless self.respond_to? self.class.index
             raise NoIndex, "No such method: `#{self.class.index}' for #{self.class}"
           end
-          self.send self.class.index
+          self.send( self.class.index)
         end
       else
         raise Familia::NoIndex, self
       end
     end
-    def index=(i)
-      @index = i
+    def index=(v)
+      case self.class.index
+      when Proc
+        raise ArgumentError, "Cannot set a Proc index"
+      when Array
+        unless Array === v && v.size == self.class.index.size
+          raise ArgumentError, "Index mismatch (#{v.size} for #{self.class.index.size})"
+        end
+        parts = self.class.index.each_with_index { |meth,idx| 
+          unless self.respond_to? "#{meth}="
+            raise NoIndex, "No such method: `#{meth}=' for #{self.class}"
+          end
+          self.send("#{meth}=", v[idx]) 
+        }
+      when Symbol, String
+        if self.class.redis_object?(self.class.index.to_sym)
+          raise Familia::NoIndex, "Cannot use a RedisObject as an index"
+        else
+          unless self.respond_to? "#{self.class.index}="
+            raise NoIndex, "No such method: `#{self.class.index}=' for #{self.class}"
+          end
+          self.send("#{self.class.index}=", v)
+        end
+      else
+        raise Familia::NoIndex, self
+      end
+      
     end
     def expire(ttl=nil)
       ttl ||= self.class.ttl