familia 2.0.0.pre10 → 2.0.0.pre13

data/lib/familia/secure_identifier.rb

@@ -2,13 +2,14 @@
 
 require 'securerandom'
 
+# Provides a suite of tools for generating and manipulating cryptographically
+# secure identifiers in various formats and lengths.
 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.
+    # @security Provides ~10^77 possible values, far exceeding UUIDv4's 128 bits.
     def generate_hex_id
       SecureRandom.hex(32)
     end
@@ -26,13 +27,6 @@ module Familia
     #
     # @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')
@@ -43,87 +37,69 @@ module Familia
     #
     # @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..
+    # Creates a deterministic 64-bit trace identifier from a longer hex ID.
     #
-    # @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.
+    # This is a convenience method for `truncate_hex(hex_id, bits: 64)`.
+    # Useful for creating short, consistent IDs for logging and tracing.
+    #
+    # @param (see #truncate_hex)
+    # @return (see #truncate_hex)
     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')
+      truncate_hex(hex_id, bits: 64, base: base)
     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
+    # Deterministically truncates a hexadecimal ID to a specified bit length.
+    #
+    # This function preserves the most significant bits of the input `hex_id` to
+    # create a shorter, yet still random-looking, identifier.
+    #
+    # @param hex_id [String] The input hexadecimal string.
+    # @param bits [Integer] The desired output bit length (e.g., 128, 64). Defaults to 128.
+    # @param base [Integer] The numeric base for the output string (2-36). Defaults to 36.
+    # @return [String] A new, shorter identifier in the specified base.
+    # @raise [ArgumentError] if `hex_id` is not a valid hex string, or if `input_bits`
+    #   is less than the desired output `bits`.
+    def truncate_hex(hex_id, bits: 128, base: 36)
+      target_length = SecureIdentifier.min_length_for_bits(bits, base)
+      input_bits = hex_id.length * 4
 
-    # 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)
+      unless hex_id.match?(/\A[0-9a-fA-F]+\z/)
+        raise ArgumentError, "Invalid hexadecimal string: #{hex_id}"
+      end
 
-    # 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
+      if input_bits < bits
+        raise ArgumentError, "Input bits (#{input_bits}) cannot be less than desired output bits (#{bits})."
+      end
 
-    # Get minimum character length needed to encode `bits` of entropy in `base`
+      # Truncate by right-shifting to keep the most significant bits
+      truncated_int = hex_id.to_i(16) >> (input_bits - bits)
+      truncated_int.to_s(base).rjust(target_length, '0')
+    end
+
+    # Calculates the minimum string length required to represent a given number of
+    # bits in a specific numeric base.
+    #
+    # @private
     #
-    # @param bits [Integer] Number of bits of entropy needed
-    # @param base [Integer] Numeric base (2-36)
-    # @return [Integer] Minimum string length required
+    # @param bits [Integer] The number of bits of entropy.
+    # @param base [Integer] The numeric base (2-36).
+    # @return [Integer] The minimum string length required.
     def self.min_length_for_bits(bits, base)
-      return HEX_LENGTHS[bits] if base == 16 && HEX_LENGTHS.key?(bits)
+      # Fast lookup for hex (base 16) - our most common case
+      hex_lengths = {
+        256 => 64,  # SHA-256 equivalent entropy
+        128 => 32,  # UUID equivalent entropy
+        64  => 16,  # Compact ID
+      }.freeze
+      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
+      @min_length_for_bits_cache ||= {}
+      @min_length_for_bits_cache[[bits, base]] ||= (bits * Math.log(2) / Math.log(base)).ceil
     end
   end
 end

data/lib/familia/utils.rb

@@ -6,6 +6,8 @@ module Familia
   #
   module Utils
 
+    using Familia::Refinements::TimeUtils
+
     # Joins array elements with Familia delimiter
     # @param val [Array] elements to join
     # @return [String] joined string

data/lib/familia/validation/{test_helpers.rb → validation_helpers.rb}

@@ -1,4 +1,4 @@
-# lib/familia/validation/test_helpers.rb
+# lib/familia/validation/validation_helpers.rb
 
 module Familia
   module Validation
@@ -7,7 +7,7 @@ module Familia
     # and automatic setup/cleanup for command validation tests.
     #
     # @example Basic usage in a try file
-    #   require_relative '../validation/test_helpers'
+    #   require_relative '../validation/validation_helpers'
     #   extend Familia::Validation::TestHelpers
     #
     #   ## User save should execute expected Redis commands

