new file mode 100644

@@ -0,0 +1,2 @@

+#eval "$(lorri direnv)"

+use flake

new file mode 100644

@@ -0,0 +1,4 @@

+.direnv

+zig-out

+zig-cache

+*~

new file mode 100644

@@ -0,0 +1,42 @@

+#+TITLE: socket-based command runner

+#+TAGS: utilities

+#+AUTHOR: Ed Langley

+

+** Introduction

+

+Run a command everytime a line is written to a unix socket, passing

+the line written as the last argument to the command. Useful in an

+=after-save-hook= in emacs to run tests after the buffer is saved.

+Unlike file-watchers, this allows more precise control of when the

+tests are run, reducing the amount of time spent configuring ignore

+files and waiting for spurious reruns.

+

+** Building

+

+#+BEGIN_SRC zsh :results output :post proc

+  zig build --verbose 2>&1

+#+END_SRC

+

+** Usage

+

+#+BEGIN_SRC zsh

+rm /tmp/jest.sock ; $OLDPWD/zig-out/bin/zig-test /tmp/jest.sock npx jest --

+#+END_SRC

+

+#+NAME: proc

+#+BEGIN_SRC elisp :exports none

+  (defun fix (fn inp)

+    (cl-loop for old = inp then new

+             for new = (funcall fn inp)

+             until (equal new old)

+             finally (cl-return new)))

+  (s-join

+   "\n"

+   (funcall (fwoar/over (lambda (it)

+                          (    (lambda (v)

+                                 (s-replace-regexp " \\(--\\|#\\)" " \\\\\n  \\1" v))

+                               (s-replace-regexp "/nix/store/[^/]*/\\(.* \\)"

+                                                 "/nix/.../\\1"

+                                                 (s-replace "/Users/edwlan" "~" it)))))

+            (s-lines (s-trim *this*))))

+#+END_SRC

new file mode 100644

@@ -0,0 +1,34 @@

+const std = @import("std");

+

+pub fn build(b: *std.build.Builder) 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 release options allow the person running `zig build` to select

+    // between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall.

+    const mode = b.standardReleaseOptions();

+

+    const exe = b.addExecutable("sigexec", "src/main.zig");

+    exe.setTarget(target);

+    exe.setBuildMode(mode);

+    exe.install();

+

+    const run_cmd = exe.run();

+    run_cmd.step.dependOn(b.getInstallStep());

+    if (b.args) |args| {

+        run_cmd.addArgs(args);

+    }

+

+    const run_step = b.step("run", "Run the app");

+    run_step.dependOn(&run_cmd.step);

+

+    const exe_tests = b.addTest("src/main.zig");

+    exe_tests.setTarget(target);

+    exe_tests.setBuildMode(mode);

+

+    const test_step = b.step("test", "Run unit tests");

+    test_step.dependOn(&exe_tests.step);

+}

new file mode 100644

@@ -0,0 +1,95 @@

+{

+  "nodes": {

+    "flake-compat": {

+      "flake": false,

+      "locked": {

+        "lastModified": 1648199409,

+        "narHash": "sha256-JwPKdC2PoVBkG6E+eWw3j6BMR6sL3COpYWfif7RVb8Y=",

+        "owner": "edolstra",

+        "repo": "flake-compat",

+        "rev": "64a525ee38886ab9028e6f61790de0832aa3ef03",

+        "type": "github"

+      },

+      "original": {

+        "owner": "edolstra",

+        "repo": "flake-compat",

+        "type": "github"

+      }

+    },

+    "flake-utils": {

+      "locked": {

+        "lastModified": 1629481132,

+        "narHash": "sha256-JHgasjPR0/J1J3DRm4KxM4zTyAj4IOJY8vIl75v/kPI=",

+        "owner": "numtide",

+        "repo": "flake-utils",

+        "rev": "997f7efcb746a9c140ce1f13c72263189225f482",

+        "type": "github"

+      },

+      "original": {

+        "owner": "numtide",

+        "repo": "flake-utils",

+        "type": "github"

+      }

+    },

+    "nixpkgs": {

+      "locked": {

+        "lastModified": 1648352901,

+        "narHash": "sha256-1R31hIpqA+3mKBSayiqUhCm21gw4YRioPuR1WqjlCwU=",

+        "owner": "nixos",

+        "repo": "nixpkgs",

+        "rev": "12417777b226eff91efee8b03578daa76c8178a3",

+        "type": "github"

+      },

+      "original": {

+        "owner": "nixos",

+        "ref": "12417777b226eff91efee8b03578daa76c8178a3",

+        "repo": "nixpkgs",

+        "type": "github"

+      }

+    },

+    "nixpkgs_2": {

+      "locked": {

+        "lastModified": 1631288242,

+        "narHash": "sha256-sXm4KiKs7qSIf5oTAmrlsEvBW193sFj+tKYVirBaXz0=",

+        "owner": "NixOS",

+        "repo": "nixpkgs",

+        "rev": "0e24c87754430cb6ad2f8c8c8021b29834a8845e",

+        "type": "github"

+      },

+      "original": {

+        "owner": "NixOS",

+        "ref": "nixpkgs-unstable",

+        "repo": "nixpkgs",

+        "type": "github"

+      }

+    },

+    "root": {

+      "inputs": {

+        "flake-compat": "flake-compat",

+        "nixpkgs": "nixpkgs",

+        "zig": "zig"

+      }

+    },

+    "zig": {

+      "inputs": {

+        "flake-utils": "flake-utils",

+        "nixpkgs": "nixpkgs_2"

+      },

+      "locked": {

+        "lastModified": 1648341617,

+        "narHash": "sha256-j4HXFD1eKxCFfMbBYhNnLmXZ7q6cahVqH/Hlq43v8RM=",

+        "owner": "arqv",

+        "repo": "zig-overlay",

+        "rev": "8d79efd701963ac3c9a55755de44e6fd4a6c8d76",

+        "type": "github"

+      },

+      "original": {

+        "owner": "arqv",

+        "repo": "zig-overlay",

+        "type": "github"

+      }

+    }

+  },

+  "root": "root",

+  "version": 7

+}

