add serde zon example (#95)

Close #87

Author: jiacai2050

book-src/10-02-zon.md

@@ -0,0 +1,20 @@
+## Serialize and deserialize Zon
+
+ZON ("Zig Object Notation") is a textual file format. Outside of `nan` and `inf` literals, ZON's grammar is a subset of Zig's.
+
+Supported Zig primitives:
+* boolean literals
+* number literals (including `nan` and `inf`)
+* character literals
+* enum literals
+* `null` literals
+* string literals
+* multiline string literals
+
+ Supported Zig container types:
+ * anonymous struct literals
+ * anonymous tuple literals
+
+```zig
+{{#include ../src/10-02.zig }}
+```

book-src/10-02-base64.md renamed to book-src/10-03-base64.md

@@ -53,8 +53,9 @@
 
 - [Encoding]()
 
-  - [Deserialize JSON](./10-01-json.md)
-  - [Encode and decode base64](./10-02-base64.md)
+  - [(De)serialize JSON](./10-01-json.md)
+  - [(De)serialize Zon](./10-02-zon.md)
+  - [Encode and decode base64](./10-03-base64.md)
 
 - [Mathematics]()
 

book-src/SUMMARY.md

@@ -1,28 +1,62 @@
 const std = @import("std");
-const print = std.debug.print;
-const Encoder = std.base64.standard.Encoder;
-const Decoder = std.base64.standard.Decoder;
+const zon = std.zon;
+const Allocator = std.mem.Allocator;
+
+const Student = struct {
+    name: []const u8,
+    age: u16,
+    favourites: []const []const u8,
+
+    fn deinit(self: *Student, allocator: Allocator) void {
+        allocator.free(self.name);
+        for (self.favourites) |item| {
+            allocator.free(item);
+        }
+        allocator.free(self.favourites);
+    }
+};
 
 pub fn main() !void {
     var gpa = std.heap.GeneralPurposeAllocator(.{}){};
-    defer _ = gpa.deinit();
+    defer if (gpa.deinit() != .ok) @panic("leak");
     const allocator = gpa.allocator();
 
-    const src = "hello zig";
+    const source = Student{
+        .name = "John",
+        .age = 20,
+        .favourites = &.{ "swimming", "running" },
+    };
+
+    var dst = std.ArrayList(u8).init(allocator);
+    defer dst.deinit();
+    try zon.stringify.serialize(source, .{}, dst.writer());
 
-    // Encode
-    const encoded_length = Encoder.calcSize(src.len);
-    const encoded_buffer = try allocator.alloc(u8, encoded_length);
-    defer allocator.free(encoded_buffer);
+    const expected =
+        \\.{
+        \\    .name = "John",
+        \\    .age = 20,
+        \\    .favourites = .{ "swimming", "running" },
+        \\}
+    ;
+    try std.testing.expectEqualStrings(expected, dst.items);
 
-    _ = Encoder.encode(encoded_buffer, src);
-    try std.testing.expectEqualStrings("aGVsbG8gemln", encoded_buffer);
+    // Make it 0-sentinel
+    try dst.append(0);
+    const input = dst.items[0 .. dst.items.len - 1 :0];
 
-    // Decode
-    const decoded_length = try Decoder.calcSizeForSlice(encoded_buffer);
-    const decoded_buffer = try allocator.alloc(u8, decoded_length);
-    defer allocator.free(decoded_buffer);
+    var status: zon.parse.Status = .{};
+    defer status.deinit(allocator);
+    var parsed = zon.parse.fromSlice(
+        Student,
+        allocator,
+        input,
+        &status,
+        .{ .free_on_error = true },
+    ) catch |err| {
+        std.debug.print("Parse status: {any}\n", .{status});
+        return err;
+    };
+    defer parsed.deinit(allocator);
 
-    try Decoder.decode(decoded_buffer, encoded_buffer);
-    try std.testing.expectEqualStrings(src, decoded_buffer);
+    try std.testing.expectEqualDeep(source, parsed);
 }

src/10-02.zig

@@ -0,0 +1,28 @@
+const std = @import("std");
+const print = std.debug.print;
+const Encoder = std.base64.standard.Encoder;
+const Decoder = std.base64.standard.Decoder;
+
+pub fn main() !void {
+    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    defer _ = gpa.deinit();
+    const allocator = gpa.allocator();
+
+    const src = "hello zig";
+
+    // Encode
+    const encoded_length = Encoder.calcSize(src.len);
+    const encoded_buffer = try allocator.alloc(u8, encoded_length);
+    defer allocator.free(encoded_buffer);
+
+    _ = Encoder.encode(encoded_buffer, src);
+    try std.testing.expectEqualStrings("aGVsbG8gemln", encoded_buffer);
+
+    // Decode
+    const decoded_length = try Decoder.calcSizeForSlice(encoded_buffer);
+    const decoded_buffer = try allocator.alloc(u8, decoded_length);
+    defer allocator.free(decoded_buffer);
+
+    try Decoder.decode(decoded_buffer, encoded_buffer);
+    try std.testing.expectEqualStrings(src, decoded_buffer);
+}