data/lib/familia/validation.rb

@@ -51,7 +51,7 @@
 require_relative 'validation/command_recorder'
 require_relative 'validation/expectations'
 require_relative 'validation/validator'
-require_relative 'validation/test_helpers'
+require_relative 'validation/validation_helpers'
 
 module Familia
   module Validation

data/lib/familia/verifiable_identifier.rb

@@ -0,0 +1,162 @@
+# lib/familia/verifiable_identifier.rb
+
+require 'openssl'
+require_relative 'secure_identifier'
+
+module Familia
+  # Creates and verifies identifiers that contain an embedded HMAC signature,
+  # allowing for stateless verification of an identifier's authenticity.
+  module VerifiableIdentifier
+    # By extending SecureIdentifier, we gain access to its instance methods
+    # (like generate_hex_id) as class methods on this module.
+    extend Familia::SecureIdentifier
+
+    # The secret key for HMAC generation, loaded from an environment variable.
+    #
+    # This key is the root of trust for verifying identifier authenticity. It must be
+    # a long, random, and cryptographically strong string.
+    #
+    # @!attribute [r] SECRET_KEY
+    #   @return [String] The secret key.
+    #
+    # @note Security Considerations:
+    #   - **Secrecy:** This key MUST be kept secret and secure, just like a database
+    #     password or API key. Do not commit it to version control.
+    #   - **Consistency:** All running instances of your application must use the
+    #     exact same key, otherwise verification will fail across different servers.
+    #   - **Rotation:** If this key is ever compromised, it must be rotated. Be
+    #     aware that rotating the key will invalidate all previously generated
+    #     verifiable identifiers.
+    #
+    # @example Generating and Setting the Key
+    #     1. Generate a new secure key in your terminal:
+    #        $ openssl rand -hex 32
+    #        > cafef00dcafef00dcafef00dcafef00dcafef00dcafef00d
+    #
+    #     2. Set it as an environment variable in your production environment:
+    #        export VERIFIABLE_ID_HMAC_SECRET="cafef00dcafef00dcafef00dcafef00dcafef00dcafef00d"
+    #
+    SECRET_KEY = ENV.fetch('VERIFIABLE_ID_HMAC_SECRET', 'cafef00dcafef00dcafef00dcafef00dcafef00dcafef00d')
+
+    # The length of the random part of the ID in hex characters (256 bits).
+    RANDOM_HEX_LENGTH = 64
+    # The length of the HMAC tag in hex characters (64 bits).
+    # 64 bits is strong enough to prevent forgery (1 in 18 quintillion chance).
+    TAG_HEX_LENGTH = 16
+
+    # Generates a verifiable, base-36 encoded identifier.
+    #
+    # The final identifier contains a 256-bit random component and a 64-bit
+    # authentication tag.
+    #
+    # @param base [Integer] The base for encoding the output string.
+    # @return [String] A verifiable, signed identifier.
+    def self.generate_verifiable_id(base_or_scope = nil, scope: nil, base: 36)
+      # Handle backward compatibility with positional base argument
+      if base_or_scope.is_a?(Integer)
+        base = base_or_scope
+        # scope remains as passed in keyword argument
+      elsif base_or_scope.is_a?(String) || base_or_scope.nil?
+        scope = base_or_scope if scope.nil?
+        # base remains as passed in keyword argument or default
+      end
+
+      # Re-use generate_hex_id from the SecureIdentifier module.
+      random_hex = generate_hex_id
+      tag_hex = generate_tag(random_hex, scope: scope)
+
+      combined_hex = random_hex + tag_hex
+
+      # Re-use the min_length_for_bits helper from the SecureIdentifier module.
+      total_bits = (RANDOM_HEX_LENGTH + TAG_HEX_LENGTH) * 4
+      target_length = Familia::SecureIdentifier.min_length_for_bits(total_bits, base)
+
+      combined_hex.to_i(16).to_s(base).rjust(target_length, '0')
+    end
+
+    # Verifies the authenticity of a given identifier using a timing-safe comparison.
+    #
+    # @param verifiable_id [String] The identifier string to check.
+    # @param base [Integer] The base of the input string.
+    # @return [Boolean] True if the identifier is authentic, false otherwise.
+    def self.verified_identifier?(verifiable_id, base_or_scope = nil, scope: nil, base: 36)
+      # Handle backward compatibility with positional base argument
+      if base_or_scope.is_a?(Integer)
+        base = base_or_scope
+        # scope remains as passed in keyword argument
+      elsif base_or_scope.is_a?(String) || base_or_scope.nil?
+        scope = base_or_scope if scope.nil?
+        # base remains as passed in keyword argument or default
+      end
+
+      return false unless plausible_identifier?(verifiable_id, base)
+
+      expected_hex_length = (RANDOM_HEX_LENGTH + TAG_HEX_LENGTH)
+      combined_hex = verifiable_id.to_i(base).to_s(16).rjust(expected_hex_length, '0')
+
+      random_part = combined_hex[0...RANDOM_HEX_LENGTH]
+      tag_part = combined_hex[RANDOM_HEX_LENGTH..]
+
+      expected_tag = generate_tag(random_part, scope: scope)
+      OpenSSL.secure_compare(expected_tag, tag_part)
+    end
+
+    # Checks if an identifier is plausible (correct format and length) without
+    # performing cryptographic verification.
+    #
+    # This can be used as a fast pre-flight check to reject obviously
+    # malformed identifiers.
+    #
+    # @param identifier_str [String] The identifier string to check.
+    # @param base [Integer] The base of the input string.
+    # @return [Boolean] True if the identifier has a valid format, false otherwise.
+    def self.plausible_identifier?(identifier_str, base = 36)
+      return false unless identifier_str.is_a?(::String)
+
+      # 1. Check length
+      total_bits = (RANDOM_HEX_LENGTH + TAG_HEX_LENGTH) * 4
+      expected_length = Familia::SecureIdentifier.min_length_for_bits(total_bits, base)
+      return false unless identifier_str.length == expected_length
+
+      # 2. Check character set
+      # The most efficient way to check for invalid characters is to attempt
+      # conversion and rescue the error.
+      Integer(identifier_str, base)
+      true
+    rescue ArgumentError
+      false
+    end
+
+    class << self
+      private
+
+      # Generates the HMAC tag for a given message.
+      # @private
+      def generate_tag(message, scope: nil)
+        # Include scope in HMAC calculation for domain separation if provided.
+        # The scope parameter enables creating cryptographically isolated identifier
+        # namespaces (e.g., per-domain, per-tenant, per-application) while maintaining
+        # all security properties of the base system.
+        #
+        # Security considerations for scope values:
+        # - Any string content is cryptographically safe (HMAC handles arbitrary input)
+        # - No length restrictions (short scopes like "a" or long scopes work equally well)
+        # - UTF-8 encoding is handled consistently
+        # - Empty string "" vs nil produce different identifiers (intentional for security)
+        # - Different scope values guarantee different identifier spaces
+        #
+        # Examples of scope usage:
+        # - Customer isolation: scope: "tenant:#{tenant_id}"
+        # - Environment separation: scope: "production" vs scope: "staging"
+        # - Domain scoping: scope: "example.com"
+        # - Application scoping: scope: "#{app_name}:#{version}"
+        hmac_input = scope ? "#{message}:scope:#{scope}" : message
+
+        digest = OpenSSL::Digest.new('sha256')
+        hmac = OpenSSL::HMAC.hexdigest(digest, SECRET_KEY, hmac_input)
+        # Truncate to the desired length for the tag.
+        hmac[0...TAG_HEX_LENGTH]
+      end
+    end
+  end
+end

