swapped encode function params, added tests

Author: oxelf

example/c-vt-paste/src/main.c

@@ -45,7 +45,7 @@ int main() {
   char simple_paste[] = "pasted content";
   char encoded[128];
 
-  if (ghostty_paste_encoder_encode(simple_paste, strlen(simple_paste), encoder,
+  if (ghostty_paste_encoder_encode(encoder, simple_paste, strlen(simple_paste),
                                    encoded, sizeof(encoded),
                                    &required) != GHOSTTY_SUCCESS) {
     printf("Failed to encode paste data\n");
@@ -69,7 +69,7 @@ int main() {
   char encoded_multi[128];
 
   if (ghostty_paste_encoder_encode(
-          multiline_paste, strlen(multiline_paste), encoder, encoded_multi,
+          encoder, multiline_paste, strlen(multiline_paste), encoded_multi,
           sizeof(encoded_multi), &required) != GHOSTTY_SUCCESS) {
     printf("Failed to encode multiline paste data\n");
     return 1;

include/ghostty/vt/paste.h

@@ -75,7 +75,7 @@
  * char simple_paste[] = "pasted content";
  * char encoded[128];
  *
- * if (ghostty_paste_encoder_encode(simple_paste, strlen(simple_paste), encoder,
+ * if (ghostty_paste_encoder_encode(encoder, simple_paste, strlen(simple_paste),
  *                                  encoded, sizeof(encoded),
  *                                  &required) != GHOSTTY_SUCCESS) {
  *   printf("Failed to encode paste data\n");
@@ -197,9 +197,9 @@ void ghostty_paste_encoder_set_bracketed(GhosttyPasteEncoder encoder,
  * > WARNING: The input data is not checked for safety. See the
  * ghostty_paste_is_safe() function to check if the data is safe to paste.
  *
+ * @param encoder The paste encoder handle, (must not be NULL)
  * @param data The paste data to encode (must not be NULL)
  * @param len The length of the data in bytes
- * @param encoder The paste encoder handle, (must not be NULL)
  * @param out The output buffer to write the encoded data into (must not be
  * NULL)
  * @param out_len The length of the output buffer in bytes
@@ -209,9 +209,9 @@ void ghostty_paste_encoder_set_bracketed(GhosttyPasteEncoder encoder,
  *
  * @ingroup paste
  */
-GhosttyResult ghostty_paste_encoder_encode(char* data,
+GhosttyResult ghostty_paste_encoder_encode(GhosttyPasteEncoder encoder,
+                                           char* data,
                                            size_t len,
-                                           GhosttyPasteEncoder encoder,
                                            char* out,
                                            size_t out_len,
                                            size_t* out_written);

src/terminal/c/paste.zig

@@ -42,9 +42,9 @@ pub fn encoder_set_bracketed(encoder_: Encoder, enabled: bool) callconv(.c) void
 }
 
 pub fn encode(
+    encoder_: Encoder,
     data_: ?[*]u8,
     len: usize,
-    encoder_: Encoder,
     out_: ?[*]u8,
     out_len: usize,
     out_written_: ?*usize,
@@ -74,16 +74,6 @@ pub fn is_safe(data: ?[*]const u8, len: usize) callconv(.c) bool {
     return paste.isSafe(slice);
 }
 
-test "alloc paste encoder" {
-    const testing = std.testing;
-    var e: Encoder = undefined;
-    try testing.expectEqual(Result.success, new(
-        &lib_alloc.test_allocator,
-        &e,
-    ));
-    free(e);
-}
-
 test "is_safe with safe data" {
     const testing = std.testing;
     const safe = "hello world";
@@ -112,3 +102,83 @@ test "is_safe with null empty data" {
     const testing = std.testing;
     try testing.expect(is_safe(null, 0));
 }
+
+test "encode bracketed" {
+    const testing = std.testing;
+    const alloc = testing.allocator;
+
+    var encoder: Encoder = undefined;
+    try testing.expect(new(&lib_alloc.test_allocator, &encoder) == .success);
+    encoder_set_bracketed(encoder, true);
+
+    const text: []u8 = try alloc.dupe(u8, "hello");
+    defer alloc.free(text);
+
+    var out: [128]u8 = undefined;
+    var out_len: usize = 0;
+
+    try testing.expect(encode(encoder, text.ptr, text.len, &out, out.len, &out_len) == .success);
+    try testing.expectEqualStrings("\x1b[200~hello\x1b[201~", out[0 .. out_len - 1]);
+
+    free(encoder);
+}
+
+test "encode unbracketed no newlines" {
+    const testing = std.testing;
+    const alloc = testing.allocator;
+
+    var encoder: Encoder = undefined;
+    try testing.expect(new(&lib_alloc.test_allocator, &encoder) == .success);
+    encoder_set_bracketed(encoder, false);
+
+    const text: []u8 = try alloc.dupe(u8, "hello");
+    defer alloc.free(text);
+
+    var out: [128]u8 = undefined;
+    var out_len: usize = 0;
+
+    try testing.expect(encode(encoder, text.ptr, text.len, &out, out.len, &out_len) == .success);
+    try testing.expectEqualStrings("hello", out[0 .. out_len - 1]);
+
+    free(encoder);
+}
+
+test "encode unbracketed newlines" {
+    const testing = std.testing;
+    const alloc = testing.allocator;
+
+    var encoder: Encoder = undefined;
+    try testing.expect(new(&lib_alloc.test_allocator, &encoder) == .success);
+    encoder_set_bracketed(encoder, false);
+
+    const text: []u8 = try alloc.dupe(u8, "hello\nworld");
+    defer alloc.free(text);
+
+    var out: [128]u8 = undefined;
+    var out_len: usize = 0;
+
+    try testing.expect(encode(encoder, text.ptr, text.len, &out, out.len, &out_len) == .success);
+    try testing.expectEqualStrings("hello\rworld", out[0 .. out_len - 1]);
+
+    free(encoder);
+}
+
+test "encode unbracketed windows-style newline" {
+    const testing = std.testing;
+    const alloc = testing.allocator;
+
+    var encoder: Encoder = undefined;
+    try testing.expect(new(&lib_alloc.test_allocator, &encoder) == .success);
+    encoder_set_bracketed(encoder, false);
+
+    const text: []u8 = try alloc.dupe(u8, "hello\r\nworld");
+    defer alloc.free(text);
+
+    var out: [128]u8 = undefined;
+    var out_len: usize = 0;
+
+    try testing.expect(encode(encoder, text.ptr, text.len, &out, out.len, &out_len) == .success);
+    try testing.expectEqualStrings("hello\r\rworld", out[0 .. out_len - 1]);
+
+    free(encoder);
+}