familia 2.0.0.pre15 → 2.0.0.pre17

data/try/core/conventional_inheritance_try.rb

@@ -0,0 +1,130 @@
+require_relative '../helpers/test_helpers'
+
+# Define test classes in global namespace
+class ::TestVehicle < Familia::Horreum
+  identifier_field :vin
+  field :vin
+  field :make
+  field :model
+  field :year
+  feature :expiration
+  list :maintenance_log
+  set :tags
+end
+
+class ::TestCar < ::TestVehicle
+  field :doors
+  field :fuel_type
+end
+
+class ::TestElectricCar < ::TestCar
+  field :battery_capacity
+  field :range_miles
+end
+
+class ::TestMotorcycle < ::TestVehicle
+  field :engine_cc
+  field :has_sidecar
+end
+
+class ::TestBaseModel < Familia::Horreum
+end
+
+class ::TestConcreteModel < ::TestBaseModel
+  identifier_field :id
+  field :name
+end
+
+## Creates a parent class with various configurations
+@vehicle = TestVehicle.new(vin: 'ABC123', make: 'Toyota', model: 'Camry', year: 2020)
+
+## Parent class has expected configuration
+TestVehicle.identifier_field
+#=> :vin
+
+## Parent class has fields defined
+TestVehicle.fields
+#=> [:vin, :make, :model, :year]
+
+## Parent class has features enabled
+TestVehicle.features_enabled
+#=> [:expiration]
+
+## Child class inherits parent identifier_field
+TestCar.identifier_field
+#=> :vin
+
+## Child class inherits parent fields and adds its own
+TestCar.fields
+#=> [:vin, :make, :model, :year, :doors, :fuel_type]
+
+## Child class inherits parent features
+TestCar.features_enabled
+#=> [:expiration]
+
+## Child instance works with inherited configuration
+@car = TestCar.new(vin: 'DEF456', make: 'Honda', model: 'Civic', year: 2021, doors: 4, fuel_type: 'gasoline')
+@car.identifier
+#=> "DEF456"
+
+## Child instance can access inherited fields
+@car.make
+#=> "Honda"
+
+## Child instance can access new fields
+@car.doors
+#=> 4
+
+## Child instance inherits DataType relationships
+@car.maintenance_log.class
+#=> Familia::ListKey
+
+## Child instance can use inherited DataType relationships
+@car.tags << 'reliable'
+@car.tags.members
+#=> ["reliable"]
+
+## Grandchild inherits all ancestor configuration
+TestElectricCar.identifier_field
+#=> :vin
+
+## Grandchild inherits all ancestor fields
+TestElectricCar.fields
+#=> [:vin, :make, :model, :year, :doors, :fuel_type, :battery_capacity, :range_miles]
+
+## Grandchild inherits all ancestor features
+TestElectricCar.features_enabled
+#=> [:expiration]
+
+## Grandchild instance works correctly
+@electric = TestElectricCar.new(vin: 'TESLA123', make: 'Tesla', model: 'Model 3', doors: 4, battery_capacity: 75)
+@electric.identifier
+#=> "TESLA123"
+
+## Parent and child classes remain independent after inheritance
+TestVehicle.fields.size
+#=> 4
+
+## Child class has correct field count
+TestCar.fields.size
+#=> 6
+
+## Grandchild class has correct field count
+TestElectricCar.fields.size
+#=> 8
+
+## Parent field count unchanged after adding new child
+TestVehicle.fields.size
+#=> 4
+
+## New child class has correct field count
+TestMotorcycle.fields.size
+#=> 6
+
+## Child of empty parent inherits correctly
+TestConcreteModel.identifier_field
+#=> :id
+
+## Child of empty parent has correct fields
+TestConcreteModel.fields
+#=> [:name]

data/try/core/create_method_try.rb

@@ -16,7 +16,7 @@ end
 # Clean up any existing test data
 cleanup_keys = []
 begin
-  existing_test_keys = Familia.dbclient.keys('createtestmodel:*')
+  existing_test_keys = Familia.dbclient.keys('create_test_model:*')
   cleanup_keys.concat(existing_test_keys)
   Familia.dbclient.del(*existing_test_keys) if existing_test_keys.any?
 rescue => e
@@ -26,16 +26,18 @@ end
 @test_id_counter = 0
 def next_test_id
   @test_id_counter += 1
-  "create-test-#{Time.now.to_i}-#{@test_id_counter}"
+  identifier = "create-test-#{Familia.now.to_i}-#{@test_id_counter}"
+  identifier
 end
 
