Making things work properly

src/file.zig

@@ -14,32 +14,12 @@ const FileError = error{
 };
 
 pub const File = struct {
-    reader: *Reader,
     name: []const u8,
     inode: inode.Inode,
 
-    pub fn fromRef(read: *Reader, ref: inode.InodeRef, name: []const u8) !File {
-        var meta_rdr: MetadataReader = try .init(
-            read.arena.allocator(),
-            read.holder.anyAt(ref.block_start + read.super.inode_table_start),
-            read.super.decomp,
-        );
-        defer meta_rdr.deinit();
-        try meta_rdr.skip(ref.offset);
-        return .{
-            .reader = read,
-            .name = name,
-            .inode = try .init(
-                read.arena.allocator(),
-                meta_rdr.any(),
-                read.super.block_size,
-            ),
-        };
-    }
-
     // pub fn fromDirEntry(read: Reader, ent: DirEntry) !File {}
 
-    pub fn open(self: File, path: []const u8) !File {
+    pub fn open(self: File, reader: *Reader, path: []const u8) !File {
         if (path.len == 0 || std.mem.eql(u8, path, ".")) {
             return self;
         }
@@ -47,6 +27,7 @@ pub const File = struct {
             .dir, .ext_dir => {},
             else => return FileError.NotDirectory,
         }
+        _ = reader;
         //TODO: read dir entries and find correct inode and file
     }
 

src/reader.zig

@@ -1,8 +1,11 @@
 const std = @import("std");
 
+const inode = @import("inode/inode.zig");
+
 const FileHolder = @import("readers/file_holder.zig").FileHolder;
 const Superblock = @import("superblock.zig").Superblock;
 const File = @import("file.zig").File;
+const MetadataReader = @import("readers/metadata.zig").MetadataReader;
 
 pub const Reader = struct {
     arena: std.heap.ArenaAllocator,
@@ -12,7 +15,7 @@ pub const Reader = struct {
 
     pub fn init(alloc: std.mem.Allocator, filepath: []const u8, offset: u64) !Reader {
         var holder: FileHolder = try .init(filepath, offset);
-        const super: Superblock = try holder.anyAt(0).readStruct(Superblock);
+        const super: Superblock = try holder.reader().readStruct(Superblock);
         try super.validate();
         const arena: std.heap.ArenaAllocator = .init(alloc);
         var out: Reader = .{
@@ -21,13 +24,32 @@ pub const Reader = struct {
             .super = super,
             .root = undefined,
         };
-        out.root = try .fromRef(&out, super.root_ref, "");
+        out.root = try out.fileFromRef(super.root_ref, "");
         return out;
     }
-    pub fn deinit(self: *const Reader) void {
+    pub fn deinit(self: *Reader) void {
         self.arena.deinit();
         self.holder.deinit();
     }
+
+    fn fileFromRef(self: *Reader, ref: inode.InodeRef, name: []const u8) !File {
+        var offset_rdr = self.holder.readerAt(ref.block_start + self.super.inode_table_start);
+        var meta_rdr: MetadataReader = try .init(
+            self.arena.allocator(),
+            offset_rdr.any(),
+            self.super.decomp,
+        );
+        defer meta_rdr.deinit();
+        try meta_rdr.skip(ref.offset);
+        return .{
+            .name = name,
+            .inode = try .init(
+                self.arena.allocator(),
+                meta_rdr.any(),
+                self.super.block_size,
+            ),
+        };
+    }
 };
 
 test "reader" {

src/readers/file_holder.zig

@@ -7,9 +7,8 @@ pub const FileHolder = struct {
     offset: u64,
 
     pub fn init(path: []const u8, offset: u64) !FileHolder {
-        const fil = try fs.cwd().openFile(path, .{ .mode = .read_write });
         return .{
-            .file = fil,
+            .file = try fs.cwd().openFile(path, .{ .mode = .read_write }),
             .offset = offset,
         };
     }
@@ -17,26 +16,27 @@ pub const FileHolder = struct {
         self.file.close();
     }
 
-    pub fn anyAt(self: *FileHolder, offset: u64) io.AnyReader {
+    pub fn reader(self: *FileHolder) fs.File.Reader {
-        var offsetRdr = FileOffsetReader{
+        return self.file.reader();
-            .file = self.file,
+    }
+    pub fn readerAt(self: *FileHolder, offset: u64) FileOffsetReader {
+        return .{
+            .file = &self.file,
             .offset = self.offset + offset,
         };
-        return offsetRdr.any();
     }
 };
 
 const FileOffsetReader = struct {
-    file: fs.File,
+    file: *fs.File,
     offset: u64,
 
-    fn read(self: *FileOffsetReader, bytes: []u8) !usize {
+    pub fn read(self: *FileOffsetReader, bytes: []u8) !usize {
-        std.debug.print("yo {}\n", .{self.file.open()});
         const red = try self.file.preadAll(bytes, self.offset);
         self.offset += red;
         return red;
     }
-    fn any(self: *FileOffsetReader) io.AnyReader {
+    pub fn any(self: *FileOffsetReader) io.AnyReader {
         return .{
             .context = @ptrCast(self),
             .readFn = readOpaque,