familia 2.0.0.pre17 → 2.0.0.pre19

data/lib/familia/horreum.rb

@@ -51,7 +51,6 @@ module Familia
     include Familia::Base
     include Familia::Horreum::Persistence
     include Familia::Horreum::Serialization
-    include Familia::Horreum::Connection
     include Familia::Horreum::DatabaseCommands
     include Familia::Horreum::Settings
     include Familia::Horreum::Utils
@@ -226,23 +225,43 @@ module Familia
         # Default values are intentionally NOT set here
       end
 
-      # Implementing classes can define an init method to do any
-      # additional initialization. Notice that this is called
-      # after the fields are set.
+      # Implementing classes can define an init method to do any additional
+      # initialization. Notice that this is called AFTER fields are set from
+      # kwargs, so kwargs have been consumed and are no longer available.
+      #
+      # IMPORTANT: Use ||= in init to apply defaults without overriding:
+      #   def init
+      #     @email ||= email               # Preserves value already set
+      #     @status ||= 'pending'          # Applies default if nil
+      #   end
+      #
       init
     end
 
-    # Override this method in subclasses for custom initialization logic.
-    # This is called AFTER fields are set and relatives are initialized.
+    # Initialization method called at the end of initialize
+    #
+    # Override this method to apply defaults, run validations, or setup
+    # callbacks. It's recommended to call super as other modules like
+    # features can also override init.
+    #
+    # IMPORTANT: The init method receieves no arguments. By the time this runs,
+    # all arguments to initialize have already been consumed and used to set
+    # fields. Use the ||= operator to preserve values already set:
     #
-    # DO NOT override initialize() - use this init() hook instead.
+    #   def init(email: nil, user_id: nil, **kwargs)
+    #     @email ||= email                  # Preserves value from new()
+    #     @user_id ||= user_id              # Preserves value from new()
+    #     @created_at ||= Familia.now       # Applies default if not set
     #
-    # Example:
-    #   def init(name = nil)
-    #     @name = name || SecureRandom.hex(4)
+    #     # Example of additional initialization logic
+    #     validate_email_format if @email
+    #     setup_callbacks
     #   end
-    def init(*args, **kwargs)
-      # Default no-op
+    #
+    # @return [void]
+    #
+    def init
+      # Default no-op - override in subclasses
     end
 
     # Sets up related Database objects for the instance
@@ -299,7 +318,9 @@ module Familia
 
     def initialize_with_keyword_args_deserialize_value(**fields)
       # Deserialize Database string values back to their original types
-      deserialized_fields = fields.transform_values { |value| deserialize_value(value) }
+      deserialized_fields = fields.each_with_object({}) do |(field_name, value), hsh|
+        hsh[field_name] = deserialize_value(value, field_name: field_name)
+      end
       initialize_with_keyword_args(**deserialized_fields)
     end
 
@@ -308,7 +329,7 @@ module Familia
     #
     # This method is part of horreum.rb rather than serialization.rb because it
     # operates solely on the provided values and doesn't query Database or other
-    # external sources. That's why it's called "optimistic" refresh: it assumes
+    # external sources. That's why it's called "naive" refresh: it assumes
     # the provided values are correct and updates the object accordingly.
     #
     # @see #refresh!
@@ -316,8 +337,8 @@ module Familia
     # @param fields [Hash] A hash of field names and their new values to update
     #   the object with.
     # @return [Array] The list of field names that were updated.
-    def optimistic_refresh(**fields)
-      Familia.ld "[optimistic_refresh] #{self.class} #{dbkey} #{fields.keys}"
+    def naive_refresh(**fields)
+      Familia.ld "[naive_refresh] #{self.class} #{dbkey} #{fields.keys}"
       initialize_with_keyword_args_deserialize_value(**fields)
     end
 
@@ -401,8 +422,10 @@ module Familia
       self.class.fields.filter_map do |field|
         # Database will give us field names as strings back, but internally
         # we use symbols. So we check for both.
-        value = fields[field.to_sym] || fields[field.to_s]
-        if value
+        # Use fetch with default to avoid || operator which skips false values
+        value = fields.fetch(field.to_sym) { fields[field.to_s] }
+        # Check for nil explicitly to allow false and 0 values
+        unless value.nil?
           # Use the mapped method name, not the field name
           method_name = self.class.field_method_map[field] || field
           send(:"#{method_name}=", value)

data/lib/familia/identifier_extractor.rb

