feat: base project

build.zig

@@ -0,0 +1,75 @@
+const std = @import("std");
+
+// Although this function looks imperative, note that its job is to
+// declaratively construct a build graph that will be executed by an external
+// runner.
+pub fn build(b: *std.Build) void {
+    // Standard target options allows the person running `zig build` to choose
+    // what target to build for. Here we do not override the defaults, which
+    // means any target is allowed, and the default is native. Other options
+    // for restricting supported target set are available.
+    const target = b.standardTargetOptions(.{});
+
+    // Standard optimization options allow the person running `zig build` to select
+    // between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall. Here we do not
+    // set a preferred release mode, allowing the user to decide how to optimize.
+    const optimize = b.standardOptimizeOption(.{});
+
+    // We will also create a module for our other entry point, 'main.zig'.
+    const exe_mod = b.createModule(.{
+        // `root_source_file` is the Zig "entry point" of the module. If a module
+        // only contains e.g. external object files, you can make this `null`.
+        // In this case the main source file is merely a path, however, in more
+        // complicated build scripts, this could be a generated file.
+        .root_source_file = b.path("src/main.zig"),
+        .target = target,
+        .optimize = optimize,
+    });
+
+    // This creates another `std.Build.Step.Compile`, but this one builds an executable
+    // rather than a static library.
+    const exe = b.addExecutable(.{
+        .name = "FileTime3",
+        .root_module = exe_mod,
+    });
+
+    // This declares intent for the executable to be installed into the
+    // standard location when the user invokes the "install" step (the default
+    // step when running `zig build`).
+    b.installArtifact(exe);
+
+    // This *creates* a Run step in the build graph, to be executed when another
+    // step is evaluated that depends on it. The next line below will establish
+    // such a dependency.
+    const run_cmd = b.addRunArtifact(exe);
+
+    // By making the run step depend on the install step, it will be run from the
+    // installation directory rather than directly from within the cache directory.
+    // This is not necessary, however, if the application depends on other installed
+    // files, this ensures they will be present and in the expected location.
+    run_cmd.step.dependOn(b.getInstallStep());
+
+    // This allows the user to pass arguments to the application in the build
+    // command itself, like this: `zig build run -- arg1 arg2 etc`
+    if (b.args) |args| {
+        run_cmd.addArgs(args);
+    }
+
+    // This creates a build step. It will be visible in the `zig build --help` menu,
+    // and can be selected like this: `zig build run`
+    // This will evaluate the `run` step rather than the default, which is "install".
+    const run_step = b.step("run", "Run the app");
+    run_step.dependOn(&run_cmd.step);
+
+    const exe_unit_tests = b.addTest(.{
+        .root_module = exe_mod,
+    });
+
+    const run_exe_unit_tests = b.addRunArtifact(exe_unit_tests);
+
+    // Similar to creating the run step earlier, this exposes a `test` step to
+    // the `zig build --help` menu, providing a way for the user to request
+    // running the unit tests.
+    const test_step = b.step("test", "Run unit tests");
+    test_step.dependOn(&run_exe_unit_tests.step);
+}

build.zig.zon

@@ -0,0 +1,86 @@
+.{
+    // This is the default name used by packages depending on this one. For
+    // example, when a user runs `zig fetch --save <url>`, this field is used
+    // as the key in the `dependencies` table. Although the user can choose a
+    // different name, most users will stick with this provided value.
+    //
+    // It is redundant to include "zig" in this name because it is already
+    // within the Zig package namespace.
+    .name = .FileTime3,
+
+    // This is a [Semantic Version](https://semver.org/).
+    // In a future version of Zig it will be used for package deduplication.
+    .version = "0.0.0",
+
+    // Together with name, this represents a globally unique package
+    // identifier. This field is generated by the Zig toolchain when the
+    // package is first created, and then *never changes*. This allows
+    // unambiguous detection of one package being an updated version of
+    // another.
+    //
+    // When forking a Zig project, this id should be regenerated (delete the
+    // field and run `zig build`) if the upstream project is still maintained.
+    // Otherwise, the fork is *hostile*, attempting to take control over the
+    // original project's identity. Thus it is recommended to leave the comment
+    // on the following line intact, so that it shows up in code reviews that
+    // modify the field.
+    .fingerprint = 0xfce21aceb907b72f, // Changing this has security and trust implications.
+
+    // Tracks the earliest Zig version that the package considers to be a
+    // supported use case.
+    .minimum_zig_version = "0.14.0",
+
+    // This field is optional.
+    // Each dependency must either provide a `url` and `hash`, or a `path`.
+    // `zig build --fetch` can be used to fetch all dependencies of a package, recursively.
+    // Once all dependencies are fetched, `zig build` no longer requires
+    // internet connectivity.
+    .dependencies = .{
+        // See `zig fetch --save <url>` for a command-line interface for adding dependencies.
+        //.example = .{
+        //    // When updating this field to a new URL, be sure to delete the corresponding
+        //    // `hash`, otherwise you are communicating that you expect to find the old hash at
+        //    // the new URL. If the contents of a URL change this will result in a hash mismatch
+        //    // which will prevent zig from using it.
+        //    .url = "https://example.com/foo.tar.gz",
+        //
+        //    // This is computed from the file contents of the directory of files that is
+        //    // obtained after fetching `url` and applying the inclusion rules given by
+        //    // `paths`.
+        //    //
+        //    // This field is the source of truth; packages do not come from a `url`; they
+        //    // come from a `hash`. `url` is just one of many possible mirrors for how to
+        //    // obtain a package matching this `hash`.
+        //    //
+        //    // Uses the [multihash](https://multiformats.io/multihash/) format.
+        //    .hash = "...",
+        //
+        //    // When this is provided, the package is found in a directory relative to the
+        //    // build root. In this case the package's hash is irrelevant and therefore not
+        //    // computed. This field and `url` are mutually exclusive.
+        //    .path = "foo",
+        //
+        //    // When this is set to `true`, a package is declared to be lazily
+        //    // fetched. This makes the dependency only get fetched if it is
+        //    // actually used.
+        //    .lazy = false,
+        //},
+    },
+
+    // Specifies the set of files and directories that are included in this package.
+    // Only files and directories listed here are included in the `hash` that
+    // is computed for this package. Only files listed here will remain on disk
+    // when using the zig package manager. As a rule of thumb, one should list
+    // files required for compilation plus any license(s).
+    // Paths are relative to the build root. Use the empty string (`""`) to refer to
+    // the build root itself.
+    // A directory listed here means that all files within, recursively, are included.
+    .paths = .{
+        "build.zig",
+        "build.zig.zon",
+        "src",
+        // For example...
+        //"LICENSE",
+        //"README.md",
+    },
+}

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();
+        }
+    }
+};