familia 1.0.0.pre.rc6 → 1.1.0.pre.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4d368f329560a1afd7252a2c8de830a7230334933cd00715b4b952e44d9fbf63
-  data.tar.gz: edd7b843ff07cf87aa2fe46766d7b0fd6dfa814b5404c9ca04bc42de18b05619
+  metadata.gz: f7e5fe48e629eab30af342be4ad81f6afe5854b33b678b926b9c3470c0515627
+  data.tar.gz: 1d938baae35feb17f3d9855055152fdb0ba441317315fd3b2de6932e3c47e0cf
 SHA512:
-  metadata.gz: 0f4db87dbaa2c12636d8293a477ef1e2a000364d3e6e2515cac90dad7277efc29d3670103cdf4f7697960ec90012ddec7071004146785ec7d3c838863e1a241b
-  data.tar.gz: a1812fce749dc485753a10c39281feb1babab24fd95ecdd553398c4a07a800836d7bf4ac4a7574ee987d4d181842e089cd732efa343141a0bf4610594ea8f1cd
+  metadata.gz: 707e9aba376653fa439ab1ffc85c4b794f1f52444dbed86a093f1d9c93a1952d8f84fe465cdcf8798bf0f72e5a4099586f1895cad5225f6d81899deeedcbf3a5
+  data.tar.gz: a9323482330bef4a632d92fd6828da32f0be7aa4f107d659e4440a2e3a09ad3dd0c2011d90a5e1a3380ca85fdf5afe47fb4634e9cf21951986d92115523bfbba

data/Gemfile

@@ -5,7 +5,9 @@ source 'https://rubygems.org'
 gemspec
 
 group :development, :test do
-  gem 'pry-byebug', '~> 3.10.1', require: false
+  # byebug only works with MRI
+  gem 'byebug', '~> 11.0', require: false if RUBY_ENGINE == 'ruby'
+  gem 'pry-byebug', '~> 3.10.1', require: false if RUBY_ENGINE == 'ruby'
   gem 'rubocop', require: false
   gem 'rubocop-performance', require: false
   gem 'rubocop-thread_safety', require: false

data/Gemfile.lock

@@ -1,8 +1,9 @@
 PATH
   remote: .
   specs:
-    familia (1.0.0.pre.rc6)
+    familia (1.1.0.pre.rc1)
       redis (>= 4.8.1, < 6.0)
+      stringio (~> 3.1.1)
       uri-redis (~> 1.3)
 
 GEM
@@ -55,6 +56,7 @@ GEM
       rubocop (>= 0.90.0)
     ruby-progressbar (1.13.0)
     storable (0.10.0)
+    stringio (3.1.1)
     strscan (3.1.0)
     sysinfo (0.10.0)
       drydock (< 1.0)

data/README.md

@@ -1,4 +1,4 @@
-# Familia - 1.0.0-rc6 (August 2024)
+# Familia - 1.1.0-rc1 (November 2024)
 
 **Organize and store Ruby objects in Redis. A powerful Ruby ORM (of sorts) for Redis.**
 
@@ -9,7 +9,7 @@ Familia provides a flexible and feature-rich way to interact with Redis using Ru
 
 Get it in one of the following ways:
 
-* In your Gemfile: `gem 'familia', '>= 1.0.0-rc4'`
+* In your Gemfile: `gem 'familia', '>= 1.1.0-rc1'`
 * Install it by hand: `gem install familia --pre`
 * Or for development: `git clone git@github.com:delano/familia.git`
 
@@ -152,11 +152,11 @@ end
 
 ```ruby
 class ComplexObject < Familia::Horreum
-  def to_redis
+  def serialize_value
     custom_serialization_method
   end
 
-  def self.from_redis(data)
+  def self.deserialize_value(data)
     custom_deserialization_method(data)
   end
 end
@@ -188,7 +188,7 @@ flower.save
 ### Retrieving and Updating Objects
 
 ```ruby