data/lib/familia/version.rb

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

data/lib/familia.rb

@@ -1,11 +1,12 @@
 # lib/familia.rb
 
-require 'json'
+require 'oj'
 require 'redis'
 require 'uri/valkey'
 require 'connection_pool'
 
-require_relative 'familia/core_ext'
+# OJ configuration is handled internally by Familia::JsonSerializer
+
 require_relative 'familia/refinements'
 require_relative 'familia/errors'
 require_relative 'familia/version'
@@ -71,6 +72,7 @@ module Familia
   require_relative 'familia/connection'
   require_relative 'familia/settings'
   require_relative 'familia/utils'
+  require_relative 'familia/json_serializer'
 
   extend SecureIdentifier
   extend Connection
@@ -80,7 +82,18 @@ module Familia
 end
 
 require_relative 'familia/base'
+require_relative 'familia/features/autoloadable'
 require_relative 'familia/features'
 require_relative 'familia/data_type'
 require_relative 'familia/horreum'
 require_relative 'familia/encryption'
+
+# Ensure JSON constant is available for backward compatibility with existing code
+# This approach is safer than monkey-patching core classes globally
+begin
+  require 'json'
+rescue LoadError
+  # If json gem is not available, define a minimal JSON constant
+  # that delegates to Familia::JsonSerializer for compatibility
+  JSON = Familia::JsonSerializer
+end

