familia 2.0.0.pre12 → 2.0.0.pre14

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::TimeLiterals
+
+  # 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::TimeLiterals
+
+  def self.eval_in_refined_context(code)
+    eval(code)
+  end
+
+  def self.instance_eval_in_refined_context(code)
+    instance_eval(code)
+  end
+end
+
+# Test TimeLiterals 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::TimeLiterals::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::TimeLiterals::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::TimeLiterals::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::TimeLiterals::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::TimeLiterals::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::TimeLiterals::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::TimeLiterals::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::TimeLiterals::PER_MONTH)  # 2 months ago
+from_time = Time.now - Familia::Refinements::TimeLiterals::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::TimeLiterals::PER_YEAR)  # 2 years ago
+from_time = Time.now - Familia::Refinements::TimeLiterals::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::TimeLiterals::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::TimeLiterals::PER_YEAR.round(0)
+#=> 31556952.0
+
+## UNIT_METHODS contains months mapping
+Familia::Refinements::TimeLiterals::UNIT_METHODS['months']
+#=> :months
+
+## UNIT_METHODS contains mo mapping
+Familia::Refinements::TimeLiterals::UNIT_METHODS['mo']
+#=> :months
+
+## UNIT_METHODS contains month mapping
+Familia::Refinements::TimeLiterals::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

data/try/features/encrypted_fields/secure_by_default_behavior_try.rb

@@ -188,18 +188,30 @@ rescue TypeError => e
 end
 #=> true
 
-## JSON serialization is safe
-@user_json = {
-  id: @user.id,
-  username: @user.username,
-  password: @user.password_hash
-}.to_json
-
-@user_json.include?("bcrypt")
-#=> false
+## JSON serialization prevents leakage by raising error
+begin
+  user_json = {
+    id: @user.id,
+    username: @user.username,
+    password: @user.password_hash
+  }.to_json
+  false
+rescue Familia::SerializerError
+  true
+end
+#=> true
 
-## JSON contains concealed marker
-@user_json.include?("[CONCEALED]")
+## JSON serialization with ConcealedString raises error
+begin
+  user_json = {
+    id: @user.id,
+    username: @user.username,
+    password: @user.password_hash
+  }.to_json
+  false
+rescue Familia::SerializerError => e
+  e.message.include?("ConcealedString")
+end
 #=> true
 
 ## Bulk field operations are secure
@@ -281,16 +293,46 @@ api_response = {
   }
 }
 
-@response_json = api_response.to_json
-@response_json.include?("bcrypt")
-#=> false
+begin
+  @response_json = api_response.to_json
+  false
+rescue Familia::SerializerError
+  true
+end
+#=> true
 
 ## API response doesn't leak secrets
-@response_json.include?("sk-1234567890abcdef")
-#=> false
+api_response = {
+  user_id: @user.id,
+  credentials: {
+    password: @user.password_hash,
+    api_key: @user.api_secret
+  }
+}
+
+begin
+  @response_json = api_response.to_json
+  false
+rescue Familia::SerializerError
+  true
+end
+#=> true
 
 ## API response contains concealed markers
-@response_json.include?("[CONCEALED]")
+api_response = {
+  user_id: @user.id,
+  credentials: {
+    password: @user.password_hash,
+    api_key: @user.api_secret
+  }
+}
+
+begin
+  @response_json = api_response.to_json
+  false
+rescue Familia::SerializerError => e
+  e.message.include?("ConcealedString")
+end
 #=> true
 
 ## Debug logging safety

data/try/features/encrypted_fields/universal_serialization_safety_try.rb

@@ -67,9 +67,14 @@ hash_result.keys.include?("api_token")
 @record.api_token.inspect
 #=> "[CONCEALED]"
 
-## JSON serialization - to_json
-@record.api_token.to_json
-#=> "\"[CONCEALED]\""
+## JSON serialization - to_json (fails for security)
+begin
+  @record.api_token.to_json
+  raise "Should have raised SerializerError"
+rescue Familia::SerializerError => e
+  e.class
+end
+#=> Familia::SerializerError
 
 ## JSON serialization - as_json
 @record.api_token.as_json
