strbuilder

2 files changed, 137 insertions, 0 deletions

diff --git a/scripts/strbuilder/src/main.zig b/scripts/strbuilder/src/main.zig
new file mode 100644
index 0000000..c8a3f67
--- /dev/null
+++ b/scripts/strbuilder/src/main.zig
@@ -0,0 +1,24 @@
+const std = @import("std");
+
+pub fn main() !void {
+    // Prints to stderr (it's a shortcut based on `std.io.getStdErr()`)
+    std.debug.print("All your {s} are belong to us.\n", .{"codebase"});
+
+    // stdout is for the actual output of your application, for example if you
+    // are implementing gzip, then only the compressed bytes should be sent to
+    // stdout, not any debugging messages.
+    const stdout_file = std.io.getStdOut().writer();
+    var bw = std.io.bufferedWriter(stdout_file);
+    const stdout = bw.writer();
+
+    try stdout.print("Run `zig build test` to run the tests.\n", .{});
+
+    try bw.flush(); // don't forget to flush!
+}
+
+test "simple test" {
+    var list = std.ArrayList(i32).init(std.testing.allocator);
+    defer list.deinit(); // try commenting this out and see if zig detects the memory leak!
+    try list.append(42);
+    try std.testing.expectEqual(@as(i32, 42), list.pop());
+}
diff --git a/scripts/strbuilder/src/root.zig b/scripts/strbuilder/src/root.zig
new file mode 100644
index 0000000..bcaf445
--- /dev/null
+++ b/scripts/strbuilder/src/root.zig
@@ -0,0 +1,113 @@
+const std = @import("std");
+const testing = std.testing;
+const Allocator = std.heap.Allocator;
+const ArrayList = std.ArrayList;
+
+// Considerations
+// When doing replaces, each replace may need to factor in previous replaces, deletes, etc.
+// E.g. the text "Hi (Deletedah) ahThere" will be -2 bytes with replace("ah", "") after the
+// deletion has occurred, but if naively written, then -4 bytes will be calculated for.
+
+const OpTag = enum {
+    append,
+    prepend,
+    insert,
+    replace_all,
+};
+
+const Op = union(OpTag) {
+    append: struct { s: []const u8 },
+    prepend: struct { s: []const u8 },
+    insert: struct { pos: usize, s: []const u8 },
+    replace_all: struct { old: []const u8, new: []const u8, additional_bytes_to_allocate: isize },
+};
+
+// TODO
+export const StrBuilder = struct {
+    allocator: Allocator,
+    ops: ArrayList(Op),
+    base: []const u8,
+
+    pub fn new(allocator: Allocator, base: []const u8) StrBuilder {
+        var ret = StrBuilder{};
+        ret.allocator = allocator;
+        ret.ops = ArrayList(Op).init(allocator);
+        ret.base = base;
+
+        return ret;
+    }
+
+    pub fn build(self: StrBuilder) []const u8 {
+        // TODO
+    }
+
+    pub fn deinit(self: StrBuilder) void {
+        self.ops.deinit();
+    }
+
+    pub fn append(self: StrBuilder, s: []const u8) void {
+        self.ops.append(Op{ .append = .{ .s = s } });
+    }
+    pub fn prepend(self: StrBuilder, s: []const u8) void {
+        self.ops.append(Op{ .prepend = .{ .s = s } });
+    }
+    pub fn insert(self: StrBuilder, pos: usize, s: []const u8) void {
+        self.ops.append(Op{ .insert = .{ .pos = pos, .s = s } });
+    }
+    pub fn replaceAll(self: StrBuilder, old_str: []const u8, new_str: []const u8) void {
+        // TODO: find count of `old` and store the additional allocatable size in the enum(union).
+        // Signed (isize) so as to allow the case when old.len > new.len.
+        const additional_bytes_req: isize = std.mem.count(u8, self.base, self.old) * (new.len - old.len);
+        self.ops.append(Op{ .replace_all = .{ .old = old_str, .new = new_str, .additional_bytes_to_allocate = additional_bytes_req } });
+    }
+    /// If the line matches the given predicate, delete the line.
+    pub fn deleteLineIf(self: StrBuilder, pred: fn (line: []const u8) bool) void {
+        // TODO
+    }
+
+    /// Replaces a prefix in all lines if the line begins with said prefix.
+    pub fn replacePrefixLinewise(self: StrBuilder, old_prefix: []const u8, new_prefix: []const u8) void {
+        // TODO
+    }
+
+    // Used for replacing text of the form: P*I*S where P is a common prefix, I
+    // an infix, and S a suffix. Any text can occur in * (though consider opts).
+    // Useful, e.g. to turn @@[text][href] into <a href="href">text</a>.
+    pub const ReplaceBipartOpts = struct {
+        allowNewline: bool,
+    };
+    pub fn replaceBipart(
+        self: StrBuilder,
+        p: []const u8,
+        i: []const u8,
+        s: []const u8,
+        new_p: []const u8,
+        new_i: []const u8,
+        new_s: []const u8,
+        opts: ReplaceBipartOpts,
+    ) void {
+        // TODO
+    }
+
+    pub fn calculateSizeToAllocate(self: StrBuilder) usize {
+        var diff: isize = 0;
+        for (self.ops.items) |op| {
+            switch (op) {
+                OpTag.append, OpTag.prepend => |s| {
+                    diff += s.len;
+                },
+                OpTag.insert => |c| {
+                    diff += c.s.len;
+                },
+                OpTag.replace_all => |c| {
+                    diff += c.additional_bytes_to_allocate;
+                },
+            }
+        }
+        return self.base.len + diff;
+    }
+};
+
+test "basic add functionality" {
+    try testing.expect(add(3, 7) == 10);
+}