feat: base project

src/core/consts.zig

@@ -0,0 +1 @@
+pub const PathSeparator: []const u8 = "/";

src/core/deinit.zig

@@ -0,0 +1,42 @@
+const std = @import("std");
+const Mutex = std.Thread.Mutex;
+
+const Error = error{
+    Deinitialized,
+};
+
+pub const DeinitTracker = struct {
+    allocator: std.mem.Allocator,
+    deinited: bool,
+    usageCount: u16,
+    mutex: Mutex,
+
+    pub fn init(self: *DeinitTracker, allocator: std.mem.Allocator) void {
+        self.* = .{
+            .allocator = allocator,
+            .deinited = false,
+            .usageCount = 1,
+            .mutex = Mutex{},
+        };
+    }
+
+    pub fn use(self: *DeinitTracker) Error!void {
+        self.mutex.lock();
+        defer self.mutex.unlock();
+
+        if (self.deinited) return Error.Deinitialized;
+
+        self.usageCount += 1;
+    }
+
+    pub fn unuse(self: *DeinitTracker) void {
+        self.mutex.lock();
+        defer self.mutex.unlock();
+
+        self.usageCount -= 1;
+
+        if (self.usageCount == 0) {
+            self.allocator.destroy(self);
+        }
+    }
+};

src/core/models.zig

@@ -0,0 +1,97 @@
+const std = @import("std");
+const Provider = @import("provider/provider.zig").Provider;
+const DeinitTracker = @import("deinit.zig").DeinitTracker;
+const consts = @import("consts.zig");
+
+pub const Item = struct {
+    allocator: std.mem.Allocator,
+    provider: Provider,
+    deinitTracker: *DeinitTracker,
+    name: []const u8,
+    displayName: []const u8,
+    fullName: FullName,
+    nativePath: NativePath,
+    parent: ?AbsolutePath,
+    item: ItemEnum,
+    errors: std.ArrayList(Error),
+    deiniting: bool = false,
+    deinited: bool = false,
+
+    pub fn deinit(self: *Item) void {
+        if (self.deinited) return;
+        self.deiniting = true;
+
+        self.allocator.free(self.name);
+        self.allocator.free(self.displayName);
+        self.allocator.free(self.fullName.path);
+        self.allocator.free(self.nativePath.path);
+        self.deinitTracker.deinited = true;
+        self.deinitTracker.unuse();
+        for (self.errors.items) |e| {
+            self.allocator.free(e.content);
+        }
+        self.item.deinit();
+        self.deinited = true;
+    }
+};
+
+pub const ItemEnum = union(enum) {
+    container: *Container,
+    element: *Element,
+    pub fn deinit(self: ItemEnum) void {
+        switch (self) {
+            .container => |c| c.deinit(),
+            .element => |e| e.deinit(),
+        }
+    }
+};
+
+pub const Element = struct {
+    item: Item,
+
+    fn deinit(self: *Element) void {
+        self.item.allocator.destroy(self);
+    }
+};
+
+pub const Container = struct {
+    item: Item,
+
+    children: std.ArrayList(FullName),
+    childrenLoading: bool,
+    fn deinit(self: *Container) void {
+        for (self.children.items) |itemFullName| {
+            self.item.allocator.free(itemFullName.path);
+        }
+        self.children.deinit();
+        self.item.allocator.destroy(self);
+    }
+};
+
+pub const FullName = struct {
+    path: []const u8,
+
+    pub fn getChild(self: *FullName, childName: []const u8, allocator: std.mem.Allocator) !FullName {
+        const path = try std.fmt.allocPrint(allocator, "{s}{s}{s}", .{ self.path, consts.PathSeparator, childName });
+
+        return FullName{ .path = path };
+    }
+};
+
+pub const NativePath = struct {
+    path: []const u8,
+};
+
+pub const AbsolutePath = struct {
+    path: []const u8,
+    type: AbsolutePathType,
+};
+
+pub const Error = struct {
+    content: []const u8,
+};
+
+pub const AbsolutePathType = enum {
+    Container,
+    Item,
+};

