From a8d485ffe1a1ec295e3481c7250a91ef10629118 Mon Sep 17 00:00:00 2001 From: mitteneer Date: Fri, 7 Mar 2025 10:23:03 -0500 Subject: [PATCH 1/3] Fix memory leak I'm not sure I'm happy with this yet, but it works, so who am I to judge --- src/root.zig | 42 ++++++++++++++++++++++-------------------- 1 file changed, 22 insertions(+), 20 deletions(-) diff --git a/src/root.zig b/src/root.zig index efaad7f..c21e0df 100644 --- a/src/root.zig +++ b/src/root.zig @@ -8,43 +8,33 @@ const Client = std.http.Client; pub const user_agent: []const u8 = "ZuletztMBClient/0.0.1 (swebbguy@gmail.com)"; -pub fn mbSearch(allocator: std.mem.Allocator, track_name: []const u8, album_name: []const u8, artist_name: []const u8) !?QR.Result { +pub fn mbSearch(allocator: std.mem.Allocator, ar: *std.ArrayList(u8), track_name: []const u8, album_name: []const u8, artist_name: []const u8) !?[]const u8 { var client = Client{ .allocator = allocator }; defer client.deinit(); const query: []const u8 = try std.fmt.allocPrint(allocator, "https://musicbrainz.org/ws/2/recording/?query=\"{s}\"%20AND%20artist:\"{s}\"%20AND%20release:\"{s}\"&fmt=json", .{ track_name, artist_name, album_name }); defer allocator.free(query); - var mb_result = std.ArrayList(u8).init(allocator); - errdefer mb_result.deinit(); - - const response: Client.FetchResult = try client.fetch(.{ .response_storage = .{ .dynamic = &mb_result }, .location = .{ .url = query }, .method = .GET, .headers = .{ .user_agent = .{ .override = user_agent } } }); + const response: Client.FetchResult = try client.fetch(.{ .response_storage = .{ .dynamic = ar }, .location = .{ .url = query }, .method = .GET, .headers = .{ .user_agent = .{ .override = user_agent } } }); switch (@intFromEnum(response.status)) { - 0...299 => std.log.debug("Success", .{}), + 0...299 => std.log.debug("Success\n", .{}), 300...399 => { - std.log.debug("Redirected", .{}); + std.log.err("Redirected\n", .{}); return null; }, 400...511 => { - std.log.err("Get rekt\n{s}", .{mb_result.items}); + std.log.err("Get rekt\n{s}", .{ar.items}); return Client.ConnectError.ConnectionRefused; }, 512 => { - std.log.debug("Need to login", .{}); + std.log.err("Need to login\n", .{}); return null; }, else => unreachable, } - //std.log.err("{s}", .{mb_result_slice}); - - const result = try std.json.parseFromSlice(QR.Result, allocator, mb_result.items, .{ .ignore_unknown_fields = true }); - defer result.deinit(); - - const query_result = result.value; - - return query_result; + return ar.items; } //pub fn getAlbumMBID(query: QR.Result) @@ -66,9 +56,21 @@ test "iamthemorning" { const iatm_id: []const u8 = "5854a6de-af8f-4b99-8710-cb47d6436a19"; - const search_result: ?QR.Result = try mbSearch(test_alloc, track, album, artist); + var mb_result = std.ArrayList(u8).init(test_alloc); + defer mb_result.deinit(); + + const search_result = try mbSearch(test_alloc, &mb_result, track, album, artist); + if (search_result) |sr| { - const recording = sr.recordings.?[0]; - try testing.expect(std.mem.eql(u8, recording.id, iatm_id)); + const result = try std.json.parseFromSlice(QR.Result, test_alloc, sr, .{ .ignore_unknown_fields = true }); + defer result.deinit(); + try testing.expect(std.mem.eql(u8, result.value.recordings.?[0].@"artist-credit"[0].artist.id, iatm_id)); } + + //defer result.deinit(); + //std.log.err("{s}", .{search_result.?.recordings.?[0].id}); + //if (search_result) |sr| { + // const recording = sr.recordings.?[0]; + // try testing.expect(std.mem.eql(u8, recording.id, iatm_id)); + //} } From daff0dc8c94d54cf646c2eebe369b893f7b0dee3 Mon Sep 17 00:00:00 2001 From: mitteneer Date: Fri, 7 Mar 2025 13:01:59 -0500 Subject: [PATCH 2/3] Make tests --- src/Alias.zig | 12 +++--- src/Entities.zig | 19 +++++++-- src/QueryResults.zig | 63 +++++++++++++++++++++++++++++ src/root.zig | 95 +++++++++++++++++++++++++++++++++++--------- 4 files changed, 161 insertions(+), 28 deletions(-) diff --git a/src/Alias.zig b/src/Alias.zig index c81b148..434fcf2 100644 --- a/src/Alias.zig +++ b/src/Alias.zig @@ -1,14 +1,14 @@ pub const Alias = struct { @"sort-name": []const u8, //sort_name: []const u8, - @"type-id": []const u8, + @"type-id": ?[]const u8 = null, //type_id: []const u8, name: []const u8, - locale: ?[]const u8, - type: []const u8, - primary: ?[]const u8, - @"begin-date": ?[]const u8, + locale: ?[]const u8 = null, + type: ?[]const u8 = null, + primary: ?[]const u8 = null, + @"begin-date": ?[]const u8 = null, //begin_date: []const u8, - @"end-date": ?[]const u8, + @"end-date": ?[]const u8 = null, //end_date: []const u8, }; diff --git a/src/Entities.zig b/src/Entities.zig index 9f0b49d..05d47ca 100644 --- a/src/Entities.zig +++ b/src/Entities.zig @@ -9,9 +9,11 @@ pub const Artist = struct { @"sort-name": []const u8, //sort_name: []const u8, aliases: ?[]Alias = null, + disambiguation: ?[]const u8 = null, }; pub const ArtistCredit = struct { + joinphrase: ?[]const u8 = null, name: []const u8, artist: Artist, }; @@ -23,15 +25,18 @@ pub const Recording = struct { video: ?bool, @"artist-credit": []ArtistCredit, //artist_credit: []ArtistCredit, - @"first-release-date": []const u8, + @"first-release-date": ?[]const u8 = null, //first_release_date: []const u8, releases: []Release, + isrcs: ?[][]const u8 = null, + tags: ?[]Tag = null, + disambiguation: ?[]const u8 = null, }; pub const Release = struct { id: []const u8, @"status-id": ?[]const u8 = null, //status_id: ?[]const u8 = null, - count: i32, + count: u8, title: []const u8, @"artist-credit": []ArtistCredit, //artist_credit: []ArtistCredit, @@ -45,10 +50,11 @@ pub const Release = struct { country: ?[]const u8 = null, @"release-events": ?[]ReleaseEvent = null, //release_events: ?[]ReleaseEvent = null, + disambiguation: ?[]const u8 = null, }; pub const Medium = struct { position: u8, - format: []const u8, + format: ?[]const u8 = null, track: []Track, @"track-count": u8, //track_count: u8, @@ -82,4 +88,11 @@ pub const ReleaseGroup = struct { title: []const u8, @"primary-type": []const u8, //primary_type: []const u8, + @"secondary-types": ?[][]const u8 = null, + @"secondary-type-ids": ?[][]const u8 = null, +}; + +const Tag = struct { + count: u8, + name: []const u8, }; diff --git a/src/QueryResults.zig b/src/QueryResults.zig index 15b5694..b6dc9e4 100644 --- a/src/QueryResults.zig +++ b/src/QueryResults.zig @@ -1,11 +1,74 @@ +const std = @import("std"); + const Entities = @import("Entities.zig"); +const Artist = Entities.Artist; const Recording = Entities.Recording; pub const Result = struct { created: ?[]const u8 = null, count: ?u32 = null, offset: ?u32 = null, + artists: ?[]Artist = null, recordings: ?[]Recording = null, @"error": ?[]const u8 = null, help: ?[]const u8 = null, + + pub fn getSpecifiedARID(self: *const Result, an: []const u8, tn: []const u8) ?[]const u8 { + if (self.count) |count| { // Otherwise there was an error + switch (count) { + 0 => return null, // No results + 1 => { + switch (self.recordings.?[0].@"artist-credit".len) { + 0 => unreachable, // All recordings have at least one ArtistCredit + 1 => return self.recordings.?[0].@"artist-credit"[0].artist.id, + else => { + for (self.recordings.?[0].@"artist-credit") |ac| { + if (std.mem.eql(u8, ac.name, an)) return ac.artist.id; + } + }, + } + }, + else => { + for (self.recordings.?) |rc| { + if (std.mem.eql(u8, rc.title, tn)) { // I'd really prefer not including track name, but for complete accuracy + for (rc.@"artist-credit") |ac| { + if (std.mem.eql(u8, ac.name, an)) return ac.artist.id; + } + } + } + }, + } + } + return null; // Maybe return error here instead + } + + // Not sure if I want to get a ReleaseGroup or Release yet. Start with ReleaseGroup + pub fn getSpecifiedRGID(self: *const Result, tn: []const u8, rgn: []const u8) ?[]const u8 { + if (self.count) |count| { + switch (count) { + 0 => return null, + 1 => { + switch (self.recordings.?[0].releases.len) { + 0 => unreachable, + 1 => return self.recordings.?[0].releases[0].id, + else => { + for (self.recordings.?[0].releases) |re| { + if (std.mem.eql(u8, re.title, rgn)) return re.id; + } + }, + } + }, + else => { // This is not ideal, limit the number of results + for (self.recordings.?) |rc| { + if (std.mem.eql(u8, rc.title, tn)) { + for (rc.releases) |re| { + if (std.mem.eql(u8, re.@"release-group".title, rgn)) return re.@"release-group".id; + } + } + } + }, + } + } + return null; + } }; diff --git a/src/root.zig b/src/root.zig index c21e0df..3e36a9b 100644 --- a/src/root.zig +++ b/src/root.zig @@ -37,18 +37,10 @@ pub fn mbSearch(allocator: std.mem.Allocator, ar: *std.ArrayList(u8), track_name return ar.items; } -//pub fn getAlbumMBID(query: QR.Result) -//pub fn getArtistMBID(query: QR.Result) -//pub fn getSongMBID(query: QR.Result) - -//test "basic add functionality" { -// try testing.expect(add(3, 7) == 10); -//} - // This test is very volatile, but I think // these params are specific enough that // it shouldn't need changing too often -test "iamthemorning" { +test "arid_via_recording" { const test_alloc = std.testing.allocator; const track: []const u8 = "Veni%20Veni%20Emmanuel"; const album: []const u8 = "Counting%20the%20Ghosts"; @@ -62,15 +54,80 @@ test "iamthemorning" { const search_result = try mbSearch(test_alloc, &mb_result, track, album, artist); if (search_result) |sr| { - const result = try std.json.parseFromSlice(QR.Result, test_alloc, sr, .{ .ignore_unknown_fields = true }); - defer result.deinit(); - try testing.expect(std.mem.eql(u8, result.value.recordings.?[0].@"artist-credit"[0].artist.id, iatm_id)); - } + const json = try std.json.parseFromSlice(QR.Result, test_alloc, sr, .{ .ignore_unknown_fields = true }); + defer json.deinit(); - //defer result.deinit(); - //std.log.err("{s}", .{search_result.?.recordings.?[0].id}); - //if (search_result) |sr| { - // const recording = sr.recordings.?[0]; - // try testing.expect(std.mem.eql(u8, recording.id, iatm_id)); - //} + const result: QR.Result = json.value; + + try testing.expect(std.mem.eql(u8, result.getSpecifiedARID(artist, "Veni veni Emmanuel").?, iatm_id)); + } +} + +test "arid_via_recording_multiple_artists_1" { + const test_alloc = std.testing.allocator; + const track: []const u8 = "Roll%20Me%20Up%20And%20Smoke%20Me%20When%20I%20Die"; + const album: []const u8 = "Willie%20Nelson%20American%20Outlaw"; + const artist: []const u8 = "Lyle%20Lovett"; + + const ll_id: []const u8 = "7241e3ed-5ad4-4849-94df-6858ea833472"; + + var mb_result = std.ArrayList(u8).init(test_alloc); + defer mb_result.deinit(); + + const search_result = try mbSearch(test_alloc, &mb_result, track, album, artist); + + if (search_result) |sr| { + const json = try std.json.parseFromSlice(QR.Result, test_alloc, sr, .{ .ignore_unknown_fields = true }); + defer json.deinit(); + + const result: QR.Result = json.value; + + try testing.expect(std.mem.eql(u8, result.getSpecifiedARID("Lyle Lovett", "Roll Me Up and Smoke Me When I Die").?, ll_id)); + } +} + +test "rgid_via_recording" { + const test_alloc = std.testing.allocator; + const track: []const u8 = "I%20Of%20The%20Storm"; + const album: []const u8 = "Beneath%20The%20Skin"; + const artist: []const u8 = "Of%20Monsters%20and%20Men"; + + const bts_id: []const u8 = "2e1e605d-5090-420d-beae-e7ff73791082"; + + var mb_result = std.ArrayList(u8).init(test_alloc); + defer mb_result.deinit(); + + const search_result = try mbSearch(test_alloc, &mb_result, track, album, artist); + + if (search_result) |sr| { + const json = try std.json.parseFromSlice(QR.Result, test_alloc, sr, .{ .ignore_unknown_fields = true }); + defer json.deinit(); + + const result: QR.Result = json.value; + + try testing.expect(std.mem.eql(u8, result.getSpecifiedRGID("I of the Storm", "Beneath the Skin").?, bts_id)); + } +} + +test "rgid_via_recording_multiple_artists_2" { + const test_alloc = std.testing.allocator; + const track: []const u8 = "Hesitating%20Beauty"; + const album: []const u8 = "Mermaid%Avenue"; + const artist: []const u8 = "Wilco"; + + const wilco_id: []const u8 = "9e53f84d-ef44-4c16-9677-5fd4d78cbd7d"; + + var mb_result = std.ArrayList(u8).init(test_alloc); + defer mb_result.deinit(); + + const search_result = try mbSearch(test_alloc, &mb_result, track, album, artist); + + if (search_result) |sr| { + const json = try std.json.parseFromSlice(QR.Result, test_alloc, sr, .{ .ignore_unknown_fields = true }); + defer json.deinit(); + + const result: QR.Result = json.value; + + try testing.expect(std.mem.eql(u8, result.getSpecifiedARID("Wilco", "Hesitating Beauty").?, wilco_id)); + } } From 1bcbad8f8031ab47fb1fd8adff586f6e7fab05f2 Mon Sep 17 00:00:00 2001 From: mitteneer Date: Fri, 7 Mar 2025 19:44:33 -0500 Subject: [PATCH 3/3] Word on recording id test --- Alias.zig | 0 build.zig | 58 +++++++++++++++++++++++--------------------- src/Entities.zig | 5 +++- src/QueryResults.zig | 17 +++++++++++++ src/root.zig | 27 ++++++++++++++++++++- 5 files changed, 77 insertions(+), 30 deletions(-) delete mode 100644 Alias.zig diff --git a/Alias.zig b/Alias.zig deleted file mode 100644 index e69de29..0000000 diff --git a/build.zig b/build.zig index cc733a9..beffc71 100644 --- a/build.zig +++ b/build.zig @@ -29,20 +29,20 @@ pub fn build(b: *std.Build) void { }); // We will also create a module for our other entry point, 'main.zig'. - const exe_mod = b.createModule(.{ - // `root_source_file` is the Zig "entry point" of the module. If a module - // only contains e.g. external object files, you can make this `null`. - // In this case the main source file is merely a path, however, in more - // complicated build scripts, this could be a generated file. - .root_source_file = b.path("src/main.zig"), - .target = target, - .optimize = optimize, - }); + //const exe_mod = b.createModule(.{ + // // `root_source_file` is the Zig "entry point" of the module. If a module + // // only contains e.g. external object files, you can make this `null`. + // // In this case the main source file is merely a path, however, in more + // // complicated build scripts, this could be a generated file. + // .root_source_file = b.path("src/main.zig"), + // .target = target, + // .optimize = optimize, + //}); // Modules can depend on one another using the `std.Build.Module.addImport` function. // This is what allows Zig source code to use `@import("foo")` where 'foo' is not a // file path. In this case, we set up `exe_mod` to import `lib_mod`. - exe_mod.addImport("muzigbrainz_lib", lib_mod); + //exe_mod.addImport("muzigbrainz_lib", lib_mod); // Now, we will create a static library based on the module we created above. // This creates a `std.Build.Step.Compile`, which is the build step responsible @@ -60,41 +60,41 @@ pub fn build(b: *std.Build) void { // This creates another `std.Build.Step.Compile`, but this one builds an executable // rather than a static library. - const exe = b.addExecutable(.{ - .name = "muzigbrainz", - .root_module = exe_mod, - }); + //const exe = b.addExecutable(.{ + // .name = "muzigbrainz", + // .root_module = exe_mod, + //}); const zig_time_dep = b.dependency("zeit", .{}); - exe.root_module.addImport("zeit", zig_time_dep.module("zeit")); + lib.root_module.addImport("zeit", zig_time_dep.module("zeit")); // This declares intent for the executable to be installed into the // standard location when the user invokes the "install" step (the default // step when running `zig build`). - b.installArtifact(exe); + //b.installArtifact(exe); // This *creates* a Run step in the build graph, to be executed when another // step is evaluated that depends on it. The next line below will establish // such a dependency. - const run_cmd = b.addRunArtifact(exe); + //const run_cmd = b.addRunArtifact(exe); // By making the run step depend on the install step, it will be run from the // installation directory rather than directly from within the cache directory. // This is not necessary, however, if the application depends on other installed // files, this ensures they will be present and in the expected location. - run_cmd.step.dependOn(b.getInstallStep()); + //run_cmd.step.dependOn(b.getInstallStep()); // This allows the user to pass arguments to the application in the build // command itself, like this: `zig build run -- arg1 arg2 etc` - if (b.args) |args| { - run_cmd.addArgs(args); - } + //if (b.args) |args| { + // run_cmd.addArgs(args); + //} // This creates a build step. It will be visible in the `zig build --help` menu, // and can be selected like this: `zig build run` // This will evaluate the `run` step rather than the default, which is "install". - const run_step = b.step("run", "Run the app"); - run_step.dependOn(&run_cmd.step); + //const run_step = b.step("run", "Run the app"); + //run_step.dependOn(&run_cmd.step); // Creates a step for unit testing. This only builds the test executable // but does not run it. @@ -102,18 +102,20 @@ pub fn build(b: *std.Build) void { .root_module = lib_mod, }); + lib_unit_tests.root_module.addImport("zeit", zig_time_dep.module("zeit")); + const run_lib_unit_tests = b.addRunArtifact(lib_unit_tests); - const exe_unit_tests = b.addTest(.{ - .root_module = exe_mod, - }); + //const exe_unit_tests = b.addTest(.{ + // .root_module = exe_mod, + //}); - const run_exe_unit_tests = b.addRunArtifact(exe_unit_tests); + //const run_exe_unit_tests = b.addRunArtifact(exe_unit_tests); // Similar to creating the run step earlier, this exposes a `test` step to // the `zig build --help` menu, providing a way for the user to request // running the unit tests. const test_step = b.step("test", "Run unit tests"); test_step.dependOn(&run_lib_unit_tests.step); - test_step.dependOn(&run_exe_unit_tests.step); + //test_step.dependOn(&run_exe_unit_tests.step); } diff --git a/src/Entities.zig b/src/Entities.zig index 05d47ca..05654c0 100644 --- a/src/Entities.zig +++ b/src/Entities.zig @@ -2,6 +2,7 @@ //! Fields based on JSON response fields const Alias = @import("Alias.zig").Alias; +const zeit = @import("zeit"); pub const Artist = struct { id: []const u8, @@ -17,6 +18,7 @@ pub const ArtistCredit = struct { name: []const u8, artist: Artist, }; + pub const Recording = struct { id: []const u8, score: u8, @@ -25,7 +27,8 @@ pub const Recording = struct { video: ?bool, @"artist-credit": []ArtistCredit, //artist_credit: []ArtistCredit, - @"first-release-date": ?[]const u8 = null, + //@"first-release-date": ?[]const u8 = null, + @"first-release-date": ?union(enum) { slice: []const u8, dt: zeit.Date } = null, //first_release_date: []const u8, releases: []Release, isrcs: ?[][]const u8 = null, diff --git a/src/QueryResults.zig b/src/QueryResults.zig index b6dc9e4..f38e6e1 100644 --- a/src/QueryResults.zig +++ b/src/QueryResults.zig @@ -1,4 +1,5 @@ const std = @import("std"); +const zeit = @import("zeit"); const Entities = @import("Entities.zig"); const Artist = Entities.Artist; @@ -6,6 +7,7 @@ const Recording = Entities.Recording; pub const Result = struct { created: ?[]const u8 = null, + //created: ?zeit.Instant.Source.iso8601 = null, count: ?u32 = null, offset: ?u32 = null, artists: ?[]Artist = null, @@ -71,4 +73,19 @@ pub const Result = struct { } return null; } + + pub fn getSpecifiedRID(self: *const Result, tn: []const u8, rgn: []const u8, an: []const u8) ?[]const u8 { + _ = tn; + _ = rgn; + _ = an; + if (self.count) |count| { + switch (count) { + 0 => return null, + 1 => return self.recording.?[0].id, + else => { + return null; // Sort by date + }, + } + } + } }; diff --git a/src/root.zig b/src/root.zig index 3e36a9b..59c093f 100644 --- a/src/root.zig +++ b/src/root.zig @@ -112,7 +112,7 @@ test "rgid_via_recording" { test "rgid_via_recording_multiple_artists_2" { const test_alloc = std.testing.allocator; const track: []const u8 = "Hesitating%20Beauty"; - const album: []const u8 = "Mermaid%Avenue"; + const album: []const u8 = "Mermaid%20Avenue"; const artist: []const u8 = "Wilco"; const wilco_id: []const u8 = "9e53f84d-ef44-4c16-9677-5fd4d78cbd7d"; @@ -130,4 +130,29 @@ test "rgid_via_recording_multiple_artists_2" { try testing.expect(std.mem.eql(u8, result.getSpecifiedARID("Wilco", "Hesitating Beauty").?, wilco_id)); } + + //try testing.expect(false); } + +//test "rid" { +// const test_alloc = std.testing.allocator; +// const track: []const u8 = "Battery"; +// const album: []const u8 = "Master%20of%20Puppets"; +// const artist: []const u8 = "Metallica"; +// +// const battery_id: []const u8 = "3bfda26a-49fa-4bc4-a4d6-8bbfa0767ab7"; +// +// var mb_result = std.ArrayList(u8).init(test_alloc); +// defer mb_result.deinit(); +// +// const search_result = try mbSearch(test_alloc, &mb_result, track, album, artist); +// +// if (search_result) |sr| { +// const json = try std.json.parseFromSlice(QR.Result, test_alloc, sr, .{ .ignore_unknown_fields = true }); +// defer json.deinit(); +// +// const result: QR.Result = json.value; +// +// try testing.expect(std.mem.eql(u8, result.getSpecifiedARID("Wilco", "Hesitating Beauty").?, battery_id)); +// } +//}