From 3f62410c524fd647c083f7225251e3b09808c6bb Mon Sep 17 00:00:00 2001
From: George Abbott <george@gabbott.dev>
Date: Sun, 26 Jan 2025 11:37:33 +0000
Subject: strbuilder

---
 scripts/strbuilder/src/root.zig | 113 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 113 insertions(+)
 create mode 100644 scripts/strbuilder/src/root.zig

(limited to 'scripts/strbuilder/src/root.zig')

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);
+}
-- 
cgit v1.2.1