chore: better name for context

Author: jiacai2050

README.org

@@ -1,6 +1,6 @@
 #+TITLE: zig-curl
 #+DATE: 2023-09-16T23:16:15+0800
-#+LASTMOD: 2025-07-27T19:36:36+0800
+#+LASTMOD: 2025-07-27T20:02:08+0800
 #+OPTIONS: toc:nil num:nil
 #+STARTUP: content
 
@@ -44,7 +44,7 @@ pub fn main() !void {
     });
     defer easy.deinit();
 
-    var ctx = curl.DynamicContext.init(allocator);
+    var ctx = curl.ResizableWriteContext.init(allocator);
     defer ctx.deinit();
     const resp = try easy.fetch("https://httpbin.org/anything", .{}, &ctx);
 

examples/advanced.zig

@@ -41,9 +41,9 @@ fn putWithCustomHeader(allocator: Allocator, easy: Easy) !void {
     try easy.setVerbose(true);
     try easy.setPostFields(body);
 
-    var writeContext = curl.DynamicContext.init(allocator);
+    var writeContext = curl.ResizableWriteContext.init(allocator);
     defer writeContext.deinit();
-    try easy.setWriteContext(&writeContext, curl.DynamicContext.write);
+    try easy.setWriteContext(&writeContext, curl.ResizableWriteContext.write);
 
     const resp = try easy.perform();
     std.debug.print("Status code: {d}\nBody: {s}\n", .{
@@ -103,9 +103,9 @@ fn postMultiPart(allocator: Allocator, easy: Easy) !void {
     try easy.setMultiPart(multi_part);
     try easy.setVerbose(true);
 
-    var writeContext = curl.DynamicContext.init(allocator);
+    var writeContext = curl.ResizableWriteContext.init(allocator);
     defer writeContext.deinit();
-    try easy.setWriteContext(&writeContext, curl.DynamicContext.write);
+    try easy.setWriteContext(&writeContext, curl.ResizableWriteContext.write);
 
     const resp = try easy.perform();
     std.debug.print("code: {d}, resp:{s}\n", .{ resp.status_code, writeContext.asSlice() });

examples/basic.zig

@@ -18,7 +18,7 @@ fn get(easy: Easy) !void {
     {
         println("GET with fixed buffer");
         var buffer: [1024]u8 = undefined;
-        var writeContext = curl.StaticContext.init(&buffer);
+        var writeContext = curl.FixedWriteContext.init(&buffer);
         const resp = try easy.fetch("https://httpbin.org/anything", .{}, &writeContext);
         std.debug.print("Status code: {d}\nBody: {s}\n", .{
             resp.status_code,
@@ -31,7 +31,7 @@ fn post(allocator: Allocator, easy: Easy) !void {
     const payload =
         \\{"name": "John", "age": 15}
     ;
-    var writeContext = curl.DynamicContext.init(allocator);
+    var writeContext = curl.ResizableWriteContext.init(allocator);
     defer writeContext.deinit();
     const resp = try easy.fetch(
         "https://httpbin.org/anything",
@@ -53,7 +53,7 @@ fn post(allocator: Allocator, easy: Easy) !void {
 
 fn upload(allocator: Allocator, easy: Easy) !void {
     const path = "LICENSE";
-    var writeContext = curl.DynamicContext.init(allocator);
+    var writeContext = curl.ResizableWriteContext.init(allocator);
     defer writeContext.deinit();
 
     const resp = try easy.upload(LOCAL_SERVER_ADDR ++ "/anything", path, &writeContext);

examples/hello.zig

@@ -13,7 +13,7 @@ pub fn main() !void {
     });
     defer easy.deinit();
 
-    var ctx = curl.DynamicContext.init(allocator);
+    var ctx = curl.ResizableWriteContext.init(allocator);
     defer ctx.deinit();
     const resp = try easy.fetch("https://httpbin.org/anything", .{}, &ctx);
 

examples/multi.zig

@@ -8,10 +8,10 @@ const Multi = curl.Multi;
 const c = curl.libcurl;
 const checkCode = curl.checkCode;
 
-fn newEasy(ctx: *curl.DynamicContext, url: [:0]const u8) !Easy {
+fn newEasy(ctx: *curl.ResizableWriteContext, url: [:0]const u8) !Easy {
     const easy = try Easy.init(.{});
     try easy.setUrl(url);
-    try easy.setWriteContext(ctx, curl.DynamicContext.write);
+    try easy.setWriteContext(ctx, curl.ResizableWriteContext.write);
     // CURLOPT_PRIVATE allows us to store a pointer to the ctx in the easy handle
     // so we can retrieve it later in the callback.
     try easy.setPrivate(ctx);
@@ -27,9 +27,9 @@ pub fn main() !void {
     const multi = try Multi.init();
     defer multi.deinit();
 
-    var ctx1 = curl.DynamicContext.init(allocator);
+    var ctx1 = curl.ResizableWriteContext.init(allocator);
     defer ctx1.deinit();
-    var ctx2 = curl.DynamicContext.init(allocator);
+    var ctx2 = curl.ResizableWriteContext.init(allocator);
     defer ctx2.deinit();
 
     try multi.addHandle(try newEasy(&ctx1, "http://httpbin.org/headers"));
@@ -69,7 +69,7 @@ pub fn main() !void {
         // Get the private data (buffer) associated with this handle
         var private_data: ?*anyopaque = null;
         try checkCode(c.curl_easy_getinfo(easy_handle, c.CURLINFO_PRIVATE, &private_data));
-        const ctx: *curl.DynamicContext = @ptrCast(@alignCast(private_data.?));
+        const ctx: *curl.ResizableWriteContext = @ptrCast(@alignCast(private_data.?));
 
         std.debug.print("Response body: {s}\n", .{ctx.asSlice()});
     }

src/Easy.zig

@@ -7,8 +7,7 @@ const mem = std.mem;
 const fmt = std.fmt;
 const Allocator = mem.Allocator;
 const checkCode = errors.checkCode;
-const DynamicBuffer = util.DynamicBuffer;
-const StaticBuffer = util.StaticBuffer;
+const ResizableBuffer = util.ResizableBuffer;
 
 const hasParseHeaderSupport = @import("util.zig").hasParseHeaderSupport;
 
@@ -17,7 +16,7 @@ const Self = @This();
 handle: *c.CURL,
 timeout_ms: usize,
 user_agent: [:0]const u8,
-ca_bundle: ?DynamicBuffer,
+ca_bundle: ?ResizableBuffer,
 
 pub const Method = enum {
     GET,
@@ -256,7 +255,7 @@ pub const Options = struct {
     // Note that the vendored libcurl is compiled with mbedtls and does not include a CA bundle,
     // so this should be set when link with vendored libcurl, otherwise https
     // requests will fail.
-    ca_bundle: ?DynamicBuffer = null,
+    ca_bundle: ?ResizableBuffer = null,
     /// The maximum time in milliseconds that the entire transfer operation to take.
     default_timeout_ms: usize = 30_000,
     default_user_agent: [:0]const u8 = "zig-curl/" ++ @import("build_info").version,
@@ -457,8 +456,8 @@ pub fn head(self: Self, url: [:0]const u8) !Response {
 /// Fetch issues a request to the specified URL.
 ///
 /// `writeContext` is used to write the response body. There are two built-in write contexts:
-/// 1. `DynamicContext` - a dynamic buffer that grows as needed.
-/// 2. `StaticContext` - a fixed-size buffer that must be large enough to hold the response body.
+/// 1. `ResizableWriteContext` - a resizable context that grows as needed to hold the response body.
+/// 2. `FixedWriteContext` - a fixed-size one that must be large enough to hold the response body.
 /// Or it can be `void`, which means you don't care about the response body.
 pub fn fetch(
     self: Self,

src/root.zig

@@ -4,8 +4,8 @@ pub const checkCode = @import("errors.zig").checkCode;
 
 pub const Easy = @import("Easy.zig");
 pub const Multi = @import("Multi.zig");
-pub const DynamicContext = util.DynamicContext;
-pub const StaticContext = util.StaticContext;
+pub const ResizableWriteContext = util.ResizableWriteContext;
+pub const FixedWriteContext = util.FixedWriteContext;
 
 pub const printLibcurlVersion = util.printLibcurlVersion;
 pub const hasParseHeaderSupport = util.hasParseHeaderSupport;

src/util.zig

@@ -4,30 +4,30 @@ pub const c = @cImport({
 });
 const Allocator = std.mem.Allocator;
 const Encoder = std.base64.standard.Encoder;
-pub const DynamicBuffer = std.ArrayList(u8);
-pub const StaticBuffer = struct {
+pub const ResizableBuffer = std.ArrayList(u8);
+pub const FixedBuffer = struct {
     data: []u8,
     // How many bytes are used in the buffer.
     size: usize,
 
-    pub fn init(data: []u8) StaticBuffer {
+    pub fn init(data: []u8) FixedBuffer {
         return .{ .data = data, .size = 0 };
     }
 
-    pub fn asSlice(self: *StaticBuffer) []const u8 {
+    pub fn asSlice(self: *FixedBuffer) []const u8 {
         return self.data[0..self.size];
     }
 };
 
-pub const StaticContext = struct {
-    buffer: StaticBuffer,
+pub const FixedWriteContext = struct {
+    buffer: FixedBuffer,
 
-    pub fn init(buffer: []u8) StaticContext {
+    pub fn init(buffer: []u8) FixedWriteContext {
         return .{ .buffer = .init(buffer) };
     }
 
     pub fn write(
-        ctx: *StaticContext,
+        ctx: *FixedWriteContext,
         data: []const u8,
     ) usize {
         if (ctx.buffer.size + data.len > ctx.buffer.data.len) {
@@ -39,24 +39,24 @@ pub const StaticContext = struct {
         return data.len;
     }
 
-    pub fn asSlice(self: *StaticContext) []const u8 {
+    pub fn asSlice(self: *FixedWriteContext) []const u8 {
         return self.buffer.asSlice();
     }
 };
 
-pub const DynamicContext = struct {
-    buffer: DynamicBuffer,
+pub const ResizableWriteContext = struct {
+    buffer: ResizableBuffer,
 
-    pub fn init(allocator: Allocator) DynamicContext {
-        return .{ .buffer = DynamicBuffer.init(allocator) };
+    pub fn init(allocator: Allocator) ResizableWriteContext {
+        return .{ .buffer = ResizableBuffer.init(allocator) };
     }
 
-    pub fn deinit(self: *DynamicContext) void {
+    pub fn deinit(self: *ResizableWriteContext) void {
         self.buffer.deinit();
     }
 
     pub fn write(
-        ctx: *DynamicContext,
+        ctx: *ResizableWriteContext,
         data: []const u8,
     ) usize {
         ctx.buffer.appendSlice(data) catch {
@@ -67,7 +67,7 @@ pub const DynamicContext = struct {
         return data.len;
     }
 
-    pub fn asSlice(self: *DynamicContext) []const u8 {
+    pub fn asSlice(self: *ResizableWriteContext) []const u8 {
         return self.buffer.items;
     }
 };
@@ -159,11 +159,11 @@ test "url encode" {
 const CERT_MARKER_BEGIN = "-----BEGIN CERTIFICATE-----";
 const CERT_MARKER_END = "\n-----END CERTIFICATE-----\n";
 
-pub fn allocCABundle(allocator: std.mem.Allocator) !DynamicBuffer {
+pub fn allocCABundle(allocator: std.mem.Allocator) !ResizableBuffer {
     var bundle: std.crypto.Certificate.Bundle = .{};
     defer bundle.deinit(allocator);
 
-    var blob = DynamicBuffer.init(allocator);
+    var blob = ResizableBuffer.init(allocator);
     try bundle.rescan(allocator);
     var iter = bundle.map.iterator();
     while (iter.next()) |entry| {