initial commit

src/file_op.zig

@@ -0,0 +1,66 @@
+const std = @import("std");
+const fs = std.fs;
+
+const FileRead = struct {
+    file: fs.File,
+    tasks: std.ArrayList([]u8),
+};
+
+pub fn readTasksFromFile(allocator: std.mem.Allocator, filename: []const u8) !FileRead {
+    var tasks = std.ArrayList([]u8).init(allocator);
+
+    var file = fs.cwd().openFile(filename, .{ .mode = .read_write }) catch |err| {
+        if (err == error.FileNotFound) {
+            std.debug.print("File not found: {s}\n", .{filename});
+            // todo needs to be closed eventually
+            const new_file = fs.cwd().createFile(filename, .{}) catch |e| {
+                std.debug.print("Failed to create the file: {}", .{e});
+                return e;
+            };
+
+            return FileRead{
+                .file = new_file,
+                .tasks = tasks,
+            };
+        } else {
+            std.debug.print("Failed to open the file: {s}, error: {}\n", .{ filename, err });
+            return err;
+        }
+    };
+
+    // wrap the file reader in a buffered reader
+    // since it's usually faster to read a bunch of bytes at once.
+    var buf_reader = std.io.bufferedReader(file.reader());
+    const reader = buf_reader.reader();
+
+    var line = std.ArrayList(u8).init(allocator);
+    defer line.deinit();
+
+    const writer = line.writer();
+
+    while (reader.streamUntilDelimiter(writer, '\n', null)) {
+        // clear the line so we can reuse it
+        defer line.clearRetainingCapacity();
+
+        const copy = try allocator.dupe(u8, line.items);
+        try tasks.append(copy);
+    } else |err| switch (err) {
+        error.EndOfStream => {
+            // end of file
+            if (line.items.len > 0) {
+                const copy = try allocator.dupe(u8, line.items);
+                try tasks.append(copy);
+            }
+        },
+        else => return err, //propagate error
+    }
+
+    return FileRead{ .file = file, .tasks = tasks };
+}
+
+pub fn writeTasksToFile(file_system: FileRead) !void {
+    for (file_system.tasks.items) |item| {
+        try file_system.file.writeAll(item);
+        try file_system.file.writeAll("\n");
+    }
+}

src/main.zig

@@ -0,0 +1,60 @@
+const std = @import("std");
+const file_op = @import("file_op.zig");
+
+pub fn main() !void {
+    const filename = "todo-db.txt";
+    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    defer _ = gpa.deinit();
+    const allocator = gpa.allocator();
+
+    var file_res = file_op.readTasksFromFile(allocator, filename) catch |err| {
+        std.debug.print("Failed read or create file, exiting ...", .{});
+        return err;
+    };
+
+    defer {
+        for (file_res.tasks.items) |task| {
+            allocator.free(task);
+        }
+        file_res.tasks.deinit();
+        file_res.file.close();
+    }
+
+    std.debug.print("Reading from file:\n", .{});
+    for (file_res.tasks.items) |i| {
+        std.debug.print("{s}\n", .{i});
+    }
+
+    try userInteraction();
+
+    file_op.writeTasksToFile(file_res) catch |err| {
+        std.debug.print("Error while writing data to file:\n{}", .{err});
+    };
+}
+
+fn userInteraction() !void {
+    const stdin = std.io.getStdIn().reader();
+    const stdout = std.io.getStdOut().writer();
+    // var buf: [100]u8 = undefined;
+
+    while (true) {
+        try stdout.print("Please enter your choice add/remove/edit/quit: ", .{});
+        const bare_line = try stdin.readUntilDelimiterAlloc(std.heap.page_allocator, '\n', 8192);
+        defer std.heap.page_allocator.free(bare_line);
+        // windows legacy
+        const line = std.mem.trim(u8, bare_line, "\r");
+        std.debug.print("You entered: {s}\n", .{line});
+
+        const Case = enum { add, edit, delete, quit };
+        const case = std.meta.stringToEnum(Case, line) orelse return;
+
+        switch (case) {
+            .add => {},
+            .edit => {},
+            .delete => {},
+            .quit => break,
+        }
+
+        //break;
+    }
+}