-rose = Flower.from_identifier("rrose")
+rose = Flower.find_by_id("rrose")
 rose.name = "Pink Rose"
 rose.save
 ```

data/VERSION.yml

@@ -1,5 +1,5 @@
 ---
 :MAJOR: 1
-:MINOR: 0
+:MINOR: 1
 :PATCH: 0
-:PRE: rc6
+:PRE: rc1

data/familia.gemspec

@@ -20,9 +20,8 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version = Gem::Requirement.new('>= 2.7.8')
 
   spec.add_dependency 'redis', '>= 4.8.1', '< 6.0'
+  spec.add_dependency 'stringio', '~> 3.1.1'
   spec.add_dependency 'uri-redis', '~> 1.3'
 
-  # byebug only works with MRI
-  spec.add_development_dependency 'byebug', '~> 11.0' if RUBY_ENGINE == 'ruby'
   spec.metadata['rubygems_mfa_required'] = 'true'
 end

data/lib/familia/base.rb

@@ -30,21 +30,21 @@ module Familia
       end
     end
 
-    # Yo, this class is like that one friend who never checks expiration dates.
-    # It's living life on the edge, data-style!
+    # Base implementation of update_expiration that maintains API compatibility
+    # with the :expiration feature's implementation.
     #
-    # @param ttl [Integer, nil] Time To Live? More like Time To Laugh! This param
-    #   is here for compatibility, but it's as useful as a chocolate teapot.
+    # This is a no-op implementation that gets overridden by features like
+    # :expiration. It accepts an optional ttl parameter to maintain interface
+    # compatibility with the overriding implementations.
     #
-    # @return [nil] Always returns nil. It's consistent in its laziness!
+    # @param ttl [Integer, nil] Time To Live in seconds (ignored in base implementation)
+    # @return [nil] Always returns nil
     #
-    # @example Trying to teach an old dog new tricks
-    #   immortal_data.update_expiration(86400) # Nice try, but this data is here to stay!
+    # @note This is a no-op implementation. Classes that need expiration
+    #       functionality should include the :expiration feature.
     #
-    # @note This method is a no-op. It's like shouting into the void, but less echo-y.
-    #
-    def update_expiration(*)
-      Familia.info "[update_expiration] Skipped for #{rediskey}. #{self.class} data is immortal!"
+    def update_expiration(ttl: nil)
+      Familia.ld "[update_expiration] Feature not enabled for #{self.class}. Key: #{rediskey} (caller: #{caller(1..1)})"
       nil
     end
 

data/lib/familia/connection.rb

@@ -6,6 +6,7 @@ require_relative '../../lib/redis_middleware'
 module Familia
   @uri = URI.parse 'redis://127.0.0.1'
   @redis_clients = {}
+  @redis_uri_by_class = {}
 
   # The Connection module provides Redis connection management for Familia.
   # It allows easy setup and access to Redis clients across different URIs.
@@ -25,17 +26,20 @@ module Familia
     # Establishes a connection to a Redis server.
     #
     # @param uri [String, URI, nil] The URI of the Redis server to connect to.
-    #   If nil, uses the default URI.
-    # @return [Redis] The connected Redis client
+    #   If nil, uses the default URI from `@redis_uri_by_class` or `Familia.uri`.
+    # @return [Redis] The connected Redis client.
+    # @raise [ArgumentError] If no URI is specified.
     # @example
     #   Familia.connect('redis://localhost:6379')
     def connect(uri = nil)
       uri = URI.parse(uri) if uri.is_a?(String)
+      uri ||= @redis_uri_by_class[self]
       uri ||= Familia.uri
 
       raise ArgumentError, 'No URI specified' unless uri
 
       conf = uri.conf
+      @redis_uri_by_class[self] = uri.serverid
 
       if Familia.enable_redis_logging
         RedisLogger.logger = Familia.logger
@@ -49,6 +53,9 @@ module Familia
       end
 
       redis = Redis.new(conf)
+
+      # Close the existing connection if it exists
+      @redis_clients[uri.serverid].close if @redis_clients[uri.serverid]
       @redis_clients[uri.serverid] = redis
     end
 
@@ -72,6 +79,15 @@ module Familia
       @redis_clients[uri.serverid]
     end
 
+    # Retrieves the Redis client associated with the given class.
+    #
+    # @param klass [Class] The class for which to retrieve the Redis client.
+    # @return [Redis] The Redis client associated with the given class.
+    def redis_uri_by_class(klass)
+      uri = @redis_uri_by_class[klass]
+      connect(uri)
+    end
+
     # Sets the default URI for Redis connections.
     #
     # @param v [String, URI] The new default URI

data/lib/familia/errors.rb

@@ -30,4 +30,18 @@ module Familia
       "No client for #{uri.serverid}"
     end
   end
+
+  # Raised when attempting to refresh an object whose key doesn't exist in Redis
+  class KeyNotFoundError < Problem
+    attr_reader :key
+
+    def initialize(key)
+      @key = key
+      super
+    end
+
+    def message
+      "Key not found in Redis: #{key}"
+    end
+  end
 end

data/lib/familia/features/expiration.rb

@@ -49,7 +49,7 @@ module Familia::Features
     #   false otherwise.
     #
     # @example Setting an expiration of one day
-    #   object.update_expiration(86400)
+    #   object.update_expiration(ttl: 86400)
     #
     # @note If TTL is set to zero, the expiration will be removed, making the
     #   data persist indefinitely.
@@ -57,8 +57,19 @@ module Familia::Features
     # @raise [Familia::Problem] Raises an error if the TTL is not a non-negative
     #   integer.
     #
-  def update_expiration(ttl = nil)
+    def update_expiration(ttl: nil)
       ttl ||= self.ttl
+
+      if self.class.has_relations?
+        Familia.ld "[update_expiration] #{self.class} has relations: #{self.class.redis_types.keys}"
+        self.class.redis_types.each do |name, definition|
+          next if definition.opts[:ttl].nil?
+          obj = send(name)
+          Familia.ld "[update_expiration] Updating expiration for #{name} (#{obj.rediskey}) to #{ttl}"
+          obj.update_expiration(ttl: ttl)
+        end
+      end
+
       # It's important to raise exceptions here and not just log warnings. We
       # don't want to silently fail at setting expirations and cause data
       # retention issues (e.g. not removed in a timely fashion).

data/lib/familia/features/quantization.rb

@@ -46,7 +46,7 @@ module Familia::Features
     end
 
     def qstamp(quantum = nil, pattern: nil, time: nil)
-      self.class.qstamp(quantum || ttl, pattern: pattern, time: time)
+      self.class.qstamp(quantum || self.class.ttl, pattern: pattern, time: time)
     end
 
     extend ClassMethods

data/lib/familia/horreum/class_methods.rb

@@ -33,9 +33,6 @@ module Familia
       include Familia::Settings
       include Familia::Horreum::RelationsManagement
 
-      attr_accessor :parent
-      attr_writer :redis, :dump_method, :load_method
-
       # Returns the Redis connection for the class.
       #
       # This method retrieves the Redis connection instance for the class. If no
@@ -74,42 +71,90 @@ module Familia
         fields << name
         attr_accessor name
 
-        # Every field gets a fast writer method for immediately persisting
-        fast_writer! name
+        # Every field gets a fast attribute method for immediately persisting
+        fast_attribute! name
       end
 
-      # Defines a fast writer method with a bang (!) suffix for a given
-      # attribute name. Fast writer methods are used to immediately persist
-      # attribute values to Redis. Calling a fast writer method has no
-      # effect on any of the object's other attributes and does not trigger
-      # a called to update the object's expiration time.
+      # Defines a fast attribute method with a bang (!) suffix for a given
+      # attribute name. Fast attribute methods are used to immediately read or
+      # write attribute values from/to Redis. Calling a fast attribute method
+      # has no effect on any of the object's other attributes and does not
+      # trigger a call to update the object's expiration time.
       #
       # The dynamically defined method performs the following:
-      # - Checks if the correct number of arguments is provided (exactly one).
+      # - Acts as both a reader and a writer method.
+      # - When called without arguments, retrieves the current value from Redis.
+      # - When called with an argument, persists the value to Redis immediately.
+      # - Checks if the correct number of arguments is provided (zero or one).
       # - Converts the provided value to a format suitable for Redis storage.
-      # - Uses the existing accessor method to set the attribute value.
-      # - Persists the value to Redis immediately using the hset command.
-      # - Includes custom error handling to raise an ArgumentError if the wrong number of arguments is given.
-      # - Raises a custom error message if an exception occurs during the execution of the method.
-      #
-      # @param [Symbol, String] name the name of the attribute for which the writer method is defined.
-      # @raise [ArgumentError] if the wrong number of arguments is provided.
-      # @raise [RuntimeError] if an exception occurs during the execution of the method.
-      #
-      def fast_writer!(name)
+      # - Uses the existing accessor method to set the attribute value when
+      #   writing.
+      # - Persists the value to Redis immediately using the hset command when
+      #   writing.
+      # - Includes custom error handling to raise an ArgumentError if the wrong
+      #   number of arguments is given.
+      # - Raises a custom error message if an exception occurs during the
+      #   execution of the method.
+      #
+      # @param [Symbol, String] name the name of the attribute for which the
+      #   fast method is defined.
+      # @return [Object] the current value of the attribute when called without
+      #   arguments.
+      # @raise [ArgumentError] if more than one argument is provided.
+      # @raise [RuntimeError] if an exception occurs during the execution of the
+      #   method.
+      #
+      def fast_attribute!(name = nil)
+        # Fast attribute accessor method for the '#{name}' attribute.
+        # This method provides immediate read and write access to the attribute
+        # in Redis.
+        #
+        # When called without arguments, it retrieves the current value of the
+        # attribute from Redis.
+        # When called with an argument, it immediately persists the new value to
+        # Redis.
+        #
+        # @overload #{name}!
+        #   Retrieves the current value of the attribute from Redis.
+        #   @return [Object] the current value of the attribute.
+        #
+        # @overload #{name}!(value)
+        #   Sets and immediately persists the new value of the attribute to
+        #   Redis.
+        #   @param value [Object] the new value to set for the attribute.
+        #   @return [Object] the newly set value.
+        #
+        # @raise [ArgumentError] if more than one argument is provided.
+        # @raise [RuntimeError] if an exception occurs during the execution of
+        #   the method.
+        #
+        # @note This method bypasses any object-level caching and interacts
+        #   directly with Redis. It does not trigger updates to other attributes
+        #   or the object's expiration time.
+        #
+        # @example
+        #
+        #      def #{name}!(*args)
+        #        # Method implementation
+        #      end
+        #
         define_method :"#{name}!" do |*args|
           # Check if the correct number of arguments is provided (exactly one).
-          raise ArgumentError, "wrong number of arguments (given #{args.size}, expected 1)" if args.size != 1
+          raise ArgumentError, "wrong number of arguments (given #{args.size}, expected 0 or 1)" if args.size > 1
 
           val = args.first
 
+          # If no value is provided to this fast attribute method, make a call
+          # to redis to return the current stored value of the hash field.
+          return hget name if val.nil?
+
           begin
             # Trace the operation if debugging is enabled.
             Familia.trace :FAST_WRITER, redis, "#{name}: #{val.inspect}", caller(1..1) if Familia.debug?
 
             # Convert the provided value to a format suitable for Redis storage.
-            prepared = to_redis(val)
-            Familia.ld "[.fast_writer!] #{name} val: #{val.class} prepared: #{prepared.class}"
+            prepared = serialize_value(val)
+            Familia.ld "[.fast_attribute!] #{name} val: #{val.class} prepared: #{prepared.class}"
 
             # Use the existing accessor method to set the attribute value.
             send :"#{name}=", val
@@ -148,6 +193,10 @@ module Familia
         @redis_types
       end
 
+      def has_relations?
+        @has_relations ||= false
+      end
+
       def db(v = nil)
         @db = v unless v.nil?
         @db || parent&.db
@@ -161,16 +210,20 @@ module Familia
       def all(suffix = nil)
         suffix ||= self.suffix
         # objects that could not be parsed will be nil
-        keys(suffix).filter_map { |k| from_rediskey(k) }
+        keys(suffix).filter_map { |k| find_by_key(k) }
       end
 
       def any?(filter = '*')
-        size(filter) > 0
+        matching_keys_count(filter) > 0
       end
 
-      def size(filter = '*')
+      # Returns the number of Redis keys matching the given filter pattern
+      # @param filter [String] Redis key pattern to match (default: '*')
+      # @return [Integer] Number of matching keys
+      def matching_keys_count(filter = '*')
         redis.keys(rediskey(filter)).compact.size
       end
+      alias size matching_keys_count # For backwards compatibility
 
       def suffix(a = nil, &blk)
         @suffix = a || blk if a || !blk.nil?
@@ -264,17 +317,17 @@ module Familia
       # debugging.
       #
       # @example
-      #   User.from_rediskey("user:123")  # Returns a User instance if it exists,
+      #   User.find_by_key("user:123")  # Returns a User instance if it exists,
       #   nil otherwise
       #
-      def from_rediskey(objkey)
+      def find_by_key(objkey)
         raise ArgumentError, 'Empty key' if objkey.to_s.empty?
 
         # We use a lower-level method here b/c we're working with the
         # full key and not just the identifier.
         does_exist = redis.exists(objkey).positive?
 
-        Familia.ld "[.from_rediskey] #{self} from key #{objkey} (exists: #{does_exist})"
+        Familia.ld "[.find_by_key] #{self} from key #{objkey} (exists: #{does_exist})"
         Familia.trace :FROM_KEY, redis, objkey, caller(1..1) if Familia.debug?
 
         # This is the reason for calling exists first. We want to definitively
@@ -289,6 +342,7 @@ module Familia
 
         new(**obj)
       end
+      alias from_rediskey find_by_key # deprecated
 
       # Retrieves and instantiates an object from Redis using its identifier.
       #
@@ -299,7 +353,7 @@ module Familia
       # @return [Object, nil] An instance of the class if found, nil otherwise.
       #
       # This method constructs the full Redis key using the provided identifier
-      # and suffix, then delegates to `from_rediskey` for the actual retrieval and
+      # and suffix, then delegates to `find_by_key` for the actual retrieval and
       # instantiation.
       #
       # It's a higher-level method that abstracts away the key construction,
@@ -307,19 +361,21 @@ module Familia
       # identifier.
       #
       # @example
-      #   User.from_identifier(123)  # Equivalent to User.from_rediskey("user:123:object")
+      #   User.find_by_id(123)  # Equivalent to User.find_by_key("user:123:object")
       #
-      def from_identifier(identifier, suffix = nil)
+      def find_by_id(identifier, suffix = nil)
         suffix ||= self.suffix
         return nil if identifier.to_s.empty?
 
         objkey = rediskey(identifier, suffix)
 
-        Familia.ld "[.from_identifier] #{self} from key #{objkey})"
-        Familia.trace :FROM_IDENTIFIER, Familia.redis(uri), objkey, caller(1..1).first if Familia.debug?
-        from_rediskey objkey
+        Familia.ld "[.find_by_id] #{self} from key #{objkey})"
+        Familia.trace :FIND_BY_ID, Familia.redis(uri), objkey, caller(1..1).first if Familia.debug?
+        find_by_key objkey
       end
-      alias load from_identifier
+      alias find find_by_id
+      alias load find_by_id # deprecated
+      alias from_identifier find_by_id # deprecated
 
       # Checks if an object with the given identifier exists in Redis.
       #
@@ -351,8 +407,10 @@ module Familia
       # @param suffix [Symbol, nil] The suffix to use in the Redis key (default: class suffix).
       # @return [Boolean] true if the object was successfully destroyed, false otherwise.
       #
-      # This method constructs the full Redis key using the provided identifier and suffix,
-      # then removes the corresponding key from Redis.
+      # This method is part of Familia's high-level object lifecycle management. While `delete!`
+      # operates directly on Redis keys, `destroy!` operates at the object level and is used for
+      # ORM-style operations. Use `destroy!` when removing complete objects from the system, and
+      # `delete!` when working directly with Redis keys.
       #
       # @example
       #   User.destroy!(123)  # Removes user:123:object from Redis
@@ -364,7 +422,7 @@ module Familia
         objkey = rediskey identifier, suffix
 
         ret = redis.del objkey
-        Familia.trace :DELETED, redis, "#{objkey}: #{ret.inspect}", caller(1..1) if Familia.debug?
+        Familia.trace :DESTROY!, redis, "#{objkey} #{ret.inspect}", caller(1..1) if Familia.debug?
         ret.positive?
       end
 
@@ -380,7 +438,7 @@ module Familia
       #   User.find  # Returns all keys matching user:*:object
       #   User.find('active')  # Returns all keys matching user:*:active
       #
-      def find(suffix = '*')
+      def find_keys(suffix = '*')
         redis.keys(rediskey('*', suffix)) || []
       end
 

data/lib/familia/horreum/commands.rb

@@ -18,11 +18,35 @@ module Familia
     #
     module Commands
 
+      def move(db)
+        redis.move rediskey, db
+      end
+
+      # Checks if the calling object's key exists in Redis and has a non-zero size.
+      #
+      # This method retrieves the Redis URI associated with the calling object's class
+      # using `Familia.redis_uri_by_class`. It then checks if the specified key exists
+      # in Redis and that its size is not zero. If debugging is enabled, it logs the
+      # existence check using `Familia.trace`.
+      #
+      # @return [Boolean] Returns `true` if the key exists in Redis and its size is not zero, otherwise `false`.
+      # @example
+      #   if some_object.exists?
+      #     # perform action
+      #   end
       def exists?
-        # Trace output comes from the class method
-        self.class.exists? identifier, suffix
+        true_or_false = self.class.redis.exists?(rediskey) && !size.zero?
+        Familia.trace :EXISTS, redis, "#{key} #{true_or_false.inspect}", caller(1..1) if Familia.debug?
+        true_or_false
       end
 
+      # Returns the number of fields in the main object hash
+      # @return [Integer] number of fields
+      def field_count
+        redis.hlen rediskey
+      end
+      alias size field_count
+
       # Sets a timeout on key. After the timeout has expired, the key will
       # automatically be deleted. Returns 1 if the timeout was set, 0 if key
       # does not exist or the timeout could not be set.
@@ -33,20 +57,27 @@ module Familia
         redis.expire rediskey, ttl.to_i
       end
 
+      # Retrieves the remaining time to live (TTL) for the object's Redis key.
+      #
+      # This method accesses the ovjects Redis client to obtain the TTL of `rediskey`.
+      # If debugging is enabled, it logs the TTL retrieval operation using `Familia.trace`.
+      #
+      # @return [Integer] The TTL of the key in seconds. Returns -1 if the key does not exist
+      #   or has no associated expire time.
       def realttl
         Familia.trace :REALTTL, redis, redisuri, caller(1..1) if Familia.debug?
         redis.ttl rediskey
       end
 
-      # Deletes a field from the hash stored at the Redis key.
+      # Removes a field from the hash stored at the Redis key.
       #
-      # @param field [String] The field to delete from the hash.
+      # @param field [String] The field to remove from the hash.
       # @return [Integer] The number of fields that were removed from the hash (0 or 1).
-      # @note This method is destructive, as indicated by the bang (!).
-      def hdel!(field)
+      def remove_field(field)
         Familia.trace :HDEL, redis, field, caller(1..1) if Familia.debug?
         redis.hdel rediskey, field
       end
+      alias remove remove_field # deprecated
 
       def redistype
         Familia.trace :REDISTYPE, redis, redisuri, caller(1..1) if Familia.debug?
@@ -59,6 +90,15 @@ module Familia
         redis.rename rediskey, newkey
       end
 
+      # Retrieves the prefix for the current instance by delegating to its class.
+      #
+      # @return [String] The prefix associated with the class of the current instance.
+      # @example
+      #   instance.prefix
+      def prefix
+        self.class.prefix
+      end
+
       # For parity with RedisType#hgetall
       def hgetall
         Familia.trace :HGETALL, redis, redisuri, caller(1..1) if Familia.debug?
@@ -78,8 +118,10 @@ module Familia
         redis.hset rediskey, field, value
       end
 
-      def hmset
-        redis.hmset rediskey(suffix), self.to_h
+      def hmset(hsh={})
+        hsh ||= self.to_h
+        Familia.trace :HMSET, redis, hsh, caller(1..1) if Familia.debug?
+        redis.hmset rediskey(suffix), hsh
       end
 
       def hkeys
@@ -116,11 +158,6 @@ module Familia
       end
       alias decrement decr
 
-      def hlen
-        redis.hlen rediskey(suffix)
-      end
-      alias hlength hlen
-
       def hstrlen(field)
         redis.hstrlen rediskey(suffix), field
       end
@@ -131,12 +168,14 @@ module Familia
       end
       alias has_key? key?
 
+      # Deletes the entire Redis key
+      # @return [Boolean] true if the key was deleted, false otherwise
       def delete!
         Familia.trace :DELETE!, redis, redisuri, caller(1..1) if Familia.debug?
         ret = redis.del rediskey
         ret.positive?
       end
-      protected :delete!
+      alias clear delete!
 
     end
 

data/lib/familia/horreum/relations_management.rb

@@ -16,6 +16,10 @@ module Familia
     #   Call setup_relations_accessors to initialize the feature
     #
     module RelationsManagement
+      # A practical flag to indicate that a Horreum member has relations,
+      # not just theoretically but actually at least one list/haskey/etc.
+      @has_relations = nil
+
       def self.included(base)
         base.extend(ClassMethods)
         base.setup_relations_accessors
@@ -31,14 +35,17 @@ module Familia
 
             # Dynamically define instance-level relation methods
             #
-            # Once defined, these methods can be used at the class-level of a
+            # Once defined, these methods can be used at the instance-level of a
             # Familia member to define *instance-level* relations to any of the
             # RedisType types (e.g. set, list, hash, etc).
             #
             define_method :"#{kind}" do |*args|
               name, opts = *args
+
+              # As log as we have at least one relation, we can set this flag.
+              @has_relations = true
+
               attach_instance_redis_object_relation name, klass, opts
-              redis_types[name.to_s.to_sym]
             end
             define_method :"#{kind}?" do |name|
               obj = redis_types[name.to_s.to_sym]