familia 2.0.0.pre2 → 2.0.0.pre4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e104394eac8f785cc87da94119810cf0634d9c4b26e0c37bbf9682a64223637c
-  data.tar.gz: 91d80c9e21c48e0e50867a0296ac7bfee93f800ca23905369d2e0e47f41e6a03
+  metadata.gz: c17c7c0fbd21ec7edf380a157f36bcf50632838c083474ac56291653e5e5b5f2
+  data.tar.gz: 496226f45b28c48a20f4a7c0901e45f048407b53cb80d4d373f5840f06673bd5
 SHA512:
-  metadata.gz: a50739960222cae1f8e66cc1e6ece4bf023d18d23ad141acd80c5a9b22387d99be22111459da2a34a7b22b45361d57311dd943ee3cc595e081a8fbf36ef81abf
-  data.tar.gz: dc330db28c720538589341ceb3a914687c83efe5d3ead5f892953c6bdf36882c08468f00e031a767758ae7887cfb3525df9224b5852804ef50739eac403ae333
+  metadata.gz: bfce15edc52796648eb1356be796260d8e8dae8bcba38f11a435b86cd732f73acacc8959e67d2bb3e3025d82a962e63ca2627fecb2f88dfc0e76bb1da174592d
+  data.tar.gz: 3cc196dc11aaf65409061ed5772043c151dfbc0fe39701b86e2808d2c9f1a55a5647f9ba22cb80cc806752ad17d41a05c2cce743fecf2258e8ff6b91f9868c12

data/CLAUDE.md

@@ -5,10 +5,17 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 ## Development Commands
 
 ### Testing
-- **Run tests**: `bundle exec tryouts` (uses tryouts testing framework)
-- **Run specific test file**: `bundle exec tryouts try/specific_test_try.rb`
-- **Debug mode**: `FAMILIA_DEBUG=1 bundle exec tryouts`
-- **Trace mode**: `FAMILIA_TRACE=1 bundle exec tryouts` (detailed Redis operation logging)
+
+A couple rules when writing tests:
+1) Every tryouts file has three sections: setup, testcases, teardown.
+2) Every tryouts testcase also has three parts: description, code, expectations.
+3) Tryouts tests are meant to double as documentation examples; keep that in mind when considering syntax choices.
+4) There are multiple kinds of expectations: `#=>` is the default comparison, `#=:>` is a class comparison via `is_a?` or `kind_of?`, `#=!>` is an exception class which allows you to knowingly raise an exception without needing a begin/rescue.
+
+- **Run tests**: `bundle exec try` (uses tryouts testing framework)
+- **Run specific test file, verbose**: `bundle exec try -v try/specific_test_try.rb`
+- **Debug mode**: `FAMILIA_DEBUG=1 bundle exec try -D`
+- **Trace mode**: `FAMILIA_TRACE=1 bundle exec try -D` (detailed Redis operation logging)
 
 ### Development Setup
 - **Install dependencies**: `bundle install`
