clean up VLC-related code

src/main.zig

@@ -1,5 +1,4 @@
 const std = @import("std");
-const xml = @import("./xml.zig");
 
 // Music Player:
 // - Launch VLC and control it via HTTP interface
@@ -20,16 +19,8 @@ pub fn main() !void {
     defer _ = gpa.deinit();
     const allocator = gpa.allocator();
 
-    // var vlc = std.process.Child.init(&[_][]const u8{
+    var vlc = try VLC.init(allocator, try std.Uri.parse("http://localhost:8080"));
-    //     "vlc",
+    defer vlc.deinit();
-    //     "--intf",
-    //     "http",
-    //     "--http-host",
-    //     "localhost",
-    //     "--http-password",
-    //     "1234",
-    // }, allocator);
-    // try vlc.spawn();
 
     var tz_file = try std.fs.openFileAbsolute("/etc/localtime", .{});
     defer tz_file.close();
@@ -38,25 +29,24 @@ pub fn main() !void {
 
     while (true) : (std.time.sleep(1_000_000_000)) { // sleep 500ms
         try updateTime(tz);
-        try updateStatus(allocator);
+        try updateStatus(allocator, &vlc);
         scroll += 1;
     }
-
-    // try vlc.kill();
 }
 
 const base64_encoder = std.base64.standard.Encoder;
 
+// TODO make the URL something short like jeevio.xyz/streamboy
 const topic = "Something Fun For Everyone With Streamboy!!!!!!!! git.jeevio.xyz/jeeves/streamboy";
 
 var scroll: usize = 0;
 
-fn updateStatus(allocator: std.mem.Allocator) !void {
+fn updateStatus(allocator: std.mem.Allocator, vlc: *VLC) !void {
     var stream_info_file = try std.fs.createFileAbsolute("/tmp/streaminfo", .{ .truncate = true });
     defer stream_info_file.close();
 
-    var song_info = try getSongInfo(allocator);
+    var song_info = try vlc.getSongInfo();
-    defer song_info.deinit(allocator);
+    defer song_info.deinit();
 
     const string = try std.fmt.allocPrint(allocator, "{s}    |    ♪ {s} - {s}    |    ", .{
         topic,
@@ -72,50 +62,108 @@ fn updateStatus(allocator: std.mem.Allocator) !void {
     }
 }
 
-const SongInfo = struct {
+pub const VLC = struct {
-    title: ?[]const u8,
+    allocator: std.mem.Allocator,
-    album: ?[]const u8,
+    http: std.http.Client,
-    artist: ?[]const u8,
+    base_uri: std.Uri,
-
+    authorization: []u8,
-    pub fn deinit(self: *SongInfo, allocator: std.mem.Allocator) void {
-        if (self.title) |b| allocator.free(b);
-        if (self.album) |b| allocator.free(b);
-        if (self.artist) |b| allocator.free(b);
-    }
-};
-
-fn getSongInfo(allocator: std.mem.Allocator) !SongInfo {
-    var http = std.http.Client{ .allocator = allocator };
-    defer http.deinit();
 
+    pub fn init(allocator: std.mem.Allocator, base_uri: std.Uri) !VLC {
         const userpass = try std.fmt.allocPrint(allocator, ":{s}", .{"1234"});
         defer allocator.free(userpass);
 
         const base64_userpass = try allocator.alloc(u8, base64_encoder.calcSize(userpass.len));
         defer allocator.free(base64_userpass);
 
-    const final_userpass = try std.fmt.allocPrint(allocator, "Basic {s}", .{base64_encoder.encode(base64_userpass, userpass)});
+        const authorization = try std.fmt.allocPrint(allocator, "Basic {s}", .{base64_encoder.encode(base64_userpass, userpass)});
-    defer allocator.free(final_userpass);
+        errdefer allocator.free(authorization);
 
-    var response = std.ArrayList(u8).init(allocator);
+        // var vlc = std.process.Child.init(&[_][]const u8{
+        //     "vlc",
+        //     "--intf",
+        //     "http",
+        //     "--http-host",
+        //     "localhost",
+        //     "--http-password",
+        //     "1234",
+        // }, allocator);
+        // try vlc.spawn();
+
+        return .{
+            .allocator = allocator,
+            .http = std.http.Client{ .allocator = allocator },
+            .base_uri = base_uri,
+            .authorization = authorization,
+        };
+    }
+
+    pub fn deinit(self: *VLC) void {
+        self.http.deinit();
+        self.allocator.free(self.authorization);
+        // try vlc.kill();
+    }
+
+    fn request(self: *VLC, uri: std.Uri) !Response {
+        var combined_uri = self.base_uri;
+        combined_uri.path = uri.path;
+        combined_uri.query = uri.query;
+        combined_uri.fragment = uri.fragment;
+
+        var response = std.ArrayList(u8).init(self.allocator);
         defer response.deinit();
 
-    const result = try http.fetch(.{
+        const result = try self.http.fetch(.{
-        .location = .{ .url = "http://localhost:8080/requests/status.xml" },
+            .location = .{ .uri = combined_uri },
-        .headers = .{ .authorization = .{ .override = final_userpass } },
+            .headers = .{ .authorization = .{ .override = self.authorization } },
             .response_storage = .{ .dynamic = &response },
         });
 
-    std.debug.print("{any}\n{s}\n", .{ result, response.items });
+        // std.debug.print("{any}\n{s}\n", .{ result, response.items });
 
-    const document = try xml.parse(allocator, response.items);
+        if (result.status != .ok) return error.HttpRequestFailed;
-    defer document.deinit();
+
+        const buffer = try response.toOwnedSlice();
+        return .{
+            .buffer = buffer,
+            .document = try xml.parse(self.allocator, buffer),
+        };
+    }
+
+    const Response = struct {
+        buffer: []u8,
+        document: xml.Document,
+
+        pub fn deinit(self: *Response, allocator: std.mem.Allocator) void {
+            self.document.deinit();
+            allocator.free(self.buffer);
+        }
+    };
+
+    pub const SongInfo = struct {
+        allocator: std.mem.Allocator,
+        title: ?[]const u8,
+        album: ?[]const u8,
+        artist: ?[]const u8,
+
+        // TODO move allocator into struct
+        pub fn deinit(self: *SongInfo) void {
+            if (self.title) |b| self.allocator.free(b);
+            if (self.album) |b| self.allocator.free(b);
+            if (self.artist) |b| self.allocator.free(b);
+        }
+    };
+
+    pub fn getSongInfo(self: *VLC) !SongInfo {
+        var response = try self.request(.{ .scheme = "http", .path = .{ .percent_encoded = "/requests/status.xml" } });
+        defer response.deinit(self.allocator);
+
+        // std.debug.print("{s}\n", .{response.buffer});
 
         var title: ?[]const u8 = null;
         var album: ?[]const u8 = null;
         var artist: ?[]const u8 = null;
 
-    if (document.root.findChildByTag("information")) |information| {
+        if (response.document.root.findChildByTag("information")) |information| {
             var categories_it = information.findChildrenByTag("category");
             while (categories_it.next()) |category| {
                 if (std.mem.eql(u8, category.getAttribute("name").?, "meta")) {
@@ -123,40 +171,45 @@ fn getSongInfo(allocator: std.mem.Allocator) !SongInfo {
                     while (info_it.next()) |info| {
                         const info_name = info.getAttribute("name").?;
                         if (std.mem.eql(u8, info_name, "title"))
-                        title = try processHtmlString(allocator, info.children[0].char_data)
+                            title = try processHtmlString(self, info.children[0].char_data)
                         else if (std.mem.eql(u8, info_name, "album"))
-                        album = try processHtmlString(allocator, info.children[0].char_data)
+                            album = try processHtmlString(self, info.children[0].char_data)
                         else if (std.mem.eql(u8, info_name, "artist"))
-                        artist = try processHtmlString(allocator, info.children[0].char_data);
+                            artist = try processHtmlString(self, info.children[0].char_data);
                     }
                 }
             }
         }
 
         return .{
+            .allocator = self.allocator,
             .title = title,
             .album = album,
             .artist = artist,
         };
-}
+    }
 
-fn processHtmlString(allocator: std.mem.Allocator, string: []const u8) ![]const u8 {
+    // TODO clean up
-    var new: []u8 = try allocator.dupe(u8, string);
+    fn processHtmlString(self: *VLC, string: []const u8) ![]const u8 {
-    errdefer allocator.free(new);
+        var new: []u8 = try self.allocator.dupe(u8, string);
+        errdefer self.allocator.free(new);
         while (true) {
             if (std.mem.indexOf(u8, new, "&#")) |amp| {
                 if (std.mem.indexOfScalarPos(u8, new, amp, ';')) |semi| {
                     const int = try std.fmt.parseInt(u8, new[amp + 2 .. semi], 10);
-                const nnew = try allocator.alloc(u8, std.mem.replacementSize(u8, new, new[amp .. semi + 1], &[1]u8{int}));
+                    const nnew = try self.allocator.alloc(u8, std.mem.replacementSize(u8, new, new[amp .. semi + 1], &[1]u8{int}));
                     _ = std.mem.replace(u8, new, new[amp .. semi + 1], &[1]u8{int}, nnew);
-                allocator.free(new);
+                    self.allocator.free(new);
                     new = nnew;
                 }
             } else break;
         }
-    std.debug.print("{s}\n", .{new});
+        // std.debug.print("{s}\n", .{new});
         return new;
-}
+    }
+
+    const xml = @import("./xml.zig");
+};
 
 fn updateTime(tz: std.Tz) !void {
     const original_timestamp = std.time.timestamp();