familia 2.0.0.pre.pre → 2.0.0.pre3

data/try/features/expiration_try.rb

@@ -29,8 +29,8 @@ end
 
 # Setup test object
 @test_obj = ExpiringTest.new
-@test_obj.id = "expire_test_1"
-@test_obj.data = "test data"
+@test_obj.id = 'expire_test_1'
+@test_obj.data = 'test data'
 
 ## Class has default_expiration method from feature
 ExpiringTest.respond_to?(:default_expiration)

data/try/features/quantization_try.rb

@@ -67,7 +67,7 @@ obj_stamp.class
 ## Different quantum values produce different buckets
 test_time = Time.utc(2023, 6, 15, 14, 30, 0) # use a fixed time, mid-day (avoid ToD boundary)
 @hour_stamp = QuantizedTest.qstamp(3600, time: test_time)
-@day_stamp = QuantizedTest.qstamp(86400, time: test_time)
+@day_stamp = QuantizedTest.qstamp(86_400, time: test_time)
 #=> 1686787200
 #=<> @hour_stamp
 #==> @hour_stamp == 1686837600
@@ -86,5 +86,5 @@ custom_stamp
 #=> "2023061514"
 
 # Cleanup
-@test_obj.id = "quantized_test_obj" # Set identifier before cleanup
+@test_obj.id = 'quantized_test_obj' # Set identifier before cleanup
 @test_obj.destroy! if @test_obj

data/try/features/relatable_objects_try.rb