@@ -74,7 +81,7 @@ end
 ```
 
 **Identifier Resolution**: Multiple strategies for object identification:
-- Symbol: `identifier :email`
+- Symbol: `identifier_field :email`
 - Proc: `identifier ->(user) { "user:#{user.email}" }`
 - Array: `identifier [:type, :email]`
 

data/Gemfile

@@ -9,7 +9,7 @@ group :test do
     gem 'tryouts', path: '../tryouts'
     gem 'uri-valkey', path: '..//uri-valkey/gems', glob: 'uri-valkey.gemspec'
   else
-    gem 'tryouts', '~> 3.1.1', require: false
+    gem 'tryouts', '~> 3.1.2', require: false
   end
   gem 'concurrent-ruby', '~> 1.3.5', require: false
   gem 'ruby-prof'

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    familia (2.0.0.pre2)
+    familia (2.0.0.pre4)
       benchmark
       connection_pool
       csv
@@ -23,7 +23,6 @@ GEM
     csv (3.3.5)
     date (3.4.1)
     diff-lcs (1.6.2)
-    drydock (0.6.9)
     erb (5.0.2)
     io-console (0.8.1)
     irb (1.15.2)
@@ -107,15 +106,10 @@ GEM
       base64
     ruby-progressbar (1.13.0)
     stackprof (0.2.27)
-    storable (0.10.0)
     stringio (3.1.7)
-    sysinfo (0.10.0)
-      drydock (< 1.0)
-      storable (~> 0.10)
-    tryouts (3.1.1)
+    tryouts (3.1.2)
       minitest (~> 5.0)
       rspec (~> 3.0)
-      sysinfo (>= 0.8, < 1.0)
     unicode-display_width (3.1.4)
       unicode-emoji (~> 4.0, >= 4.0.4)
     unicode-emoji (4.0.4)
@@ -138,7 +132,7 @@ DEPENDENCIES
   rubocop-thread_safety
   ruby-prof
   stackprof
-  tryouts (~> 3.1.1)
+  tryouts (~> 3.1.2)
   yard (~> 0.9)
 
 BUNDLED WITH

data/lib/familia/core_ext.rb

@@ -12,7 +12,7 @@ class String
   #
   # @return [Float, nil] The time in seconds, or nil if the string is invalid
   def in_seconds
-    q, u = scan(/([\d.]+)([smh])?/).flatten
+    q, u = scan(/([\d.]+)([smhyd])?/).flatten
     q &&= q.to_f and u ||= 's'
     q&.in_seconds(u)
   end
@@ -125,7 +125,7 @@ class Numeric
     size = abs.to_f
     unit = 0
 
-    while size > 1024 && unit < units.length - 1
+    while size >= 1024 && unit < units.length - 1
       size /= 1024
       unit += 1
     end

data/lib/familia/features/expiration.rb

@@ -92,7 +92,6 @@ module Familia::Features
       # a bool.
       expire(default_expiration)
     end
-
     extend ClassMethods
 
     Familia::Base.add_feature self, :expiration

data/lib/familia/features/relatable_objects.rb

@@ -0,0 +1,127 @@
+# apps/api/v2/models/features/relatable_object.rb
+
+module V2
+  module Features
+    class RelatableObjectError < Familia::Problem; end
+
+    # RelatableObject
+    #
+    # Provides the standard core object fields and methods.
+    #
+    module RelatableObject
+      klass = self
+      err_klass = V2::Features::RelatableObjectError
+
+      def self.included(base)
+        base.class_sorted_set :relatable_objids
+        base.class_hashkey :owners
+
+        # NOTE: we do not automatically assign the objid field as the
+        # main identifier field. That's up to the implementing class.
+        base.field :objid
+        base.field :extid
+        base.field :api_version
+
+        base.extend(ClassMethods)
+
+        # prepend ensures our methods execute BEFORE field-generated accessors
+        # include would place them AFTER, but they'd never execute because
+        # attr_reader doesn't call super - it just returns the instance variable
+        #
+        # Method lookup chain:
+        #   prepend:  [InstanceMethods] → [Field Methods] → [Parent]
+        #   include:  [Field Methods] → [InstanceMethods] → [Parent]
+        #              (stops here, no super)    (never reached)
+        #
+        base.prepend(InstanceMethods)
+      end
+
+      module InstanceMethods
+        # We lazily generate the object ID and external ID when they are first
+        # accessed so that we can instantiate and load existing objects, without
+        # eagerly generating them, only to be overridden by the storage layer.
+        #
+        def init
+          super if defined?(super) # Only call if parent has init
+
+          @api_version ||= 'v2'
+        end
+
+        def objid
+          @objid ||= begin # lazy loader
+            generated_id = self.class.generate_objid
+            # Using the attr_writer method ensures any future Familia
+            # enhancements to the setter are properly invoked (as opposed
+            # to directly assigning @objid).
+            self.objid   = generated_id
+          end
+        end
+        alias relatable_objid objid
+
+        def extid
+          @extid ||= begin # lazy loader
+            generated_id = self.class.generate_extid
+            self.extid   = generated_id
+          end
+        end
+        alias external_identifier extid
+
+        # Check if the given customer is the owner of this domain
+        #
+        # @param cust [V2::Customer, String] The customer object or customer ID to check
+        # @return [Boolean] true if the customer is the owner, false otherwise
+        def owner?(related_object)
+          self.class.relatable?(related_object) do
+            # Check the hash (our objid => related_object's objid)
+            owner_objid = self.class.owners.get(objid).to_s
+            return false if owner_objid.empty?
+
+            owner_objid.eql?(related_object.objid)
+          end
+        end
+
+        def owned?
+          # We can only have an owner if we are relatable ourselves.
+          return false unless self.is_a?(RelatableObject)
+          # If our object identifier is present, we have an owner
+          self.class.owners.key?(objid)
+        end
+      end
+
+      module ClassMethods
+        def relatable?(obj, &)
+          is_relatable = obj.is_a?(RelatableObject)
+          err_klass = V2::Features::RelatableObjectError
+          raise err_klass, 'Not relatable object' unless is_relatable
+          raise err_klass, 'No self-ownership' if obj.class == self
+
+          block_given? ? yield : is_relatable
+        end
+
+        def find_by_objid(objid)
+          return nil if objid.to_s.empty?
+
+          if Familia.debug?
+            reference = caller(1..1).first
+            Familia.trace :FIND_BY_OBJID, Familia.dbclient(uri), objkey, reference
+          end
+
+          find_by_key objkey
+        end
+
+        def generate_objid
+          SecureRandom.uuid_v7
+        end
+
+        # Guaranteed length of 54
+        def generate_extid
+          format('ext_%s', Familia.generate_id)
+        end
+      end
+      extend ClassMethods
+
+      # Self-register the kids for martial arts classes
+      Familia::Base.add_feature self, :relatable_object
+    end
+  end
+end

data/lib/familia/features.rb

@@ -47,6 +47,10 @@ module Familia
 
 end
 
-require_relative 'features/expiration'
-require_relative 'features/quantization'
-require_relative 'features/safe_dump'
+# Load all feature files from the features directory
+features_dir = File.join(__dir__, 'features')
+if Dir.exist?(features_dir)
+  Dir.glob(File.join(features_dir, '*.rb')).each do |feature_file|
+    require_relative feature_file
+  end
+end

data/lib/familia/horreum/class_methods.rb

@@ -217,9 +217,38 @@ module Familia
         @suffix || Familia.default_suffix
       end
 
+      # Sets or retrieves the prefix for generating Redis keys.
+      #
+      # @param a [String, Symbol, nil] the prefix to set (optional).
+      # @return [String, Symbol] the current prefix.
+      #
+      # The exception is only raised when both @prefix is nil/falsy AND name is nil,
+      # which typically occurs with anonymous classes that haven't had their prefix
+      # explicitly set.
+      #
       def prefix(a = nil)
         @prefix = a if a
-        @prefix || name.downcase.gsub('::', Familia.delim).to_sym
+        @prefix || begin
+          if name.nil?
+            raise Problem, 'Cannot generate prefix for anonymous class. ' \
+                           'Use `prefix` method to set explicitly.'
+          end
+          name.downcase.gsub('::', Familia.delim).to_sym
+        end
+      end
+
+      # Converts the class name into a string that can be used to look up
+      # configuration values. This is particularly useful when mapping
+      # familia models with specific database numbers in the configuration.
+      #
+      # @example V2::Session.config_name => 'session'
+      #
+      # @return [String] The underscored class name as a string
+      def config_name
+        name.split('::').last
+          .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+          .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+          .downcase
       end
 
       # Creates and persists a new instance of the class.
@@ -258,8 +287,8 @@ module Familia
       # @see #exists?
       # @see #save
       #
-      def create *args, **kwargs
-        fobj = new(*args, **kwargs)
+      def create(*, **)
+        fobj = new(*, **)
         raise Familia::Problem, "#{self} already exists: #{fobj.dbkey}" if fobj.exists?
 
         fobj.save
@@ -455,6 +484,5 @@ module Familia
         @load_method || :from_json # Familia.load_method
       end
     end
-
   end
 end

data/lib/familia/secure_identifier.rb

@@ -0,0 +1,129 @@
+# lib/familia/secure_identifier.rb
+
+require 'securerandom'
+
+module Familia
+  module SecureIdentifier
+
+    # Generates a 256-bit cryptographically secure hexadecimal identifier.
+    #
+    # @return [String] A 64-character hex string representing 256 bits of entropy.
+    # @security Provides ~10^77 possible values, far exceeding UUID4's 128 bits.
+    def generate_hex_id
+      SecureRandom.hex(32)
+    end
+
+    # Generates a 64-bit cryptographically secure hexadecimal trace identifier.
+    #
+    # @return [String] A 16-character hex string representing 64 bits of entropy.
+    # @note 64 bits provides ~18 quintillion values, sufficient for request tracing.
+    def generate_hex_trace_id
+      SecureRandom.hex(8)
+    end
+
+    # Generates a cryptographically secure identifier, encoded in the specified base.
+    # By default, this creates a compact, URL-safe base-36 string.
+    #
+    # @param base [Integer] The base for encoding the output string (2-36, default: 36).
+    # @return [String] A secure identifier.
+    #
+    # @example Generate a 256-bit ID in base-36 (default)
+    #   generate_id # => "25nkfebno45yy36z47ffxef2a7vpg4qk06ylgxzwgpnz4q3os4"
+    #
+    # @example Generate a 256-bit ID in base-16 (hexadecimal)
+    #   generate_id(16) # => "568bdb582bc5042bf435d3f126cf71593981067463709c880c91df1ad9777a34"
+    #
+    def generate_id(base = 36)
+      target_length = SecureIdentifier.min_length_for_bits(256, base)
+      generate_hex_id.to_i(16).to_s(base).rjust(target_length, '0')
+    end
+
+    # Generates a short, secure trace identifier, encoded in the specified base.
+    # Suitable for tracing, logging, and other ephemeral use cases.
+    #
+    # @param base [Integer] The base for encoding the output string (2-36, default: 36).
+    # @return [String] A secure short identifier.
+    #
+    # @example Generate a 64-bit short ID in base-36 (default)
+    #   generate_trace_id # => "lh7uap704unf"
+    #
+    # @example Generate a 64-bit short ID in base-16 (hexadecimal)
+    #   generate_trace_id(16) # => "94cf9f8cfb0eb692"
+    #
+    def generate_trace_id(base = 36)
+      target_length = SecureIdentifier.min_length_for_bits(64, base)
+      generate_hex_trace_id.to_i(16).to_s(base).rjust(target_length, '0')
+    end
+
+    # Truncates a 256-bit hexadecimal ID to 64 bits and encodes it in a given base.
+    # These short, deterministic IDs are useful for secure logging. By inputting the
+    # full hexadecimal string, you can generate a consistent short ID that allows
+    # tracking an entity through logs without exposing the entity's full identifier..
+    #
+    # @param hex_id [String] A 64-character hexadecimal string (representing 256 bits).
+    # @param base [Integer] The base for encoding the output string (2-36, default: 36).
+    # @return [String] A 64-bit identifier, encoded in the specified base.
+    def shorten_to_trace_id(hex_id, base: 36)
+      target_length = SecureIdentifier.min_length_for_bits(64, base)
+      truncated = hex_id.to_i(16) >> (256 - 64) # Always 64 bits
+      truncated.to_s(base).rjust(target_length, '0')
+    end
+
+    # Truncates a 256-bit hexadecimal ID to 128 bits and encodes it in a given base.
+    # This function takes the most significant bits from the hex string to maintain
+    # randomness while creating a shorter, deterministic identifier that's safe for
+    # outdoor use.
+    #
+    # @param hex_id [String] A 64-character hexadecimal string (representing 256 bits).
+    # @param base [Integer] The base for encoding the output string (2-36, default: 36).
+    # @return [String] A 128-bit identifier, encoded in the specified base.
+    #
+    # @example Create a shorter external ID from a full 256-bit internal ID
+    #   hex_id = generate_hex_id
+    #   external_id = shorten_to_external_id(hex_id)
+    #
+    # @note This is useful for creating shorter, public-facing IDs from secure internal ones.
+    # @security Truncation preserves the cryptographic properties of the most significant bits.
+    def shorten_to_external_id(hex_id, base: 36)
+      target_length = SecureIdentifier.min_length_for_bits(128, base)
+      truncated = hex_id.to_i(16) >> (256 - 128) # Always 128 bits
+      truncated.to_s(base).rjust(target_length, '0')
+    end
+
+    # Calculate minimum string length to represent N bits in given base
+    #
+    # When generating random IDs, we need to know how many characters are required
+    # to represent a certain amount of entropy. This ensures consistent ID lengths.
+    #
+    # Formula: ceil(bits * log(2) / log(base))
+    #
+    # @example Common usage with SecureRandom
+    #   SecureRandom.hex(32)  # 32 bytes = 256 bits = 64 hex chars
+    #   SecureRandom.hex(16)  # 16 bytes = 128 bits = 32 hex chars
+    #
+    # @example Using the method
+    #   min_length_for_bits(256, 16)  # => 64 (hex)
+    #   min_length_for_bits(256, 36)  # => 50 (base36)
+    #   min_length_for_bits(128, 10)  # => 39 (decimal)
+
+    # Fast lookup for hex (base 16) - our most common case
+    # Avoids calculation overhead for 99% of ID generation
+    HEX_LENGTHS = {
+      256 => 64,  # SHA-256 equivalent entropy
+      128 => 32,  # UUID equivalent entropy
+      64  => 16,  # Compact ID
+    }.freeze
+
+    # Get minimum character length needed to encode `bits` of entropy in `base`
+    #
+    # @param bits [Integer] Number of bits of entropy needed
+    # @param base [Integer] Numeric base (2-36)
+    # @return [Integer] Minimum string length required
+    def self.min_length_for_bits(bits, base)
+      return HEX_LENGTHS[bits] if base == 16 && HEX_LENGTHS.key?(bits)
+
+      @length_cache ||= {}
+      @length_cache[[bits, base]] ||= (bits * Math.log(2) / Math.log(base)).ceil
+    end
+  end
+end

data/lib/familia/utils.rb

@@ -1,93 +1,8 @@
 # lib/familia/utils.rb
 
-require 'securerandom'
-
 module Familia
-
   module Utils
 
-
-    # Generates a 256-bit cryptographically secure hexadecimal identifier.
-    #
-    # @return [String] A 64-character hex string representing 256 bits of entropy.
-    # @security Provides ~10^77 possible values, far exceeding UUID4's 128 bits.
-    def generate_hex_id
-      SecureRandom.hex(32)
-    end
-
-    # Generates a cryptographically secure identifier, encoded in the specified base.
-    # By default, this creates a compact, URL-safe base-36 string.
-    #
-    # @param base [Integer] The base for encoding the output string (2-36, default: 36).
-    # @return [String] A secure identifier.
-    #
-    # @example Generate a 256-bit ID in base-36 (default)
-    #   generate_id # => "25nkfebno45yy36z47ffxef2a7vpg4qk06ylgxzwgpnz4q3os4"
-    #
-    # @example Generate a 256-bit ID in base-16 (hexadecimal)
-    #   generate_id(16) # => "568bdb582bc5042bf435d3f126cf71593981067463709c880c91df1ad9777a34"
-    #
-    def generate_id(base = 36)
-      target_length = LENGTH_256_BIT[base]
-      generate_hex_id.to_i(16).to_s(base).rjust(target_length, '0')
-    end
-
-    # Generates a 64-bit cryptographically secure hexadecimal trace identifier.
-    #
-    # @return [String] A 16-character hex string representing 64 bits of entropy.
-    # @note 64 bits provides ~18 quintillion values, sufficient for request tracing.
-    def generate_hex_trace_id
-      SecureRandom.hex(8)
-    end
-
-    # Generates a short, secure trace identifier, encoded in the specified base.
-    # Suitable for tracing, logging, and other ephemeral use cases.
-    #
-    # @param base [Integer] The base for encoding the output string (2-36, default: 36).
-    # @return [String] A secure short identifier.
-    #
-    # @example Generate a 64-bit short ID in base-36 (default)
-    #   generate_trace_id # => "lh7uap704unf"
-    #
-    # @example Generate a 64-bit short ID in base-16 (hexadecimal)
-    #   generate_trace_id(16) # => "94cf9f8cfb0eb692"
-    #
-    def generate_trace_id(base = 36)
-      target_length = LENGTH_64_BIT[base]
-      generate_hex_trace_id.to_i(16).to_s(base).rjust(target_length, '0')
-    end
-
-    # Truncates a 256-bit hexadecimal ID to 128 bits and encodes it in a given base.
-    # This function takes the most significant bits from the hex string to maintain
-    # randomness while creating a shorter, deterministic identifier.
-    #
-    # @param hex_id [String] A 64-character hexadecimal string (representing 256 bits).
-    # @param base [Integer] The base for encoding the output string (2-36, default: 36).
-    # @return [String] A 128-bit identifier, encoded in the specified base.
-    #
-    # @example Create a shorter external ID from a full 256-bit internal ID
-    #   hex_id = generate_hex_id
-    #   external_id = shorten_to_external_id(hex_id)
-    #
-    # @note This is useful for creating shorter, public-facing IDs from secure internal ones.
-    # @security Truncation preserves the cryptographic properties of the most significant bits.
-    def shorten_to_external_id(hex_id, base: 36)
-      target_length = LENGTH_128_BIT[base]
-      truncated = hex_id.to_i(16) >> (256 - 128)  # Always 128 bits
-      truncated.to_s(base).rjust(target_length, '0')
-    end
-
-    # Truncates a 256-bit hexadecimal ID to 64 bits and encodes it in a given base.
-    #
-    # @param hex_id [String] A 64-character hexadecimal string (representing 256 bits).
-    # @param base [Integer] The base for encoding the output string (2-36, default: 36).
-    # @return [String] A 64-bit identifier, encoded in the specified base.
-    def shorten_to_trace_id(hex_id, base: 36)
-      target_length = LENGTH_64_BIT[base]
-      truncated = hex_id.to_i(16) >> (256 - 64)   # Always 64 bits
-      truncated.to_s(base).rjust(target_length, '0')
-    end
-
     # Joins array elements with Familia delimiter
     # @param val [Array] elements to join
     # @return [String] joined string
@@ -152,7 +67,6 @@ module Familia
       end
     end
 
-
     # This method determines the appropriate transformation to apply based on
     # the class of the input argument.
     #
@@ -179,14 +93,14 @@ module Familia
     def distinguisher(value_to_distinguish, strict_values: true)
       case value_to_distinguish
       when ::Symbol, ::String, ::Integer, ::Float
-        Familia.trace :TOREDIS_DISTINGUISHER, dbclient, "string", caller(1..1) if Familia.debug?
+        Familia.trace :TOREDIS_DISTINGUISHER, dbclient, 'string', caller(1..1) if Familia.debug?
 
         # Symbols and numerics are naturally serializable to strings
         # so it's a relatively low risk operation.
         value_to_distinguish.to_s
 
       when ::TrueClass, ::FalseClass, ::NilClass
-        Familia.trace :TOREDIS_DISTINGUISHER, dbclient, "true/false/nil", caller(1..1) if Familia.debug?
+        Familia.trace :TOREDIS_DISTINGUISHER, dbclient, 'true/false/nil', caller(1..1) if Familia.debug?
 
         # TrueClass, FalseClass, and NilClass are considered high risk because their
         # original types cannot be reliably determined from their serialized string
@@ -200,10 +114,11 @@ module Familia
         # explicitly set to false.
         #
         raise Familia::HighRiskFactor, value_to_distinguish if strict_values
+
         value_to_distinguish.to_s #=> "true", "false", ""
 
       when Familia::Base, Class
-        Familia.trace :TOREDIS_DISTINGUISHER, dbclient, "base", caller(1..1) if Familia.debug?
+        Familia.trace :TOREDIS_DISTINGUISHER, dbclient, 'base', caller(1..1) if Familia.debug?
 
         # When called with a class we simply transform it to its name. For
         # instances of Familia class, we store the identifier.
@@ -214,25 +129,21 @@ module Familia
         end
 
       else
-         Familia.trace :TOREDIS_DISTINGUISHER, dbclient, "else1 #{strict_values}", caller(1..1) if Familia.debug?
+        Familia.trace :TOREDIS_DISTINGUISHER, dbclient, "else1 #{strict_values}", caller(1..1) if Familia.debug?
 
         if value_to_distinguish.class.ancestors.member?(Familia::Base)
-          Familia.trace :TOREDIS_DISTINGUISHER, dbclient, "isabase", caller(1..1) if Familia.debug?
+          Familia.trace :TOREDIS_DISTINGUISHER, dbclient, 'isabase', caller(1..1) if Familia.debug?
 
           value_to_distinguish.identifier
 
         else
           Familia.trace :TOREDIS_DISTINGUISHER, dbclient, "else2 #{strict_values}", caller(1..1) if Familia.debug?
           raise Familia::HighRiskFactor, value_to_distinguish if strict_values
+
           nil
         end
       end
     end
 
-    # Calculate minimum string length to represent N bits in given base
-    calc_length = ->(bits, base) { (bits * Math.log(2) / Math.log(base)).ceil }
-    LENGTH_256_BIT = [nil, nil] + (2..36).map { |b| calc_length.call(256, b) }
-    LENGTH_128_BIT = [nil, nil] + (2..36).map { |b| calc_length.call(128, b) }
-    LENGTH_64_BIT = [nil, nil] + (2..36).map { |b| calc_length.call(64, b) }
   end
 end

data/lib/familia/version.rb

@@ -3,6 +3,6 @@
 module Familia
   # Version information for the Familia
   unless defined?(Familia::VERSION)
-    VERSION = '2.0.0.pre2'
+    VERSION = '2.0.0.pre4'
   end
 end

data/lib/familia.rb

@@ -66,11 +66,13 @@ module Familia
     end
   end
 
+  require_relative 'familia/secure_identifier'
   require_relative 'familia/logging'
   require_relative 'familia/connection'
   require_relative 'familia/settings'
   require_relative 'familia/utils'
 
+  extend SecureIdentifier
   extend Logging
   extend Connection
   extend Settings