support partial writes

Author: sentriz

taglib.cpp

@@ -9,6 +9,7 @@ char *to_char_array(const TagLib::String &s) {
   const std::string str = s.to8Bit(true);
   return ::strdup(str.c_str());
 }
+
 TagLib::String to_string(const char *s) {
   return TagLib::String(s, TagLib::String::UTF8);
 }
@@ -37,7 +38,7 @@ taglib_file_tags(const char *filename) {
   for (const auto &kvs : properties)
     for (const auto &v : kvs.second) {
       TagLib::String row = kvs.first + "\t" + v;
-      tags[i] = stringToCharArray(row);
+      tags[i] = to_char_array(row);
       i++;
     }
   tags[len] = nullptr;
@@ -46,7 +47,7 @@ taglib_file_tags(const char *filename) {
 }
 
 __attribute__((export_name("taglib_file_write_tags"))) bool
-taglib_file_write_tags(const char *filename, const char **tags) {
+taglib_file_write_tags(const char *filename, const char **tags, bool replace) {
   if (!filename || !tags)
     return false;
 
@@ -55,18 +56,31 @@ taglib_file_write_tags(const char *filename, const char **tags) {
     return false;
 
   TagLib::PropertyMap properties;
-  for (size_t i = 0; tags[i] != NULL; i++) {
-    TagLib::String row = to_string(tags[i]);
-    if (auto ti = row.find("\t"); ti >= 0) {
+  for (size_t i = 0; tags[i] != nullptr; i++) {
+    TagLib::String row(tags[i], TagLib::String::UTF8);
+    if (auto ti = row.find("\t"); ti != -1) {
       TagLib::String key(row.substr(0, ti));
-      TagLib::StringList value(row.substr(ti + 1));
-      properties.insert(key, value);
+      if (auto v = row.substr(ti + 1); !v.isEmpty()) {
+        properties.insert(key, TagLib::StringList(v));
+      } else {
+        properties.insert(key, TagLib::StringList());
+      }
     }
   }
 
-  if (auto rejected = file.setProperties(properties); rejected.size() > 0)
-    return 0;
+  if (replace) {
+    if (auto rejected = file.setProperties(properties); !rejected.isEmpty())
+      return 0;
+    return file.save();
+  }
 
+  auto existing = file.properties();
+  existing.erase(properties); // wipe the keys we're sending
+  existing.merge(properties); // merge them in
+  existing.removeEmpty();
+
+  if (auto rejected = file.setProperties(existing); !rejected.isEmpty())
+    return 0;
   return file.save();
 }
 

taglib.go

@@ -30,7 +30,7 @@ var ErrSavingFile = fmt.Errorf("can't save file")
 
 // These constants define normalized tag keys used by TagLib's [property mapping].
 // When using [ReadTags], the library will map format-specific metadata to these standardized keys.
-// Similarly, [WriteTags] will map these keys back to the appropriate format-specific fields.
+// Similarly, [WriteTags] and [ReplaceTags] will map these keys back to the appropriate format-specific fields.
 //
 // While these constants provide a consistent interface across different audio formats,
 // you can also use custom tag keys if the underlying format supports arbitrary tags.
@@ -221,8 +221,17 @@ func ReadProperties(path string) (Properties, error) {
 	}, nil
 }
 
-// WriteTags writes metadata tags to an audio file at the given path.
+// WriteTags writes the metadata key-values pairs to path, leaving other found keys untouched.
 func WriteTags(path string, tags map[string][]string) error {
+	return writeTagsOpt(path, tags, false)
+}
+
+// ReplaceTags replaces all tag metadata at path with the the metadata in thhe map.
+func ReplaceTags(path string, tags map[string][]string) error {
+	return writeTagsOpt(path, tags, true)
+}
+
+func writeTagsOpt(path string, tags map[string][]string, replace bool) error {
 	var err error
 	path, err = filepath.Abs(path)
 	if err != nil {
@@ -238,13 +247,17 @@ func WriteTags(path string, tags map[string][]string) error {
 
 	var raw []string
 	for k, vs := range tags {
+		if len(vs) == 0 {
+			raw = append(raw, k+"\t") // allow clearing
+			continue
+		}
 		for _, v := range vs {
 			raw = append(raw, k+"\t"+v)
 		}
 	}
 
 	var out bool
-	if err := mod.call("taglib_file_write_tags", &out, wasmPath(path), raw); err != nil {
+	if err := mod.call("taglib_file_write_tags", &out, wasmPath(path), raw, replace); err != nil {
 		return fmt.Errorf("call: %w", err)
 	}
 	if !out {
@@ -353,6 +366,12 @@ func (m *module) call(name string, dest any, args ...any) error {
 	params := make([]uint64, 0, len(args))
 	for _, a := range args {
 		switch a := a.(type) {
+		case bool:
+			if a {
+				params = append(params, 1)
+			} else {
+				params = append(params, 0)
+			}
 		case int:
 			params = append(params, uint64(a))
 		case uint32:

taglib.wasm

@@ -32,14 +32,14 @@ func TestClear(t *testing.T) {
 	for _, path := range paths {
 		t.Run(filepath.Base(path), func(t *testing.T) {
 			// set some tags first
-			err := taglib.WriteTags(path, map[string][]string{
+			err := taglib.ReplaceTags(path, map[string][]string{
 				"ARTIST":     {"Example A"},
 				"ALUMARTIST": {"Example"},
 			})
 			nilErr(t, err)
 
 			// then clear
-			err = taglib.WriteTags(path, nil)
+			err = taglib.ReplaceTags(path, nil)
 			nilErr(t, err)
 
 			got, err := taglib.ReadTags(path)
@@ -94,20 +94,88 @@ func TestReadWrite(t *testing.T) {
 	for _, path := range paths {
 		for i, tags := range testTags {
 			t.Run(fmt.Sprintf("%s_tags_%d", filepath.Base(path), i), func(t *testing.T) {
-				err := taglib.WriteTags(path, tags)
+				err := taglib.ReplaceTags(path, tags)
 				nilErr(t, err)
 
 				got, err := taglib.ReadTags(path)
 				nilErr(t, err)
 
-				if !maps.EqualFunc(got, tags, slices.Equal) {
-					t.Fatalf("%v != %v", got, tags)
-				}
+				tagEq(t, got, tags)
 			})
 		}
 	}
 }
 
+func TestMergeWrite(t *testing.T) {
+	t.Parallel()
+
+	paths := testPaths(t)
+
+	cmp := func(t *testing.T, path string, want map[string][]string) {
+		t.Helper()
+		tags, err := taglib.ReadTags(path)
+		nilErr(t, err)
+		tagEq(t, tags, want)
+	}
+
+	for _, path := range paths {
+		t.Run(filepath.Base(path), func(t *testing.T) {
+			err := taglib.ReplaceTags(path, nil) // clear
+			nilErr(t, err)
+
+			err = taglib.WriteTags(path, map[string][]string{
+				"ONE": {"one"},
+			})
+			nilErr(t, err)
+			cmp(t, path, map[string][]string{
+				"ONE": {"one"},
+			})
+
+			nilErr(t, err)
+			err = taglib.WriteTags(path, map[string][]string{
+				"TWO": {"two", "two!"},
+			})
+			nilErr(t, err)
+			cmp(t, path, map[string][]string{
+				"ONE": {"one"},
+				"TWO": {"two", "two!"},
+			})
+
+			err = taglib.WriteTags(path, map[string][]string{
+				"THREE": {"three"},
+			})
+			nilErr(t, err)
+			cmp(t, path, map[string][]string{
+				"ONE":   {"one"},
+				"TWO":   {"two", "two!"},
+				"THREE": {"three"},
+			})
+
+			// change prev
+			err = taglib.WriteTags(path, map[string][]string{
+				"ONE": {"one new"},
+			})
+			nilErr(t, err)
+			cmp(t, path, map[string][]string{
+				"ONE":   {"one new"},
+				"TWO":   {"two", "two!"},
+				"THREE": {"three"},
+			})
+
+			// change prev
+			err = taglib.WriteTags(path, map[string][]string{
+				"ONE":   {},
+				"THREE": {"three new!"},
+			})
+			nilErr(t, err)
+			cmp(t, path, map[string][]string{
+				"TWO":   {"two", "two!"},
+				"THREE": {"three new!"},
+			})
+		})
+	}
+}
+
 func TestReadExistingUnicode(t *testing.T) {
 	tags, err := taglib.ReadTags("testdata/normal.flac")
 	nilErr(t, err)
@@ -208,14 +276,14 @@ func BenchmarkWrite(b *testing.B) {
 	b.ResetTimer()
 
 	for range b.N {
-		err := taglib.WriteTags(path, bigTags)
+		err := taglib.ReplaceTags(path, bigTags)
 		nilErr(b, err)
 	}
 }
 
 func BenchmarkRead(b *testing.B) {
 	path := tmpf(b, egFLAC, "eg.flac")
-	err := taglib.WriteTags(path, bigTags)
+	err := taglib.ReplaceTags(path, bigTags)
 	nilErr(b, err)
 	b.ResetTimer()
 
@@ -267,6 +335,12 @@ func eq[T comparable](t testing.TB, a, b T) {
 		t.Fatalf("%v != %v", a, b)
 	}
 }
+func tagEq(t testing.TB, a, b map[string][]string) {
+	if !maps.EqualFunc(a, b, slices.Equal) {
+		t.Helper()
+		t.Fatalf("%q != %q", a, b)
+	}
+}
 
 func checkMem(t testing.TB) {
 	stop := make(chan struct{})