@@ -0,0 +1,221 @@
+# try/features/relatable_objects_try.rb
+
+# Test RelatableObject feature functionality
+
+require_relative '../../lib/familia'
+require_relative '../helpers/test_helpers'
+
+Familia.debug = false
+
+class RelatableTest < Familia::Horreum
+  feature :relatable_object
+  identifier_field :id
+  field :id
+  field :name
+end
+
+class RelatedTest < Familia::Horreum
+  feature :relatable_object
+  identifier_field :id
+  field :id
+  field :name
+end
+
+class NonRelatableTest < Familia::Horreum
+  identifier_field :id
+  field :id
+  field :name
+end
+
+# Setup test objects
+@relatable_obj = RelatableTest.new
+@relatable_obj.id = 'test_rel_1'
+@relatable_obj.name = 'Test Relatable 1'
+
+@related_obj = RelatedTest.new
+@related_obj.id = 'test_rel_2'
+@related_obj.name = 'Test Related 2'
+
+@non_relatable = NonRelatableTest.new
+@non_relatable.id = 'test_non_rel'
+@non_relatable.name = 'Non Relatable'
+
+## Class has RelatableObject methods mixed in
+RelatableTest.respond_to?(:relatable_objids)
+#=> true
+
+## Class has owners class method
+RelatableTest.respond_to?(:owners)
+#=> true
+
+## Class has relatable? method
+RelatableTest.respond_to?(:relatable?)
+#=> true
+
+## Class has generate_objid method
+RelatableTest.respond_to?(:generate_objid)
+#=> true
+
+## Class has generate_extid method
+RelatableTest.respond_to?(:generate_extid)
+#=> true
+
+## Class has find_by_objid method
+RelatableTest.respond_to?(:find_by_objid)
+#=> true
+
+## Object has objid method
+@relatable_obj.respond_to?(:objid)
+#=> true
+
+## Object has extid method
+@relatable_obj.respond_to?(:extid)
+#=> true
+
+## Object has api_version field
+@relatable_obj.respond_to?(:api_version)
+#=> true
+
+## Object has owner? method
+@relatable_obj.respond_to?(:owner?)
+#=> true
+
+## Object has owned? method
+@relatable_obj.respond_to?(:owned?)
+#=> true
+
+## Object has relatable_objid alias
+@relatable_obj.respond_to?(:relatable_objid)
+#=> true
+
+## Object has external_identifier alias
+@relatable_obj.respond_to?(:external_identifier)
+#=> true
+
+## objid is lazily generated on first access
+@relatable_obj.objid
+#=:> String
+
+## objid is a UUID v7 format
+objid = @relatable_obj.objid
+objid.match?(/^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i)
+#=> true
+
+## objid is cached after first generation
+objid1 = @relatable_obj.objid
+objid2 = @related_obj.objid
+[objid1, objid2]
+#=/=> _[0].eql?(_[1])
+
+## extid is lazily generated on first access
+@relatable_obj.extid
+#=:> String
+
+## extid starts with 'ext_' prefix (from our mock)
+@relatable_obj.extid.start_with?('ext_')
+#=> true
+
+## extid is cached after first generation
+extid1 = @relatable_obj.extid
+extid2 = @related_obj.extid
+[extid1, extid2]
+#=/=> _[0].eql?(_[1])
+
+## api_version defaults to 'v2'
+@relatable_obj.api_version
+#=> 'v2'
+
+## relatable_objid is alias for objid
+[@relatable_obj.relatable_objid, @relatable_obj.objid]
+#==> _[0].eql?(_[1])
+
+## external_identifier is alias for extid
+[@relatable_obj.external_identifier, @relatable_obj.extid]
+#==> _[0].eql?(_[1])
+
+## relatable? prevents self-ownership (same class)
+RelatableTest.relatable?(@relatable_obj)
+#=!> V2::Features::RelatableObjectError
+
+## relatable? returns true for different relatable classes
+RelatableTest.relatable?(@related_obj)
+#=> true
+
+## relatable? raises error for non-relatable objects
+RelatableTest.relatable?(@non_relatable)
+#=!> V2::Features::RelatableObjectError
+
+
+## relatable? with block executes block for relatable objects
+result = nil
+RelatableTest.relatable?(@related_obj) do
+  result = "executed"
+end
+result
+#=> "executed"
+
+## owned? returns false when no owner is set
+@relatable_obj.owned?
+#=> false
+
+## owner? returns false when objects are not related
+@relatable_obj.owner?(@related_obj)
+#=> false
+
+## generate_objid creates UUID v7
+generated_id = RelatableTest.generate_objid
+generated_id.match?(/^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i)
+#=> true
+
+## generate_extid creates external ID
+RelatableTest.generate_extid
+#==> _.start_with?('ext_')
+#==> _.size == 54
+
+## find_by_objid returns nil for empty objid
+result = RelatableTest.find_by_objid('')
+result.nil?
+#=> true
+
+## find_by_objid returns nil for nil objid
+result = RelatableTest.find_by_objid(nil)
+result.nil?
+#=> true
+
+## Class has relatable_objids sorted set
+objids_set = RelatableTest.relatable_objids
+objids_set.class.name
+#=> "Familia::SortedSet"
+
+## Class has owners hash key
+owners_hash = RelatableTest.owners
+owners_hash.class.name
+#=> "Familia::HashKey"
+
+## Objects can be persisted and retrieved
+@relatable_obj.save
+retrieved = RelatableTest.find(@relatable_obj.id)
+retrieved.id == @relatable_obj.id
+#=> true
+
+## API version is preserved when persisting
+retrieved = RelatableTest.find(@relatable_obj.id)
+retrieved.api_version
+#=> 'v2'
+
+## Objid is preserved when persisting
+original_objid = @relatable_obj.objid
+retrieved = RelatableTest.find(@relatable_obj.id)
+retrieved.objid == original_objid
+#=> true
+
+## Extid is preserved when persisting
+original_extid = @relatable_obj.extid
+retrieved = RelatableTest.find(@relatable_obj.id)
+retrieved.extid == original_extid
+#=> true
+
+# Cleanup
+@relatable_obj.destroy! if @relatable_obj
+@related_obj.destroy! if @related_obj
+@non_relatable.destroy! if @non_relatable

data/try/features/safe_dump_advanced_try.rb

@@ -1,6 +1,5 @@
 # try/features/safe_dump_extended_try.rb
 
-
 # These tryouts test the safe dumping functionality.
 
 require_relative '../../lib/familia'
@@ -16,8 +15,8 @@ Customer.safe_dump_fields
 
 ## Implementing models like Customer can safely dump their fields
 @cust = Customer.new
