MahmoudEmad/herolib
1
0
Fork 0
Code Issues 55 Pull Requests 1 Actions Packages Projects Releases 26 Wiki Activity

Merge branch 'development_fs' of https://github.com/Incubaid/herolib into development_fs

Browse Source
This commit is contained in:
Mahmoud-Emad
2025-09-16 18:38:08 +03:00
parent af1d6a7485 825a644ce9
commit 4778bb3fb3
11 changed files with 1913 additions and 61 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
lib/hero/db/core_methods.v
View File

@@ -2,10 +2,10 @@ module db
import freeflowuniverse.herolib.data.ourtime
import freeflowuniverse.herolib.data.encoder
import time
pub fn (mut self DB) set[T](mut obj T) !T {
pub fn (mut self DB) set[T](obj_ T) !T {
// Get the next ID
mut obj := obj_
if obj.id == 0 {
obj.id = self.new_id()!
}

31
lib/hero/herofs/README.md
View File

@@ -38,63 +38,70 @@ mut fs_factory := herofs.new()!
### Creating a Filesystem
```v
fs_id := fs_factory.fs.set(fs_factory.fs.new(
mut fs := fs_factory.fs.new(
name: 'my_filesystem'
quota_bytes: 1000000000 // 1GB quota
)!)!
)!
fs = fs_factory.fs.set(fs)!
fs_id := fs.id
```
### Working with Directories
```v
// Create root directory
root_dir_id := fs_factory.fs_dir.set(fs_factory.fs_dir.new(
mut root_dir := fs_factory.fs_dir.new(
name: 'root'
fs_id: fs_id
parent_id: 0
)!)!
)!
root_dir_id := fs_factory.fs_dir.set(root_dir)!
// Create subdirectory
sub_dir_id := fs_factory.fs_dir.set(fs_factory.fs_dir.new(
mut sub_dir := fs_factory.fs_dir.new(
name: 'documents'
fs_id: fs_id
parent_id: root_dir_id
)!)!
)!
sub_dir_id := fs_factory.fs_dir.set(sub_dir)!
```
### Working with Blobs
```v
// Create a blob with binary data
blob_id := fs_factory.fs_blob.set(fs_factory.fs_blob.new(
mut blob := fs_factory.fs_blob.new(
data: content_bytes
mime_type: 'text/plain'
)!)!
)!
blob_id := fs_factory.fs_blob.set(blob)!
```
### Working with Files
```v
// Create a file
file_id := fs_factory.fs_file.set(fs_factory.fs_file.new(
mut file := fs_factory.fs_file.new(
name: 'example.txt'
fs_id: fs_id
directories: [root_dir_id]
blobs: [blob_id]
)!)!
)!
file_id := fs_factory.fs_file.set(file)!
```
### Working with Symbolic Links
```v
// Create a symbolic link to a file
symlink_id := fs_factory.fs_symlink.set(fs_factory.fs_symlink.new(
mut symlink := fs_factory.fs_symlink.new(
name: 'example_link.txt'
fs_id: fs_id
parent_id: root_dir_id
target_id: file_id
target_type: .file
)!)!
)!
symlink_id := fs_factory.fs_symlink.set(symlink)!
```
## API Reference

17
lib/hero/herofs/aiinstructions/set_changes.md Normal file
View File

@@ -0,0 +1,17 @@
```v
pub fn (mut self DBFsBlobMembership) set(mut o FsBlobMembership) ! {
```
becomes
```v
pub fn (mut self DBFsBlobMembership) set(o FsBlobMembership) FsBlobMembership! {
... the other code
return o
}
```
we need to change each set in this module to be like this, then we need to make sure that _test.v programs use it the same way
see how we don't use the mut statement in set.

1418
lib/hero/herofs/aiinstructions/vlang_herolib_core.md Normal file
View File

File diff suppressed because it is too large Load Diff

16
lib/hero/herofs/fs.v
View File

@@ -136,21 +136,23 @@ pub fn (mut self DBFs) new_get_set(args_ FsArg) !Fs {
return o
}
pub fn (mut self DBFs) set(mut o Fs) ! {
if o.root_dir_id == 0 {
pub fn (mut self DBFs) set(o Fs) !Fs {
mut o_mut := o
if o_mut.root_dir_id == 0 {
// If no root directory is set, create one
mut root_dir := self.factory.fs_dir.new(
name: 'root'
fs_id: o.id
fs_id: o_mut.id
parent_id: 0 // Root has no parent
)!
self.factory.fs_dir.set(mut root_dir)!
o.root_dir_id = root_dir.id
root_dir = self.factory.fs_dir.set(root_dir)!
o_mut.root_dir_id = root_dir.id
// Update the filesystem with the new root directory ID
}
self.db.redis.hset('fs:names', o.name, o.id.str())!
self.db.redis.hset('fs:names', o_mut.name, o_mut.id.str())!
// Use db set function which now modifies the object in-place
self.db.set[Fs](mut o)!
self.db.set[Fs](o_mut)!
return o_mut
}
pub fn (mut self DBFs) delete(id u32) ! {

6
lib/hero/herofs/fs_blob.v
View File

@@ -68,14 +68,14 @@ pub fn (mut self DBFsBlob) new(args FsBlobArg) !FsBlob {
return o
}
pub fn (mut self DBFsBlob) set(mut o FsBlob) ! {
pub fn (mut self DBFsBlob) set(o_ FsBlob) !FsBlob {
// Use db set function which now modifies the object in-place
self.db.set[FsBlob](mut o)!
o := self.db.set[FsBlob](o_)!
// Store the hash -> id mapping for lookup
self.db.redis.hset('fsblob:hashes', o.hash, o.id.str())!
// Note: Blob membership will be created when the blob is associated with a filesystem
return o
}
pub fn (mut self DBFsBlob) delete(id u32) ! {

66
lib/hero/herofs/fs_blob_membership.v
View File

@@ -22,13 +22,13 @@ pub fn (self FsBlobMembership) type_name() string {
return 'fs_blob_membership'
}
pub fn (self FsBlobMembership) dump(mut e encoder.Encoder) ! {
pub fn (self FsBlobMembership) dump(e encoder.Encoder) ! {
e.add_string(self.hash)
e.add_list_u32(self.fsid)
e.add_u32(self.blobid)
}
fn (mut self DBFsBlobMembership) load(mut o FsBlobMembership, mut e encoder.Decoder) ! {
fn (self DBFsBlobMembership) load(o FsBlobMembership, e encoder.Decoder) ! {
o.hash = e.get_string()!
o.fsid = e.get_list_u32()!
o.blobid = e.get_u32()!
@@ -42,8 +42,8 @@ pub mut:
blobid u32 @[required]
}
pub fn (mut self DBFsBlobMembership) new(args FsBlobMembershipArg) !FsBlobMembership {
mut o := FsBlobMembership{
pub fn (self DBFsBlobMembership) new(args FsBlobMembershipArg) !FsBlobMembership {
o := FsBlobMembership{
hash: args.hash
fsid: args.fsid
blobid: args.blobid
@@ -52,7 +52,7 @@ pub fn (mut self DBFsBlobMembership) new(args FsBlobMembershipArg) !FsBlobMember
return o
}
pub fn (mut self DBFsBlobMembership) set(mut o FsBlobMembership) ! {
pub fn (self DBFsBlobMembership) set(o FsBlobMembership) !FsBlobMembership {
// Validate that the blob exists
if o.blobid == 0 {
return error('Blob ID cannot be 0')
@@ -62,19 +62,21 @@ pub fn (mut self DBFsBlobMembership) set(mut o FsBlobMembership) ! {
return error('Blob with ID ${o.blobid} does not exist')
}
if o.hash == '' {
mut blob := self.factory.fs_blob.get(o.blobid) or {
return error('Failed to retrieve blob with ID ${o.blobid}: ${err.msg()}')
o_mut := o
if o_mut.hash == '' {
blob := self.factory.fs_blob.get(o_mut.blobid) or {
return error('Failed to retrieve blob with ID ${o_mut.blobid}: ${err.msg()}')
}
o.hash = blob.hash
o_mut.hash = blob.hash
}
if o.fsid.len == 0 {
if o_mut.fsid.len == 0 {
return error('Blob membership filesystem IDs cannot be empty')
}
// Validate that all filesystems exist
for fs_id in o.fsid {
for fs_id in o_mut.fsid {
fs_exists := self.factory.fs.exist(fs_id)!
if !fs_exists {
return error('Filesystem with ID ${fs_id} does not exist')
@@ -82,22 +84,24 @@ pub fn (mut self DBFsBlobMembership) set(mut o FsBlobMembership) ! {
}
// Encode the object
mut e_encoder := encoder.new()
o.dump(mut e_encoder)!
e_encoder := encoder.new()
o_mut.dump(e_encoder)!
// Store using hash as key in the blob_membership hset
self.db.redis.hset('fs_blob_membership', o.hash, e_encoder.data.bytestr())!
self.db.redis.hset('fs_blob_membership', o_mut.hash, e_encoder.data.bytestr())!
return o_mut
}
pub fn (mut self DBFsBlobMembership) delete(hash string) ! {
pub fn (self DBFsBlobMembership) delete(hash string) ! {
self.db.redis.hdel('fs_blob_membership', hash)!
}
pub fn (mut self DBFsBlobMembership) exist(hash string) !bool {
pub fn (self DBFsBlobMembership) exist(hash string) !bool {
return self.db.redis.hexists('fs_blob_membership', hash)!
}
pub fn (mut self DBFsBlobMembership) get(hash string) !FsBlobMembership {
pub fn (self DBFsBlobMembership) get(hash string) !FsBlobMembership {
// Get the data from Redis
data := self.db.redis.hget('fs_blob_membership', hash)!
if data == '' {
@@ -105,34 +109,34 @@ pub fn (mut self DBFsBlobMembership) get(hash string) !FsBlobMembership {
}
data2 := data.bytes()
// Create object and decode
mut o := FsBlobMembership{}
mut e_decoder := encoder.decoder_new(data2)
self.load(mut o, mut e_decoder)!
o := FsBlobMembership{}
e_decoder := encoder.decoder_new(data2)
self.load(o, e_decoder)!
return o
}
// Add a filesystem to an existing blob membership
pub fn (mut self DBFsBlobMembership) add_filesystem(hash string, fs_id u32) ! {
pub fn (self DBFsBlobMembership) add_filesystem(hash string, fs_id u32) ! {
// Validate filesystem exists
fs_exists := self.factory.fs.exist(fs_id)!
if !fs_exists {
return error('Filesystem with ID ${fs_id} does not exist')
}
mut membership := self.get(hash)!
membership := self.get(hash)!
// Check if filesystem is already in the list
if fs_id !in membership.fsid {
membership.fsid << fs_id
}
self.set(mut membership)!
self.set(membership)!
}
// Remove a filesystem from an existing blob membership
pub fn (mut self DBFsBlobMembership) remove_filesystem(hash string, fs_id u32) ! {
mut membership := self.get(hash)!
pub fn (self DBFsBlobMembership) remove_filesystem(hash string, fs_id u32) ! {
membership := self.get(hash)!
// Remove filesystem from the list
membership.fsid = membership.fsid.filter(it != fs_id)
@@ -143,7 +147,7 @@ pub fn (mut self DBFsBlobMembership) remove_filesystem(hash string, fs_id u32) !
return
}
self.set(mut membership)!
self.set(membership)!
}
// BlobList represents a simplified blob structure for listing purposes
@@ -156,10 +160,10 @@ pub mut:
// list_by_hash_prefix lists blob memberships where hash starts with the given prefix
// Returns maximum 10000 items as FsBlobMembership entries
pub fn (mut self DBFsBlobMembership) list_prefix(prefix string) ![]FsBlobMembership {
mut result := []FsBlobMembership{}
mut cursor := 0
mut count := 0
pub fn (self DBFsBlobMembership) list_prefix(prefix string) ![]FsBlobMembership {
result := []FsBlobMembership{}
cursor := 0
count := 0
for {
if count >= 10000 {
@@ -174,7 +178,7 @@ pub fn (mut self DBFsBlobMembership) list_prefix(prefix string) ![]FsBlobMembers
// Process the returned field-value pairs
// hscan returns alternating field-value pairs, so we iterate by 2
mut i := 0
i := 0
for i < values.len && count < 10000 {
hash := values[i]
// Skip the value (we don't need it since we'll get the object by hash)

398
lib/hero/herofs/fs_blob_membership_test.v Normal file
View File

@@ -0,0 +1,398 @@
module herofs
import freeflowuniverse.herolib.hero.db
import freeflowuniverse.herolib.core.redisclient
fn test_cleanup() ! {
delete_fs_test()!
}
fn test_basic() ! {
defer {
test_cleanup() or { panic('cleanup failed: ${err.msg()}') }
}
// Initialize the HeroFS factory for test purposes
mut r := redisclient.test_get()!
mut fs_factory := new(redis: r)!
// Create a new filesystem (required for FsBlobMembership validation)
mut test_fs := fs_factory.fs.new_get_set(
name: 'test_filesystem'
description: 'Filesystem for testing FsBlobMembership functionality'
quota_bytes: 1024 * 1024 * 1024 // 1GB quota
)!
test_fs = fs_factory.fs.set(test_fs)!
println('Created test filesystem with ID: ${test_fs.id}')
// Create root directory for the filesystem
mut root_dir := fs_factory.fs_dir.new(
name: 'root'
fs_id: test_fs.id
parent_id: 0 // Root has no parent
description: 'Root directory for testing'
)!
fs_factory.fs_dir.set(root_dir)!
root_dir_id := root_dir.id
// Update the filesystem with the root directory ID
test_fs.root_dir_id = root_dir_id
fs_factory.fs.set(test_fs)!
// Create test blob for membership
test_data := 'This is test content for blob membership'.bytes()
mut test_blob := fs_factory.fs_blob.new(data: test_data)!
test_blob = fs_factory.fs_blob.set(test_blob)!
blob_id := test_blob.id
println('Created test blob with ID: ${blob_id}')
// Create test file to get a valid fsid (file ID) for membership
mut test_file := fs_factory.fs_file.new(
name: 'test_file.txt'
fs_id: test_fs.id
blobs: [blob_id]
description: 'Test file for blob membership'
mime_type: .txt
)!
test_file = fs_factory.fs_file.set(test_file)!
file_id := test_file.id
println('Created test file with ID: ${file_id}')
// Add file to directory
mut dir := fs_factory.fs_dir.get(root_dir_id)!
dir.files << file_id
fs_factory.fs_dir.set(dir)!
// Create test blob membership
mut test_membership := fs_factory.fs_blob_membership.new(
hash: test_blob.hash
fsid: [test_fs.id] // Use filesystem ID
blobid: blob_id
)!
// Save the test membership
test_membership = fs_factory.fs_blob_membership.set(test_membership)!
membership_hash := test_membership.hash
println('Created test blob membership with hash: ${membership_hash}')
// Test loading membership by hash
println('Testing blob membership loading...')
loaded_membership := fs_factory.fs_blob_membership.get(membership_hash)!
assert loaded_membership.hash == test_membership.hash
assert loaded_membership.fsid == test_membership.fsid
assert loaded_membership.blobid == test_membership.blobid
println('✓ Loaded blob membership: ${loaded_membership.hash} (Blob ID: ${loaded_membership.blobid})')
// Verify that loaded membership matches the original one
println('Verifying data integrity...')
assert loaded_membership.hash == test_blob.hash
println('✓ Blob membership data integrity check passed')
// Test exist method
println('Testing blob membership existence checks...')
mut exists := fs_factory.fs_blob_membership.exist(membership_hash)!
assert exists == true
println('✓ Blob membership exists: ${exists}')
// Test with non-existent hash
non_existent_hash := '0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef'
exists = fs_factory.fs_blob_membership.exist(non_existent_hash)!
assert exists == false
println('✓ Non-existent blob membership exists: ${exists}')
println('FsBlobMembership basic test completed successfully!')
}
fn test_filesystem_operations() ! {
println('Testing FsBlobMembership filesystem operations...')
defer {
test_cleanup() or { panic('cleanup failed: ${err.msg()}') }
}
// Initialize the HeroFS factory for test purposes
mut r := redisclient.test_get()!
mut fs_factory := new(redis: r)!
// Create filesystems for testing
mut fs1 := fs_factory.fs.new_get_set(
name: 'test_filesystem_1'
description: 'First filesystem for testing'
quota_bytes: 1024 * 1024 * 1024 // 1GB quota
)!
fs_factory.fs.set(fs1)!
fs1_id := fs1.id
mut fs2 := fs_factory.fs.new_get_set(
name: 'test_filesystem_2'
description: 'Second filesystem for testing'
quota_bytes: 1024 * 1024 * 1024 // 1GB quota
)!
fs_factory.fs.set(fs2)!
fs1_root_dir_id := fs1.root_dir_id
fs2_id := fs2.id
// Create test blob
test_data := 'This is test content for filesystem operations'.bytes()
mut test_blob := fs_factory.fs_blob.new(data: test_data)!
fs_factory.fs_blob.set(test_blob)!
blob_id := test_blob.id
// Create test files to get valid fsid (file IDs) for membership
mut test_file1 := fs_factory.fs_file.new(
name: 'test_file1.txt'
fs_id: fs1_id
blobs: [blob_id]
description: 'Test file 1 for blob membership'
mime_type: .txt
)!
test_file1 = fs_factory.fs_file.set(test_file1)!
file1_id := test_file1.id
println('Created test file 1 with ID: ${file1_id}')
// Add file to directory
mut fs1_root_dir := fs_factory.fs_dir.get(fs1.root_dir_id)!
fs1_root_dir.files << file1_id
fs_factory.fs_dir.set(fs1_root_dir)!
mut test_file2 := fs_factory.fs_file.new(
name: 'test_file2.txt'
fs_id: fs2_id
blobs: [blob_id]
description: 'Test file 2 for blob membership'
mime_type: .txt
)!
test_file2 = fs_factory.fs_file.set(test_file2)!
file2_id := test_file2.id
println('Created test file 2 with ID: ${file2_id}')
// Add file to directory
mut fs2_root_dir := fs_factory.fs_dir.get(fs2.root_dir_id)!
fs2_root_dir.files << file2_id
fs_factory.fs_dir.set(fs2_root_dir)!
// Create blob membership with first filesystem
mut membership := fs_factory.fs_blob_membership.new(
hash: test_blob.hash
fsid: [fs1_id]
blobid: blob_id
)!
fs_factory.fs_blob_membership.set(membership)!
membership_hash := membership.hash
println('Created blob membership with filesystem 1: ${membership_hash}')
// Test adding a filesystem to membership
println('Testing add_filesystem operation...')
// Add second filesystem
fs_factory.fs_blob_membership.add_filesystem(membership_hash, fs2_id)!
mut updated_membership := fs_factory.fs_blob_membership.get(membership_hash)!
// Verify both filesystems are in the list
assert updated_membership.fsid.len == 2
assert fs1_id in updated_membership.fsid
assert fs2_id in updated_membership.fsid
println('✓ Added filesystem 2 to blob membership')
// Test removing a filesystem from membership
println('Testing remove_filesystem operation...')
// Remove first filesystem
fs_factory.fs_blob_membership.remove_filesystem(membership_hash, fs1_id)!
mut updated_membership2 := fs_factory.fs_blob_membership.get(membership_hash)!
// Verify only second filesystem is in the list
assert updated_membership2.fsid.len == 1
assert updated_membership2.fsid[0] == fs2_id
println('✓ Removed filesystem 1 from blob membership')
// Test removing the last filesystem (should delete the membership)
fs_factory.fs_blob_membership.remove_filesystem(membership_hash, fs2_id)!
// Verify membership no longer exists
exists := fs_factory.fs_blob_membership.exist(membership_hash)!
assert exists == false
println('✓ Removed last filesystem and deleted blob membership')
println('FsBlobMembership filesystem operations test completed successfully!')
}
fn test_validation() ! {
println('Testing FsBlobMembership validation...')
defer {
test_cleanup() or { panic('cleanup failed: ${err.msg()}') }
}
// Initialize the HeroFS factory for test purposes
mut r := redisclient.test_get()!
mut fs_factory := new(redis: r)!
// Create a filesystem for validation tests
mut test_fs := fs_factory.fs.new_get_set(
name: 'validation_filesystem'
description: 'Filesystem for validation tests'
quota_bytes: 1024 * 1024 * 1024 // 1GB quota
)!
test_fs = fs_factory.fs.set(test_fs)!
fs_id := test_fs.id
// Test setting membership with non-existent blob (should fail)
println('Testing membership set with non-existent blob...')
// Create a membership with a non-existent blob ID
mut test_membership := fs_factory.fs_blob_membership.new(
hash: '0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef'
fsid: [test_fs.id]
blobid: 999999 // Non-existent blob ID
)!
// Try to save it, which should fail
fs_factory.fs_blob_membership.set(test_membership) or {
println('✓ Membership set correctly failed with non-existent blob')
return
}
panic('Validation should have failed for non-existent blob')
// Test setting membership with non-existent filesystem (should fail)
println('Testing membership set with non-existent filesystem...')
// Create a test blob
test_data := 'This is test content for validation'.bytes()
mut test_blob := fs_factory.fs_blob.new(data: test_data)!
fs_factory.fs_blob.set(test_blob)!
blob_id := test_blob.id
// Create a membership with a non-existent filesystem ID
mut test_membership2 := fs_factory.fs_blob_membership.new(
hash: test_blob.hash
fsid: [u32(999999)] // Non-existent filesystem ID
blobid: blob_id
)!
// Try to save it, which should fail
fs_factory.fs_blob_membership.set(test_membership2) or {
println('✓ Membership set correctly failed with non-existent filesystem')
return
}
panic('Validation should have failed for non-existent filesystem')
println('FsBlobMembership validation test completed successfully!')
}
fn test_list_by_prefix() ! {
println('
Testing FsBlobMembership list by prefix...')
defer {
test_cleanup() or { panic('cleanup failed: ${err.msg()}') }
}
// Initialize the HeroFS factory for test purposes
mut r := redisclient.test_get()!
mut fs_factory := new(redis: r)!
// Create a filesystem
mut test_fs := fs_factory.fs.new_get_set(
name: 'list_test_filesystem'
description: 'Filesystem for list testing'
quota_bytes: 1024 * 1024 * 1024 // 1GB quota
)!
test_fs = fs_factory.fs.set(test_fs)!
fs_id := test_fs.id
// Create root directory for the filesystem
mut root_dir := fs_factory.fs_dir.new(
name: 'root'
fs_id: fs_id
parent_id: 0 // Root has no parent
description: 'Root directory for testing'
)!
fs_factory.fs_dir.set(root_dir)!
root_dir_id := root_dir.id
// Update the filesystem with the root directory ID
test_fs.root_dir_id = root_dir_id
fs_factory.fs.set(test_fs)!
// Create multiple test blobs
test_data1 := 'This is test content 1'.bytes()
test_data2 := 'This is test content 2'.bytes()
test_data3 := 'This is test content 3'.bytes()
mut blob1 := fs_factory.fs_blob.new(data: test_data1)!
mut blob2 := fs_factory.fs_blob.new(data: test_data2)!
mut blob3 := fs_factory.fs_blob.new(data: test_data3)!
fs_factory.fs_blob.set(blob1)!
blob1_id := blob1.id
fs_factory.fs_blob.set(blob2)!
blob2_id := blob2.id
fs_factory.fs_blob.set(blob3)!
blob3_id := blob3.id
// Create test files to get valid fsid (file IDs) for membership
mut test_file := fs_factory.fs_file.new(
name: 'test_file.txt'
fs_id: fs_id
blobs: [blob1_id]
description: 'Test file for blob membership'
mime_type: .txt
)!
fs_factory.fs_file.set(test_file)!
file_id := test_file.id
println('Created test file with ID: ${file_id}')
// Create memberships with similar hashes (first 16 characters)
mut membership1 := fs_factory.fs_blob_membership.new(
hash: blob1.hash
fsid: [test_fs.id]
blobid: blob1_id
)!
membership1 = fs_factory.fs_blob_membership.set(membership1)!
membership1_hash := membership1.hash
mut membership2 := fs_factory.fs_blob_membership.new(
hash: blob2.hash
fsid: [test_fs.id]
blobid: blob2_id
)!
fs_factory.fs_blob_membership.set(membership2)!
membership2_hash := membership2.hash
mut membership3 := fs_factory.fs_blob_membership.new(
hash: blob3.hash
fsid: [test_fs.id]
blobid: blob3_id
)!
membership3 = fs_factory.fs_blob_membership.set(membership3)!
membership3_hash := membership3.hash
println('Created test memberships:')
println('- Membership 1 hash: ${membership1_hash}')
println('- Membership 2 hash: ${membership2_hash}')
println('- Membership 3 hash: ${membership3_hash}')
// Test listing by hash prefix
// Use first 16 characters of the first hash as prefix
prefix := membership1_hash[..16]
mut memberships := fs_factory.fs_blob_membership.list_prefix(prefix)!
// Should find at least one membership (membership1)
assert memberships.len >= 1
mut found := false
for membership in memberships {
if membership.hash == membership1.hash {
found = true
break
}
}
assert found == true
println('✓ Listed blob memberships by prefix: ${prefix}')
// Test with non-existent prefix
non_existent_prefix := '0000000000000000'
mut empty_memberships := fs_factory.fs_blob_membership.list_prefix(non_existent_prefix)!
assert empty_memberships.len == 0
println('✓ List with non-existent prefix returns empty array')
println('FsBlobMembership list by prefix test completed successfully!')
}

5
lib/hero/herofs/fs_dir.v
View File

@@ -110,8 +110,9 @@ pub fn (mut self DBFsDir) new(args FsDirArg) !FsDir {
return o
}
pub fn (mut self DBFsDir) set(mut o FsDir) ! {
self.db.set[FsDir](mut o)!
pub fn (mut self DBFsDir) set(o FsDir) !FsDir {
self.db.set[FsDir](o)!
return o
}
pub fn (mut self DBFsDir) delete(id u32) ! {

8
lib/hero/herofs/fs_file.v
View File

@@ -130,7 +130,9 @@ pub fn (mut self DBFsFile) new(args FsFileArg) !FsFile {
return o
}
pub fn (mut self DBFsFile) set(mut o FsFile) ! {
pub fn (mut self DBFsFile) set(o_ FsFile) !FsFile {
mut o := o_
// Check that blobs exist
for blob_id in o.blobs {
blob_exists := self.db.exists[FsBlob](blob_id)!
@@ -138,7 +140,9 @@ pub fn (mut self DBFsFile) set(mut o FsFile) ! {
return error('Blob with ID ${blob_id} does not exist')
}
}
self.db.set[FsFile](mut o)!
self.db.set[FsFile](o)!
return o
}
// add_to_directory adds a file to a directory's files list

5
lib/hero/herofs/fs_symlink.v
View File

@@ -79,7 +79,7 @@ pub fn (mut self DBFsSymlink) new(args FsSymlinkArg) !FsSymlink {
return o
}
pub fn (mut self DBFsSymlink) set(mut o FsSymlink) ! {
pub fn (mut self DBFsSymlink) set(o FsSymlink) !FsSymlink {
// Check parent directory exists
if o.parent_id > 0 {
parent_exists := self.db.exists[FsDir](o.parent_id)!
@@ -101,7 +101,8 @@ pub fn (mut self DBFsSymlink) set(mut o FsSymlink) ! {
}
}
self.db.set[FsSymlink](mut o)!
self.db.set[FsSymlink](o)!
return o
}
pub fn (mut self DBFsSymlink) delete(id u32) ! {