feat: all

Author: davidprokopec

Makefile

@@ -0,0 +1,7 @@
+PHONY: build run
+
+build:
+	zig build
+
+run:
+	zig build run

build.zig

@@ -0,0 +1,123 @@
+const std = @import("std");
+
+// Although this function looks imperative, note that its job is to
+// declaratively construct a build graph that will be executed by an external
+// runner.
+pub fn build(b: *std.Build) 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 optimization options allow the person running `zig build` to select
+    // between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall. Here we do not
+    // set a preferred release mode, allowing the user to decide how to optimize.
+    const optimize = b.standardOptimizeOption(.{});
+
+    // This creates a "module", which represents a collection of source files alongside
+    // some compilation options, such as optimization mode and linked system libraries.
+    // Every executable or library we compile will be based on one or more modules.
+    const lib_mod = b.createModule(.{
+        // `root_source_file` is the Zig "entry point" of the module. If a module
+        // only contains e.g. external object files, you can make this `null`.
+        // In this case the main source file is merely a path, however, in more
+        // complicated build scripts, this could be a generated file.
+        .root_source_file = b.path("src/root.zig"),
+        .target = target,
+        .optimize = optimize,
+    });
+
+    // We will also create a module for our other entry point, 'main.zig'.
+    const exe_mod = b.createModule(.{
+        // `root_source_file` is the Zig "entry point" of the module. If a module
+        // only contains e.g. external object files, you can make this `null`.
+        // In this case the main source file is merely a path, however, in more
+        // complicated build scripts, this could be a generated file.
+        .root_source_file = b.path("src/main.zig"),
+        .target = target,
+        .optimize = optimize,
+    });
+
+    // Modules can depend on one another using the `std.Build.Module.addImport` function.
+    // This is what allows Zig source code to use `@import("foo")` where 'foo' is not a
+    // file path. In this case, we set up `exe_mod` to import `lib_mod`.
+    exe_mod.addImport("zig_plscommit_lib", lib_mod);
+
+    // Now, we will create a static library based on the module we created above.
+    // This creates a `std.Build.Step.Compile`, which is the build step responsible
+    // for actually invoking the compiler.
+    const lib = b.addLibrary(.{
+        .linkage = .static,
+        .name = "zig_plscommit",
+        .root_module = lib_mod,
+    });
+
+    // This declares intent for the library to be installed into the standard
+    // location when the user invokes the "install" step (the default step when
+    // running `zig build`).
+    b.installArtifact(lib);
+
+    // This creates another `std.Build.Step.Compile`, but this one builds an executable
+    // rather than a static library.
+    const exe = b.addExecutable(.{
+        .name = "zig_plscommit",
+        .root_module = exe_mod,
+    });
+
+    const prompter_dep = b.dependency("prompter", .{
+        .target = target,
+        .optimize = optimize,
+    });
+
+    exe.root_module.addImport("prompter", prompter_dep.module("prompter"));
+
+    // This declares intent for the executable to be installed into the
+    // standard location when the user invokes the "install" step (the default
+    // step when running `zig build`).
+    b.installArtifact(exe);
+
+    // This *creates* a Run step in the build graph, to be executed when another
+    // step is evaluated that depends on it. The next line below will establish
+    // such a dependency.
+    const run_cmd = b.addRunArtifact(exe);
+
+    // By making the run step depend on the install step, it will be run from the
+    // installation directory rather than directly from within the cache directory.
+    // This is not necessary, however, if the application depends on other installed
+    // files, this ensures they will be present and in the expected location.
+    run_cmd.step.dependOn(b.getInstallStep());
+
+    // This allows the user to pass arguments to the application in the build
+    // command itself, like this: `zig build run -- arg1 arg2 etc`
+    if (b.args) |args| {
+        run_cmd.addArgs(args);
+    }
+
+    // This creates a build step. It will be visible in the `zig build --help` menu,
+    // and can be selected like this: `zig build run`
+    // This will evaluate the `run` step rather than the default, which is "install".
+    const run_step = b.step("run", "Run the app");
+    run_step.dependOn(&run_cmd.step);
+
+    // Creates a step for unit testing. This only builds the test executable
+    // but does not run it.
+    const lib_unit_tests = b.addTest(.{
+        .root_module = lib_mod,
+    });
+
+    const run_lib_unit_tests = b.addRunArtifact(lib_unit_tests);
+
+    const exe_unit_tests = b.addTest(.{
+        .root_module = exe_mod,
+    });
+
+    const run_exe_unit_tests = b.addRunArtifact(exe_unit_tests);
+
+    // Similar to creating the run step earlier, this exposes a `test` step to
+    // the `zig build --help` menu, providing a way for the user to request
+    // running the unit tests.
+    const test_step = b.step("test", "Run unit tests");
+    test_step.dependOn(&run_lib_unit_tests.step);
+    test_step.dependOn(&run_exe_unit_tests.step);
+}