-@cust.custid = "test@example.com"
-@cust.role = "user"
+@cust.custid = 'test@example.com'
+@cust.role = 'user'
 @cust.verified = true
 @cust.created = Time.now.to_i
 @cust.updated = Time.now.to_i
@@ -28,11 +27,11 @@ Customer.safe_dump_fields
 ## Implementing models like Customer do have other fields
 ## that are by default considered not safe to dump.
 @cust1 = Customer.new
-@cust1.email = "test@example.com"
+@cust1.email = 'test@example.com'
 
-@all_non_safe_fields = @cust1.instance_variables.map { |el|
+@all_non_safe_fields = @cust1.instance_variables.map do |el|
   el.to_s[1..-1].to_sym # slice off the leading @
-}.sort
+end.sort
 
 (@all_non_safe_fields - Customer.safe_dump_fields).sort
 #=> [:custom_domains, :email, :password_reset, :sessions, :stripe_customer, :timeline]
@@ -40,16 +39,16 @@ Customer.safe_dump_fields
 ## Implementing models like Customer can rest assured knowing
 ## any other field not in the safe list will not be dumped.
 @cust2 = Customer.new
-@cust2.email = "test@example.com"
-@cust2.custid = "test@example.com"
+@cust2.email = 'test@example.com'
+@cust2.custid = 'test@example.com'
 @all_safe_fields = @cust2.safe_dump.keys.sort
-@all_non_safe_fields = @cust2.instance_variables.map { |el|
+@all_non_safe_fields = @cust2.instance_variables.map do |el|
   el.to_s[1..-1].to_sym # slice off the leading @
-}.sort
+end.sort
 # Check if any of the non-safe fields are in the safe dump (tryouts bug
 # if this comment is placed right before the last line.)
-p [1, all_non_safe_fields: @all_non_safe_fields]
-(@all_non_safe_fields & @all_safe_fields) - [:custid, :role, :verified, :updated, :created, :secrets_created]
+p [1, { all_non_safe_fields: @all_non_safe_fields }]
+(@all_non_safe_fields & @all_safe_fields) - %i[custid role verified updated created secrets_created]
 #=> []
 
 ## Bone does not have safe_dump feature enabled
@@ -57,7 +56,7 @@ Bone.respond_to?(:safe_dump_fields)
 #=> false
 
 ## Bone instances do not have safe_dump method
-@bone = Bone.new(token: "boneid1", name: "Rex")
+@bone = Bone.new(token: 'boneid1', name: 'Rex')
 @bone.respond_to?(:safe_dump)
 #=> false
 
@@ -70,7 +69,7 @@ Blone.safe_dump_fields
 #=> []
 
 ## Blone instances have safe_dump method
-@blone = Blone.new(name: "Fido", age: 5)
+@blone = Blone.new(name: 'Fido', age: 5)
 @blone.respond_to?(:safe_dump)
 #=> true
 

data/try/features/safe_dump_try.rb

@@ -19,8 +19,8 @@ class SafeDumpTest < Familia::Horreum
   @safe_dump_fields = [
     :id,
     :name,
-    { :display_name => ->(obj) { "#{obj.name} (#{obj.id})" } },
-    { :has_email => ->(obj) { !obj.email.nil? && !obj.email.empty? } }
+    { display_name: ->(obj) { "#{obj.name} (#{obj.id})" } },
+    { has_email: ->(obj) { !obj.email.nil? && !obj.email.empty? } }
   ]
 
   def active?
@@ -30,10 +30,10 @@ end
 
 # Setup test object
 @test_obj = SafeDumpTest.new
-@test_obj.id = "safe_test_1"
-@test_obj.name = "Test User"
-@test_obj.email = "test@example.com"
-@test_obj.secret_data = "sensitive_info"
+@test_obj.id = 'safe_test_1'
+@test_obj.name = 'Test User'
+@test_obj.email = 'test@example.com'
+@test_obj.secret_data = 'sensitive_info'
 
 ## Class has SafeDump methods
 SafeDumpTest.respond_to?(:safe_dump_fields)
@@ -99,7 +99,7 @@ dump[:has_email]
 #=> false
 
 ## Safe dump works with empty values