+@first_test_id = next_test_id
+
 # =============================================
 # 1. Basic create method functionality
 # =============================================
 
 ## create method successfully creates new object
-@test_id = next_test_id
-@created_obj = CreateTestModel.create(id: @test_id, name: 'Created Object', value: 'test_value')
+@created_obj = CreateTestModel.create(id: @first_test_id, name: 'Created Object', value: 'test_value')
 [@created_obj.class, @created_obj.exists?, @created_obj.name]
 #=> [CreateTestModel, true, 'Created Object']
 
@@ -53,27 +55,17 @@ end
 # =============================================
 
 ## create method raises RecordExistsError for duplicate
-begin
-  CreateTestModel.create(id: @test_id, name: 'Duplicate Attempt')
-  false  # Should not reach here
-rescue => e
-  e.class
-end
-#=> Familia::RecordExistsError
+CreateTestModel.create(id: @first_test_id, name: 'Duplicate Attempt')
+#=!> Familia::RecordExistsError
 
 ## RecordExistsError includes the dbkey in the message
-begin
-  CreateTestModel.create(id: @test_id, name: 'Another Duplicate')
-  false  # Should not reach here
-rescue Familia::RecordExistsError => e
-  expected_dbkey = "createtestmodel:#{@test_id}:object"
-  e.message.include?(expected_dbkey)
-end
-#=> true
+CreateTestModel.create(id: @first_test_id, name: 'Another Duplicate')
+#=!> Familia::RecordExistsError
+#==> !!error.message.match(/create_test_model:#{@first_test_id}:object/)
 
 ## RecordExistsError message follows consistent format
 begin
-  CreateTestModel.create(id: @test_id, name: 'Yet Another Duplicate')
+  CreateTestModel.create(id: @first_test_id, name: 'Yet Another Duplicate')
   false  # Should not reach here
 rescue Familia::RecordExistsError => e
   e.message.start_with?('Key already exists:')
@@ -140,12 +132,12 @@ end
 #=> true
 
 ## create failure doesn't leave partial data
-before_failed_create = Familia.dbclient.keys("createtestmodel:#{@concurrent_id}:*").length
+before_failed_create = Familia.dbclient.keys("create_test_model:#{@concurrent_id}:*").length
 begin
   CreateTestModel.create(id: @concurrent_id, name: 'Should Fail')
 rescue Familia::RecordExistsError
   # Should not create any additional keys
-  after_failed_create = Familia.dbclient.keys("createtestmodel:#{@concurrent_id}:*").length
+  after_failed_create = Familia.dbclient.keys("create_test_model:#{@concurrent_id}:*").length
   after_failed_create == before_failed_create
 end
 #=> true
@@ -236,5 +228,5 @@ instance_sees_exists = @class_created.exists?
 # =============================================
 
 # Clean up all test data
-test_keys = Familia.dbclient.keys('createtestmodel:*')
+test_keys = Familia.dbclient.keys('create_test_model:*')
 Familia.dbclient.del(*test_keys) if test_keys.any?

data/try/core/database_consistency_try.rb

@@ -28,14 +28,14 @@ end
 @test_id_counter = 0
 def next_test_id
   @test_id_counter += 1
-  "consistency-#{Time.now.to_i}-#{@test_id_counter}"
+  "consistency-#{Familia.now.to_i}-#{@test_id_counter}"
 end
 
 # =============================================
 # 1. Database Consistency Verification
 # =============================================
 
-## Redis key structure follows expected pattern
+## Valkey/Redis key structure follows expected pattern
 @key_test = ConsistencyTestModel.new(id: next_test_id, name: 'Key Test')
 @key_test.save
 dbkey = @key_test.dbkey
@@ -139,7 +139,7 @@ end
 @empty_hash.save
 
 # Manually remove all fields to create an empty hash
-# First add a temp field then remove it, which creates empty hash in some Redis versions
+# First add a temp field then remove it, which creates empty hash in some Valkey/Redis versions
 Familia.dbclient.hset(@empty_hash.dbkey, 'temp_field', 'temp_value')
 Familia.dbclient.hdel(@empty_hash.dbkey, 'temp_field')
 # Now remove all remaining fields to create truly empty hash
@@ -159,17 +159,17 @@ obj_exists_without_check = @empty_hash.exists?(check_size: false)
 @tx_test = ConsistencyTestModel.new(id: next_test_id, name: 'Transaction Test')
 @tx_test.save
 
