familia 2.0.0.pre12 → 2.0.0.pre13

data/lib/familia/refinements.rb

@@ -1,51 +1,5 @@
 # lib/familia/refinements.rb
 
-require 'pathname'
-require 'logger'
-
-# Controls whether tracing is enabled via an environment variable
-FAMILIA_TRACE = ENV.fetch('FAMILIA_TRACE', 'false').downcase
-
-# LoggerTraceRefinement
-#
-# This module adds a 'trace' log level to the Ruby Logger class.
-# It is enabled when the FAMILIA_TRACE environment variable is set to
-# '1', 'true', or 'yes' (case-insensitive).
-#
-# @example Enabling trace logging
-#   # Set environment variable
-#   ENV['FAMILIA_TRACE'] = 'true'
-#
-#   # In your Ruby code
-#   require 'logger'
-#   using LoggerTraceRefinement
-#
-#   logger = Logger.new(STDOUT)
-#   logger.trace("This is a trace message")
-#
-module LoggerTraceRefinement
-  unless defined?(ENABLED)
-    # Indicates whether trace logging is enabled
-    ENABLED = %w[1 true yes].include?(FAMILIA_TRACE).freeze
-    # The numeric level for trace logging (same as DEBUG)
-    TRACE = 0
-  end
-
-  refine Logger do
-    ##
-    # Logs a message at the TRACE level.
-    #
-    # @param progname [String] The program name to include in the log message
-    # @yield A block that evaluates to the message to log
-    # @return [true] Always returns true
-    #
-    # @example Logging a trace message
-    #   logger.trace("MyApp") { "Detailed trace information" }
-    def trace(progname = nil, &block)
-      Thread.current[:severity_letter] = 'T'
-      add(LoggerTraceRefinement::TRACE, nil, progname, &block)
-    ensure
-      Thread.current[:severity_letter] = nil
-    end
-  end
-end
+require_relative 'refinements/logger_trace'
+require_relative 'refinements/snake_case'
+require_relative 'refinements/time_utils'

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/version.rb

@@ -2,5 +2,5 @@
 
 module Familia
   # Version information for the Familia
-  VERSION = '2.0.0.pre12'.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,8 +82,18 @@ module Familia
 end
 
 require_relative 'familia/base'
+require_relative 'familia/features/autoloadable'
 require_relative 'familia/features'
-require_relative 'familia/features/autoloader'
 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'

data/try/core/time_utils_try.rb

