new TPS v1.1.0

Author: KSemenenko

design/TPS.md

@@ -13,6 +13,7 @@ public sealed record TpsStructureHeaderSnapshot(
     string Name,
     int? TargetWpm,
     string EmotionKey,
+    string Speaker,
     string Timing)
 {
     public bool SupportsTiming => Kind == TpsStructureHeaderKind.Segment;

src/PrompterOne.Core/Editor/Models/TpsStructureHeaderSnapshot.cs

@@ -4,35 +4,30 @@
 
 namespace PrompterOne.Core.Services.Editor;
 
-public sealed class TpsFrontMatterDocumentService
+public sealed partial class TpsFrontMatterDocumentService
 {
-    private static readonly Regex FrontMatterRegex = new(
-        @"\A---\s*\r?\n(?<front>.*?)\r?\n---\s*\r?\n?",
-        RegexOptions.Singleline | RegexOptions.Compiled);
-
     private static readonly string[] PreferredMetadataOrder =
     [
         MetadataKeys.Title,
-        MetadataKeys.Author,
         MetadataKeys.Profile,
+        MetadataKeys.Duration,
         MetadataKeys.BaseWpm,
-        MetadataKeys.DisplayDuration,
-        MetadataKeys.XslowOffset,
-        MetadataKeys.SlowOffset,
-        MetadataKeys.FastOffset,
-        MetadataKeys.XfastOffset,
-        MetadataKeys.Version,
-        MetadataKeys.Created
+        MetadataKeys.Author,
+        MetadataKeys.Created,
+        MetadataKeys.Version
     ];
 
+    [GeneratedRegex(@"\A---\s*\r?\n(?<front>.*?)\r?\n---\s*\r?\n?", RegexOptions.Singleline)]
+    private static partial Regex FrontMatterRegex();
+
     public TpsFrontMatterDocument Parse(string? text)
     {
         if (string.IsNullOrWhiteSpace(text))
         {
             return new TpsFrontMatterDocument(new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase), string.Empty, 0);
         }
 
-        var match = FrontMatterRegex.Match(text);
+        var match = FrontMatterRegex().Match(text);
         if (!match.Success)
         {
             return new TpsFrontMatterDocument(new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase), text, 0);
@@ -45,25 +40,23 @@ public TpsFrontMatterDocument Parse(string? text)
     public string Build(IReadOnlyDictionary<string, string> metadata, string? body)
     {
         var builder = new StringBuilder();
-        builder.AppendLine(MetadataTokens.Delimiter);
+        builder.AppendLine("---");
 
         foreach (var key in PreferredMetadataOrder.Where(metadata.ContainsKey))
         {
-            builder.Append(key);
-            builder.Append(MetadataTokens.Separator);
-            builder.AppendLine(FormatMetadataValue(key, metadata[key]));
+            AppendMetadataEntry(builder, key, metadata[key], IsNumericKey(key));
         }
 
+        AppendSpeedOffsets(builder, metadata);
+
         foreach (var entry in metadata
-                     .Where(entry => !PreferredMetadataOrder.Contains(entry.Key, StringComparer.OrdinalIgnoreCase))
+                     .Where(entry => !PreferredMetadataOrder.Contains(entry.Key, StringComparer.OrdinalIgnoreCase) && !IsSpeedOffsetKey(entry.Key))
                      .OrderBy(entry => entry.Key, StringComparer.OrdinalIgnoreCase))
         {
-            builder.Append(entry.Key);
-            builder.Append(MetadataTokens.Separator);
-            builder.AppendLine(FormatMetadataValue(entry.Key, entry.Value));
+            AppendMetadataEntry(builder, entry.Key, entry.Value, IsNumericKey(entry.Key));
         }
 
-        builder.AppendLine(MetadataTokens.Delimiter);
+        builder.AppendLine("---");
         builder.AppendLine();
         builder.Append((body ?? string.Empty).TrimStart());
         return builder.ToString();
@@ -95,104 +88,165 @@ public string Upsert(string? text, IReadOnlyDictionary<string, string?> updates)
 
     public string ResolveTitle(string? text, string fallback)
     {
-        var document = Parse(text);
-        return document.Metadata.TryGetValue(MetadataKeys.Title, out var title) &&
-               !string.IsNullOrWhiteSpace(title)
-            ? title.Trim()
-            : fallback;
+        return ResolveValue(text, MetadataKeys.Title, fallback);
     }
 
     public string ResolveValue(string? text, string key, string fallback)
     {
         var document = Parse(text);
-        return document.Metadata.TryGetValue(key, out var value) &&
-               !string.IsNullOrWhiteSpace(value)
+        return document.Metadata.TryGetValue(key, out var value) && !string.IsNullOrWhiteSpace(value)
             ? value.Trim()
             : fallback;
     }
 
-    private static string FormatMetadataValue(string key, string? value)
-    {
-        value ??= string.Empty;
-
-        if (IsNumericMetadataKey(key) && int.TryParse(value, out _))
-        {
-            return value;
-        }
-
-        return $"{MetadataTokens.Quote}{value.Replace(MetadataTokens.Quote, MetadataTokens.EscapedQuote, StringComparison.Ordinal)}{MetadataTokens.Quote}";
-    }
-
     public static class MetadataKeys
     {
-        public const string Author = "author";
-        public const string BaseWpm = "base_wpm";
-        public const string Created = "created";
-        public const string DisplayDuration = "display_duration";
-        public const string FastOffset = "fast_offset";
-        public const string Profile = "profile";
-        public const string SlowOffset = "slow_offset";
-        public const string Title = "title";
-        public const string Version = "version";
-        public const string XfastOffset = "xfast_offset";
-        public const string XslowOffset = "xslow_offset";
+        public const string Author = TpsSpec.FrontMatterKeys.Author;
+        public const string BaseWpm = TpsSpec.FrontMatterKeys.BaseWpm;
+        public const string Created = TpsSpec.FrontMatterKeys.Created;
+        public const string Duration = TpsSpec.FrontMatterKeys.Duration;
+        public const string Profile = TpsSpec.FrontMatterKeys.Profile;
+        public const string SpeedOffsetFast = TpsSpec.FrontMatterKeys.SpeedOffsetsFast;
+        public const string SpeedOffsetSlow = TpsSpec.FrontMatterKeys.SpeedOffsetsSlow;
+        public const string SpeedOffsetXfast = TpsSpec.FrontMatterKeys.SpeedOffsetsXfast;
+        public const string SpeedOffsetXslow = TpsSpec.FrontMatterKeys.SpeedOffsetsXslow;
+        public const string Title = TpsSpec.FrontMatterKeys.Title;
+        public const string Version = TpsSpec.FrontMatterKeys.Version;
     }
 
     private static Dictionary<string, string> ParseMetadata(string frontMatterText)
     {
         var metadata = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
         string? currentSection = null;
 
-        foreach (var rawLine in frontMatterText.Split('\n', StringSplitOptions.RemoveEmptyEntries))
+        foreach (var rawLine in frontMatterText.Split('\n'))
         {
-            var line = rawLine.TrimEnd();
-            var trimmedLine = line.Trim();
-            if (string.IsNullOrWhiteSpace(trimmedLine))
+            if (string.IsNullOrWhiteSpace(rawLine))
             {
                 continue;
             }
 
-            var separatorIndex = trimmedLine.IndexOf(':');
+            var indentationLength = rawLine.Length - rawLine.TrimStart().Length;
+            var line = rawLine.Trim();
+            var separatorIndex = line.IndexOf(':');
             if (separatorIndex <= 0)
             {
                 continue;
             }
 
-            var key = trimmedLine[..separatorIndex].Trim();
-            var value = trimmedLine[(separatorIndex + 1)..].Trim().Trim('"', '\'');
-            var isNestedLine = line.Length != line.TrimStart().Length;
-
-            if (isNestedLine && !string.IsNullOrWhiteSpace(currentSection))
+            var key = line[..separatorIndex].Trim();
+            var value = TrimValue(line[(separatorIndex + 1)..]);
+            if (indentationLength > 0 && !string.IsNullOrWhiteSpace(currentSection))
             {
-                metadata[$"{currentSection}.{key}"] = value;
+                var compositeKey = $"{currentSection}.{key}";
+                if (!IsLegacyKey(compositeKey))
+                {
+                    metadata[compositeKey] = value;
+                }
+
                 continue;
             }
 
+            currentSection = string.IsNullOrWhiteSpace(value) ? key : null;
             if (string.IsNullOrWhiteSpace(value))
             {
-                currentSection = key;
                 continue;
             }
 
-            currentSection = null;
-            metadata[key] = value;
+            if (!IsLegacyKey(key))
+            {
+                metadata[key] = value;
+            }
         }
 
-        return TpsFrontMatterMetadataNormalizer.Normalize(metadata);
+        return metadata;
     }
 
-    private static bool IsNumericMetadataKey(string key) =>
-        string.Equals(key, MetadataKeys.BaseWpm, StringComparison.OrdinalIgnoreCase) ||
-        string.Equals(key, MetadataKeys.XslowOffset, StringComparison.OrdinalIgnoreCase) ||
-        string.Equals(key, MetadataKeys.SlowOffset, StringComparison.OrdinalIgnoreCase) ||
-        string.Equals(key, MetadataKeys.FastOffset, StringComparison.OrdinalIgnoreCase) ||
-        string.Equals(key, MetadataKeys.XfastOffset, StringComparison.OrdinalIgnoreCase);
+    private static void AppendSpeedOffsets(StringBuilder builder, IReadOnlyDictionary<string, string> metadata)
+    {
+        var speedOffsetKeys = new[]
+        {
+            MetadataKeys.SpeedOffsetXslow,
+            MetadataKeys.SpeedOffsetSlow,
+            MetadataKeys.SpeedOffsetFast,
+            MetadataKeys.SpeedOffsetXfast
+        };
+
+        if (!speedOffsetKeys.Any(metadata.ContainsKey))
+        {
+            return;
+        }
+
+        builder.AppendLine("speed_offsets:");
+        AppendNestedSpeedOffset(builder, metadata, MetadataKeys.SpeedOffsetXslow, TpsSpec.Tags.Xslow);
+        AppendNestedSpeedOffset(builder, metadata, MetadataKeys.SpeedOffsetSlow, TpsSpec.Tags.Slow);
+        AppendNestedSpeedOffset(builder, metadata, MetadataKeys.SpeedOffsetFast, TpsSpec.Tags.Fast);
+        AppendNestedSpeedOffset(builder, metadata, MetadataKeys.SpeedOffsetXfast, TpsSpec.Tags.Xfast);
+    }
+
+    private static void AppendNestedSpeedOffset(StringBuilder builder, IReadOnlyDictionary<string, string> metadata, string key, string nestedKey)
+    {
+        if (!metadata.TryGetValue(key, out var value))
+        {
+            return;
+        }
+
+        builder.Append("  ");
+        builder.Append(nestedKey);
+        builder.Append(": ");
+        builder.AppendLine(FormatValue(value, numeric: true));
+    }
+
+    private static void AppendMetadataEntry(StringBuilder builder, string key, string value, bool numeric)
+    {
+        builder.Append(key);
+        builder.Append(": ");
+        builder.AppendLine(FormatValue(value, numeric));
+    }
+
+    private static string TrimValue(string value)
+    {
+        var trimmed = value.Trim();
+        if (trimmed.Length >= 2 &&
+            ((trimmed.StartsWith("\"", StringComparison.Ordinal) && trimmed.EndsWith("\"", StringComparison.Ordinal)) ||
+             (trimmed.StartsWith("'", StringComparison.Ordinal) && trimmed.EndsWith("'", StringComparison.Ordinal))))
+        {
+            return trimmed[1..^1];
+        }
+
+        return trimmed;
+    }
+
+    private static string FormatValue(string value, bool numeric)
+    {
+        return numeric && int.TryParse(value, out _)
+            ? value
+            : $"\"{value.Replace("\"", "\\\"", StringComparison.Ordinal)}\"";
+    }
+
+    private static bool IsNumericKey(string key)
+    {
+        return key.Equals(MetadataKeys.BaseWpm, StringComparison.OrdinalIgnoreCase) || IsSpeedOffsetKey(key);
+    }
+
+    private static bool IsSpeedOffsetKey(string key)
+    {
+        return key.Equals(MetadataKeys.SpeedOffsetXslow, StringComparison.OrdinalIgnoreCase) ||
+               key.Equals(MetadataKeys.SpeedOffsetSlow, StringComparison.OrdinalIgnoreCase) ||
+               key.Equals(MetadataKeys.SpeedOffsetFast, StringComparison.OrdinalIgnoreCase) ||
+               key.Equals(MetadataKeys.SpeedOffsetXfast, StringComparison.OrdinalIgnoreCase);
+    }
 
-    private static class MetadataTokens
+    private static bool IsLegacyKey(string key)
     {
-        public const string Delimiter = "---";
-        public const string EscapedQuote = "\\\"";
-        public const string Quote = "\"";
-        public const string Separator = ": ";
+        return key.Equals(TpsSpec.LegacyKeys.DisplayDuration, StringComparison.OrdinalIgnoreCase) ||
+               key.Equals(TpsSpec.LegacyKeys.XslowOffset, StringComparison.OrdinalIgnoreCase) ||
+               key.Equals(TpsSpec.LegacyKeys.SlowOffset, StringComparison.OrdinalIgnoreCase) ||
+               key.Equals(TpsSpec.LegacyKeys.FastOffset, StringComparison.OrdinalIgnoreCase) ||
+               key.Equals(TpsSpec.LegacyKeys.XfastOffset, StringComparison.OrdinalIgnoreCase) ||
+               key.Equals(TpsSpec.LegacyKeys.PresetsXslow, StringComparison.OrdinalIgnoreCase) ||
+               key.Equals(TpsSpec.LegacyKeys.PresetsSlow, StringComparison.OrdinalIgnoreCase) ||
+               key.Equals(TpsSpec.LegacyKeys.PresetsFast, StringComparison.OrdinalIgnoreCase) ||
+               key.Equals(TpsSpec.LegacyKeys.PresetsXfast, StringComparison.OrdinalIgnoreCase);
     }
 }