Use std.process.Init

Author: sam701

.githooks/pre-push

@@ -0,0 +1,9 @@
+#!/usr/bin/env sh
+
+set -e
+
+echo "Running tests before push..."
+
+zig fmt --check *.zig src/*.zig
+zig build
+zig build test

README.md

@@ -32,10 +32,8 @@ var config = struct {
     port: u16 = undefined,
 }{};
 
-pub fn main() !void {
-    var threaded = std.Io.Threaded.init(std.heap.page_allocator, .{});
-    defer threaded.deinit();
-    var r = try cli.AppRunner.init(threaded.io(), std.heap.page_allocator);
+pub fn main(init: std.process.Init) !void {
+    var r = cli.AppRunner.init(&init);
 
     // Create an App with a command named "short" that takes host and port options.
     const app = cli.App{
@@ -75,10 +73,10 @@ fn run_server() !void {
 ### Using with the Zig package manager
 Add `cli` to your `build.zig.zon`
 ```
-# For zig 0.14.x
+# For zig master
 zig fetch --save git+https://github.com/sam701/zig-cli
 
-# For zig master
+# For zig 0.15
 zig fetch --save git+https://github.com/sam701/zig-cli#zig-0.15
 ```
 

examples/short.zig

@@ -7,10 +7,8 @@ var config = struct {
     port: u16 = undefined,
 }{};
 
-pub fn main() !void {
-    var threaded = std.Io.Threaded.init(std.heap.page_allocator, .{});
-    defer threaded.deinit();
-    var r = try cli.AppRunner.init(threaded.io(), std.heap.page_allocator);
+pub fn main(init: std.process.Init) !void {
+    var r = cli.AppRunner.init(&init);
 
     // Create an App with a command named "short" that takes host and port options.
     const app = cli.App{

examples/simple.zig

@@ -1,9 +1,6 @@
 const std = @import("std");
 const cli = @import("cli");
 
-var gpa = std.heap.GeneralPurposeAllocator(.{}){};
-const allocator = gpa.allocator();
-
 var config = struct {
     ip: []const u8 = undefined,
     int: i32 = undefined,
@@ -52,9 +49,9 @@ fn sub3(r: *cli.AppRunner) !cli.Command {
     };
 }
 
-fn parseArgs(io: std.Io) cli.AppRunner.Error!cli.ExecFn {
+fn parseArgs(init: *const std.process.Init) cli.AppRunner.Error!cli.ExecFn {
     // This allocator will be used to allocate config.ip and config.arg2.
-    var r = try cli.AppRunner.init(io, allocator);
+    var r = cli.AppRunner.init(init);
 
     const sub2 = cli.Command{
         .name = "sub2",
@@ -129,30 +126,9 @@ fn parseArgs(io: std.Io) cli.AppRunner.Error!cli.ExecFn {
     return r.getAction(&app);
 }
 
-pub fn main() anyerror!void {
-    var threaded = std.Io.Threaded.init(std.heap.page_allocator, .{});
-    defer threaded.deinit();
-
-    const action = try parseArgs(threaded.io());
-    const r = action();
-    freeConfig();
-    return r;
-}
-
-// Usually, you just use an arena allocator to free all allocated resources in a batch.
-// This only illustrates the fact that the config data are allocated with the allocator
-// you pass to cli.AppRunner.init(allocator).
-fn freeConfig() void {
-    allocator.free(config.ip);
-    if (config.arg2.len > 0) {
-        for (config.arg2) |item| {
-            allocator.free(item);
-        }
-        allocator.free(config.arg2);
-    }
-    if (gpa.deinit() == .leak) {
-        @panic("config leaked");
-    }
+pub fn main(init: std.process.Init) anyerror!void {
+    const action = try parseArgs(&init);
+    return action();
 }
 
 fn run_sub3() !void {

src/app_runner.zig

@@ -17,13 +17,17 @@ pub const AppRunner = struct {
     arena: ArenaAllocator,
     orig_allocator: Allocator,
     io: std.Io,
+    environ: *const std.process.Environ.Map,
+    args: *const std.process.Args,
 
     const Self = @This();
-    pub fn init(io: std.Io, alloc: Allocator) !Self {
+    pub fn init(orig_init: *const std.process.Init) Self {
         return .{
-            .arena = ArenaAllocator.init(alloc),
-            .orig_allocator = alloc,
-            .io = io,
+            .arena = ArenaAllocator.init(orig_init.gpa),
+            .orig_allocator = orig_init.gpa,
+            .io = orig_init.io,
+            .environ = orig_init.environ_map,
+            .args = &orig_init.minimal.args,
         };
     }
 
@@ -56,10 +60,10 @@ pub const AppRunner = struct {
 
     /// `getAction` returns the action function that should be called by the main app.
     pub fn getAction(self: *Self, app: *const App) Error!command.ExecFn {
-        const iter = try std.process.argsWithAllocator(self.arena.allocator());
+        const iter = try self.args.iterateAllocator(self.arena.allocator());
 
         // Here we pass the child allocator because any values allocated on the client behalf may not be freed.
-        var cr = try Parser(std.process.ArgIterator).init(app, iter, self.io, self.orig_allocator);
+        var cr = try Parser(std.process.Args.Iterator).init(app, iter, self.io, self.orig_allocator, self.environ);
         defer cr.deinit();
 
         if (cr.parse()) |action| {

src/parser.zig

@@ -60,12 +60,14 @@ pub fn Parser(comptime Iterator: type) type {
         error_data: ?ErrorData = null,
 
         io: std.Io,
+        environ: *const std.process.Environ.Map,
 
-        pub fn init(app: *const command.App, it: Iterator, io: std.Io, alloc: Allocator) !Self {
+        pub fn init(app: *const command.App, it: Iterator, io: std.Io, alloc: Allocator, environ: *const std.process.Environ.Map) !Self {
             return .{
                 .orig_allocator = alloc,
                 .arena = ArenaAllocator.init(alloc),
                 .io = io,
+                .environ = environ,
                 .arg_iterator = it,
                 .app = app,
                 .command_path = try std.ArrayList(*const command.Command).initCapacity(alloc, 16),
@@ -190,7 +192,7 @@ pub fn Parser(comptime Iterator: type) type {
             if (opt.value_ref.element_count > 0) return;
 
             if (try getEnvvarName(opt, self.app.option_envvar_prefix, self.arena.allocator())) |envvar_name| {
-                if (std.process.getEnvVarOwned(self.arena.allocator(), envvar_name)) |value| {
+                if (self.environ.get(envvar_name)) |value| {
                     opt.value_ref.put(value, self.orig_allocator) catch |err| {
                         self.error_data = ErrorData{ .invalid_value = .{
                             .entity_type = .option,
@@ -201,7 +203,7 @@ pub fn Parser(comptime Iterator: type) type {
                         } };
                         return err;
                     };
-                } else |_| {}
+                }
             }
         }
 

src/tests.zig

@@ -6,9 +6,11 @@ const ppack = @import("./parser.zig");
 const Parser = ppack.Parser;
 const ParseResult = ppack.ParseResult;
 const AppRunner = @import("app_runner.zig").AppRunner;
+const value_ref = @import("value_ref.zig");
 
 const expect = std.testing.expect;
 const alloc = std.testing.allocator;
+const environ = std.process.Environ.Map.init(alloc);
 const expectError = std.testing.expectError;
 
 const StringSliceIterator = struct {
@@ -21,8 +23,22 @@ const StringSliceIterator = struct {
     }
 };
 
-fn runner() AppRunner {
-    return AppRunner.init(std.testing.io, alloc) catch unreachable;
+const MockedAppRunner = struct {
+    arena: std.heap.ArenaAllocator,
+
+    pub fn deinit(self: *MockedAppRunner) void {
+        self.arena.deinit();
+    }
+
+    pub fn mkRef(self: *MockedAppRunner, dest: anytype) *value_ref.ValueRef {
+        return value_ref.allocRef(dest, self.arena.allocator());
+    }
+};
+
+fn runner() MockedAppRunner {
+    return .{
+        .arena = std.heap.ArenaAllocator.init(alloc),
+    };
 }
 
 fn run(app: *const command.App, items: []const []const u8) !void {
@@ -31,6 +47,7 @@ fn run(app: *const command.App, items: []const []const u8) !void {
         StringSliceIterator{ .items = items },
         std.testing.io,
         alloc,
+        &environ,
     );
     defer parser.deinit();
     _ = try parser.parse();