@@ -0,0 +1,130 @@
+require_relative '../helpers/test_helpers'
+
+module RefinedContext
+  using Familia::Refinements::TimeUtils
+
+  def self.eval_in_refined_context(code)
+    eval(code)
+  end
+
+  def self.instance_eval_in_refined_context(code)
+    instance_eval(code)
+  end
+end
+
+# Test TimeUtils refinement
+
+## Numeric#months - convert number to months in seconds
+result = RefinedContext.eval_in_refined_context("1.month")
+result.round(0)
+#=> 2629746.0
+
+## Numeric#months - plural form
+result = RefinedContext.instance_eval_in_refined_context("2.months")
+result.round(0)
+#=> 5259492.0
+
+## Numeric#years - convert number to years in seconds
+result = RefinedContext.eval_in_refined_context("1.year")
+result.round(0)
+#=> 31556952.0
+
+## Numeric#in_months - convert seconds to months
+RefinedContext.instance_eval_in_refined_context("2629746.in_months")
+#=> 1.0
+
+## Numeric#in_years - convert seconds to years
+result = RefinedContext.eval_in_refined_context("#{Familia::Refinements::TimeUtils::PER_YEAR}.in_years")
+result.round(1)
+#=> 1.0
+
+## String#in_seconds - parse month string
+RefinedContext.instance_eval_in_refined_context("'1mo'.in_seconds")
+#=> 2629746.0
+
+## String#in_seconds - parse month string (long form)
+RefinedContext.eval_in_refined_context("'2months'.in_seconds")
+#=> 5259492.0
+
+## String#in_seconds - parse year string
+result = RefinedContext.instance_eval_in_refined_context("'1y'.in_seconds")
+result.round(0)
+#=> 31556952.0
+
+## Numeric#age_in - calculate age in months from timestamp (approximately 1 month ago)
+timestamp = Time.now.to_f - Familia::Refinements::TimeUtils::PER_MONTH
+result = RefinedContext.eval_in_refined_context("#{timestamp}.age_in(:months)")
+(result - 1.0).abs < 0.01
+#=> true
+
+## Numeric#age_in - calculate age in years from timestamp (approximately 1 year ago)
+timestamp = Time.now.to_f - Familia::Refinements::TimeUtils::PER_YEAR
+result = RefinedContext.instance_eval_in_refined_context("#{timestamp}.age_in(:years)")
+(result - 1.0).abs < 0.01
+#=> true
+
+## Numeric#months_old - convenience method for age_in(:months)
+timestamp = Time.now.to_f - Familia::Refinements::TimeUtils::PER_MONTH
+result = RefinedContext.eval_in_refined_context("#{timestamp}.months_old")
+(result - 1.0).abs < 0.01
+#=> true
+
+## Numeric#years_old - convenience method for age_in(:years)
+timestamp = Time.now.to_f - Familia::Refinements::TimeUtils::PER_YEAR
+result = RefinedContext.instance_eval_in_refined_context("#{timestamp}.years_old")
+(result - 1.0).abs < 0.01
+#=> true
+
+## Numeric#months_old - should NOT return seconds (the original bug)
+timestamp = Time.now.to_f - Familia::Refinements::TimeUtils::PER_MONTH
+result = RefinedContext.eval_in_refined_context("#{timestamp}.months_old")
+result.between?(0.9, 1.1)  # Should be ~1 month, not millions of seconds
+#=> true
+
+## Numeric#years_old - should NOT return seconds (the original bug)
+timestamp = Time.now.to_f - Familia::Refinements::TimeUtils::PER_YEAR
+result = RefinedContext.instance_eval_in_refined_context("#{timestamp}.years_old")
+result.between?(0.9, 1.1)  # Should be ~1 year, not millions of seconds
+#=> true
+
+## age_in with from_time parameter - months
+past_time = Time.now - (2 * Familia::Refinements::TimeUtils::PER_MONTH)  # 2 months ago
+from_time = Time.now - Familia::Refinements::TimeUtils::PER_MONTH  # 1 month ago
+result = RefinedContext.eval_in_refined_context("#{past_time.to_f}.age_in(:months, #{from_time.to_f})")
+(result - 1.0).abs < 0.01
+#=> true
+
+## age_in with from_time parameter - years
+past_time = Time.now - (2 * Familia::Refinements::TimeUtils::PER_YEAR)  # 2 years ago
+from_time = Time.now - Familia::Refinements::TimeUtils::PER_YEAR  # 1 year ago
+result = RefinedContext.instance_eval_in_refined_context("#{past_time.to_f}.age_in(:years, #{from_time.to_f})")
+(result - 1.0).abs < 0.01
+#=> true
+
+## Verify month constant is approximately correct (30.437 days)
+expected_seconds_per_month = 30.437 * 24 * 60 * 60
+Familia::Refinements::TimeUtils::PER_MONTH.round(0)
+#=> 2629746.0
+
+## Verify year constant (365.2425 days - Gregorian year)
+expected_seconds_per_year = 365.2425 * 24 * 60 * 60
+Familia::Refinements::TimeUtils::PER_YEAR.round(0)
+#=> 31556952.0
+
+## UNIT_METHODS contains months mapping
+Familia::Refinements::TimeUtils::UNIT_METHODS['months']
+#=> :months
+
+## UNIT_METHODS contains mo mapping
+Familia::Refinements::TimeUtils::UNIT_METHODS['mo']
+#=> :months
+
+## UNIT_METHODS contains month mapping
+Familia::Refinements::TimeUtils::UNIT_METHODS['month']
+#=> :months
+
+## Calendar consistency - 12 months equals 1 year (fix for inconsistency issue)
+result1 = RefinedContext.eval_in_refined_context("12.months")
+result2 = RefinedContext.instance_eval_in_refined_context("1.year")
+result1 == result2
+#=> true