build.zig.zon

@@ -0,0 +1,52 @@
+.{
+    // This is the default name used by packages depending on this one. For
+    // example, when a user runs `zig fetch --save <url>`, this field is used
+    // as the key in the `dependencies` table. Although the user can choose a
+    // different name, most users will stick with this provided value.
+    //
+    // It is redundant to include "zig" in this name because it is already
+    // within the Zig package namespace.
+    .name = .zig_plscommit,
+
+    // This is a [Semantic Version](https://semver.org/).
+    // In a future version of Zig it will be used for package deduplication.
+    .version = "0.0.0",
+
+    // Together with name, this represents a globally unique package
+    // identifier. This field is generated by the Zig toolchain when the
+    // package is first created, and then *never changes*. This allows
+    // unambiguous detection of one package being an updated version of
+    // another.
+    //
+    // When forking a Zig project, this id should be regenerated (delete the
+    // field and run `zig build`) if the upstream project is still maintained.
+    // Otherwise, the fork is *hostile*, attempting to take control over the
+    // original project's identity. Thus it is recommended to leave the comment
+    // on the following line intact, so that it shows up in code reviews that
+    // modify the field.
+    .fingerprint = 0x5ea5675e189ddb99, // Changing this has security and trust implications.
+
+    // Tracks the earliest Zig version that the package considers to be a
+    // supported use case.
+    .minimum_zig_version = "0.14.0",
+
+    // This field is optional.
+    // Each dependency must either provide a `url` and `hash`, or a `path`.
+    // `zig build --fetch` can be used to fetch all dependencies of a package, recursively.
+    // Once all dependencies are fetched, `zig build` no longer requires
+    // internet connectivity.
+    .dependencies = .{
+        .prompter = .{
+            .url = "git+https://github.com/davidprokopec/zig-prompter/#37f78b8a82411ef9eed99b5ccc2bf4e60df93a1a",
+            .hash = "prompter-0.1.0-AAAAAEpPAACoy55adcSMiPAQlbF4TIQVaNbkOYYNwp53",
+        },
+    },
+    .paths = .{
+        "build.zig",
+        "build.zig.zon",
+        "src",
+        // For example...
+        //"LICENSE",
+        //"README.md",
+    },
+}

src/main.zig

