familia 2.0.0.pre15 → 2.0.0.pre17

data/try/features/relationships/relationships_api_changes_try.rb

@@ -1,13 +1,13 @@
 # try/features/relationships/relationships_api_changes_try.rb
 #
 # Test coverage for Familia v2 relationships API changes
-# Testing new class_tracked_in and class_indexed_by methods
+# Testing new class_participates_in and unique_index methods
 # Testing breaking changes and argument validation
 
 require_relative '../../helpers/test_helpers'
 
 # Test classes for new API
-class ApiTestUser < Familia::Horreum
+class ::ApiTestUser < Familia::Horreum
   feature :relationships
 
   identifier_field :user_id
@@ -17,16 +17,16 @@ class ApiTestUser < Familia::Horreum
   field :created_at
   field :status
 
-  # New API: class_tracked_in for class-level tracking
-  class_tracked_in :all_users, score: :created_at
-  class_tracked_in :active_users, score: -> { status == 'active' ? Time.now.to_i : 0 }
+  # New API: class_participates_in for class-level participation
+  class_participates_in :all_users, score: :created_at
+  class_participates_in :active_users, score: -> { status == 'active' ? Familia.now.to_i : 0 }
 
-  # New API: class_indexed_by for class-level indexing
-  class_indexed_by :email, :email_lookup
-  class_indexed_by :username, :username_lookup, finder: false
+  # New API: unique_index for class-level indexing
+  unique_index :email, :email_lookup
+  unique_index :username, :username_lookup, query: false
 end
 
-class ApiTestProject < Familia::Horreum
+class ::ApiTestProject < Familia::Horreum
   feature :relationships
 
   identifier_field :project_id
@@ -35,7 +35,7 @@ class ApiTestProject < Familia::Horreum
   field :created_at
 end
 
-class ApiTestMembership < Familia::Horreum
+class ::ApiTestMembership < Familia::Horreum
   feature :relationships
 
   identifier_field :membership_id
@@ -45,20 +45,21 @@ class ApiTestMembership < Familia::Horreum
   field :role
   field :created_at
 
-  # New API: using parent: instead of context:
-  indexed_by :user_id, :user_memberships, parent: ApiTestUser
-  indexed_by :project_id, :project_memberships, parent: ApiTestProject
+  # New API: using target: parameter
+  multi_index :user_id, :user_memberships, within: ApiTestUser
+  multi_index :project_id, :project_memberships, within: ApiTestProject
 
-  # Tracking with parent class
-  tracked_in ApiTestProject, :memberships, score: :created_at
+  # Participation with parent class
+  participates_in ApiTestProject, :memberships, score: :created_at
 end
 
+
 # Setup test objects
 @user = ApiTestUser.new(
   user_id: 'user_123',
   email: 'test@example.com',
   username: 'testuser',
-  created_at: Time.now.to_i,
+  created_at: Familia.now.to_i,
   status: 'active'
 )
 
@@ -66,14 +67,14 @@ end
   user_id: 'user_456',
   email: 'inactive@example.com',
   username: 'inactiveuser',
-  created_at: Time.now.to_i - 3600,
+  created_at: Familia.now.to_i - 3600,
   status: 'inactive'
 )
 
 @project = ApiTestProject.new(
   project_id: 'proj_789',
   name: 'Test Project',
-  created_at: Time.now.to_i
+  created_at: Familia.now.to_i
 )
 
 @membership = ApiTestMembership.new(
@@ -81,34 +82,34 @@ end
   user_id: @user.user_id,
   project_id: @project.project_id,
   role: 'admin',
-  created_at: Time.now.to_i
+  created_at: Familia.now.to_i
 )
 
 # =============================================
-# 1. New API: class_tracked_in Method Tests
+# 1. New API: class_participates_in Method Tests
 # =============================================
 
-## class_tracked_in generates class-level collection class methods
+## class_participates_in generates class-level collection class methods
 ApiTestUser.respond_to?(:all_users)
 #=> true
 
-## class_tracked_in generates class-level collection access methods
+## class_participates_in generates class-level collection access methods
 ApiTestUser.respond_to?(:active_users)
 #=> true
 
