logging: add more logging

currently there is an issue where `--test` along with a filename will
usually cause seamstress to exit prematurely.

Author: robbielyman

lua/core/test.lua

@@ -171,15 +171,10 @@ end
 
 local ok, busted = pcall(require, 'busted')
 if ok then
-  local ret = seamstress.async(runner)
-  event.addSubscriber({ 'init' }, function()
-    seamstress.async.Promise(function()
-      ret():await()
+  return seamstress.async(function()
+      seamstress.async.Promise(runner):await()
       seamstress:stop()
-    end)
-    return false
   end)
-  return ret
 end
 
 return function()

src/args.zig

@@ -3,6 +3,22 @@ const Args = @This();
 logging: logging.Args,
 run: Seamstress.RunArgs,
 
+pub fn format(args: Args, comptime _: []const u8, _: std.fmt.FormatOptions, writer: anytype) !void {
+    try writer.print("log file: {s}, log level: {s}\n", .{ args.logging.path orelse "default", switch (args.logging.level) {
+        .err => "error",
+        .warn => "warning",
+        .info => "info",
+        .debug => "debug",
+    } });
+    if (args.run.file) |name| {
+        try writer.print("root lua file: {s}\n", .{name});
+    }
+    if (!args.run.tests.run_tests) return;
+    try writer.writeAll("running tests\n");
+    const dir = args.run.tests.dir orelse return;
+    try writer.print("additional tests directory: {s}\n", .{dir});
+}
+
 pub fn process(cli_args: []const []const u8) Args {
     var file: ?[]const u8 = null;
     var logging_arg: logging.Args = .{};

src/async.zig

@@ -411,24 +411,44 @@ fn anonCallback(ptr: ?*anyopaque, loop: *xev.Loop, _: *xev.Completion, r: xev.As
     return .disarm;
 }
 
-pub fn waitForLua(
-    l: *Lua,
-    num_args: i32,
-) !void {
+pub fn waitForLua(l: *Lua, waiting_on: union(enum) {
+    function_with_num_args: i32,
+    async_function_with_num_args: i32,
+    promise: void,
+}) !void {
     const builtin = @import("builtin");
     const a = try xev.Async.init();
     const top = if (builtin.mode == .Debug) blk: {
         const top = l.getTop();
+        const num_args: i32 = switch (waiting_on) {
+            .promise => 0,
+            .function_with_num_args, .async_function_with_num_args => |n| n,
+        };
         std.debug.assert(top >= num_args + 2 + 1);
         break :blk top;
     };
-    lu.load(l, "seamstress.async.Promise");
-    l.rotate(-num_args - 4, 3); // stack is now: closure closure Promise function ...
-    try lu.doCall(l, num_args + 1, 1); // stack is now closure closure returned_promise
+    switch (waiting_on) {
+        .promise => l.rotate(-3, 2), // stack is now: closure closure promise
+        .function_with_num_args => |num_args| {
+            lu.load(l, "seamstress.async.Promise");
+            l.rotate(-num_args - 4, 3); // stack is now: closure closure Promise function ...
+            try lu.doCall(l, num_args + 1, 1); // stack is now closure closure returned_promise
+        },
+        .async_function_with_num_args => |num_args| {
+            l.rotate(-num_args - 3, 3); // stack is now: closure closure function ...
+            try lu.doCall(l, num_args, 1); // stack is now closure closure returned_promise
+        },
+    }
     const promise: *Promise = l.newUserdata(Promise, 3);
     l.pushValue(-1); // copy it
     const handle = try l.ref(ziglua.registry_index); // ref pops
-    defer if (builtin.mode == .Debug) std.debug.assert(l.getTop() + num_args + 2 == top);
+    defer if (builtin.mode == .Debug) {
+        const num_args: i32 = switch (waiting_on) {
+            .promise => 0,
+            .function_with_num_args, .async_function_with_num_args => |n| n,
+        };
+        std.debug.assert(l.getTop() + num_args + 2 == top);
+    };
     const thread = l.newThread();
     l.rotate(-5, -2); // stack is now: returned_promise new_promise thread closure closure
     l.xMove(thread, 2); // pops closures
@@ -438,8 +458,11 @@ pub fn waitForLua(
         .data = .{ .@"async" = a },
     };
     _ = l.getUserValue(-2, 2) catch unreachable; // get the table of dependent promises
+    l.len(-1); // get its length
+    const len = l.toInteger(-1) catch unreachable;
+    l.pop(1);
     l.pushValue(-2); // copy new_promise
-    l.setIndex(-2, 1); // assign as dependent promise
+    l.setIndex(-2, len + 1); // assign as dependent promise
     l.pop(1); // pop the table
     l.rotate(-2, 1); // stack is now new_promise returned_promise
     l.setUserValue(-2, 3) catch unreachable;

src/cli.zig

@@ -158,7 +158,7 @@ fn stdinCallback2(cli: *Cli, l: *Lua, loop: *xev.Loop, c: *xev.Completion, ptr:
     l.pushValue(-2);
     l.pushClosure(ziglua.wrap(resumeRepl(.failure)), 1);
     l.remove(-3);
-    try lu.waitForLuaCall(l, 0);
+    try lu.waitForLuaCall(l, .{ .function_with_num_args = 0 });
     l.pop(1); // pop the promise
 }
 

src/env.zig

@@ -12,7 +12,10 @@ old: switch (builtin.os.tag) {
 },
 
 pub fn set(gpa: std.mem.Allocator) ?Env {
-    var env = Env.init(gpa) catch return null;
+    var env = Env.init(gpa) catch |err| {
+        std.log.scoped(.env).warn("environment not set; encountered error: {s}", .{@errorName(err)});
+        return null;
+    };
     env.old = switch (builtin.os.tag) {
         .macos, .linux => std.c.environ,
         .windows => std.os.windows.peb().ProcessParameters.Environment,
@@ -29,6 +32,7 @@ pub fn init(gpa: std.mem.Allocator) !Env {
             .allocator = gpa,
             .argv = &.{ "luarocks", "path" },
         }) catch |err| {
+            std.log.scoped(.env).warn("error running luarocks path: {s}", .{@errorName(err)});
             if (err == error.FileNotFound) break :luarocks;
             return err;
         };
@@ -42,6 +46,7 @@ pub fn init(gpa: std.mem.Allocator) !Env {
             const equals = std.mem.indexOfScalar(u8, inner, '=') orelse continue;
             const key = inner[0..equals];
             const value = inner[equals + 2 .. inner.len - 1];
+            std.log.scoped(.env).debug("setting {s} to {s}", .{ key, value });
             try map.put(key, value);
         }
     }

src/main.zig

@@ -11,6 +11,8 @@ pub fn main() !void {
 
     logging.init(allocator, args.logging);
 
+    std.log.scoped(.args).debug("{}", .{args});
+
     defer {
         std.process.argsFree(allocator, cli_args);
         if (gpa.deinit() == .leak) {
@@ -24,7 +26,7 @@ pub fn main() !void {
     const environ = Env.set(allocator);
     defer if (environ) |env| env.deinit(allocator);
 
-    // handle SIGABRT (called by lua in Debug mode)
+    // handle SIGABRT (raised by lua in Debug mode)
     const using_sigaction = builtin.mode == .Debug and builtin.os.tag != .windows;
     if (using_sigaction) setAbrtHandler() catch {};
 

src/seamstress.zig

@@ -121,8 +121,8 @@ pub fn main(l: *Lua, run_args: RunArgs) !void {
             lua.traceback(lua, error_msg, 1); // local with_stack_trace = debug.traceback(error_msg, 1)
             const with_stack_trace = lua.toString(-1) catch unreachable;
             @call(.always_inline, std.debug.panic, .{ "lua crashed: {s}", .{with_stack_trace} });
+            // no need to return anything since std.debug.panic is of type noreturn
         }
-        // no need to return anything since std.debug.panic is of type noreturn
     }.panic));
     lu.load(l, "seamstress");
     const seamstress = l.toUserdata(Seamstress, -1) catch unreachable;