src/core/provider/local.zig

@@ -0,0 +1,141 @@
+const std = @import("std");
+const models = @import("../models.zig");
+const Provider = @import("provider.zig").Provider;
+const ProviderVTable = @import("provider.zig").VTable;
+const GetItemsError = @import("provider.zig").GetItemsError;
+const DeinitTracker = @import("../deinit.zig").DeinitTracker;
+
+const FullName = models.FullName;
+const Item = models.Item;
+const ItemEnum = models.ItemEnum;
+const Element = models.Element;
+const Container = models.Container;
+
+fn loadChildren(container: *Container, deinitTracker: *DeinitTracker) void {
+    defer {
+        if (!deinitTracker.deinited)
+            container.childrenLoading = false;
+    }
+
+    deinitTracker.use() catch {
+        std.debug.print("already deinitialized", .{});
+        return;
+    };
+    defer deinitTracker.unuse();
+
+    var dir = std.fs.cwd().openDir(container.item.nativePath.path, .{ .iterate = true }) catch {
+        if (deinitTracker.deinited) return;
+
+        const errorContent = std.fmt.allocPrint(container.item.allocator, "Could not open directory '{s}'.", .{container.item.nativePath.path}) catch return;
+        container.item.errors.append(.{ .content = errorContent }) catch return;
+        return;
+    };
+    defer dir.close();
+
+    var it = dir.iterate();
+    while (it.next() catch return) |entry| {
+        const child = container.item.fullName.getChild(entry.name, container.item.allocator) catch return;
+        if (deinitTracker.deinited) return;
+        container.children.append(child) catch return;
+    }
+}
+
+const VTable: ProviderVTable = .{
+    .getItemByFullName = getItemByFullNameGeneric,
+};
+
+pub fn getItemByFullNameGeneric(
+    context: *anyopaque,
+    fullName: FullName,
+    allocator: std.mem.Allocator,
+    globalAllocator: std.mem.Allocator,
+) GetItemsError!Item {
+    const self: *LocalContentProvider = @ptrCast(@alignCast(context));
+    return self.getItemByFullName(fullName, allocator, globalAllocator);
+}
+
+pub const LocalContentProvider = struct {
+    threadPool: *std.Thread.Pool,
+
+    pub fn getItemByFullName(
+        self: *LocalContentProvider,
+        fullName: FullName,
+        allocator: std.mem.Allocator,
+        globalAllocator: std.mem.Allocator,
+    ) GetItemsError!Item {
+        const stat = std.fs.cwd().statFile(fullName.path) catch return GetItemsError.NotExists;
+        var deinitTracker = try globalAllocator.create(DeinitTracker);
+        deinitTracker.init(globalAllocator);
+
+        const basename = std.fs.path.basename(fullName.path);
+
+        const name = try allocator.alloc(u8, basename.len);
+        @memcpy(name, basename);
+
+        const displayName = try allocator.alloc(u8, basename.len);
+        @memcpy(displayName, basename);
+
+        const fullName2 = try allocator.alloc(u8, fullName.path.len);
+        @memcpy(fullName2, fullName.path);
+
+        const nativePath = try allocator.alloc(u8, fullName.path.len);
+        @memcpy(nativePath, fullName.path);
+
+        var item = Item{
+            .allocator = allocator,
+            .provider = self.provider(),
+            .deinitTracker = deinitTracker,
+            .name = name,
+            .displayName = displayName,
+            .fullName = .{ .path = fullName2 },
+            .nativePath = models.NativePath{ .path = nativePath },
+            .parent = null,
+            .item = undefined,
+            .errors = std.ArrayList(models.Error).init(allocator),
+        };
+
+        const innerItem: ItemEnum = switch (stat.kind) {
+            .directory => blk: {
+                const container = try allocator.create(Container);
+                container.* = Container{
+                    .children = std.ArrayList(FullName).init(allocator),
+                    .childrenLoading = true,
+                    .item = item,
+                };
+
+                const val: ItemEnum = .{
+                    .container = container,
+                };
+
+                try self.threadPool.spawn(loadChildren, .{ container, deinitTracker });
+
+                break :blk val;
+            },
+            .file => blk: {
+                const element = try allocator.create(Element);
+                element.* = Element{
+                    .item = item,
+                };
+
+                const val: ItemEnum = .{
+                    .element = element,
+                };
+                break :blk val;
+            },
+            else => @panic(
+                "Unsupported file type\n",
+            ),
+        };
+
+        item.item = innerItem;
+
+        return item;
+    }
+
+    pub fn provider(self: *LocalContentProvider) Provider {
+        return Provider{
+            .object = self,
+            .vtable = &VTable,
+        };
+    }
+};