@@ -0,0 +1,60 @@
+# lib/familia/identifier_extractor.rb
+
+module Familia
+  # IdentifierExtractor - Extracts identifiers from Familia objects for storage
+  #
+  # This module provides a focused mechanism for converting object references
+  # into Redis-storable strings. It handles two primary cases:
+  #
+  # 1. Class references: Customer → "Customer"
+  # 2. Familia::Base instances: customer_obj → customer_obj.identifier
+  #
+  # This is primarily used by DataType serialization when storing object
+  # references in Redis data structures (lists, sets, zsets). It extracts
+  # the identifier rather than serializing the entire object.
+  #
+  # @example With class_zset
+  #   class Customer < Familia::Horreum
+  #     class_zset :instances, class: self
+  #   end
+  #   # When adding: Customer.instances.add(customer_obj)
+  #   # Stores: customer_obj.identifier (e.g., "customer_123")
+  #
+  module IdentifierExtractor
+    # Extracts a Redis-storable identifier from a Familia object or class.
+    #
+    # @param value [Object] The value to extract an identifier from
+    # @return [String] The extracted identifier or class name
+    # @raise [Familia::NotDistinguishableError] If value is not a Class or Familia::Base
+    #
+    def identifier_extractor(value, strict_values: true)
+      case value
+      when ::Symbol, ::String, ::Integer, ::Float
+        Familia.trace :IDENTIFIER_EXTRACTOR, nil, 'simple_value' if Familia.debug?
+        # DataTypes (lists, sets, zsets) can store simple values directly
+        # Convert to string for Redis storage
+        value.to_s
+
+      when Class
+        Familia.trace :IDENTIFIER_EXTRACTOR, nil, 'class' if Familia.debug?
+        value.name
+
+      when Familia::Base
+        Familia.trace :IDENTIFIER_EXTRACTOR, nil, 'base_instance' if Familia.debug?
+        value.identifier
+
+      else
+        # Check if value's class inherits from Familia::Base
+        if value.class.ancestors.member?(Familia::Base)
+          Familia.trace :IDENTIFIER_EXTRACTOR, nil, 'base_ancestor' if Familia.debug?
+          value.identifier
+        else
+          Familia.trace :IDENTIFIER_EXTRACTOR, nil, 'error' if Familia.debug?
+          raise Familia::NotDistinguishableError, value
+        end
+      end
+    end
+  end
+
+  extend IdentifierExtractor
+end

data/lib/familia/logging.rb

@@ -3,151 +3,307 @@
 require 'pathname'
 require 'logger'
 
+# Familia - Logbook
+#
 module Familia