-## class_tracked_in generates class methods for adding items
+## class_participates_in generates class methods for adding items
 ApiTestUser.respond_to?(:add_to_all_users)
 #=> true
 
-## class_tracked_in generates class methods for removing items
+## class_participates_in generates class methods for removing items
 ApiTestUser.respond_to?(:remove_from_all_users)
 #=> true
 
-## class_tracked_in generates membership check methods
+## class_participates_in generates membership check methods
 @user.respond_to?(:in_class_all_users?)
 #=> true
 
-## class_tracked_in generates score retrieval methods
+## class_participates_in generates score retrieval methods
 @user.respond_to?(:score_in_class_all_users)
 #=> true
 
@@ -129,49 +130,49 @@ score.is_a?(Float) && score > 0
 #=> true
 
 ## Score calculation works for lambda scores with active user
-@user.save  # Should automatically add to active_users
+ApiTestUser.add_to_active_users(@user)  # Explicit addition to active_users collection
 active_score = ApiTestUser.active_users.score(@user.identifier)
 active_score > 0
 #=> true
 
 ## Score calculation works for lambda scores with inactive user
-@inactive_user.save  # Should automatically add to active_users
+ApiTestUser.add_to_active_users(@inactive_user)  # Explicit addition to active_users collection
 ApiTestUser.active_users.member?(@inactive_user.identifier)
 #=> true
 
 # =============================================
-# 2. New API: class_indexed_by Method Tests
+# 2. New API: unique_index Method Tests
 # =============================================
 
-## class_indexed_by with finder: true generates finder methods
+## unique_index with query: true generates query methods
 ApiTestUser.respond_to?(:find_by_email)
 #=> true
 
-## class_indexed_by with finder: true generates bulk finder methods
+## unique_index with query: true generates bulk query methods
 ApiTestUser.respond_to?(:find_all_by_email)
 #=> true
 
-## class_indexed_by with finder: false does not generate finder methods
+## unique_index with query: false does not generate query methods
 ApiTestUser.respond_to?(:find_by_username)
 #=> false
 
-## class_indexed_by generates class-level index access methods
+## unique_index generates class-level index access methods
 ApiTestUser.respond_to?(:email_lookup)
 #=> true
 
-## class_indexed_by generates class-level index rebuild methods
+## unique_index generates class-level index rebuild methods
 ApiTestUser.respond_to?(:rebuild_email_lookup)
 #=> true
 
-## class_indexed_by generates instance methods for class indexing
+## unique_index generates instance methods for class indexing
 @user.respond_to?(:add_to_class_email_lookup)
 #=> true
 
-## class_indexed_by generates removal methods
+## unique_index generates removal methods
 @user.respond_to?(:remove_from_class_email_lookup)
 #=> true
 
-## class_indexed_by generates update methods
+## unique_index generates update methods
 @user.respond_to?(:update_in_class_email_lookup)
 #=> true
 
@@ -189,16 +190,16 @@ ApiTestUser.email_lookup.get(@user.email) == @user.user_id
 # 3. New API: parent: Parameter Tests
 # =============================================
 
-## indexed_by with parent: generates context-specific methods
-@membership.respond_to?(:add_to_apitestuser_user_memberships)
+## multi_index with within: generates context-specific methods
+@membership.respond_to?(:add_to_api_test_user_user_memberships)
 #=> true
 
-## indexed_by with parent: generates removal methods
-@membership.respond_to?(:remove_from_apitestuser_user_memberships)
+## multi_index with within: generates removal methods
+@membership.respond_to?(:remove_from_api_test_user_user_memberships)
 #=> true
 
-## indexed_by with parent: generates update methods
-@membership.respond_to?(:update_in_apitestuser_user_memberships)
+## multi_index with within: generates update methods
+@membership.respond_to?(:update_in_api_test_user_user_memberships)
 #=> true
 
 ## Parent class gets finder methods for indexed relationships
@@ -212,18 +213,18 @@ true
 # 4. Breaking Changes: ArgumentError Tests
 # =============================================
 
-## class_tracked_in creates class-level collections without error
+## class_participates_in creates class-level collections without error
 test_class = Class.new(Familia::Horreum) do
   feature :relationships