src/core/provider/provider.zig

@@ -0,0 +1,32 @@
+pub const VTable = struct {
+    getItemByFullName: *const fn (
+        self: *anyopaque,
+        fullName: FullName,
+        allocator: std.mem.Allocator,
+        globalAllocator: std.mem.Allocator,
+    ) GetItemsError!Item,
+};
+
+pub const GetItemsError = error{
+    OutOfMemory,
+    NotExists,
+};
+
+pub const Provider = struct {
+    object: *anyopaque,
+    vtable: *const VTable,
+
+    pub inline fn getItemByFullName(
+        self: *const Provider,
+        fullName: FullName,
+        allocator: std.mem.Allocator,
+        globalAllocator: std.mem.Allocator,
+    ) GetItemsError!Item {
+        return &self.vtable.getItemByFullName(self.object, fullName, allocator, globalAllocator);
+    }
+};
+
+const std = @import("std");
+const models = @import("../models.zig");
+const Item = models.Item;
+const FullName = models.FullName;

src/core/tab/tab.zig

@@ -0,0 +1,65 @@
+const std = @import("std");
+const assert = std.debug.assert;
+const Mutex = std.Thread.Mutex;
+
+const models = @import("../models.zig");
+const Container = models.Container;
+const Item = models.Item;
+
+pub const Tab = struct {
+    allocator: std.mem.Allocator,
+    currentLocation: ?*Container,
+    currentItems: ?std.ArrayList(Item),
+    threadPool: *std.Thread.Pool,
+    _private: Private,
+
+    const Private = struct {
+        currentItemsAllocator: ?std.heap.ArenaAllocator,
+    };
+
+    pub fn create(
+        threadPool: *std.Thread.Pool,
+        allocator: std.mem.Allocator,
+    ) Tab {
+        return Tab{
+            .allocator = allocator,
+            .currentItems = null,
+            .currentLocation = null,
+            .threadPool = threadPool,
+            ._private = .{
+                .currentItemsAllocator = null,
+            },
+        };
+    }
+
+    pub fn setCurrentLocation(self: *Tab, newLocation: *Container) void {
+        if (self.currentLocation) |c| {
+            c.item.deinit();
+        }
+
+        self.currentLocation = newLocation;
+
+        //TODO: Proper error handling
+        std.Thread.Pool.spawn(self.threadPool, loadItems, .{ self, newLocation }) catch unreachable;
+    }
+
+    fn loadItems(self: *Tab, location: *Container) void {
+        if (self._private.currentItemsAllocator) |arena| {
+            arena.deinit();
+        }
+
+        self._private.currentItemsAllocator = std.heap.ArenaAllocator.init(self.allocator);
+        for (location.children.items) |item| {
+            _ = item;
+        }
+    }
+
+    pub fn deinit(self: *Tab) void {
+        if (self.currentLocation) |c| {
+            c.deinit();
+        }
+        if (self._private.currentItemsAllocator) |arena| {
+            arena.deinit();
+        }
+    }
+};