new file mode 100644

@@ -0,0 +1,30 @@

+{

+  inputs = {

+    nixpkgs = {

+      type = "github";

+      owner = "nixos";

+      repo = "nixpkgs";

+      ref = "12417777b226eff91efee8b03578daa76c8178a3";

+    };

+    zig.url = "github:arqv/zig-overlay";

+    flake-compat = {

+      url = "github:edolstra/flake-compat";

+      flake = false;

+    };

+  };

+

+  outputs = {

+    self,

+    nixpkgs,

+    zig,

+    flake-compat,

+  }: let

+    pkgs = nixpkgs.legacyPackages.aarch64-darwin;

+    zig091 = zig.packages.aarch64-darwin."0.9.1";

+  in

+    {

+      devShell.aarch64-darwin = pkgs.mkShell {

+        buildInputs = [zig091 nixpkgs.legacyPackages.aarch64-darwin.socat];

+      };

+    };

+}

new file mode 100644

@@ -0,0 +1,58 @@

+const std = @import("std");

+const net = std.net;

+

+// pub const io_mode = .evented;

+

+pub fn main() anyerror!void {

+    var allocator = std.heap.page_allocator;

+    const args = try std.process.argsAlloc(allocator);

+    defer std.process.argsFree(allocator, args);

+

+    const stdout = std.io.getStdOut().writer();

+    try stdout.print("{}", .{args.len});

+    try stdout.writeAll("\n");

+

+    var server = net.StreamServer.init(.{});

+    defer server.deinit();

+

+    try server.listen(net.Address.initUnix(args[1]) catch unreachable);

+    std.log.warn("listening at {}\n", .{server.listen_address});

+

+    while (true) {

+        const client = try allocator.create(Client);

+        client.* = Client{

+            .conn = try server.accept(),

+            .handle_frame = async client.handle(allocator, args[2..]),

+        };

+    }

+}

+

+fn nextLine(reader: anytype, buffer: []u8) !?[]const u8 {

+    var line = (try reader.readUntilDelimiterOrEof(

+        buffer,

+        '\n',

+    )) orelse return null;

+    // trim annoying windows-only carriage return character

+    return line;

+}

+

+const Client = struct {

+    conn: net.StreamServer.Connection,

+    handle_frame: @Frame(handle),

+    fn handle(self: *Client, allocator: std.mem.Allocator, args: []const []u8) !void {

+        var dynargs = std.ArrayList([]const u8).init(allocator);

+        defer dynargs.deinit();

+

+        try dynargs.appendSlice(args);

+

+        try self.conn.stream.writer().writeAll("server: howdy!");

+

+        // const stdout = std.io.getStdOut().writer();

+        var buffer: [1024]u8 = undefined;

+        var nl = (try nextLine(self.conn.stream.reader(), &buffer)).?;

+        try dynargs.append(nl);

+

+        const proc = try std.ChildProcess.init(dynargs.toOwnedSlice(), allocator);

+        _ = try nosuspend proc.spawn();

+    }

+};