-  class_tracked_in :test_collection
+  class_participates_in :test_collection
 end
 test_class.respond_to?(:test_collection)
 #=> true
 
-## class_indexed_by works like class-level (old feature)
+## unique_index works like class-level (old feature)
 test_class = Class.new(Familia::Horreum) do
   feature :relationships
-  class_indexed_by :test_field, :test_index
+  unique_index :test_field, :test_index
 end
 test_class.respond_to?(:indexing_relationships)
 ##=> true
@@ -242,39 +243,39 @@ instance_methods = @user.methods.grep(/class_/)
 instance_methods.all? { |m| m.to_s.include?('class_') }
 #=> true
 
-## Parent-based methods use lowercased class names
-parent_methods = @membership.methods.grep(/apitestuser/)
-parent_methods.length > 0
+## Context-based methods use snake_case class names
+context_methods = @membership.methods.grep(/api_test_user/)
+context_methods.length > 0
 #=> true
 
 # =============================================
 # 6. Metadata Storage Tests
 # =============================================
 
-## class_tracked_in stores correct context_class
-tracking_meta = ApiTestUser.tracking_relationships.find { |r| r[:collection_name] == :all_users }
-tracking_meta[:context_class].end_with?('::apitestuser')
-#=> true
+## class_participates_in stores correct target_class (now a Class object)
+participation_meta = ApiTestUser.participation_relationships.find { |r| r.collection_name == :all_users }
+participation_meta.target_class
+#=> ApiTestUser
 
-## class_tracked_in stores correct context_class_name
-tracking_meta = ApiTestUser.tracking_relationships.find { |r| r[:collection_name] == :all_users }
-tracking_meta[:context_class_name].end_with?('::ApiTestUser')
-#=> true
+## class_participates_in stores correct target_class via familia_name
+participation_meta = ApiTestUser.participation_relationships.find { |r| r.collection_name == :all_users }
+participation_meta.target_class.familia_name
+#=> 'ApiTestUser'
 
-## class_indexed_by stores correct context_class
-indexing_meta = ApiTestUser.indexing_relationships.find { |r| r[:index_name] == :email_lookup }
-indexing_meta[:context_class] == ApiTestUser
-#=> true
+## unique_index stores correct target_class
+indexing_meta = ApiTestUser.indexing_relationships.find { |r| r.index_name == :email_lookup }
+indexing_meta.target_class
+#=> ApiTestUser
 
-## class_indexed_by stores correct context_class_name
-indexing_meta = ApiTestUser.indexing_relationships.find { |r| r[:index_name] == :email_lookup }
-indexing_meta[:context_class_name].end_with?('ApiTestUser')
-#=> true
+## unique_index stores correct target_class via familia_name
+indexing_meta = ApiTestUser.indexing_relationships.find { |r| r.index_name == :email_lookup }
+indexing_meta.target_class.familia_name
+#=> 'ApiTestUser'
 
-## indexed_by with parent: stores correct metadata
-membership_meta = ApiTestMembership.indexing_relationships.find { |r| r[:index_name] == :user_memberships }
-membership_meta[:context_class] == ApiTestUser
-#=> true
+## multi_index with within: stores correct metadata
+membership_meta = ApiTestMembership.indexing_relationships.find { |r| r.index_name == :user_memberships }
+membership_meta.target_class
+#=> ApiTestUser
 
 # =============================================
 # 7. Functional Integration Tests