-# Verify transaction doesn't interfere with exists? calls
-result = @tx_test.transaction do |conn|
-  # During transaction, exists? should still work
-  exists_in_tx = @tx_test.exists?
+# Verify transaction works and doesn't corrupt object state
+exists_before_tx = @tx_test.exists?
+multi_result = @tx_test.transaction do |conn|
+  # Update a field within transaction
   conn.hset(@tx_test.dbkey, 'active', 'true')
-  exists_in_tx
+  conn.hset(@tx_test.dbkey, 'processed', 'true')
 end
 
 exists_after_tx = @tx_test.exists?
-[result, exists_after_tx]
-#=> [[0], true]
+[exists_before_tx, multi_result.successful?, exists_after_tx]
+#=> [true, true, true]
 
 # =============================================
 # 4. Performance Consistency
@@ -214,6 +214,7 @@ exists_after_batch = @batch_obj.exists?
 
 ## Transient fields don't affect exists? behavior
 class TransientConsistencyTest < Familia::Horreum
+  feature :transient_fields
   identifier_field :id
   field :id
   field :name

data/try/core/errors_try.rb

@@ -26,33 +26,30 @@ rescue Familia::NonUniqueKey => e
 end
 #=> Familia::NonUniqueKey
 
-## HighRiskFactor error stores value
+## NotDistinguishableError error stores value
 begin
-  raise Familia::HighRiskFactor.new('dangerous_value')
-rescue Familia::HighRiskFactor => e
+  raise Familia::NotDistinguishableError.new('dangerous_value')
+rescue Familia::NotDistinguishableError => e
   e.value
 end
 #=> "dangerous_value"
 
-## HighRiskFactor error has custom message
-begin
-  raise Familia::HighRiskFactor.new(123)
-rescue Familia::HighRiskFactor => e
-  e.message.include?('High risk factor')
-end
-#=> true
+## NotDistinguishableError error has custom message
+raise Familia::NotDistinguishableError, 'A customized message'
+#=:> Familia::NotDistinguishableError
+#=~> /A customized message/
 
 ## NotConnected error stores URI
-test_uri = URI.parse('redis://localhost:6379')
+test_uri = URI.parse('redis://localhost:2525')
 begin
   raise Familia::NotConnected.new(test_uri)
 rescue Familia::NotConnected => e
   e.uri.to_s
 end
-#=> "redis://localhost"
+#=> "redis://localhost:2525"
 
 ## NotConnected error has custom message
-test_uri = URI.parse('redis://localhost:6379')
+test_uri = URI.parse('redis://localhost:2525')
 begin
   raise Familia::NotConnected.new(test_uri)
 rescue Familia::NotConnected => e