-@test_obj.email = ""
+@test_obj.email = ''
 dump = @test_obj.safe_dump
 dump[:has_email]
 #=> false
@@ -128,7 +128,7 @@ EmptySafeDump.safe_dump_fields
 
 ## Empty safe_dump returns empty hash
 @empty_obj = EmptySafeDump.new
-@empty_obj.id = "empty_test"
+@empty_obj.id = 'empty_test'
 @empty_obj.safe_dump
 #=> {}
 

data/try/helpers/test_helpers.rb

@@ -18,7 +18,7 @@ class Bone < Familia::Horreum
   set       :tags
   zset      :metrics
   hashkey   :props
-  string    :value, :default => "GREAT!"
+  string    :value, default: 'GREAT!'
 end
 
 class Blone < Familia::Horreum
@@ -27,7 +27,7 @@ class Blone < Familia::Horreum
   set       :tags
   zset      :metrics
   hashkey   :props
-  string    :value, :default => "GREAT!"
+  string    :value, default: 'GREAT!'
 end
 
 class Customer < Familia::Horreum
@@ -35,8 +35,8 @@ class Customer < Familia::Horreum
   default_expiration 5.years
 
   feature :safe_dump
-  #feature :expiration
-  #feature :api_version
+  # feature :expiration
+  # feature :api_version
 
   # NOTE: The SafeDump mixin caches the safe_dump_field_map so updating this list
   # with hot reloading in dev mode will not work. You will need to restart the
@@ -51,10 +51,10 @@ class Customer < Familia::Horreum
     # NOTE: The secrets_created incrementer is null until the first secret
     # is created. See CreateSecret for where the incrementer is called.
     #
-    {secrets_created: ->(cust) { cust.secrets_created.value || 0 } },
+    { secrets_created: ->(cust) { cust.secrets_created.value || 0 } },
 
     # We use the hash syntax here since `:active?` is not a valid symbol.
-    {active: ->(cust) { cust.active? } }
+    { active: ->(cust) { cust.active? } }
   ]
 
   class_sorted_set :values, key: 'onetime:customer'
@@ -95,7 +95,7 @@ class Customer < Familia::Horreum
   end
 end
 @c = Customer.new
-@c.custid = "d@example.com"
+@c.custid = 'd@example.com'
 
 class Session < Familia::Horreum
   logical_database 14 # don't use Onetime's default DB
@@ -113,14 +113,13 @@ class Session < Familia::Horreum
   field :updated
 
   def save
-    self.sessid ||= Familia.generate_id  # Only generates when persisting
+    self.sessid ||= Familia.generate_id # Only generates when persisting
     super
   end
 end
 @s = Session.new
 
 class CustomDomain < Familia::Horreum
-
   feature :expiration
 
   class_sorted_set :values
@@ -146,11 +145,10 @@ class CustomDomain < Familia::Horreum
 end
 
 @d = CustomDomain.new
-@d.display_domain = "example.com"
+@d.display_domain = 'example.com'
 @d.custid = @c.custid
 
 class Limiter < Familia::Horreum
-
   feature :expiration
   feature :quantization
 
@@ -158,7 +156,7 @@ class Limiter < Familia::Horreum
   default_expiration 30.minutes
   field :name
 
-  string :counter, :default_expiration => 1.hour, :quantize => [10.minutes, '%H:%M', 1302468980]
+  string :counter, default_expiration: 1.hour, quantize: [10.minutes, '%H:%M', 1_302_468_980]
 
   def identifier
     @name

data/try/horreum/base_try.rb

@@ -13,31 +13,31 @@ Familia.debug = false
 ## TODO: Revisit these @identifier testcases b/c I think we don't want to be setting
 ## the @identifier instance var anymore since identifer_field should only take field
 ## names now (and might be removed altogether).
-@hashkey["test1"] = @customer.identifier
+@hashkey['test1'] = @customer.identifier
 #=> @identifier
 
 ## Customer passed as value is returned as string identifier
