familia 2.0.0.pre6 → 2.0.0.pre8

data/try/features/external_identifiers/external_identifiers_try.rb

@@ -0,0 +1,203 @@
+# try/features/external_identifiers_try.rb
+
+require_relative '../../helpers/test_helpers'
+
+Familia.debug = false
+
+# Test ExternalIdentifiers feature functionality
+
+# Basic class using external identifiers
+class ExternalIdTest < Familia::Horreum
+  feature :object_identifiers
+  feature :external_identifiers
+  identifier_field :id
+  field :id
+  field :name
+end
+
+# Class with custom prefix
+class CustomPrefixTest < Familia::Horreum
+  feature :object_identifiers
+  feature :external_identifiers, prefix: 'cust'
+  identifier_field :id
+  field :id
+  field :name
+end
+
+# Class testing data integrity preservation
+class ExternalDataIntegrityTest < Familia::Horreum
+  feature :object_identifiers
+  feature :external_identifiers
+  identifier_field :id
+  field :id
+  field :name
+end
+
+# Test with existing external ID during initialization
+@existing_ext_obj = ExternalDataIntegrityTest.new(id: 'test_id', extid: 'preset_ext_123', name: 'Preset External')
+
+# Test objects for lazy generation and complex initialization
+@lazy_obj = ExternalIdTest.new
+@complex_obj = ExternalIdTest.new(id: 'complex_ext', name: 'Complex External')
+
+## Feature depends on object_identifiers
+ExternalIdTest.features_enabled.include?(:object_identifiers)
+#==> true
+
+## External identifiers feature is included
+ExternalIdTest.features_enabled.include?(:external_identifiers)
+#==> true
+
+## Class has extid field defined
+ExternalIdTest.respond_to?(:extid)
+#==> true
+
+## Object has extid accessor
+obj = ExternalIdTest.new
+obj.respond_to?(:extid)
+#==> true
+
+## External ID is generated from objid deterministically
+obj = ExternalIdTest.new
+obj.id = 'test_obj'
+obj.name = 'Test Object'
+objid = obj.objid
+extid = obj.extid
+# Same objid should always produce same extid
+obj2 = ExternalIdTest.new
+obj2.instance_variable_set(:@objid, objid)
+obj2.extid == extid
+#==> true
+
+## External ID uses default 'ext' prefix
+obj = ExternalIdTest.new
+obj.extid.start_with?('ext_')
+#==> true
+
+## Custom prefix class uses specified prefix
+custom_obj = CustomPrefixTest.new
+custom_obj.extid.start_with?('cust_')
+#==> true
+
+## External ID is URL-safe base-36 format
+obj = ExternalIdTest.new
+extid = obj.extid
+extid.match(/\Aext_[0-9a-z]+\z/)
+#=*> nil
+
+## Custom prefix external ID format is correct
+custom_obj = CustomPrefixTest.new
+extid = custom_obj.extid
+extid.match(/\Acust_[0-9a-z]+\z/)
+#=*> nil
+
+## External ID is lazy - not generated until accessed
+@lazy_obj.instance_variable_get(:@extid)
+#=> nil
+
+## External ID is generated when first accessed
+@lazy_obj.extid
+@lazy_obj.instance_variable_get(:@extid)
+#=*> nil
+
+## External ID value is stable across multiple calls
+first_call = @lazy_obj.extid
+second_call = @lazy_obj.extid
+first_call == second_call
+#==> true
+
+## Data integrity: preset extid is preserved
+@existing_ext_obj.extid
+#=> "preset_ext_123"
+
+## Data integrity: preset extid not regenerated
+@existing_ext_obj.instance_variable_get(:@extid)
+#=> "preset_ext_123"
+
+## find_by_extid class method exists
+ExternalIdTest.respond_to?(:find_by_extid)
+#==> true
+
+## find_by_extid returns correct type
+result = ExternalIdTest.find_by_extid('nonexistent')
+result.is_a?(ExternalIdTest) || result.nil?
+#==> true
+
+## External ID is deterministic from objid
+test_objid = "01234567-89ab-7def-8fed-cba987654321"
+obj1 = ExternalIdTest.new
+obj1.instance_variable_set(:@objid, test_objid)
+obj2 = ExternalIdTest.new
+obj2.instance_variable_set(:@objid, test_objid)
+obj1.extid == obj2.extid
+#==> true
+
+## External ID is different from objid
+obj = ExternalIdTest.new
+obj.objid != obj.extid
+#==> true
+
+## External ID persists through save/load cycle
+save_obj = ExternalIdTest.new
+save_obj.id = 'ext_save_test'
+save_obj.name = 'External Save Test'
+original_extid = save_obj.extid
+save_obj.save
+loaded_obj = ExternalIdTest.new(id: 'ext_save_test')
+loaded_obj.extid == original_extid
+#==> true
+
+## Different objids produce different external IDs
+obj1 = ExternalIdTest.new
+obj2 = ExternalIdTest.new
+obj1.extid != obj2.extid
+#==> true
+
+## extid field type is ExternalIdentifierFieldType
+ExternalIdTest.field_types[:extid]
+#=:> Familia::Features::ExternalIdentifiers::ExternalIdentifierFieldType
+
+## Feature options contain correct prefix
+ExternalIdTest.feature_options(:external_identifiers)[:prefix]
+#=> "ext"
+
+## Custom prefix feature options
+CustomPrefixTest.feature_options(:external_identifiers)[:prefix]
+#=> "cust"
+
+## External ID is shorter than UUID objid
+obj = ExternalIdTest.new
+obj.extid.length < obj.objid.length
+#==> true
+
+## External ID contains only lowercase alphanumeric after prefix
+obj = ExternalIdTest.new
+extid_suffix = obj.extid.split('_', 2)[1]
+extid_suffix.match(/\A[0-9a-z]+\z/)
+#=*> nil
+
+## Complex initialization preserves lazy generation
+@complex_obj.instance_variable_get(:@extid)
+#=> nil
+
+## External ID generation after complex initialization
+@complex_obj.extid
+#=*> nil
+
+## find_by_extid works with saved objects
+@test_obj = ExternalIdTest.new(id: 'findable_test', name: 'Test Object')
+@test_obj.save
+found_obj = ExternalIdTest.find_by_extid(@test_obj.extid)
+found_obj&.id
+#=> "findable_test"
+
+## find_by_extid returns nil for nonexistent extids
+ExternalIdTest.find_by_extid('nonexistent_extid')
+#=> nil
+
+## extid_lookup mapping is maintained
+ExternalIdTest.extid_lookup[@test_obj.extid]
+#=> "findable_test"
+
+# Cleanup test objects
+@test_obj.destroy! rescue nil