@@ -100,12 +105,21 @@ hash_result.keys.include?("api_token")
   }
 }
 
-@serialized = @nested_data.to_json
-@serialized.include?("token-abc123456789")
-#=> false
+begin
+  @serialized = @nested_data.to_json
+  false
+rescue Familia::SerializerError
+  true
+end
+#=> true
 
-## Nested JSON contains concealed markers
-@nested_data.to_json.include?("[CONCEALED]")
+## Nested JSON with ConcealedString raises error
+begin
+  @nested_data.to_json
+  false
+rescue Familia::SerializerError => e
+  e.message.include?("ConcealedString cannot be serialized")
+end
 #=> true
 
 ## Array of mixed field types safety
@@ -116,11 +130,21 @@ hash_result.keys.include?("api_token")
   @record.secret_notes
 ]
 
-@mixed_array.to_json.include?("token-abc123456789")
-#=> false
+begin
+  @mixed_array.to_json
+  false
+rescue Familia::SerializerError
+  true
+end
+#=> true
 
-## Mixed array preserves public data
-@mixed_array.to_json.include?("Public Record")
+## Mixed array with ConcealedString raises error
+begin
+  @mixed_array.to_json
+  false
+rescue Familia::SerializerError => e
+  e.message.include?("ConcealedString")
+end
 #=> true
 
 ## String interpolation safety

data/try/features/external_identifier/external_identifier_try.rb

@@ -198,3 +198,29 @@ ExternalIdTest.extid_lookup[@test_obj.extid]
 
 # Cleanup test objects
 @test_obj.destroy! rescue nil
+
+## Test 1: Changing extid value (should work after bug fix)
+bug_test_obj = ExternalIdTest.new(id: 'bug_test', name: 'Bug Test Object')
+bug_test_obj.save
+bug_test_obj.extid = 'new_extid_value'
+bug_test_obj.extid
+#=> "new_extid_value"
+
+## Test 2: find_by_extid with deleted object (should work after bug fix)
+delete_test_obj = ExternalIdTest.new(id: 'delete_test', name: 'Delete Test')
+delete_test_obj.save
+test_extid = delete_test_obj.extid
+# Delete the object directly from Redis to simulate cleanup scenario
+ExternalIdTest.dbclient.del(delete_test_obj.dbkey)
+# Now try to find by extid - this should clean up mapping and return nil
+ExternalIdTest.find_by_extid(test_extid)
+#=> nil
+
+## Test 3: destroy! method (should work after bug fix)
+destroy_test_obj = ExternalIdTest.new(id: 'destroy_test', name: 'Destroy Test')
+destroy_test_obj.save
+destroy_extid = destroy_test_obj.extid
+destroy_test_obj.destroy!
+# Verify mapping was cleaned up
+ExternalIdTest.extid_lookup.key?(destroy_extid)
+#=> false

data/try/features/feature_improvements_try.rb

@@ -46,7 +46,8 @@ class ::TestModelWithSafeDump
   safe_dump_field :id
   safe_dump_field :name
   safe_dump_field :status, ->(obj) { obj.active? ? 'active' : 'inactive' }
-  safe_dump_fields :email, { computed_field: ->(obj) { "#{obj.name}-computed" } }
+  safe_dump_field :email
+  safe_dump_field :computed_field, ->(obj) { "#{obj.name}-computed" }
 end
 
 # Test field definitions in feature modules

data/try/features/real_feature_integration_try.rb

@@ -101,7 +101,7 @@ SafeDumpCategoryTest.features_enabled.include?(:safe_dump)
 @safedump_result.keys.sort
 #=> [:email, :id, :public_name]
 
-## Safe dump respects safe_dump_fields configuration
+## Safe dump respects safe_dump_field configuration
 @safedump_result.key?(:tryouts_cache_data)
 #=> false