@@ -288,7 +289,7 @@ ApiTestUser.all_users.member?(@user.identifier) && ApiTestUser.email_lookup.get(
 ## Parent-based relationships work with tracking
 @project.save
 # Note: Skipping complex parent relationship test
-@membership.respond_to?(:add_to_apitestproject_memberships)
+@membership.respond_to?(:add_to_api_test_project_memberships)
 #=> true
 
 ## Score-based tracking maintains proper ordering

data/try/features/relationships/relationships_edge_cases_try.rb

@@ -24,13 +24,10 @@ class EdgeTestDomain < Familia::Horreum
   field :created_at
   field :score_value
 
-  # Test different score calculation methods - simplified
-  tracked_in EdgeTestCustomer, :domains, score: :created_at, on_destroy: :remove
-
-  # Test different collection types for membership
-  member_of EdgeTestCustomer, :domains, type: :sorted_set
-  member_of EdgeTestCustomer, :simple_domains, type: :set
-  member_of EdgeTestCustomer, :domain_list, type: :list
+  # Test different score calculation methods and collection types - simplified
+  participates_in EdgeTestCustomer, :domains, score: :created_at, type: :sorted_set
+  participates_in EdgeTestCustomer, :simple_domains, type: :set
+  participates_in EdgeTestCustomer, :domain_list, type: :list
 
   def calculated_score
     (score_value || 0) * 2
@@ -58,19 +55,19 @@ end
 # Score encoding edge cases
 
 ## Score encoding handles maximum metadata value
-max_score = @domain1.encode_score(Time.now, 255)
+max_score = @domain1.encode_score(Familia.now, 255)
 decoded = @domain1.decode_score(max_score)
 decoded[:permissions]
 #=> 255
 
 ## Score encoding handles zero metadata
-zero_score = @domain1.encode_score(Time.now, 0)
+zero_score = @domain1.encode_score(Familia.now, 0)
 decoded_zero = @domain1.decode_score(zero_score)
 decoded_zero[:permissions]
 #=> 0
 
 ## Permission encoding handles unknown permission levels
-unknown_perm_score = @domain1.permission_encode(Time.now, :unknown_permission)
+unknown_perm_score = @domain1.permission_encode(Familia.now, :unknown_permission)
 decoded_unknown = @domain1.permission_decode(unknown_perm_score)
 decoded_unknown[:permission_list]
 #=> []
@@ -90,7 +87,7 @@ decoded_large[:permissions]
 #=> 123
 
 ## Permission encoding maps correctly
-read_score = @domain1.permission_encode(Time.now, :read)
+read_score = @domain1.permission_encode(Familia.now, :read)
 decoded_read = @domain1.permission_decode(read_score)
 decoded_read[:permission_list].include?(:read)
 #=> true
@@ -102,7 +99,7 @@ decoded_epoch[:permissions]
 #=> 42
 
 ## Boundary score values work correctly
-boundary_score = @domain1.encode_score(Time.now, 255)
+boundary_score = @domain1.encode_score(Familia.now, 255)
 decoded_boundary = @domain1.decode_score(boundary_score)
 decoded_boundary[:permissions] <= 255
 #=> true
@@ -112,22 +109,22 @@ decoded_boundary[:permissions] <= 255
 ## Method score calculation works with saved objects
 @customer1.save
 @domain1.save
-@domain1.add_to_edgetestcustomer_domains(@customer1)
-method_score = @domain1.score_in_edgetestcustomer_domains(@customer1)
+@domain1.add_to_edge_test_customer_domains(@customer1)
+method_score = @domain1.score_in_edge_test_customer_domains(@customer1)
 method_score.is_a?(Float) && method_score > 0
 #=> true
 
 ## Sorted set membership works
-@domain1.in_edgetestcustomer_domains?(@customer1)
+@domain1.in_edge_test_customer_domains?(@customer1)
 #=> true
 
 ## Score methods respond correctly
-@domain1.respond_to?(:score_in_edgetestcustomer_domains)
+@domain1.respond_to?(:score_in_edge_test_customer_domains)
 #=> true
 
 ## Basic relationship cleanup works
-@domain1.remove_from_edgetestcustomer_domains(@customer1)
-@domain1.in_edgetestcustomer_domains?(@customer1)
+@domain1.remove_from_edge_test_customer_domains(@customer1)
+@domain1.in_edge_test_customer_domains?(@customer1)
 #=> false
 
 # Clean up test data

data/try/features/relationships/relationships_performance_minimal_try.rb

@@ -44,7 +44,7 @@ save_time = Benchmark.realtime do
   @domains.each do |domain|
     domain.save
     # Use numeric scores for sorted sets
-    MinimalDomain.all_domains.add(domain.priority_score.to_f, domain.identifier)
+    MinimalDomain.all_domains.add(domain.identifier, domain.priority_score.to_f)
     MinimalDomain.active_domains.add(domain.identifier)
     MinimalDomain.domain_history.push(domain.identifier)
     MinimalDomain.domain_lookup[domain.display_domain] = domain.identifier
@@ -105,7 +105,7 @@ end
 large_time = Benchmark.realtime do
   @large_domains.each do |domain|
     domain.save
-    MinimalDomain.all_domains.add(domain.priority_score.to_f, domain.identifier)
+    MinimalDomain.all_domains.add(domain.identifier, domain.priority_score.to_f)
   end
 end
 

data/try/features/relationships/relationships_performance_simple_try.rb

@@ -30,7 +30,7 @@ class SimplePerfDomain < Familia::Horreum
   class_hashkey :domain_lookup
 
   # Define tracking relationships for testing
-  tracked_in SimplePerfCustomer, :simple_domains, score: :created_at
+  participates_in SimplePerfCustomer, :simple_domains, score: :created_at
 end
 
 # =============================================
@@ -46,7 +46,7 @@ end
   SimplePerfDomain.new(
     domain_id: "simple_perf_domain_#{i}",
     display_domain: "simple#{i}.example.com",
-    created_at: Time.now.to_i + i,
+    created_at: Familia.now.to_i + i,
     priority_score: rand(100)
   )
 end
@@ -58,15 +58,15 @@ save_time = Benchmark.realtime do
     # Manually add to collections for testing (ensure numeric score)
     # Convert created_at to float, handling nil case
     score = if domain.created_at.nil?
-              Time.now.to_f
+              Familia.now
             elsif domain.created_at.is_a?(Time)
               domain.created_at.to_f
             else
-              domain.created_at.to_f
-            end
-    SimplePerfDomain.all_domains.add(score, domain.identifier)
-    SimplePerfDomain.domain_lookup[domain.display_domain] = domain.identifier
-  end
+            domain.created_at.to_f
+          end
+  SimplePerfDomain.all_domains.add(domain.identifier, score)
+  SimplePerfDomain.domain_lookup[domain.display_domain] = domain.identifier
+end
 end
 
 # Should complete in reasonable time

data/try/features/relationships/relationships_performance_try.rb

@@ -39,7 +39,7 @@ class PerfDomain < Familia::Horreum
   class_hashkey :id_lookup
 
   # Define tracking relationships for testing
-  tracked_in PerfCustomer, :domains, score: :created_at
+  participates_in PerfCustomer, :domains, score: :created_at
 end
 
 # Integration test with other features
@@ -73,7 +73,7 @@ end
 # =============================================
 
 ## Create test objects for performance testing
-@customer = PerfCustomer.new(custid: 'perf_customer', name: 'Performance Test', created_at: Time.now.to_i)
+@customer = PerfCustomer.new(custid: 'perf_customer', name: 'Performance Test', created_at: Familia.now.to_i)
 @customer.save
 
 # Create multiple domains for bulk operations
@@ -81,7 +81,7 @@ end
   PerfDomain.new(
     domain_id: "perf_domain_#{i}",
     display_domain: "perf#{i}.example.com",
-    created_at: Time.now.to_i + i,
+    created_at: Familia.now.to_i + i,
     priority_score: rand(100),
     customer_id: @customer.custid
   )
@@ -93,8 +93,8 @@ save_time = Benchmark.realtime do
     domain.save
     # Manually populate collections for testing
     score = domain.created_at.is_a?(Time) ? domain.created_at.to_f : domain.created_at.to_f
-    PerfDomain.all_domains.add(score, domain.identifier)
-    PerfDomain.priority_queue.add(domain.priority_score, domain.identifier)
+    PerfDomain.all_domains.add(domain.identifier, score)
+    PerfDomain.priority_queue.add(domain.identifier, domain.priority_score)
     PerfDomain.active_domains.add(domain.identifier)
     PerfDomain.domain_history.push(domain.identifier)
     PerfDomain.domain_lookup[domain.display_domain] = domain.identifier
@@ -153,7 +153,7 @@ instances = 100.times.map { |i| PerfDomain.new(domain_id: "mem_test_#{i}") }
 after_instances = ObjectSpace.count_objects[:T_OBJECT]
 
 # Should not have created excessive objects (relationship metadata is shared)
-(after_instances - before_instances) < 200  # Allow for reasonable overhead
+(after_instances - before_instances) < 250  # Allow for reasonable, 2.5x overhead
 #=> true
 
 ## Class-level relationship metadata should be constant size
@@ -203,19 +203,19 @@ operation_threads = 3.times.map do |i|
       domain = PerfDomain.new(
         domain_id: "thread_test_#{i}",
         display_domain: "thread#{i}.test.com",
-        created_at: Time.now.to_i + i,
+        created_at: Familia.now.to_i + i,
         priority_score: i * 10
       )
       domain.save
 
       # Add to collections manually
-      PerfDomain.all_domains.add(domain.created_at.to_f, domain.identifier)
-      PerfDomain.priority_queue.add(domain.priority_score, domain.identifier)
+      PerfDomain.all_domains.add(domain.identifier, domain.created_at.to_f)
+      PerfDomain.priority_queue.add(domain.identifier, domain.priority_score)
       domain.save
 
       # Manually add to collections for thread test
-      PerfDomain.all_domains.add(domain.created_at.to_f, domain.identifier)
-      PerfDomain.priority_queue.add(domain.priority_score, domain.identifier)
+      PerfDomain.all_domains.add(domain.identifier, domain.created_at.to_f)
+      PerfDomain.priority_queue.add(domain.identifier, domain.priority_score)
 
       # Verify the domain was added to collections
       in_all = PerfDomain.all_domains.member?(domain.identifier)
@@ -244,7 +244,7 @@ thread_results.all? { |result| result == [true, true] }
 # =============================================
 
 ## Integration with safe_dump (if available)
-integration_model = IntegrationTestModel.new(id: 'integration_test', data: 'test_data', created_at: Time.now.to_i)
+integration_model = IntegrationTestModel.new(id: 'integration_test', data: 'test_data', created_at: Familia.now.to_i)
 
 if integration_model.respond_to?(:safe_dump)
   integration_model.save
@@ -260,7 +260,7 @@ end
 #=:> String
 
 ## Integration with expiration (if available)
-integration_model2 = IntegrationTestModel.new(id: 'integration_test2', data: 'test_data2', created_at: Time.now.to_i)
+integration_model2 = IntegrationTestModel.new(id: 'integration_test2', data: 'test_data2', created_at: Familia.now.to_i)
 if integration_model2.respond_to?(:default_expiration)
   # Test that expiration works with relationship collections
   if integration_model2.class.respond_to?(:all_items)
@@ -315,15 +315,15 @@ stress_time < 0.1
 test_domain = PerfDomain.new(
   domain_id: 'atomic_test',
   display_domain: 'atomic.test.com',
-  created_at: Time.now.to_i,
+  created_at: Familia.now.to_i,
   priority_score: 50
 )
 
 # Save should succeed and add to all collections
 test_domain.save
 # Manually add to collections
-PerfDomain.all_domains.add(test_domain.created_at.to_f, test_domain.identifier)
-PerfDomain.priority_queue.add(test_domain.priority_score, test_domain.identifier)
+PerfDomain.all_domains.add(test_domain.identifier, test_domain.created_at.to_f)
+PerfDomain.priority_queue.add(test_domain.identifier, test_domain.priority_score)
 PerfDomain.active_domains.add(test_domain.identifier)
 PerfDomain.domain_history.push(test_domain.identifier)
 
@@ -337,14 +337,14 @@ all_collections_have_domain
 #=> true
 
 ## Partial failures should not leave inconsistent state
-# This would require more complex testing infrastructure to simulate Redis failures
+# This would require more complex testing infrastructure to simulate Valkey/Redis failures
 
-## Recovery from Redis connection issues
+## Recovery from Valkey/Redis connection issues
 begin
-  # Test graceful handling of Redis errors during relationship operations
+  # Test graceful handling of Valkey/Redis errors during relationship operations
   dead_domain = PerfDomain.new(domain_id: 'dead_test')
 
-  # This test would require mocking Redis to fail, which is complex in this context
+  # This test would require mocking Valkey/Redis to fail, which is complex in this context
   # For now, just verify that normal operations work
   dead_domain.save
   dead_domain.destroy!