parse
parsed = p;
return true;
}
-}
\ No newline at end of file
+}
diff --git a/DevBase.Format/README.md b/DevBase.Format/README.md
index d870026..0080b7c 100644
--- a/DevBase.Format/README.md
+++ b/DevBase.Format/README.md
@@ -1,23 +1,6 @@
# DevBase.Format
-**DevBase.Format** is a comprehensive file format parsing library for .NET 9.0, specializing in lyrics formats (LRC, SRT, ELRC, etc.) and configuration files (ENV). It provides a unified API for parsing various text-based formats with strong typing and error handling.
-
-## Supported Formats
-
-### Lyrics Formats
-- **LRC** - Standard LRC lyrics with timestamps `[mm:ss.xx]`
-- **ELRC** - Enhanced LRC with word-level timing
-- **RLRC** - Rich LRC format
-- **SRT** - SubRip subtitle format
-- **Apple XML** - Apple Music lyrics XML format
-- **Apple LRC XML** - Apple's LRC-based XML format
-- **Apple Rich XML** - Apple's rich-synced lyrics format
-- **MML** - Music Markup Language
-- **RMML** - Rich Music Markup Language
-- **KLyrics** - Karaoke lyrics format
-
-### Configuration Formats
-- **ENV** - Environment variable files (`.env`)
+`DevBase.Format` parses lyric and configuration text formats for .NET 9.0. Use `FileParser` to parse either an in-memory string or a file on disk.
## Installation
@@ -25,495 +8,368 @@
dotnet add package DevBase.Format
```
-## Features
+## Supported formats
+
+| Format | Parser | Result |
+| --- | --- | --- |
+| LRC | `LrcParser` | `AList` |
+| ELRC | `ElrcParser` | `AList` |
+| RLRC | `RlrcParser` | `AList` |
+| SRT | `SrtParser` | `AList` |
+| KLyrics | `KLyricsParser` | `AList` |
+| MML JSON | `MmlParser` | `AList` |
+| RMML JSON | `RmmlParser` | `AList` |
+| Apple XML | `AppleXmlParser` | `AList` |
+| Apple LRC XML | `AppleLrcXmlParser` | `AList` |
+| Apple Rich XML | `AppleRichXmlParser` | `AList` |
+| ENV | `EnvParser` | `ATupleList` |
+
+`LrcParser`, `ElrcParser`, and `RlrcParser` are reversible and also implement `Revert` and `TryRevert`.
+
+## Parser examples
-- **Type-Safe Parsing** - Strongly-typed result objects
-- **Error Handling** - Try-parse pattern for safe parsing
-- **File & String Input** - Parse from disk or in-memory strings
-- **Timestamp Conversion** - Automatic timestamp parsing and conversion
-- **Rich Metadata** - Extract metadata tags from lyrics files
-- **Revertable Formats** - Convert parsed data back to original format
+Every example uses the same `FileParser` API for both a source string and a disk file. `ParseFromDisk` reads the file; callers do not need to read it themselves first.
-## Quick Start
+### LRC
-### Parsing LRC Lyrics
+Leading and trailing whitespace around each source line is trimmed. Metadata-style lines are ignored rather than returned as metadata objects.
```csharp
using DevBase.Format;
using DevBase.Format.Formats.LrcFormat;
+using DevBase.Format.Structure;
+using DevBase.Generics;
-// Parse from string
string lrcContent = @"
-[00:12.00]First line
-[00:15.50]Second line
-[00:20.00]Third line
-";
-
-var parser = new FileParser>();
-var lyrics = parser.ParseFromString(lrcContent);
-
-foreach (var line in lyrics)
-{
- Console.WriteLine($"[{line.StartTime}] {line.Text}");
-}
+ [00:12.00]First line
+ [00:15.50]Second line
+ [00:20.00]Third line
+ ";
-// Parse from file
-var lyricsFromFile = parser.ParseFromDisk("song.lrc");
+var parser = new FileParser>();
+AList lyrics = parser.ParseFromString(lrcContent);
+AList lyricsFromFile = parser.ParseFromDisk("song.lrc");
```
-### Parsing SRT Subtitles
+### ELRC
-```csharp
-using DevBase.Format.Formats.SrtFormat;
-
-var parser = new FileParser>();
-var subtitles = parser.ParseFromDisk("movie.srt");
-
-foreach (var subtitle in subtitles)
-{
- Console.WriteLine($"{subtitle.StartTime}: {subtitle.Text}");
-}
-```
-
-### Parsing ENV Files
+ELRC stores a line's start/end time and individual word timings.
```csharp
-using DevBase.Format.Formats.EnvFormat;
+using DevBase.Format;
+using DevBase.Format.Formats.ElrcFormat;
+using DevBase.Format.Structure;
+using DevBase.Generics;
-var parser = new FileParser>();
-var config = parser.ParseFromDisk(".env");
+string elrcContent = @"
+ [00:00:12.000] - [00:00:13.000] First line
+ [
+ [00:00:12.000] - [00:00:12.500] First
+ [00:00:12.500] - [00:00:13.000] line
+ ]
+ ";
-string dbHost = config["DB_HOST"];
-string apiKey = config["API_KEY"];
+var parser = new FileParser>();
+AList lyrics = parser.ParseFromString(elrcContent);
+AList lyricsFromFile = parser.ParseFromDisk("song.elrc");
```
-### Safe Parsing with Try-Parse
+### RLRC
+
+RLRC is a list of raw lyric lines.
```csharp
-var parser = new FileParser>();
+using DevBase.Format;
+using DevBase.Format.Formats.RlrcFormat;
+using DevBase.Format.Structure;
+using DevBase.Generics;
-if (parser.TryParseFromString(lrcContent, out var lyrics))
-{
- Console.WriteLine($"Parsed {lyrics.Length} lines");
-}
-else
-{
- Console.WriteLine("Failed to parse lyrics");
-}
+string rlrcContent = "First line\nSecond line";
+
+var parser = new FileParser>();
+AList lyrics = parser.ParseFromString(rlrcContent);
+AList lyricsFromFile = parser.ParseFromDisk("song.rlrc");
```
-## Usage Examples
+### SRT
-### Working with Timestamps
+`SrtParser` produces rich lyrics, including both a start and an end time.
```csharp
+using DevBase.Format;
+using DevBase.Format.Formats.SrtFormat;
using DevBase.Format.Structure;
+using DevBase.Generics;
-var lyric = new TimeStampedLyric
-{
- Text = "Hello world",
- StartTime = TimeSpan.FromSeconds(12.5)
-};
-
-// Get timestamp in milliseconds
-long ms = lyric.StartTimestamp; // 12500
+string srtContent = "1\n00:00:12,000 --> 00:00:15,000\nFirst subtitle\n\n";
-// Format for display
-Console.WriteLine($"[{lyric.StartTime:mm\\:ss\\.ff}] {lyric.Text}");
+var parser = new FileParser>();
+AList subtitles = parser.ParseFromString(srtContent);
+AList subtitlesFromFile = parser.ParseFromDisk("movie.srt");
```
-### Rich-Synced Lyrics (Word-Level Timing)
+### KLyrics
```csharp
+using DevBase.Format;
+using DevBase.Format.Formats.KLyricsFormat;
using DevBase.Format.Structure;
+using DevBase.Generics;
-var richLyric = new RichTimeStampedLyric
-{
- StartTime = TimeSpan.FromSeconds(10),
- Words = new AList
- {
- new RichTimeStampedWord { Text = "Hello", StartTime = TimeSpan.FromSeconds(10.0) },
- new RichTimeStampedWord { Text = "world", StartTime = TimeSpan.FromSeconds(10.5) }
- }
-};
+string kLyricsContent = "[12000,1000](0,500)First(0,500)line";
-foreach (var word in richLyric.Words)
-{
- Console.WriteLine($"[{word.StartTime}] {word.Text}");
-}
+var parser = new FileParser>();
+AList lyrics = parser.ParseFromString(kLyricsContent);
+AList lyricsFromFile = parser.ParseFromDisk("song.klyrics");
```
-### Parsing Apple Music Lyrics
+### MML JSON
+
+`MmlParser` currently keeps only entries whose `text` matches the library's metadata-style pattern. Ordinary lyric text such as `First line` is filtered out; the example below reflects the parser's current behavior.
```csharp
-using DevBase.Format.Formats.AppleXmlFormat;
+using DevBase.Format;
+using DevBase.Format.Formats.MmlFormat;
+using DevBase.Format.Structure;
+using DevBase.Generics;
-var parser = new FileParser>();
-var lyrics = parser.ParseFromString(appleMusicXml);
+string mmlContent = """
+ [{"text":"[ar:Artist]","time":{"total":1250,"minutes":0,"seconds":1,"hundredths":25}}]
+ """;
-// Apple XML includes metadata
-foreach (var line in lyrics)
-{
- Console.WriteLine($"{line.StartTime}: {line.Text}");
-}
+var parser = new FileParser>();
+AList lyrics = parser.ParseFromString(mmlContent);
+AList lyricsFromFile = parser.ParseFromDisk("song.mml");
```
-### Creating Custom Format Parser
+### RMML JSON
```csharp
using DevBase.Format;
+using DevBase.Format.Formats.RmmlFormat;
+using DevBase.Format.Structure;
+using DevBase.Generics;
-public class MyFormat : FileFormat>
-{
- public override AList Parse(string input)
- {
- var lines = new AList();
- foreach (var line in input.Split('\n'))
- {
- if (!string.IsNullOrWhiteSpace(line))
- lines.Add(line.Trim());
- }
- return lines;
- }
-
- public override bool TryParse(string input, out AList parsed)
- {
- try
- {
- parsed = Parse(input);
- return true;
- }
- catch
- {
- parsed = null;
- return false;
- }
- }
-}
+string rmmlContent = """
+ [{"ts":12.0,"te":13.0,"l":[{"c":"First","o":0},{"c":" line","o":1}],"x":"First line"}]
+ """;
-// Use custom format
-var parser = new FileParser>();
-var result = parser.ParseFromString("line1\nline2\nline3");
+var parser = new FileParser>();
+AList lyrics = parser.ParseFromString(rmmlContent);
+AList lyricsFromFile = parser.ParseFromDisk("song.rmml");
```
-### Revertable Formats (Convert Back to String)
+### Apple XML
+
+Apple XML uses TTML with `itunes:timing="None"` and produces raw lyric lines.
```csharp
using DevBase.Format;
+using DevBase.Format.Formats.AppleXmlFormat;
+using DevBase.Format.Structure;
+using DevBase.Generics;
-// Some formats implement RevertableFileFormat
-public class LrcFormat : RevertableFileFormat>
-{
- public override string Revert(AList parsed)
- {
- StringBuilder sb = new StringBuilder();
- foreach (var lyric in parsed)
- {
- int minutes = (int)lyric.StartTime.TotalMinutes;
- double seconds = lyric.StartTime.TotalSeconds % 60;
- sb.AppendLine($"[{minutes:D2}:{seconds:00.00}]{lyric.Text}");
- }
- return sb.ToString();
- }
-}
-
-// Parse and revert
-var parser = new FileParser>();
-var lyrics = parser.ParseFromString(lrcContent);
+string appleXmlContent = """
+
+
+
+ """;
-var format = new LrcFormat();
-string lrcString = format.Revert(lyrics);
+var parser = new FileParser>();
+AList lyrics = parser.ParseFromString(appleXmlContent);
+AList lyricsFromFile = parser.ParseFromDisk("song-raw.xml");
```
-## Format-Specific Details
-
-### LRC Format
-
-**Structure:**
-```
-[mm:ss.xx]Lyric text
-[mm:ss.xx]Another line
-```
+### Apple LRC XML
-**Metadata Tags:**
-```
-[ar:Artist Name]
-[ti:Song Title]
-[al:Album Name]
-[by:Creator]
-[offset:+/-milliseconds]
-```
+Apple LRC XML uses TTML with `itunes:timing="Line"` and produces timestamped lines.
-**Example:**
```csharp
-string lrc = @"
-[ar:Rick Astley]
-[ti:Never Gonna Give You Up]
-[al:Whenever You Need Somebody]
-[00:12.00]We're no strangers to love
-[00:16.00]You know the rules and so do I
-";
-
-var parser = new FileParser>();
-var lyrics = parser.ParseFromString(lrc);
-```
-
-### SRT Format
-
-**Structure:**
-```
-1
-00:00:12,000 --> 00:00:15,000
-First subtitle
+using DevBase.Format;
+using DevBase.Format.Formats.AppleLrcXmlFormat;
+using DevBase.Format.Structure;
+using DevBase.Generics;
-2
-00:00:16,000 --> 00:00:20,000
-Second subtitle
-```
+string appleLrcXmlContent = """
+
+
+
+ """;
-**Example:**
-```csharp
-var parser = new FileParser>();
-var subtitles = parser.ParseFromDisk("movie.srt");
+var parser = new FileParser>();
+AList lyrics = parser.ParseFromString(appleLrcXmlContent);
+AList lyricsFromFile = parser.ParseFromDisk("song-line.xml");
```
-### ENV Format
+### Apple Rich XML
-**Structure:**
-```
-KEY=value
-DATABASE_URL=postgresql://localhost/mydb
-API_KEY=secret123
-# Comments are supported
-```
+Apple Rich XML uses TTML with `itunes:timing="Word"` and produces word-timed lyrics.
-**Example:**
```csharp
-var parser = new FileParser>();
-var config = parser.ParseFromString("DB_HOST=localhost\nDB_PORT=5432");
+using DevBase.Format;
+using DevBase.Format.Formats.AppleRichXmlFormat;
+using DevBase.Format.Structure;
+using DevBase.Generics;
-Console.WriteLine(config["DB_HOST"]); // "localhost"
-Console.WriteLine(config["DB_PORT"]); // "5432"
-```
+string appleRichXmlContent = """
+
+
+
+ """;
-## Core Classes
+var parser = new FileParser>();
+AList lyrics = parser.ParseFromString(appleRichXmlContent);
+AList lyricsFromFile = parser.ParseFromDisk("song-word.xml");
+```
-### FileParser
+### ENV
-Generic parser that works with any format:
+`EnvParser` returns an `ATupleList`. Its current grammar expects quoted word values.
```csharp
-public class FileParser where P : FileFormat
-{
- T ParseFromString(string content);
- bool TryParseFromString(string content, out T parsed);
- T ParseFromDisk(string filePath);
- bool TryParseFromDisk(string filePath, out T parsed);
-}
-```
+using DevBase.Format;
+using DevBase.Format.Formats.EnvFormat;
+using DevBase.Generics;
-### FileFormat
+string envContent = @"
+ DB_HOST=""localhost""
+ API_KEY=""secret123""
+ ";
-Base class for all format parsers:
+var parser = new FileParser>();
+ATupleList config = parser.ParseFromString(envContent);
+ATupleList configFromFile = parser.ParseFromDisk(".env");
-```csharp
-public abstract class FileFormat
-{
- abstract TOutput Parse(TInput input);
- abstract bool TryParse(TInput input, out TOutput parsed);
-}
+string dbHost = config.Get(0).Item2;
+string apiKey = config.Get(1).Item2;
```
-### RevertableFileFormat
+## Safe parsing
-For formats that can be converted back:
+`FileParser` creates a fresh parser with strict error handling enabled. To receive `false` for validation failures routed through `FileFormat.Error` instead of a `ParsingException`, use the concrete parser and set `StrictErrorHandling` to `false`.
```csharp
-public abstract class RevertableFileFormat : FileFormat
-{
- abstract TInput Revert(TOutput parsed);
-}
-```
+using DevBase.Format.Formats.LrcFormat;
+using DevBase.Format.Structure;
+using DevBase.Generics;
-### Data Structures
+const string lrcContent = "[00:12.00]First line";
+var parser = new LrcParser { StrictErrorHandling = false };
-| Class | Description |
-|-------|-------------|
-| `TimeStampedLyric` | Single lyric line with timestamp |
-| `RichTimeStampedLyric` | Lyric line with word-level timing |
-| `RichTimeStampedWord` | Individual word with timestamp |
-| `RawLyric` | Unparsed lyric data |
+if (parser.TryParse(lrcContent, out AList lyrics))
+ Console.WriteLine($"Parsed {lyrics.Length} lines");
+else
+ Console.WriteLine("Failed to parse LRC lyrics");
+```
-## Utilities
+## Reverting parsed formats
-### LyricsUtils
+Use the concrete reversible parser to serialize parsed data. SRT does not currently support reversion.
```csharp
-using DevBase.Format.Utilities;
-
-// Utility methods for lyrics manipulation
-string cleaned = LyricsUtils.CleanLyrics(rawLyrics);
-bool hasTimestamps = LyricsUtils.HasTimestamps(lrcContent);
-```
+using DevBase.Format.Formats.LrcFormat;
+using DevBase.Format.Structure;
+using DevBase.Generics;
-### TimeUtils
+const string lrcContent = "[00:12.00]First line";
+var parser = new LrcParser();
+AList lyrics = parser.Parse(lrcContent);
+string lrcContentAgain = parser.Revert(lyrics);
-```csharp
-using DevBase.Format.Utilities;
-
-// Time conversion utilities
-TimeSpan time = TimeUtils.ParseLrcTimestamp("[00:12.50]");
-string formatted = TimeUtils.FormatLrcTimestamp(TimeSpan.FromSeconds(12.5));
+if (parser.TryRevert(lyrics, out string reverted))
+ Console.WriteLine(reverted);
```
-## Extensions
-
-### LyricsExtensions
+## Implement a custom parser
```csharp
-using DevBase.Format.Extensions;
-
-var lyrics = new AList();
-// Extension methods for lyrics manipulation
-var sorted = lyrics.SortByTimestamp();
-var filtered = lyrics.FilterByTimeRange(TimeSpan.Zero, TimeSpan.FromMinutes(2));
-```
+using DevBase.Format;
+using DevBase.Generics;
-## Error Handling
+var parser = new FileParser>();
+AList result = parser.ParseFromString("line1\nline2\nline3");
-### Using Try-Parse Pattern
+public class PlainTextParser : FileFormat>
+{
+ public override AList Parse(string input)
+ {
+ AList lines = new AList();
-```csharp
-var parser = new FileParser>();
+ foreach (string line in input.Split('\n'))
+ {
+ string trimmed = line.Trim();
-if (parser.TryParseFromDisk("song.lrc", out var lyrics))
-{
- // Success
- ProcessLyrics(lyrics);
-}
-else
-{
- // Handle parsing failure
- Console.WriteLine("Invalid LRC format");
-}
-```
+ if (!string.IsNullOrEmpty(trimmed))
+ lines.Add(trimmed);
+ }
-### Catching Exceptions
+ return lines;
+ }
-```csharp
-try
-{
- var lyrics = parser.ParseFromString(content);
-}
-catch (ParsingException ex)
-{
- Console.WriteLine($"Parsing error: {ex.Message}");
-}
-catch (FileNotFoundException ex)
-{
- Console.WriteLine($"File not found: {ex.Message}");
+ public override bool TryParse(string input, out AList parsed)
+ {
+ parsed = Parse(input);
+ return !parsed.IsEmpty();
+ }
}
```
-## Integration with DevBase.Api
+## Data structures and extensions
-Many API clients return lyrics that can be parsed:
+| Class | Purpose |
+| --- | --- |
+| `TimeStampedLyric` | Text plus a start time |
+| `RichTimeStampedLyric` | Text plus start/end times and timed words |
+| `RichTimeStampedWord` | A word plus start/end times |
+| `RawLyric` | A raw lyric line |
```csharp
-using DevBase.Api.Apis.Deezer;
-using DevBase.Format;
-using DevBase.Format.Formats.LrcFormat;
-
-var deezer = new Deezer();
-var lyricsString = await deezer.GetLyrics("123456");
+using DevBase.Format.Extensions;
+using DevBase.Format.Structure;
+using DevBase.Generics;
-var parser = new FileParser>();
-var lyrics = parser.ParseFromString(lyricsString);
+AList timedLyrics = new AList();
+string plainText = timedLyrics.ToPlainText();
+AList rawLyrics = timedLyrics.ToRawLyrics();
-foreach (var line in lyrics)
-{
- Console.WriteLine($"[{line.StartTime}] {line.Text}");
-}
+AList richLyrics = new AList();
+AList simplifiedLyrics = richLyrics.ToTimeStampedLyrics();
```
-## Performance Tips
-
-1. **Reuse parser instances** for multiple files
-2. **Use Try-Parse** for better performance (no exceptions)
-3. **Parse from string** when data is already in memory
-4. **Use appropriate format** - don't parse LRC as SRT
-5. **Cache parsed results** for frequently accessed files
-
-## Common Patterns
-
-### Pattern 1: Multi-Format Lyrics Parser
+## Timestamp utility
```csharp
-AList ParseLyrics(string content)
-{
- // Try LRC first
- var lrcParser = new FileParser>();
- if (lrcParser.TryParseFromString(content, out var lrcLyrics))
- return lrcLyrics;
-
- // Try SRT
- var srtParser = new FileParser>();
- if (srtParser.TryParseFromString(content, out var srtLyrics))
- return srtLyrics;
-
- // Try Apple XML
- var appleParser = new FileParser>();
- if (appleParser.TryParseFromString(content, out var appleLyrics))
- return appleLyrics;
-
- return null;
-}
-```
+using DevBase.Format.Utilities;
-### Pattern 2: Lyrics Synchronization
+if (TimeUtils.TryParseTimeStamp("00:12.50", out TimeSpan time))
+ Console.WriteLine(time);
-```csharp
-void SyncLyricsToAudio(AList lyrics, TimeSpan currentTime)
-{
- var currentLyric = lyrics.Find(l =>
- l.StartTime <= currentTime &&
- (lyrics.IndexOf(l) == lyrics.Length - 1 ||
- lyrics[lyrics.IndexOf(l) + 1].StartTime > currentTime)
- );
-
- if (currentLyric != null)
- DisplayLyric(currentLyric.Text);
-}
+TimeSpan anotherTime = TimeUtils.ParseTimeStamp("00:12.50");
```
-### Pattern 3: Format Conversion
+## Integration with DevBase.Api
-```csharp
-// Convert LRC to SRT
-var lrcParser = new FileParser>();
-var lyrics = lrcParser.ParseFromDisk("song.lrc");
+When the `DevBase.Api` package or project is also referenced, `Deezer.GetLyrics` returns both raw lyric text and parsed timestamped lyrics.
-var srtFormat = new SrtFormat();
-string srtContent = srtFormat.Revert(lyrics);
-File.WriteAllText("song.srt", srtContent);
-```
+```csharp
+using DevBase.Api.Apis.Deezer;
+using DevBase.Format.Structure;
+using DevBase.Generics;
-## Target Framework
+var deezer = new Deezer();
+(string rawLyrics, AList lyrics) = await deezer.GetLyrics("123456");
-- **.NET 9.0**
+foreach (TimeStampedLyric line in lyrics)
+ Console.WriteLine($"[{line.StartTime}] {line.Text}");
+```
-## Dependencies
+## Target framework
-- **DevBase** - Core utilities and collections
-- **System.Text.RegularExpressions** - Pattern matching
+- .NET 9.0
## License
-MIT License - See LICENSE file for details
-
-## Author
-
-AlexanderDotH
+MIT License — see the repository license.
## Repository
diff --git a/DevBase.Test/DevBase/IO/AFile/AFileTest.cs b/DevBase.Test/DevBase/IO/AFile/AFileTest.cs
index bc23256..1b8a8bf 100644
--- a/DevBase.Test/DevBase/IO/AFile/AFileTest.cs
+++ b/DevBase.Test/DevBase/IO/AFile/AFileTest.cs
@@ -8,7 +8,7 @@ namespace DevBase.Test.DevBase.IO.AFile;
public class AFileTest
{
[Test]
- public void ReadFileTest()
+ public void TestReadFileTest()
{
AFileObject buffer = global::DevBase.IO.AFile.ReadFileToObject(
$"..{Path.DirectorySeparatorChar}" +
@@ -16,7 +16,7 @@ public void ReadFileTest()
$"..{Path.DirectorySeparatorChar}" +
$"DevBaseFormatData{Path.DirectorySeparatorChar}" +
$"LRC{Path.DirectorySeparatorChar}" +
- $"MÜNCHEN.lrc");
+ $"MUENCHEN.lrc");
Assert.That(buffer.Buffer.ToArray(), Is.Not.Empty);
}
diff --git a/DevBase.Test/DevBaseFormat/Formats/ElrcFormat/ElrcTester.cs b/DevBase.Test/DevBaseFormat/Formats/ElrcFormat/ElrcTester.cs
index a731274..17a7bb3 100644
--- a/DevBase.Test/DevBaseFormat/Formats/ElrcFormat/ElrcTester.cs
+++ b/DevBase.Test/DevBaseFormat/Formats/ElrcFormat/ElrcTester.cs
@@ -53,4 +53,21 @@ public void TestFormatToFile()
formatted.DumpConsole();
Assert.That(formatted, Is.EqualTo(content));
}
+
+ [Test]
+ public void TestParseIndentedContentTrimsLineWhitespace()
+ {
+ string content = @"
+ [00:00:12.000] - [00:00:13.000] First line
+ [
+ [00:00:12.000] - [00:00:12.500] First
+ [00:00:12.500] - [00:00:13.000] line
+ ]
+ ";
+
+ AList lyrics = this._elrcParser.Parse(content);
+
+ Assert.That(lyrics.Get(0).Text, Is.EqualTo("First line"));
+ Assert.That(lyrics.Get(0).Words.Length, Is.EqualTo(2));
+ }
}
diff --git a/DevBase.Test/DevBaseFormat/Formats/EnvFormat/EnvTester.cs b/DevBase.Test/DevBaseFormat/Formats/EnvFormat/EnvTester.cs
new file mode 100644
index 0000000..5c25251
--- /dev/null
+++ b/DevBase.Test/DevBaseFormat/Formats/EnvFormat/EnvTester.cs
@@ -0,0 +1,20 @@
+using DevBase.Format.Formats.EnvFormat;
+using DevBase.Generics;
+
+namespace DevBase.Test.DevBaseFormat.Formats.EnvFormat;
+
+///
+/// Tests for ENV format parser.
+///
+public class EnvTester : FormatTest
+{
+ [Test]
+ public void TestParseIndentedContentTrimsLineWhitespace()
+ {
+ ATupleList variables = new EnvParser().Parse(" API_KEY=\"value\" ");
+
+ Assert.That(variables.Length, Is.EqualTo(1));
+ Assert.That(variables.Get(0).Item1, Is.EqualTo("API_KEY"));
+ Assert.That(variables.Get(0).Item2, Is.EqualTo("value"));
+ }
+}
diff --git a/DevBase.Test/DevBaseFormat/Formats/KLyricsFormat/KLyricsTester.cs b/DevBase.Test/DevBaseFormat/Formats/KLyricsFormat/KLyricsTester.cs
index bdee294..d6ecabc 100644
--- a/DevBase.Test/DevBaseFormat/Formats/KLyricsFormat/KLyricsTester.cs
+++ b/DevBase.Test/DevBaseFormat/Formats/KLyricsFormat/KLyricsTester.cs
@@ -34,4 +34,14 @@ public void TestFormatFromFile()
list.DumpConsole();
Assert.That(list.Get(0).Text, Is.EqualTo("Rick Astley"));
}
+
+ [Test]
+ public void TestParseIndentedContentTrimsLineWhitespace()
+ {
+ string content = @" [12000,1000](0,500)First(0,500)line ";
+
+ AList lyrics = this._klyricsParser.ParseFromString(content);
+
+ Assert.That(lyrics.Get(0).Text, Is.EqualTo("First line"));
+ }
}
diff --git a/DevBase.Test/DevBaseFormat/Formats/LrcFormat/LrcTester.cs b/DevBase.Test/DevBaseFormat/Formats/LrcFormat/LrcTester.cs
index 23e808e..0223582 100644
--- a/DevBase.Test/DevBaseFormat/Formats/LrcFormat/LrcTester.cs
+++ b/DevBase.Test/DevBaseFormat/Formats/LrcFormat/LrcTester.cs
@@ -6,32 +6,67 @@
namespace DevBase.Test.DevBaseFormat.Formats.LrcFormat
{
-///
-/// Tests for LRC format parser.
-///
-public class LrcTester : FormatTest
-{
- private FileParser> _lrcParser;
-
///
- /// Sets up the LRC parser.
+ /// Tests for LRC format parser.
///
- [SetUp]
- public void Setup()
+ public class LrcTester : FormatTest
{
- this._lrcParser = new FileParser>();
- }
+ private FileParser> _lrcParser;
- ///
- /// Tests parsing LRC format from file.
- ///
- [Test]
- public void TestFormatFromFile()
- {
- AList parsed = this._lrcParser.ParseFromDisk(GetTestFile("LRC", "Circles.lrc"));
+ ///
+ /// Sets up the LRC parser.
+ ///
+ [SetUp]
+ public void Setup()
+ {
+ this._lrcParser = new FileParser>();
+ }
+
+ ///
+ /// Tests parsing LRC format from file.
+ ///
+ [Test]
+ public void TestFormatFromFile()
+ {
+ AList parsed = this._lrcParser.ParseFromDisk(GetTestFile("LRC", "Circles.lrc"));
+
+ parsed.DumpConsole();
+ Assert.That(parsed.Get(0).Text, Is.EqualTo("Lets make circles"));
+ }
- parsed.DumpConsole();
- Assert.That(parsed.Get(0).Text, Is.EqualTo("Lets make circles"));
+ [Test]
+ public void TestExampleCode()
+ {
+ // Parse from string
+ string lrcContent = @"
+ [00:12.00]First line
+ [00:15.50]Second line
+ [00:20.00]Third line
+ ";
+
+ var parser = new FileParser>();
+ var lyrics = parser.ParseFromString(lrcContent);
+
+ foreach (var line in lyrics)
+ {
+ Console.WriteLine($"[{line.StartTime}] {line.Text}");
+ }
+
+ // Pre-check if we can extract data
+ Assert.That(lyrics, Is.Not.Empty);
+ Assert.That(lyrics.Get(0), Is.Not.Null);
+
+ TimeStampedLyric testCandidate = lyrics.Get(0);
+
+ // Check if time data is correct
+ Assert.That(testCandidate.StartTime.Milliseconds, Is.EqualTo(00));
+ Assert.That(testCandidate.StartTime.Seconds, Is.EqualTo(12));
+ Assert.That(testCandidate.StartTime.Minutes, Is.EqualTo(00));
+
+ // Check if text data is correct
+ Assert.That(testCandidate.Text, Is.EqualTo("First line"));
+
+ lyrics.DumpConsole();
+ }
}
}
-}
diff --git a/DevBase.Test/DevBaseFormat/Formats/RlrcFormat/RlrcTester.cs b/DevBase.Test/DevBaseFormat/Formats/RlrcFormat/RlrcTester.cs
index 8d73409..7c0970f 100644
--- a/DevBase.Test/DevBaseFormat/Formats/RlrcFormat/RlrcTester.cs
+++ b/DevBase.Test/DevBaseFormat/Formats/RlrcFormat/RlrcTester.cs
@@ -62,4 +62,12 @@ public void TestFromRlc()
formated.DumpConsole();
Assert.That(formated, Is.EqualTo(content));
}
+
+ [Test]
+ public void TestParseIndentedContentTrimsLineWhitespace()
+ {
+ AList lyrics = this._rlrcParser.Parse(" First line ");
+
+ Assert.That(lyrics.Get(0).Text, Is.EqualTo("First line"));
+ }
}
diff --git a/DevBase.Test/DevBaseFormat/Formats/SrtFormat/SrtTester.cs b/DevBase.Test/DevBaseFormat/Formats/SrtFormat/SrtTester.cs
index b79601c..3bb341a 100644
--- a/DevBase.Test/DevBaseFormat/Formats/SrtFormat/SrtTester.cs
+++ b/DevBase.Test/DevBaseFormat/Formats/SrtFormat/SrtTester.cs
@@ -46,4 +46,14 @@ public void TestFormatFromFile()
Assert.That(list.Length, Is.GreaterThan(0));
Assert.That(list.Get(0).Text, Is.Not.Empty);
}
+
+ [Test]
+ public void TestParseIndentedContentTrimsLineWhitespace()
+ {
+ string content = " 1 \n 00:00:12,000 --> 00:00:13,000 \n First line \n\n";
+
+ AList lyrics = this._srtParser.ParseFromString(content);
+
+ Assert.That(lyrics.Get(0).Text, Is.EqualTo("First line"));
+ }
}
diff --git "a/DevBase.Test/DevBaseFormatData/LRC/M\303\234NCHEN.lrc" b/DevBase.Test/DevBaseFormatData/LRC/MUENCHEN.lrc
similarity index 100%
rename from "DevBase.Test/DevBaseFormatData/LRC/M\303\234NCHEN.lrc"
rename to DevBase.Test/DevBaseFormatData/LRC/MUENCHEN.lrc