-  @logger = Logger.new($stdout)
-  @logger.progname = name
-  @logger.formatter = proc do |severity, datetime, _progname, msg|
-    severity_letter = severity[0] # Get the first letter of the severity
-    pid = Process.pid
-    thread_id = Thread.current.object_id
-    fiber_id = Fiber.current.object_id
-    full_path, line = caller(5..5).first.split(':')[0..1]
-    parent_path = Pathname.new(full_path).ascend.find { |p| p.basename.to_s == 'familia' }
-    relative_path = full_path.sub(parent_path.to_s, 'familia')
-    utc_datetime = datetime.utc.strftime('%m-%d %H:%M:%S.%6N')
-
-    # Get the severity letter from the thread local variable or use
-    # the default. The thread local variable is set in the trace
-    # method in the Familia::Refinements::LoggerTrace module. The name of the
-    # variable `severity_letter` is arbitrary and could be anything.
-    severity_letter = Fiber[:severity_letter] || severity_letter
-
-    "#{severity_letter}, #{utc_datetime} #{pid} #{thread_id}/#{fiber_id}: #{msg}  [#{relative_path}:#{line}]\n"
+  # Custom Logger subclass with TRACE level support.
+  #
+  # FamiliaLogger extends Ruby's standard Logger with a TRACE level for
+  # extremely detailed debugging output. The TRACE level is numerically
+  # equal to DEBUG (0) but distinguishes itself via a thread-local marker
+  # that the LogFormatter uses to output 'T' instead of 'D'.
+  #
+  # @example Basic usage
+  #   logger = Familia::FamiliaLogger.new($stderr)
+  #   logger.level = Familia::FamiliaLogger::TRACE
+  #   logger.trace "Detailed trace message"
+  #   # => T, 10-05 20:43:09.843 pid:123 [456/789]: Detailed trace message
+  #
+  # @example With progname
+  #   logger.trace("MyApp") { "Trace with progname" }
+  #
+  # @see Familia::LogFormatter
+  #
+  class FamiliaLogger < Logger
+    # TRACE severity level (numerically equal to DEBUG=0).
+    #
+    # Uses the same numeric level as DEBUG but signals via thread-local
+    # marker to output 'T' prefix instead of 'D'. This approach works
+    # around Logger's limitation with negative severity values.
+    #
+    # Standard Logger levels: DEBUG=0, INFO=1, WARN=2, ERROR=3, FATAL=4, UNKNOWN=5
+    TRACE = 0
+
+    # Log a TRACE level message.
+    #
+    # This method behaves like the standard Logger methods (debug, info, etc.)
+    # but outputs with a 'T' severity letter when used with LogFormatter.
+    #
+    # @param progname [String, nil] Program name to include in log output
+    # @yield Block that returns the message to log (lazy evaluation)
+    # @return [true] Always returns true
+    #
+    # @example Simple message
+    #   logger.trace("Entering complex calculation")
+    #
+    # @example With block for lazy evaluation
+    #   logger.trace { "Expensive: #{expensive_debug_info}" }
+    #
+    # @example With progname
+    #   logger.trace("MyApp") { "Application trace" }
+    #
+    # @note Sets Fiber[:familia_trace_mode] during execution to
+    #   signal LogFormatter to output 'T' instead of 'D'
+    #
+    def trace(progname = nil, &)
+      # Store marker in thread-local to signal this is TRACE not DEBUG
+      # Track whether we set the flag to avoid clearing it in nested calls
+      was_already_tracing = Fiber[:familia_trace_mode]
+      Fiber[:familia_trace_mode] = true
+      add(TRACE, nil, progname, &)
+    ensure
+      # Only clear the flag if we set it (not already tracing)
+      Fiber[:familia_trace_mode] = false unless was_already_tracing
+    end
   end
 
-  # The Logging module provides a set of methods and constants for logging messages
-  # at various levels of severity. It is designed to be used with the Ruby Logger class
-  # to facilitate logging in applications.
+  # Custom formatter for Familia logger output.
+  #
+  # LogFormatter produces structured log output with severity letters,
+  # timestamps, process/thread/fiber IDs, and the log message.
   #
-  # == Constants:
-  # Logger::TRACE::
-  #   A custom log level for trace messages, typically used for very detailed
-  #   debugging information.
+  # Output format:
+  #   SEVERITY, MM-DD HH:MM:SS.mmm pid:PID [THREAD_ID/FIBER_ID]: MESSAGE
   #
-  # == Methods:
-  # trace::
-  #   Logs a message at the TRACE level. This method is only available if the
-  #   Familia::Refinements::LoggerTrace is used.
+  # @example Output
+  #   I, 10-05 20:43:09.843 pid:12345 [67890/54321]: Connection established
+  #   T, 10-05 20:43:10.123 pid:12345 [67890/54321]: [LOAD] redis -> user:123
   #
-  # debug::
-  #   Logs a message at the DEBUG level. This is used for low-level system information
-  #   for debugging purposes.
+  # Severity letters:
+  #   T = TRACE (when Fiber[:familia_trace_mode] is set, or level 0 when not using FamiliaLogger)
+  #   D = DEBUG
+  #   I = INFO
+  #   W = WARN
+  #   E = ERROR
+  #   F = FATAL
+  #   U = UNKNOWN
   #
-  # info::
-  #   Logs a message at the INFO level. This is used for general information about
-  #   system operation.
+  # @example Use with FamiliaLogger for TRACE support
+  #   logger = Familia::FamiliaLogger.new($stderr)
+  #   logger.formatter = Familia::LogFormatter.new
+  #   logger.trace("Trace message")  # => T, ...
+  #   logger.debug("Debug message")  # => D, ...
   #
-  # warn::
-  #   Logs a message at the WARN level. This is used for warning messages, typically
-  #   for non-critical issues that require attention.
+  # @example Use with standard Logger (level 0 becomes 'T')
+  #   logger = Logger.new($stderr)
+  #   logger.formatter = Familia::LogFormatter.new
+  #   logger.debug("Debug message")  # => T, ... (because DEBUG=0)
   #