data/try/core/autoloader_try.rb

@@ -0,0 +1,112 @@
+# try/core/autoloader_try.rb
+
+require_relative '../../lib/familia'
+require 'fileutils'
+require 'tmpdir'
+
+# Create test directory structure for Autoloader testing
+@test_dir = Dir.mktmpdir('familia_autoloader_test')
+@features_dir = File.join(@test_dir, 'features')
+@test_file1 = File.join(@features_dir, 'test_feature1.rb')
+@test_file2 = File.join(@features_dir, 'test_feature2.rb')
+@excluded_file = File.join(@features_dir, 'autoloader.rb')
+
+# Create directory structure
+FileUtils.mkdir_p(@features_dir)
+
+# Write test files
+File.write(@test_file1, <<~RUBY)
+  # Test feature file 1
+  $test_feature1_loaded = true
+RUBY
+
+File.write(@test_file2, <<~RUBY)
+  # Test feature file 2
+  $test_feature2_loaded = true
+RUBY
+
+File.write(@excluded_file, <<~RUBY)
+  # This should be excluded
+  $autoloader_file_loaded = true
+RUBY
+
+## Test that Familia::Autoloader exists and is a module
+Familia::Autoloader.is_a?(Module)
+#=> true
+
+## Test that autoload_files class method exists
+Familia::Autoloader.respond_to?(:autoload_files)
+#=> true
+
+## Test that included class method exists
+Familia::Autoloader.respond_to?(:included)
+#=> true
+
+## Test autoload_files with single pattern
+$test_feature1_loaded = false
+$test_feature2_loaded = false
+$autoloader_file_loaded = false
+
+Familia::Autoloader.autoload_files(File.join(@features_dir, '*.rb'))
+$test_feature1_loaded && $test_feature2_loaded
+#=> true
+
+## Test that autoload_files respects exclusions (using fresh files)
+@exclude_test_dir = Dir.mktmpdir('familia_autoloader_exclude_test')
+@exclude_features_dir = File.join(@exclude_test_dir, 'features')
+@include_file = File.join(@exclude_features_dir, 'include_me.rb')
+@exclude_file = File.join(@exclude_features_dir, 'autoloader.rb')
+
+FileUtils.mkdir_p(@exclude_features_dir)
+File.write(@include_file, '$include_me_loaded = true')
+File.write(@exclude_file, '$exclude_me_loaded = true')
+
+$include_me_loaded = false
+$exclude_me_loaded = false
+
+Familia::Autoloader.autoload_files(
+  File.join(@exclude_features_dir, '*.rb'),
+  exclude: ['autoloader.rb']
+)
+
+# Should load include file but not the excluded one
+$include_me_loaded && !$exclude_me_loaded
+#=> true
+
+## Test autoload_files with array of patterns (using fresh files)
+@pattern_test_dir = Dir.mktmpdir('familia_autoloader_pattern_test')
+@pattern_dir1 = File.join(@pattern_test_dir, 'dir1')
+@pattern_dir2 = File.join(@pattern_test_dir, 'dir2')
+@pattern_file1 = File.join(@pattern_dir1, 'file1.rb')
+@pattern_file2 = File.join(@pattern_dir2, 'file2.rb')
+
+FileUtils.mkdir_p(@pattern_dir1)
+FileUtils.mkdir_p(@pattern_dir2)
+File.write(@pattern_file1, '$pattern1_loaded = true')
+File.write(@pattern_file2, '$pattern2_loaded = true')
+
+$pattern1_loaded = false
+$pattern2_loaded = false
+
+Familia::Autoloader.autoload_files([
+  File.join(@pattern_dir1, '*.rb'),
+  File.join(@pattern_dir2, '*.rb')
+])
+
+$pattern1_loaded && $pattern2_loaded
+#=> true
+
+## Test that included method loads features from features directory
+# Create a mock module that includes Autoloader
+@mock_features_module = Module.new do
+  include Familia::Autoloader
+end
+
+# The Features module already includes Autoloader, so test indirectly
+Familia::Features.ancestors.include?(Familia::Autoloader)
+#=> true
+
+# Cleanup test files and directories
+FileUtils.rm_rf(@test_dir)
+FileUtils.rm_rf(@exclude_test_dir)
+FileUtils.rm_rf(@pattern_test_dir)