@@ -0,0 +1,130 @@
+const std = @import("std");
+const Prompter = @import("prompter");
+
+const CommitType = struct {
+    name: []const u8,
+    description: []const u8,
+};
+
+pub fn main() !void {
+    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    defer {
+        const check = gpa.deinit();
+        if (check == .leak) @panic("The allocator has leaked!");
+    }
+    const allocator = gpa.allocator();
+    const out = std.io.getStdOut().writer();
+
+    // Parse command line arguments
+    const args = try std.process.argsAlloc(allocator);
+    defer std.process.argsFree(allocator, args);
+
+    var path_arg: ?[]const u8 = null;
+    if (args.len > 1) {
+        path_arg = args[1];
+    }
+
+    // Setup the prompt theme
+    const theme = Prompter.Themes.SimpleTheme{};
+    var p = Prompter.Prompt.init(allocator, theme.theme());
+
+    // Define commit types with descriptions
+    const commit_types = [_]CommitType{
+        .{ .name = "feat", .description = "A new feature" },
+        .{ .name = "fix", .description = "A bug fix" },
+        .{ .name = "refactor", .description = "Code change that neither fixes a bug nor adds a feature" },
+        .{ .name = "revert", .description = "Revert to a previous commit" },
+        .{ .name = "build", .description = "Changes affecting build system or external dependencies" },
+        .{ .name = "chore", .description = "Other changes that don't modify src or test files" },
+        .{ .name = "ci", .description = "Changes to CI configuration files and scripts" },
+        .{ .name = "docs", .description = "Documentation only changes" },
+        .{ .name = "perf", .description = "A code change that improves performance" },
+        .{ .name = "style", .description = "Changes that do not affect the meaning of the code" },
+        .{ .name = "test", .description = "Adding missing tests or correcting existing tests" },
+        .{ .name = "debug", .description = "Adding or modifying debug output" },
+        .{ .name = "custom", .description = "Custom commit type" },
+    };
+
+    // Prepare options for display
+    var options = try allocator.alloc([]const u8, commit_types.len);
+    defer allocator.free(options);
+
+    // We need to free each option string before exiting
+    for (commit_types, 0..) |ct, i| {
+        const option_text = try std.fmt.allocPrint(allocator, "{s}: {s}", .{ ct.name, ct.description });
+        options[i] = option_text;
+    }
+    // Add a defer block to free all the option strings
+    defer {
+        for (options) |option| {
+            allocator.free(option);
+        }
+    }
+
+    // Prompt for commit type selection
+    try out.writeAll("Select commit type:\n");
+    const sel_opt = try p.option("Commit type", options, 0);
+
+    // Handle selection abort
+    if (sel_opt == null) {
+        try out.writeAll("Commit aborted.\n");
+        return;
+    }
+
+    // Handle selected commit type
+    var commit_type: []const u8 = undefined;
+    var custom_type: []const u8 = undefined;
+    var needs_to_free_custom_type = false;
+
+    if (sel_opt.? == commit_types.len - 1) {
+        custom_type = try p.string("Enter custom commit type", null);
+        needs_to_free_custom_type = true;
+        commit_type = custom_type;
+    } else {
+        commit_type = commit_types[sel_opt.?].name;
+    }
+
+    // Prompt for commit message
+    const commit_message = try p.string("Enter commit message", null);
+    defer allocator.free(commit_message);
+
+    // Build the full commit message
+    const full_commit_message = try std.fmt.allocPrint(allocator, "{s}: {s}", .{ commit_type, commit_message });
+    defer allocator.free(full_commit_message);
+
+    // Free custom type if it was allocated
+    defer if (needs_to_free_custom_type) allocator.free(custom_type);
+
+    // Execute git commands using process.Child
+    // Add files to staging
+    var add_cmd_args = if (path_arg) |path|
+        [_][]const u8{ "git", "add", path }
+    else
+        [_][]const u8{ "git", "add", "." };
+
+    var add_cmd = std.process.Child.init(&add_cmd_args, allocator);
+    add_cmd.stderr_behavior = .Inherit;
+    add_cmd.stdout_behavior = .Inherit;
+
+    const add_term = try add_cmd.spawnAndWait();
+
+    if (add_term.Exited != 0) {
+        try out.writeAll("Error adding files to git\n");
+        return;
+    }
+
+    // Create commit
+    var commit_cmd_args = [_][]const u8{ "git", "commit", "-m", full_commit_message };
+    var commit_cmd = std.process.Child.init(&commit_cmd_args, allocator);
+    commit_cmd.stderr_behavior = .Inherit;
+    commit_cmd.stdout_behavior = .Inherit;
+
+    const commit_term = try commit_cmd.spawnAndWait();
+
+    if (commit_term.Exited != 0) {
+        try out.writeAll("Error creating commit\n");
+        return;
+    }
+
+    try out.print("Successfully committed: {s}\n", .{full_commit_message});
+}

src/root.zig

@@ -0,0 +1,13 @@
+//! By convention, root.zig is the root source file when making a library. If
+//! you are making an executable, the convention is to delete this file and
+//! start with main.zig instead.
+const std = @import("std");
+const testing = std.testing;
+
+pub export fn add(a: i32, b: i32) i32 {
+    return a + b;
+}
+
+test "basic add functionality" {
+    try testing.expect(add(3, 7) == 10);
+}