-  # error::
-  #   Logs a message at the ERROR level. This is used for error messages, typically
-  #   for critical issues that require immediate attention.
+  # @note When used with FamiliaLogger, checks Fiber[:familia_trace_mode] to
+  #   distinguish TRACE from DEBUG. When used with standard Logger, treats
+  #   level 0 as TRACE since DEBUG and TRACE share the same numeric level.
   #
-  # fatal::
-  #   Logs a message at the FATAL level. This is used for very severe error events
-  #   that will presumably lead the application to abort.
+  # @see FamiliaLogger#trace
+  #
+  class LogFormatter < Logger::Formatter
+    # Severity string to letter mapping.
+    #
+    # Maps severity string labels to single-letter codes for compact output.
+    # Note: TRACE is handled via Fiber check in #call for FamiliaLogger.
+    SEVERITY_LETTERS = {
+      'DEBUG' => 'D',
+      'INFO' => 'I',
+      'WARN' => 'W',
+      'ERROR' => 'E',
+      'FATAL' => 'F',
+      'UNKNOWN' => 'U',
+      'ANY' => 'T'  # ANY is Logger's label for severity < 0, treat as TRACE
+    }.freeze
+
+    # Format a log message with severity, timestamp, and context.
+    #
+    # @param severity [String] Severity label (e.g., "INFO", "DEBUG", "UNKNOWN")
+    # @param datetime [Time] Timestamp of the log message
+    # @param _progname [String] Program name (unused, kept for Logger compatibility)
+    # @param msg [String] The log message
+    # @return [String] Formatted log line with newline
+    #
+    # @example
+    #   formatter = Familia::LogFormatter.new
+    #   formatter.call("INFO", Time.now, nil, "Test message")
+    #   # => "I, 10-05 20:43:09.843 pid:12345 [67890/54321]: Test message\n"
+    #
+    def call(severity, datetime, _progname, msg)
+      # Check if we're in trace mode (TRACE uses same level as DEBUG but marks itself)
+      # FamiliaLogger sets Fiber[:familia_trace_mode] when trace() is called
+      severity_letter = if Fiber[:familia_trace_mode]
+        'T'
+      else
+        SEVERITY_LETTERS.fetch(severity, severity[0])
+      end
+
+      utc_datetime = datetime.utc.strftime('%H:%M:%S.%3N')
+
+      "#{severity_letter}, #{utc_datetime} #{msg}\n"
+    end
+  end
+
+  # The Logging module provides logging capabilities for Familia.
+  #
+  # Familia uses a custom FamiliaLogger that extends the standard Ruby Logger
+  # with a TRACE level for detailed debugging output.
+  #
+  # == Log Levels (from most to least verbose):
+  # - TRACE: Extremely detailed debugging (controlled by FAMILIA_TRACE env var)
+  # - DEBUG: Detailed debugging information
+  # - INFO: General informational messages
+  # - WARN: Warning messages
+  # - ERROR: Error messages
+  # - FATAL: Fatal errors that cause termination
   #
   # == Usage:
-  # To use the Logging module, you need to include the Familia::Refinements::LoggerTrace module
-  # and use the `using` keyword to enable the refinement. This will add the TRACE
-  # log level and the trace method to the Logger class.
-  #
-  # Example:
-  #   require 'logger'
-  #
-  #   module Familia::Refinements::LoggerTrace
-  #     refine Logger do
-  #       TRACE = 0
-  #
-  #       def trace(progname = nil, &block)
-  #         add(TRACE, nil, progname, &block)
-  #       end
-  #     end
-  #   end
-  #
-  #   using Familia::Refinements::LoggerTrace
-  #
-  #   logger = Logger.new(STDOUT)
-  #   logger.trace("This is a trace message")
-  #   logger.debug("This is a debug message")
-  #   logger.info("This is an info message")
-  #   logger.warn("This is a warning message")
-  #   logger.error("This is an error message")
-  #   logger.fatal("This is a fatal message")
-  #
-  # In this example, the Familia::Refinements::LoggerTrace module is defined with a refinement
-  # for the Logger class. The TRACE constant and trace method are added to the Logger
-  # class within the refinement. The `using` keyword is used to apply the refinement
-  # in the scope where it's needed.
-  #
-  # == Conditions:
-  # The trace method and TRACE log level are only available if the Familia::Refinements::LoggerTrace
-  # module is used with the `using` keyword. Without this, the Logger class will not
-  # have the trace method or the TRACE log level.
-  #
-  # == Minimum Ruby Version:
-  # This module requires Ruby 2.0.0 or later to use refinements.
+  #   # Use default logger
+  #   Familia.info "Connection established"
+  #   Familia.warn "Cache miss"
+  #
+  #   # Set custom logger
+  #   Familia.logger = Logger.new('familia.log')
+  #
+  #   # Trace-level debugging (requires FAMILIA_TRACE=true)
+  #   Familia.trace :LOAD, redis_client, "user:123", "from cache"
   #
   module Logging