data/try/core/extensions_try.rb

@@ -1,59 +1,76 @@
 require_relative '../helpers/test_helpers'
 
+module RefinedContext
+  using Familia::Refinements::TimeUtils
+
+  # This helper evaluates code within the refined context using eval.
+  # This works because eval executes the code as if it were written
+  # at this location, making the refinements available.
+  def self.eval_in_refined_context(code)
+    eval(code)
+  end
+
+  # This helper also evaluates code in the refined context using instance_eval.
+  # This provides an alternative approach for testing refinements.
+  def self.instance_eval_in_refined_context(code)
+    instance_eval(code)
+  end
+end
+
 # Test core extensions
 
 ## String time parsing - seconds
-'60s'.in_seconds
-#=> 60
+RefinedContext.eval_in_refined_context("'60s'.in_seconds")
+#=> 60.0
 
 ## String time parsing - minutes
-'5m'.in_seconds
-#=> 300
+RefinedContext.instance_eval_in_refined_context("'5m'.in_seconds")
+#=> 300.0
 
 ## String time parsing - hours
-'2h'.in_seconds
-#=> 7200
+RefinedContext.eval_in_refined_context("'2h'.in_seconds")
+#=> 7200.0
 
 ## String time parsing - days
-'1d'.in_seconds
-#=> 86_400
+RefinedContext.instance_eval_in_refined_context("'1d'.in_seconds")
+#=> 86_400.0
 
-## String time parsing - days
-'1y'.in_seconds
-#=> 31536000
+## String time parsing - years
+RefinedContext.eval_in_refined_context("'1y'.in_seconds")
+#=> 31556952.0
 
 ## Time::Units - second
-1.second
+RefinedContext.instance_eval_in_refined_context("1.second")
 #=> 1
 
 ## Time::Units - minute
-1.minute
+RefinedContext.eval_in_refined_context("1.minute")
 #=> 60
 
 ## Time::Units - hour
-1.hour
+RefinedContext.instance_eval_in_refined_context("1.hour")
 #=> 3600
 
 ## Time::Units - day
-1.day
+RefinedContext.eval_in_refined_context("1.day")
 #=> 86_400
 
 ## Time::Units - week
-1.week
+RefinedContext.instance_eval_in_refined_context("1.week")
 #=> 604_800
 
 ## Numeric extension to_ms
-1000.to_ms
-#=> 1000 * 1000
+RefinedContext.eval_in_refined_context("1000.to_ms")
+#=> 1000000.0
 
 ## Numeric extension to_bytes - single byte
-1.to_bytes
+RefinedContext.instance_eval_in_refined_context("1.to_bytes")
 #=> '1.00 B'
 
 ## Numeric extension to_bytes - kilobytes
-1024.to_bytes
+RefinedContext.eval_in_refined_context("1024.to_bytes")
 #=> '1.00 KiB'
 
 ## Numeric extension to_bytes - megabytes
-(1024 * 1024).to_bytes
+RefinedContext.instance_eval_in_refined_context("(1024 * 1024).to_bytes")
 #=> '1.00 MiB'

data/try/core/familia_extended_try.rb

@@ -44,14 +44,15 @@ parsed_time = Familia.now(Time.parse('2011-04-10 20:56:20 UTC').utc)
 #=> [1302468980.0, true, true]
 
 ## Familia.qnow
-Familia.qstamp 10.minutes, time: 1_302_468_980
+RefinedContext.eval_in_refined_context("Familia.qstamp 10.minutes, time: 1_302_468_980")
 #=> 1302468600
 
 ## Familia::Object.qstamp
-Limiter.qstamp(10.minutes, pattern: '%H:%M', time: 1_302_468_980)
+RefinedContext.eval_in_refined_context("Limiter.qstamp(10.minutes, pattern: '%H:%M', time: 1_302_468_980)")
 #=> '20:50'
 
 ## Familia::Object#qstamp
 limiter = Limiter.new :request
-limiter.qstamp(10.minutes, pattern: '%H:%M', time: 1_302_468_980)
+RefinedContext.instance_variable_set(:@limiter, limiter)
+RefinedContext.eval_in_refined_context("@limiter.qstamp(10.minutes, pattern: '%H:%M', time: 1_302_468_980)")
 #=> '20:50'