data/try/features/object_identifiers/object_identifiers_integration_try.rb

@@ -0,0 +1,289 @@
+# try/features/object_identifiers_integration_try.rb
+
+require_relative '../../helpers/test_helpers'
+
+Familia.debug = false
+
+# Integration test for ObjectIdentifiers and ExternalIdentifiers features together
+
+# Class using both features with defaults
+class IntegrationTest < Familia::Horreum
+  feature :object_identifiers
+  feature :external_identifiers  # This depends on :object_identifiers
+  identifier_field :id
+  field :id
+  field :name
+  field :email
+end
+
+# Class with custom configurations for both features
+class CustomIntegrationTest < Familia::Horreum
+  feature :object_identifiers, generator: :hex
+  feature :external_identifiers, prefix: 'custom'
+  identifier_field :id
+  field :id
+  field :name
+end
+
+# Class testing full lifecycle with Redis persistence
+class PersistenceTest < Familia::Horreum
+  feature :object_identifiers
+  feature :external_identifiers
+  identifier_field :id
+  field :id
+  field :name
+  field :created_at
+end
+
+# Setup test objects
+@integration_obj = IntegrationTest.new(id: 'integration_1', name: 'Integration Test', email: 'test@example.com')
+@custom_obj = CustomIntegrationTest.new(id: 'custom_1', name: 'Custom Test')
+
+## Object identifiers feature is automatically included
+IntegrationTest.features_enabled.include?(:object_identifiers)
+#==> true
+
+## External identifiers feature is included
+IntegrationTest.features_enabled.include?(:external_identifiers)
+#==> true
+
+## Object responds to objid accessor
+obj = IntegrationTest.new
+obj.respond_to?(:objid)
+#==> true
+
+## Object responds to extid accessor
+obj = IntegrationTest.new
+obj.respond_to?(:extid)
+#==> true
+
+## Class responds to find_by_objid method
+IntegrationTest.respond_to?(:find_by_objid)
+#==> true
+
+## Class responds to find_by_extid method
+IntegrationTest.respond_to?(:find_by_extid)
+#==> true
+
+## objid and extid are different values
+obj = IntegrationTest.new
+obj.objid != obj.extid
+#==> true
+
+## extid is deterministically generated from objid
+obj = IntegrationTest.new
+original_objid = obj.objid
+original_extid = obj.extid
+# Create new object with same objid
+obj2 = IntegrationTest.new
+obj2.instance_variable_set(:@objid, original_objid)
+obj2.extid == original_extid
+#==> true
+
+## Custom objid uses hex format (64 chars for 256-bit)
+@custom_obj.objid.match(/\A[0-9a-f]{64}\z/)
+#=*> nil
+
+## Custom extid uses custom prefix
+@custom_obj.extid.start_with?('custom_')
+#==> true
+
+## Both IDs persist through save/load cycle
+persistence_obj = PersistenceTest.new
+persistence_obj.id = 'persistence_test'
+persistence_obj.name = 'Persistence Test Object'
+persistence_obj.created_at = Time.now.to_i
+original_objid = persistence_obj.objid
+original_extid = persistence_obj.extid
+persistence_obj.save
+
+# Load from Redis
+loaded_obj = PersistenceTest.new(id: 'persistence_test')
+
+## objid persists after save/load
+persistence_obj = PersistenceTest.new
+persistence_obj.id = 'persistence_test'
+persistence_obj.name = 'Persistence Test Object'
+persistence_obj.created_at = Time.now.to_i
+original_objid = persistence_obj.objid
+persistence_obj.save
+loaded_obj = PersistenceTest.new(id: 'persistence_test')
+loaded_obj.objid == original_objid
+#==> true
+
+## extid persists after save/load
+persistence_obj = PersistenceTest.new
+persistence_obj.id = 'persistence_test'
+persistence_obj.name = 'Persistence Test Object'
+persistence_obj.created_at = Time.now.to_i
+original_extid = persistence_obj.extid
+persistence_obj.save
+loaded_obj = PersistenceTest.new(id: 'persistence_test')
+loaded_obj.extid == original_extid
+#==> true
+
+## objid instance variable starts nil (lazy generation)
+lazy_obj = IntegrationTest.new
+lazy_obj.instance_variable_get(:@objid)
+#=> nil
+
+## extid instance variable starts nil (lazy generation)
+lazy_obj = IntegrationTest.new
+lazy_obj.instance_variable_get(:@extid)
+#=> nil
+
+## Accessing objid first doesn't trigger extid generation
+lazy_obj = IntegrationTest.new
+lazy_obj.objid
+lazy_obj.instance_variable_get(:@extid)
+#=> nil
+
+## Accessing extid triggers objid generation if needed
+lazy_obj2 = IntegrationTest.new
+lazy_obj2.extid  # This should trigger objid generation too
+lazy_obj2.instance_variable_get(:@objid)
+#=*> nil
+
+## Check field types objid
+IntegrationTest.field_types[:objid].is_a?(Familia::Features::ObjectIdentifiers::ObjectIdentifierFieldType)
+#==> true
+
+## ObjectIdentifier fields have correct types in field registry
+IntegrationTest.field_types[:objid].class.ancestors.include?(Familia::Features::ObjectIdentifiers::ObjectIdentifierFieldType)
+#==> true
+
+## ExternalIdentifier fields have correct types in field registry
+IntegrationTest.field_types[:extid].class.ancestors.include?(Familia::Features::ExternalIdentifiers::ExternalIdentifierFieldType)
+#==> true
+
+## Object identifiers options are preserved
+opts = IntegrationTest.feature_options
+opts.key?(:object_identifiers)
+#==> true
+
+## External identifiers options are preserved
+opts = IntegrationTest.feature_options
+opts.key?(:external_identifiers)
+#==> true
+
+## Generator default configuration is applied correctly
+IntegrationTest.feature_options(:object_identifiers)[:generator]
+#=> :uuid_v7
+
+## Prefix default configuration is applied correctly
+IntegrationTest.feature_options(:external_identifiers)[:prefix]
+#=> "ext"
+
+## Custom generator configuration is applied correctly
+CustomIntegrationTest.feature_options(:object_identifiers)[:generator]
+#=> :hex
+
+## Custom prefix configuration is applied correctly
+CustomIntegrationTest.feature_options(:external_identifiers)[:prefix]
+#=> "custom"
+
+## objid is URL-safe (UUID format)
+obj = IntegrationTest.new
+obj.objid.match(/\A[A-Za-z0-9\-]+\z/)
+#=*> nil
+
+## extid is URL-safe (base36 format)
+obj = IntegrationTest.new
+obj.extid.match(/\A[a-z0-9_]+\z/)
+#=*> nil
+
+## Data integrity preserved during complex initialization
+complex_obj = IntegrationTest.new(
+  id: 'complex_integration',
+  name: 'Complex Integration',
+  email: 'complex@test.com',
+  objid: 'preset_objid_123',
+  extid: 'preset_ext_456'
+)
+
+## Preset objid value is preserved
+complex_obj = IntegrationTest.new(
+  id: 'complex_integration',
+  name: 'Complex Integration',
+  email: 'complex@test.com',
+  objid: 'preset_objid_123',
+  extid: 'preset_ext_456'
+)
+complex_obj.objid
+#=> 'preset_objid_123'
+
+## Preset extid value is preserved
+complex_obj = IntegrationTest.new(
+  id: 'complex_integration',
+  name: 'Complex Integration',
+  email: 'complex@test.com',
+  objid: 'preset_objid_123',
+  extid: 'preset_ext_456'
+)
+complex_obj.extid
+#=> 'preset_ext_456'
+
+## find_by methods are available (stub implementations)
+search_obj = IntegrationTest.new
+search_obj.id = 'search_test'
+search_obj.save
+
+## find_by_objid returns nil (stub implementation)
+search_obj = IntegrationTest.new
+search_obj.id = 'search_test'
+search_obj.save
+found_by_objid = IntegrationTest.find_by_objid(search_obj.objid)
+found_by_objid
+#=> nil
+
+## find_by_extid works with real implementation
+@search_obj = IntegrationTest.new
+@search_obj.id = 'search_test'
+@search_obj.save
+found_by_extid = IntegrationTest.find_by_extid(@search_obj.extid)
+found_by_extid&.id
+#=> "search_test"
+
+## Both IDs remain stable across multiple accesses
+stability_obj = IntegrationTest.new
+first_objid = stability_obj.objid
+first_extid = stability_obj.extid
+second_objid = stability_obj.objid
+second_extid = stability_obj.extid
+
+## objid remains stable across accesses
+stability_obj = IntegrationTest.new
+first_objid = stability_obj.objid
+second_objid = stability_obj.objid
+first_objid == second_objid
+#==> true
+
+## extid remains stable across accesses
+stability_obj = IntegrationTest.new
+first_extid = stability_obj.extid
+second_extid = stability_obj.extid
+first_extid == second_extid
+#==> true
+
+## Feature dependency is enforced (external_identifiers requires object_identifiers)
+# This is automatically handled by the feature system
+IntegrationTest.features_enabled.include?(:object_identifiers)
+#==> true
+
+## Objects work with existing Horreum save pattern
+obj = IntegrationTest.new
+obj.respond_to?(:save)
+#==> true
+
+## Objects work with existing Horreum exists pattern
+obj = IntegrationTest.new
+obj.respond_to?(:exists?)
+#==> true
+
+## Objects work with existing Horreum delete pattern
+obj = IntegrationTest.new
+obj.respond_to?(:delete!)
+#==> true
+
+# Cleanup test objects
+@search_obj.destroy! rescue nil

