fix(build)!: lua_wrapper -> zlua

"lua_wrapper", while descriptive, feels significantly worse than
"ziglua". since the Zig project feels strongly that "zig" in the name
is redundant, "zlua" feels like a nice middle ground.

BREAKING CHANGE: the package and exported module are now named "zlua";
the latter change will require alteration of build.zig files.

Author: robbielyman

build.zig

@@ -24,19 +24,19 @@ pub fn build(b: *Build) void {
     }
 
     // Zig module
-    const lua_wrapper = b.addModule("lua_wrapper", .{
+    const zlua = b.addModule("zlua", .{
         .root_source_file = b.path("src/lib.zig"),
     });
 
     // Expose build configuration to the ziglua module
     const config = b.addOptions();
     config.addOption(Language, "lang", lang);
     config.addOption(bool, "luau_use_4_vector", luau_use_4_vector);
-    lua_wrapper.addOptions("config", config);
+    zlua.addOptions("config", config);
 
     if (lang == .luau) {
         const vector_size: usize = if (luau_use_4_vector) 4 else 3;
-        lua_wrapper.addCMacro("LUA_VECTOR_SIZE", b.fmt("{}", .{vector_size}));
+        zlua.addCMacro("LUA_VECTOR_SIZE", b.fmt("{}", .{vector_size}));
     }
 
     const upstream = b.dependency(@tagName(lang), .{});
@@ -53,15 +53,15 @@ pub fn build(b: *Build) void {
 
     switch (lang) {
         .luau => {
-            lua_wrapper.addIncludePath(upstream.path("Common/include"));
-            lua_wrapper.addIncludePath(upstream.path("Compiler/include"));
-            lua_wrapper.addIncludePath(upstream.path("Ast/include"));
-            lua_wrapper.addIncludePath(upstream.path("VM/include"));
+            zlua.addIncludePath(upstream.path("Common/include"));
+            zlua.addIncludePath(upstream.path("Compiler/include"));
+            zlua.addIncludePath(upstream.path("Ast/include"));
+            zlua.addIncludePath(upstream.path("VM/include"));
         },
-        else => lua_wrapper.addIncludePath(upstream.path("src")),
+        else => zlua.addIncludePath(upstream.path("src")),
     }
 
-    lua_wrapper.linkLibrary(lib);
+    zlua.linkLibrary(lib);
 
     // lib must expose all headers included by these root headers
     const c_header_path = switch (lang) {
@@ -84,15 +84,15 @@ pub fn build(b: *Build) void {
         .link_libc = c_headers.link_libc,
     });
 
-    lua_wrapper.addImport("c", ziglua_c);
+    zlua.addImport("c", ziglua_c);
 
     // Tests
     const tests = b.addTest(.{
         .root_source_file = b.path("src/tests.zig"),
         .target = target,
         .optimize = optimize,
     });
-    tests.root_module.addImport("lua_wrapper", lua_wrapper);
+    tests.root_module.addImport("zlua", zlua);
 
     const run_tests = b.addRunArtifact(tests);
     const test_step = b.step("test", "Run ziglua tests");
@@ -115,7 +115,7 @@ pub fn build(b: *Build) void {
             .target = target,
             .optimize = optimize,
         });
-        exe.root_module.addImport("lua_wrapper", lua_wrapper);
+        exe.root_module.addImport("zlua", zlua);
 
         const artifact = b.addInstallArtifact(exe, .{});
         const exe_step = b.step(b.fmt("install-example-{s}", .{example[0]}), b.fmt("Install {s} example", .{example[0]}));
@@ -151,7 +151,7 @@ pub fn build(b: *Build) void {
         .name = "define-zig-types",
         .target = target,
     });
-    def_exe.root_module.addImport("lua_wrapper", lua_wrapper);
+    def_exe.root_module.addImport("zlua", zlua);
     var run_def_exe = b.addRunArtifact(def_exe);
     run_def_exe.addFileArg(b.path("definitions.lua"));
 

build.zig.zon

@@ -1,6 +1,6 @@
 .{
-    .name = .lua_wrapper,
-    .fingerprint = 0xb40fd4eedb02233b, // changing this has security and trust implications
+    .name = .zlua,
+    .fingerprint = 0xcf671dd0b696484, // changing this has security and trust implications
     .version = "0.1.0",
     .paths = .{ "build.zig", "build.zig.zon", "src", "license", "include", "build" },
 

src/lib.zig

@@ -1,6 +1,6 @@
 //! Similar to the Lua C API documentation, each function has an indicator to describe how interacts with the stack and which errors it may return.
 //!
-//! Instead of using the form `[-o, +p, x]`, Lua_wrapper uses the words **Pops**, **Pushes**, and **Errors** for clarity.
+//! Instead of using the form `[-o, +p, x]`, Zlua uses the words **Pops**, **Pushes**, and **Errors** for clarity.
 //!
 //! * **Pops**: how many elements the function pops from the stack.
 //! * **Pushes**: how many elements the function pushes onto the stack.
@@ -302,7 +302,7 @@ pub const DebugInfo = switch (lang) {
     .luau => DebugInfoLuau,
 };
 
-/// The superset of all errors returned from lua_wrapper
+/// The superset of all errors returned from zlua
 pub const Error = error{
     /// A generic failure (used when a function can only fail in one way)
     LuaError,
@@ -750,7 +750,7 @@ pub const Lua = opaque {
     /// * Finally you call `Lua.call()`
     /// * `args.args` is the number of arguments that you pushed onto the stack. When the function returns, all arguments and
     /// the function value are popped and the call results are pushed onto the stack.
-    /// * The number of results is adjusted to `args.results`, unless `args.results` is `lua_wrapper.mult_return`. In this case, all results from the function are pushed
+    /// * The number of results is adjusted to `args.results`, unless `args.results` is `zlua.mult_return`. In this case, all results from the function are pushed
     /// * Lua takes care that the returned values fit into the stack space, but it does not ensure any extra space in the stack. The function results
     /// are pushed onto the stack in direct order (the first result is pushed first), so that after the call the last result is
     /// on the top of the stack.
@@ -4903,7 +4903,7 @@ pub const Buffer = struct {
     }
 };
 
-// Helper functions to make the lua_wrapper API easier to use
+// Helper functions to make the zlua API easier to use
 
 const Tuple = std.meta.Tuple;