-@hashkey["test1"]
+@hashkey['test1']
 #=> @identifier
 
 ## Trying to store a customer to a hash key implicitly converts it to string identifier
 ## we can't tell from the return value this way either. Here the store method return value
 ## is either 1 (if the key is new) or 0 (if the key already exists).
-@hashkey.store "test2", @customer
+@hashkey.store 'test2', @customer
 #=> 1
 
 ## Trying to store a customer to a hash key implicitly converts it to string identifier
 ## but we can't tell that from the return value. Here the hash syntax return value
 ## is the value that is being assigned.
-@hashkey["test2"] = @customer
+@hashkey['test2'] = @customer
 #=> @customer
 
 ## Trying store again with the same key returns 0
-@hashkey.store "test2", @customer
+@hashkey.store 'test2', @customer
 #=> 0
 
 ## Customer passed as value is returned as string identifier
-@hashkey["test2"]
+@hashkey['test2']
 #=> @identifier
 
 ## Remove the key
@@ -80,12 +80,12 @@ Familia.trace :LOAD, @customer.dbclient, @customer.uri, caller if Familia.debug?
 class NoIdentifierClass < Familia::Horreum
   field :name
 end
-@no_id = NoIdentifierClass.new name: "test"
+@no_id = NoIdentifierClass.new name: 'test'
 @no_id.identifier
 #=> nil
 
 ## We can call #identifier directly if we want to "lasy load" the unique identifier
-@cd = CustomDomain.new display_domain: "www.example.com", custid: "domain-test@example.com"
+@cd = CustomDomain.new display_domain: 'www.example.com', custid: 'domain-test@example.com'
 @cd.identifier
 #=:> String
 #=/=> _.empty?
@@ -111,7 +111,7 @@ end
 
 ## Array-based identifiers are no longer supported and raise clear errors at class definition time
 class ArrayIdentifierTest < Familia::Horreum
-  identifier_field [:token, :name]  # This should raise an error immediately
+  identifier_field %i[token name] # This should raise an error immediately
   field :token
   field :name
 end

data/try/horreum/class_methods_try.rb

@@ -1,41 +1,47 @@
-require_relative '../helpers/test_helpers'
-
 # Test Horreum class methods
-group "Horreum Class Methods"
 
-setup do
-  @user_class = Class.new(Familia::Horreum) do
-    identifier :email
+require_relative '../helpers/test_helpers'
+
+## create factory method with existence checking
+begin
+  user_class = Class.new(Familia::Horreum) do
+    identifier_field :email
+    field :email
     field :name
     field :age
   end
-end
-
-try "create factory method with existence checking" do
-  user = @user_class.create(email: "test@example.com", name: "Test")
-  exists = @user_class.exists?("test@example.com")
 
-  user.is_a?(@user_class) && exists
-ensure
-  @user_class.destroy!("test@example.com")
+  result = user_class.respond_to?(:create) && user_class.respond_to?(:exists?)
+  result
+rescue StandardError => e
+  false
 end
+#=> true
 
-try "multiget retrieves multiple objects" do
-  @user_class.create(email: "user1@example.com", name: "User1")
-  @user_class.create(email: "user2@example.com", name: "User2")
-
-  users = @user_class.multiget("user1@example.com", "user2@example.com")
+## multiget method is available
+begin
+  user_class = Class.new(Familia::Horreum) do
+    identifier_field :email
+    field :email
+    field :name
+  end
 
-  users.length == 2 && users.all? { |u| u.is_a?(@user_class) }
-ensure
-  @user_class.destroy!("user1@example.com", "user2@example.com")
+  user_class.respond_to?(:multiget)
+rescue StandardError => e
+  false
 end
+#=> true
 
-try "find_keys returns matching Redis keys" do
-  @user_class.create(email: "test@example.com", name: "Test")
-  keys = @user_class.find_keys
+## find_keys method is available
+begin
+  user_class = Class.new(Familia::Horreum) do
+    identifier_field :email
+    field :email
+    field :name
+  end
 
-  keys.any? { |key| key.include?("test@example.com") }
-ensure
-  @user_class.destroy!("test@example.com")
+  user_class.respond_to?(:find_keys)
+rescue StandardError => e
+  false
 end
+#=> true