@@ -105,7 +102,7 @@ Familia::RecordExistsError.superclass
 [
   Familia::NoIdentifier,
   Familia::NonUniqueKey,
-  Familia::HighRiskFactor,
+  Familia::NotDistinguishableError,
   Familia::NotConnected,
   Familia::KeyNotFoundError,
   Familia::RecordExistsError

data/try/core/familia_extended_try.rb

@@ -7,7 +7,7 @@ require_relative '../helpers/test_helpers'
 ## Has all datatype relativess
 registered_types = Familia::DataType.registered_types.keys
 registered_types.collect(&:to_s).sort
-#=> ["counter", "hash", "hashkey", "list", "lock", "set", "sorted_set", "string", "zset"]
+#=> ["counter", "hash", "hashkey", "list", "listkey", "lock", "set", "sorted_set", "string", "stringkey", "unsorted_set", "zset"]
 
 ## Familia created class methods for datatype list class
 Familia::Horreum::DefinitionMethods.public_method_defined? :list?
@@ -36,7 +36,7 @@ Bone.list? :owners
 ## A Familia object can get a specific datatype relatives def
 definition = Bone.list :owners
 definition.klass
-#=> Familia::List
+#=> Familia::ListKey
 
 ## Familia.now
 parsed_time = Familia.now(Time.parse('2011-04-10 20:56:20 UTC').utc)

data/try/core/familia_members_methods_try.rb

@@ -0,0 +1,76 @@
+# try/core/familia_members_methods_try.rb
+
+require_relative '../helpers/test_helpers'
+
+# Tests for new methods: demodularize, familia_name, and resolve_class
+
+# Use the testable methods from the refactored module
+String.include(Familia::Refinements::StylizeWordsMethods)
+
+## demodularize removes module namespace from simple class name
+'Customer'.demodularize
+#=> 'Customer'
+
+## demodularize removes module namespace from nested class name
+'V2::Customer'.demodularize
+#=> 'Customer'
+
+## demodularize handles deep nesting
+'My::Deep::Nested::Module::Customer'.demodularize
+#=> 'Customer'
+
+## demodularize handles single colon edge case
+'::Customer'.demodularize
+#=> 'Customer'
+
+## demodularize returns original string when no modules
+'SimpleClass'.demodularize
+#=> 'SimpleClass'
+
+## familia_name returns demodularized class name for Customer
+Customer.familia_name
+#=> 'Customer'
+
+## familia_name returns demodularized class name for Session
+Session.familia_name
+#=> 'Session'
+
+## familia_name returns demodularized class name for Bone
+Bone.familia_name
+#=> 'Bone'
+
+## resolve_class returns the same class when given a Class
+Familia.resolve_class(Customer)
+#=> Customer
+
+## resolve_class finds class by string name
+Familia.resolve_class('Customer')
+#=> Customer
+
+## resolve_class finds class by symbol name
+Familia.resolve_class(:Customer)
+#=> Customer
+
+## resolve_class handles CamelCase string conversion
+Familia.resolve_class('CustomDomain')
+#=> CustomDomain
+
+## resolve_class handles snake_case symbol conversion
+Familia.resolve_class(:CustomDomain)
+#=> CustomDomain
+
+## resolve_class raises error for invalid input
+begin
+  Familia.resolve_class(123)
+rescue ArgumentError => e
+  e.message
+end
+#=> "Expected Class, String, or Symbol, got Integer"
+
+## resolve_class returns nil for unknown class name
+Familia.resolve_class('NonExistentClass')
+#=> nil
+
+## resolve_class returns nil for unknown symbol
+Familia.resolve_class(:NonExistentClass)
+#=> nil

data/try/core/familia_try.rb

@@ -12,7 +12,7 @@ Familia.uri
 
 ## Familia has a uri as a string
 Familia.uri.to_s
-#=> 'redis://127.0.0.1'
+#=> 'redis://127.0.0.1:2525'
 
 ## Familia has a url, an alias to uri
 Familia.url.eql?(Familia.uri)

data/try/core/isolated_dbclient_try.rb

@@ -0,0 +1,165 @@
+# try/core/isolated_dbclient_try.rb
+
+# Tryouts: Isolated connection functionality
+#
+# Tests for isolated database connections that don't interfere
+# with the cached connection pool or existing model connections.
+
+require_relative '../helpers/test_helpers'
+
+# Clean up any existing test data in all test databases
+(0..2).each do |db|
+  Familia.with_isolated_dbclient(db) do |client|
+    client.flushdb
+  end
+end
+
+## isolated_dbclient creates a new uncached connection
+client1 = Familia.isolated_dbclient(0)
+client2 = Familia.isolated_dbclient(0)
+different_objects = client1.object_id != client2.object_id
+client1.close
+client2.close
+different_objects
+#=> true
+
+## isolated_dbclient connects to the correct database
+Familia.with_isolated_dbclient(5) do |client|
+  client.set("test_key", "test_value")
+end
+
+# Verify the key was set in database 5
+found_in_db5 = Familia.with_isolated_dbclient(5) do |client|
+  client.get("test_key") == "test_value"
+end
+
+# Verify the key is NOT in database 0
+not_found_in_db0 = Familia.with_isolated_dbclient(0) do |client|
+  client.get("test_key").nil?
+end
+
+found_in_db5 && not_found_in_db0
+#=> true
+
+## isolated_dbclient doesn't affect cached connections
+# Set up a cached connection
+regular_client = Familia.dbclient(0)
+regular_client.set("cached_key", "cached_value")
+
+# Use isolated connection on same database
+isolated_result = Familia.with_isolated_dbclient(0) do |client|
+  client.set("isolated_key", "isolated_value")
+  client.get("cached_key")
+end
+
+# Both keys should be accessible
+cached_accessible = regular_client.get("cached_key") == "cached_value"
+isolated_accessible = regular_client.get("isolated_key") == "isolated_value"
+
+cached_accessible && isolated_accessible && isolated_result == "cached_value"
+#=> true
+
+## with_isolated_dbclient properly manages connection lifecycle
+# Test by verifying functionality rather than relying on GC/ObjectSpace
+captured_clients = []
+
+5.times do |i|
+  Familia.with_isolated_dbclient(i) do |client|
+    captured_clients << client
+    client.set("temp_key_#{i}", "temp_value_#{i}")
+    # Verify connection works inside block
+    client.ping
+  end
+end
+
+# Verify all connections worked and created distinct objects
+all_worked = captured_clients.size == 5
+all_distinct = captured_clients.map(&:object_id).uniq.size == 5
+keys_set = Familia.with_isolated_dbclient(0) { |c| c.exists?("temp_key_0") }
+
+all_worked && all_distinct && keys_set
+#=> true
+
+## with_isolated_dbclient handles exceptions gracefully
+exception_raised = false
+database_state_correct = false
+
+begin
+  Familia.with_isolated_dbclient(0) do |client|
+    client.set("before_error", "value")
+    raise "Test exception"
+    # This line should not be reached
+    client.set("after_error", "should_not_be_set")
+  end
+rescue => e
+  exception_raised = (e.message == "Test exception")
+end
+
+# Verify the database state after the exception was caught
+if exception_raised
+  database_state_correct = Familia.with_isolated_dbclient(0) do |client|
+    client.get("before_error") == "value" && client.get("after_error").nil?
+  end
+end
+
+exception_raised && database_state_correct
+#=> true
+
+## isolated connections don't interfere with model connections
+class TestModel < Familia::Horreum
+  logical_database 3
+  identifier_field :name
+  field :name
+end
+
+# Create a model instance
+test_model = TestModel.new(name: "test")
+test_model.save
+
+# Use isolated connection to scan a different database
+scan_result = Familia.with_isolated_dbclient(5) do |client|
+  client.keys("*")
+end
+
+# Model should still work correctly
+model_accessible = test_model.exists? && test_model.name == "test"
+# Don't rely on database 5 being empty since previous tests may have written to it
+# Just verify the model still works correctly
+scan_result_valid = scan_result.is_a?(Array)
+
+model_accessible && scan_result_valid
+#=> true
+
+# Clean up test model and class
+test_model.delete!
+Familia.unload_member(TestModel)
+
+## isolated_dbclient with Integer argument
+client = Familia.isolated_dbclient(7)
+client.set("db_test", "seven")
+result = client.get("db_test")
+client.close
+result
+#=> "seven"
+
+## isolated_dbclient with String URI argument
+client = Familia.isolated_dbclient("redis://localhost:2525/8")
+client.set("uri_test", "eight")
+result = client.get("uri_test")
+client.close
+result
+#=> "eight"
+
+## isolated_dbclient with nil uses default
+default_db = Familia.uri.db || 0
+client = Familia.isolated_dbclient(nil)
+client.set("default_test", "default_value")
+
+# Verify it's in the expected database
+verification = Familia.with_isolated_dbclient(default_db) do |verify_client|
+  verify_client.get("default_test")
+end
+
+client.close
+verification
+#=> "default_value"

data/try/core/middleware_try.rb

@@ -1,11 +1,11 @@
 # try/core/middleware_try.rb
 
-# Test Redis middleware components
-# Mock Redis client with middleware for testing
+# Test Valkey/Redis middleware components
+# Mock Valkey/Redis client with middleware for testing
 
 require_relative '../helpers/test_helpers'
 
-class MockRedis
+class MockDatabase
   attr_reader :logged_commands
 
   def initialize
@@ -19,40 +19,40 @@ class MockRedis
   private
 
   def log_command(cmd, *args)
-    start_time = Time.now
+    start_time = Familia.now
     result = yield
-    duration = Time.now - start_time
+    duration = Familia.now - start_time
     @logged_commands << { command: cmd, args: args, duration: duration }
     result
   end
 end
 
-## MockRedis can log commands with timing
-redis = MockRedis.new
-result = redis.get("test_key")
-[result, redis.logged_commands.length, redis.logged_commands.first[:command]]
+## MockDatabase can log commands with timing
+dbclient = MockDatabase.new
+result = dbclient.get("test_key")
+[result, dbclient.logged_commands.length, dbclient.logged_commands.first[:command]]
 #=> ["test_value", 1, "GET"]
 
-## RedisCommandCounter tracks command metrics (if available)
+## DatabaseCommandCounter tracks command metrics (if available)
 begin
-  counter = RedisCommandCounter.new
+  counter = DatabaseCommandCounter.new
   counter.increment("GET")
   counter.increment("SET")
   counter.increment("GET")
   [counter.count("GET"), counter.count("SET"), counter.total]
 rescue NameError
-  # Skip if RedisCommandCounter not available
+  # Skip if DatabaseCommandCounter not available
   [2, 1, 3]
 end
 #=> [2, 1, 3]
 
 ## Command counting utility works (if available)
 begin
-  redis = Familia.dbclient
+  dbclient = Familia.dbclient
   count = count_commands do
-    redis.set("test_key", "value")
-    redis.get("test_key")
-    redis.del("test_key")
+    dbclient.set("test_key", "value")
+    dbclient.get("test_key")
+    dbclient.del("test_key")
   end
   count >= 3
 rescue NameError, NoMethodError