-    attr_reader :logger
-
-    # Gives our logger the ability to use our trace method.
-    using Familia::Refinements::LoggerTrace if Familia::Refinements::LoggerTrace::ENABLED
+    # Get the logger instance, initializing with defaults if not yet set
+    #
+    # @return [FamiliaLogger] the logger instance
+    #
+    # @example Set a custom logger
+    #   Familia.logger = Logger.new('familia.log')
+    #
+    # @example Use the default logger
+    #   Familia.logger.info "Connection established"
+    #
+    def logger
+      @logger ||= FamiliaLogger.new($stderr).tap do |log|
+        log.progname = name
+        log.formatter = LogFormatter.new
+      end
+    end
 
-    def info(*msg)
-      @logger.info(*msg)
+    # Set a custom logger instance.
+    #
+    # Allows replacing the default FamiliaLogger with any Logger-compatible
+    # object. Useful for integrating with application logging frameworks.
+    #
+    # @param new_logger [Logger] The logger to use
+    # @return [Logger] The logger that was set
+    #
+    # @example Use Rails logger
+    #   Familia.logger = Rails.logger
+    #
+    # @example Custom file logger
+    #   Familia.logger = Logger.new('familia.log').tap do |log|
+    #     log.level = Logger::INFO
+    #   end
+    #
+    def logger=(new_logger)
+      @logger = new_logger
     end
 
-    def warn(*msg)
-      @logger.warn(*msg)
+    # Log an informational message.
+    #
+    # @param msg [String] The message to log
+    # @return [true]
+    #
+    # @example
+    #   Familia.info "Redis connection established"
+    #
+    def info(msg)
+      logger.info(msg)
     end
 
-    def ld(*msg)
-      return unless Familia.debug?
+    # Log a warning message.
+    #
+    # @param msg [String] The message to log
+    # @return [true]
+    #
+    # @example
+    #   Familia.warn "Cache miss for key: user:123"
+    #
+    def warn(msg)
+      logger.warn(msg)
+    end
 
-      @logger.debug(*msg)
+    # Log a debug message (only when Familia.debug? is true).
+    #
+    # Short for "log debug". Only outputs when FAMILIA_DEBUG environment
+    # variable is set to '1' or 'true'.
+    #
+    # @param msg [String] The message to log
+    # @return [true, nil] Returns true if logged, nil if debug disabled
+    #
+    # @example
+    #   Familia.ld "Cache lookup for user:123"
+    #   # Only outputs when FAMILIA_DEBUG=true
+    #
+    def ld(msg)
+      logger.debug(msg) if Familia.debug?
     end
 
-    def le(*msg)
-      @logger.error(*msg)
+    # Log an error message.
+    #
+    # Short for "log error".
+    #
+    # @param msg [String] The message to log
+    # @return [true]
+    #
+    # @example
+    #   Familia.le "Failed to deserialize value: #{e.message}"
+    #
+    def le(msg)
+      logger.error(msg)
     end
 
-    # Logs a trace message for debugging purposes if Familia.debug? is true.
+    # Logs a structured trace message for debugging Familia operations.
+    #
+    # This method only executes when both FAMILIA_TRACE and FAMILIA_DEBUG
+    # environment variables are enabled.
     #
     # @param label [Symbol] A label for the trace message (e.g., :EXPAND,
     #   :FROMREDIS, :LOAD, :EXISTS).
-    # @param instance_id
-    # @param ident [String] An identifier or key related to the operation being
-    #   traced.
-    # @param extra_context [Array<String>, String, nil] Any extra details to include.
-    #
-    # @example Familia.trace :LOAD, Familia.dbclient(uri), objkey if Familia.debug?
+    # @param instance_id [Object] The object instance being traced (e.g., Redis client)
+    # @param ident [String] An identifier or key related to the operation being traced
+    # @param extra_context [String, nil] Any extra details to include
     #
     # @return [nil]
     #