data/try/features/object_identifiers/object_identifiers_try.rb

@@ -0,0 +1,191 @@
+# try/features/object_identifiers_try.rb
+
+require_relative '../../helpers/test_helpers'
+
+Familia.debug = false
+
+# Test ObjectIdentifiers feature functionality
+
+# Basic class using default UUID v7 generator
+class BasicObjectTest < Familia::Horreum
+  feature :object_identifiers
+  identifier_field :id
+  field :id
+  field :name
+end
+
+# Class using UUID v4 generator
+class UuidV4Test < Familia::Horreum
+  feature :object_identifiers, generator: :uuid_v4
+  identifier_field :id
+  field :id
+  field :name
+end
+
+# Class using hex generator
+class HexTest < Familia::Horreum
+  feature :object_identifiers, generator: :hex
+  identifier_field :id
+  field :id
+  field :name
+end
+
+# Class using custom proc generator
+class CustomProcTest < Familia::Horreum
+  feature :object_identifiers, generator: -> { "custom_#{SecureRandom.hex(4)}" }
+  identifier_field :id
+  field :id
+  field :name
+end
+
+# Class testing data integrity preservation
+class DataIntegrityTest < Familia::Horreum
+  feature :object_identifiers
+  identifier_field :id
+  field :id
+  field :name
+end
+
+# Test with existing object ID during initialization
+@existing_obj = DataIntegrityTest.new(id: 'test_id', objid: 'preset_id_123', name: 'Preset Object')
+
+## Feature is available on class
+BasicObjectTest.features_enabled.include?(:object_identifiers)
+#==> true
+
+## Class has objid field defined
+BasicObjectTest.respond_to?(:objid)
+#==> true
+
+## Object has objid accessor
+obj = BasicObjectTest.new
+obj.respond_to?(:objid)
+#==> true
+
+## Default generator creates UUID v7 format
+obj = BasicObjectTest.new
+obj.name = 'Test Object'
+objid = obj.objid
+objid.is_a?(String) && objid.length == 36 && objid.include?('-')
+#==> true
+
+## UUID v7 objid has correct format (8-4-4-4-12 characters)
+obj = BasicObjectTest.new
+obj.objid.match(/\A[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\z/)
+#=*> nil
+
+## UUID v4 generator creates correct format
+v4_obj = UuidV4Test.new
+v4_objid = v4_obj.objid
+v4_objid.match(/\A[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\z/)
+#=*> nil
+
+## Hex generator creates hex string
+hex_obj = HexTest.new
+hex_objid = hex_obj.objid
+hex_objid.is_a?(String) && hex_objid.length == 16 && hex_objid.match(/\A[0-9a-f]+\z/)
+#==> true
+
+## Custom proc generator works
+custom_obj = CustomProcTest.new
+custom_objid = custom_obj.objid
+custom_objid.start_with?('custom_') && custom_objid.length == 15
+#==> true
+
+## objid is lazy - not generated until accessed
+lazy_obj = BasicObjectTest.new
+lazy_obj.instance_variable_get(:@objid)
+#=> nil
+
+## objid is generated when first accessed
+lazy_obj = BasicObjectTest.new
+lazy_obj.objid
+lazy_obj
+#=*> _.instance_variable_get(:@objid)
+
+## objid is generated when first accessed (alternatve testcase expectation)
+lazy_obj = BasicObjectTest.new
+lazy_obj.objid
+lazy_obj.instance_variable_get(:@objid)
+#=<> nil
+
+## objid value is stable across multiple calls
+lazy_obj = BasicObjectTest.new
+first_call = lazy_obj.objid
+second_call = lazy_obj.objid
+first_call == second_call
+#==> true
+
+## Data integrity: preset objid is preserved
+@existing_obj.objid
+#=> "preset_id_123"
+
+## Data integrity: preset objid not regenerated
+@existing_obj.instance_variable_get(:@objid)
+#=> "preset_id_123"
+
+## find_by_objid class method exists
+BasicObjectTest.respond_to?(:find_by_objid)
+#==> true
+
+## find_by_objid returns correct type (stub for now)
+BasicObjectTest.find_by_objid('nonexistent')
+#=> nil
+
+## Generated objid is URL-safe (no special chars except hyphens)
+url_obj = BasicObjectTest.new
+objid = url_obj.objid
+objid
+#=*> _.match(/\A[A-Za-z0-9\-]+\z/)
+
+## Different objects get different objids
+obj1 = BasicObjectTest.new
+obj2 = BasicObjectTest.new
+obj1.objid != obj2.objid
+#==> true
+
+## objid persists through save/load cycle
+save_obj = BasicObjectTest.new
+save_obj.id = 'save_test'
+save_obj.name = 'Save Test'
+original_objid = save_obj.objid
+save_obj.save
+loaded_obj = BasicObjectTest.new(id: 'save_test')
+loaded_obj.objid == original_objid
+#==> true
+
+## Class with different generator has different objid pattern
+basic_obj = BasicObjectTest.new
+hex_obj = HexTest.new
+basic_obj.objid.include?('-') && !hex_obj.objid.include?('-')
+#==> true
+
+## objid field type is ObjectIdentifierFieldType
+BasicObjectTest.field_types[:objid]
+#=:> Familia::Features::ObjectIdentifiers::ObjectIdentifierFieldType
+
+## Generator configuration is accessible through feature options
+BasicObjectTest.feature_options(:object_identifiers)[:generator]
+#=> :uuid_v7
+
+## UUID v4 class has correct generator configured
+UuidV4Test.feature_options(:object_identifiers)[:generator]
+#=> :uuid_v4
+
+## Hex class has correct generator configured
+HexTest.feature_options(:object_identifiers)[:generator]
+#=> :hex
+
+## Custom proc class has proc generator
+CustomProcTest.feature_options(:object_identifiers)[:generator]
+#=:> Proc
+
+## Empty initialization preserves nil objid for lazy generation
+empty_obj = BasicObjectTest.new
+empty_obj.instance_variable_get(:@objid)
+#=> nil
+
+## Objid generation works with complex initialization
+complex_obj = BasicObjectTest.new(id: 'complex', name: 'Complex Object')
+complex_obj
+#=*> _.objid

data/try/features/{quantization_try.rb → quantization/quantization_try.rb}

@@ -1,6 +1,6 @@
 # try/features/quantization_try.rb
 
-require_relative '../helpers/test_helpers'
+require_relative '../../helpers/test_helpers'
 
 Familia.debug = false