data/try/data_types/datatype_base_try.rb

@@ -21,7 +21,7 @@ p [@a.name, @b.name]
 #=> true
 
 ## Limiter#qstamp
-@limiter1.counter.qstamp(10.minutes, '%H:%M', 1_302_468_980)
+RefinedContext.eval_in_refined_context("@limiter1.counter.qstamp(10.minutes, '%H:%M', 1_302_468_980)")
 ##=> '20:50'
 
 ## Database Types can be stored to quantized stamp suffix
@@ -32,7 +32,8 @@ p [@a.name, @b.name]
 @limiter2 = Limiter.new :requests
 p [@limiter1.default_expiration, @limiter2.default_expiration]
 p [@limiter1.counter.parent.default_expiration, @limiter2.counter.parent.default_expiration]
-@limiter2.counter.qstamp(10.minutes, pattern: nil, time: 1_302_468_980)
+RefinedContext.instance_variable_set(:@limiter2, @limiter2)
+RefinedContext.eval_in_refined_context("@limiter2.counter.qstamp(10.minutes, pattern: nil, time: 1_302_468_980)")
 #=> 1302468600
 
 ## Database Types can be stored to quantized numeric suffix. This

data/try/features/autoloadable/autoloadable_try.rb

@@ -0,0 +1,61 @@
+# try/features/autoloadable/autoloadable_try.rb
+
+require_relative '../../../lib/familia'
+
+# Create test feature module that includes Autoloadable
+module TestAutoloadableFeature
+  include Familia::Features::Autoloadable
+
+  def self.included(base)
+    super
+    base.define_method(:test_feature_method) { "feature_loaded" }
+  end
+end
+
+# Create test class to include the feature
+class TestModelForAutoloadable < Familia::Horreum
+  field :name
+end
+
+## Test that Autoloadable can be included in feature modules
+TestAutoloadableFeature.ancestors.include?(Familia::Features::Autoloadable)
+#=> true
+
+## Test that Autoloadable extends feature modules with ClassMethods
+TestAutoloadableFeature.respond_to?(:post_inclusion_autoload)
+#=> true
+
+## Test that including autoloadable feature in Horreum class works
+TestModelForAutoloadable.include(TestAutoloadableFeature)
+TestModelForAutoloadable.ancestors.include?(TestAutoloadableFeature)
+#=> true
+
+## Test that post_inclusion_autoload can be called with test class
+TestAutoloadableFeature.post_inclusion_autoload(TestModelForAutoloadable, :test_autoloadable_feature, {})
+"success"
+#=> "success"
+
+## Test that feature methods are available on the model
+@test_instance = TestModelForAutoloadable.new(name: 'test')
+@test_instance.respond_to?(:test_feature_method)
+#=> true
+
+## Test that feature method works
+@test_instance.test_feature_method
+#=> "feature_loaded"
+
+## Test that Autoloadable works with DataType classes (should not crash)
+class TestDataTypeAutoloadable < Familia::DataType
+  include Familia::Features::Autoloadable
+end
+
+TestDataTypeAutoloadable.ancestors.include?(Familia::Features::Autoloadable)
+#=> true
+
+## Test that SafeDump includes Autoloadable (real-world usage)
+Familia::Features::SafeDump.ancestors.include?(Familia::Features::Autoloadable)
+#=> true
+
+## Test that SafeDump has post_inclusion_autoload capability
+Familia::Features::SafeDump.respond_to?(:post_inclusion_autoload)
+#=> true

data/try/features/encrypted_fields/concealed_string_core_try.rb

@@ -77,9 +77,14 @@ end
 @doc.content.to_str
 #=!> NoMethodError
 
-## JSON serialization - to_json
-@doc.content.to_json
-#=> "\"[CONCEALED]\""
+## JSON serialization - to_json (fails for security)
+begin
+  @doc.content.to_json
+  raise "Should have raised SerializerError"
+rescue Familia::SerializerError => e
+  e.class
+end
+#=> Familia::SerializerError
 
 ## JSON serialization - as_json
 @doc.content.as_json