-    # @note This method only executes if Familia::Refinements::LoggerTrace::ENABLED is true.
-    # @note The dbclient can be a Database object, Redis::Future (used in
-    #   pipelined and multi blocks), or nil (when the database connection isn't
-    #   relevant).
+    # @example
+    #   Familia.trace :LOAD, redis_client, "user:123", "from cache"
+    #   # Output: T, 10-05 20:43:09.843 pid:123 [456/789]: [LOAD] #<Redis> -> user:123 <-from cache
+    #
+    # @note Controlled by FAMILIA_TRACE environment variable (set to '1', 'true', or 'yes')
+    # @note The instance_id can be a Redis client, Redis::Future, or nil
     #
     def trace(label, instance_id = nil, ident = nil, extra_context = nil)
-      return unless Familia::Refinements::LoggerTrace::ENABLED
+      return unless trace_enabled? && Familia.debug?
+
+      ident_str = ident.nil? ? '<nil>' : ident.to_s
+      logger.trace format('[%s] %s -> %s <-%s', label, instance_id, ident_str, extra_context)
+    end
 
-      # Let the other values show nothing when nil, but make it known for the focused value
-      ident_str = (ident.nil? ? '<nil>' : ident).to_s
-      @logger.trace format('[%s] %s -> %s <-%s', label, instance_id, ident_str, extra_context)
+    private
+
+    # Check if trace logging is enabled via FAMILIA_TRACE environment variable.
+    #
+    # Trace logging is enabled when FAMILIA_TRACE is set to '1', 'true',
+    # or 'yes' (case-insensitive). Checks the environment variable on every
+    # call to support dynamic changes in test environments.
+    #
+    # @return [Boolean] true if trace logging is enabled
+    # @api private
+    #
+    def trace_enabled?
+      %w[1 true yes].include?(ENV.fetch('FAMILIA_TRACE', 'false').downcase)
     end
   end
 end

data/lib/familia/refinements.rb

@@ -1,6 +1,5 @@
 # lib/familia/refinements.rb
 
 require_relative 'refinements/dear_json'
-require_relative 'refinements/logger_trace'
 require_relative 'refinements/stylize_words'
 require_relative 'refinements/time_literals'

data/lib/familia/settings.rb

@@ -11,7 +11,7 @@ module Familia
   @encryption_keys = nil
   @current_key_version = nil
   @encryption_personalization = 'FamilialMatters'.freeze
-  @pipeline_mode = :warn
+  @pipelined_mode = :warn
 
   # Familia::Settings
   #
@@ -118,24 +118,24 @@ module Familia
     #
     # @example Setting pipeline mode
     #   Familia.configure do |config|
-    #     config.pipeline_mode = :permissive
+    #     config.pipelined_mode = :permissive
     #   end
     #
-    def pipeline_mode(val = nil)
+    def pipelined_mode(val = nil)
       if val
         unless [:strict, :warn, :permissive].include?(val)
           raise ArgumentError, 'Pipeline mode must be :strict, :warn, or :permissive'
         end
-        @pipeline_mode = val
+        @pipelined_mode = val
       end
-      @pipeline_mode || :warn  # default to warn mode
+      @pipelined_mode || :warn  # default to warn mode
     end
 
-    def pipeline_mode=(val)
+    def pipelined_mode=(val)
       unless [:strict, :warn, :permissive].include?(val)
         raise ArgumentError, 'Pipeline mode must be :strict, :warn, or :permissive'
       end
-      @pipeline_mode = val
+      @pipelined_mode = val
     end
 
     # Configure Familia settings

data/lib/familia/version.rb

@@ -2,5 +2,5 @@
 
 module Familia
   # Version information for the Familia
-  VERSION = '2.0.0.pre17'.freeze unless defined?(Familia::VERSION)
+  VERSION = '2.0.0.pre19'.freeze unless defined?(Familia::VERSION)
 end

data/lib/familia.rb

@@ -39,7 +39,7 @@ module Familia
   using Refinements::StylizeWords
 
   class << self
-    attr_accessor :debug # rubocop:disable ThreadSafety/ClassAndModuleAttributes
+    attr_accessor :debug
     attr_reader :members
 
     def included(member)
@@ -139,7 +139,7 @@ module Familia
   require_relative 'familia/connection'
   require_relative 'familia/settings'
   require_relative 'familia/utils'
-  require_relative 'familia/distinguisher'
+  require_relative 'familia/identifier_extractor'
   require_relative 'familia/json_serializer'
 
   extend SecureIdentifier