Added Waffle, DateTimeOffset and TimeSpan generators

- Also removed redundant DateTime and DateOnly generators
- Also added a shuffle generator

Author: Atulin

.scripts/New.cs

@@ -36,8 +36,7 @@ namespace Forged.Core.Generators.{{module}};
      
      /// <summary>
      /// </summary>
-     /// <param name="rng">The random number generator to use</param>
-     public sealed class {{name}}Generator<T>(System.Random rng) : Generator<T>(rng)
+     public sealed class {{name}}Generator<T>(Forge forge) : Generator<T>(forge)
      {
         public override T Generate() => throw new NotImplementedException();
      }

Forged.Core/Core/TemplateCompiler.cs

@@ -0,0 +1,78 @@
+using System.Text;
+
+namespace Forged.Core.Core;
+
+internal static class TemplateCompiler
+{
+	public static List<Token> Compile(string template)
+	{
+		var tokens = new List<Token>();
+		var span = template.AsSpan();
+
+		var i = 0;
+
+		while (i < span.Length)
+		{
+			var start = template.IndexOf('{', i);
+			if (start == -1)
+			{
+				tokens.Add(new Literal(template[i..]));
+				break;
+			}
+
+			if (start > i)
+			{
+				tokens.Add(new Literal(template[i..start]));
+			}
+			
+			var end = template.IndexOf('}', start);
+			var key = template[(start + 1)..end];
+			
+			tokens.Add(new Placeholder(key));
+			
+			i = end + 1;
+		}
+
+		return tokens;
+	}
+
+	public static string Render(List<Token> tokens, Dictionary<string, string> values)
+	{
+		var sb = new StringBuilder();
+
+		foreach (var token in tokens)
+		{
+			var part = token switch
+			{
+				Literal l => l.Value,
+				Placeholder p => values[p.Key],
+				_ => throw new InvalidOperationException("Token was somehow neither literal nor placeholder"),
+			};
+			sb.Append(part);
+		}
+		
+		return sb.ToString();
+	}
+
+	public static string Render(List<Token> tokens, Dictionary<string, Func<string>> values)
+	{
+		var sb = new StringBuilder();
+
+		foreach (var token in tokens)
+		{
+			var part = token switch
+			{
+				Literal l => l.Value,
+				Placeholder p => values[p.Key](),
+				_ => throw new InvalidOperationException("Token was somehow neither literal nor placeholder"),
+			};
+			sb.Append(part);
+		}
+		
+		return sb.ToString();
+	}
+
+	internal abstract record Token;
+	internal sealed record Literal(string Value) : Token;
+	internal sealed record Placeholder(string Key) : Token;
+}

Forged.Core/Forged.Core.csproj

@@ -22,6 +22,8 @@
       <PackageReference Include="Atulin.SealAnalyzer" Version="1.0.0" PrivateAssets="all" />
       <PackageReference Include="JetBrains.Annotations" Version="2025.2.4" />
       <PackageReference Include="Microsoft.Extensions.FileProviders.Embedded" Version="10.0.9" />
+      <PackageReference Include="NetEscapades.EnumGenerators" Version="1.0.0-beta21" />
+      <PackageReference Include="NetEscapades.EnumGenerators.Interceptors" Version="1.0.0-beta21" />
     </ItemGroup>
 
 </Project>

Forged.Core/Generators/GeneratorExtensions.cs

@@ -1,5 +1,6 @@
 using System.Globalization;
 using Forged.Core.Generators.Utility;
+using Forged.Core.Generators.Utility.Collections;
 using Forged.Core.Generators.Utility.Temporal;
 using Forged.Core.Generators.Utility.Text;
 
@@ -183,20 +184,31 @@ public static Generator<HashSet<T>> AsHashSet<T>(this Generator<IEnumerable<T>>
 	public static Generator<HashSet<T>> AsHashSet<T>(this Generator<ICollection<T>> generator)
 		=> new RefineGenerator<ICollection<T>, HashSet<T>>(generator, static c => c.ToHashSet(), generator.Forge);
 
-	/// <summary>
-	/// Converts enumerables from a generator to dictionaries.
-	/// </summary>
-	/// <typeparam name="T">The type of items in the enumerable.</typeparam>
-	/// <typeparam name="TKey">The type of dictionary keys.</typeparam>
-	/// <typeparam name="TValue">The type of dictionary values.</typeparam>
 	/// <param name="generator">The generator to convert.</param>
-	/// <param name="keySelector">A function to extract the key from each item.</param>
-	/// <param name="valueSelector">A function to extract the value from each item.</param>
-	/// <returns>A generator that produces dictionaries.</returns>
-	public static Generator<Dictionary<TKey, TValue>> AsDictionary<T, TKey, TValue>(
-		this Generator<IEnumerable<T>> generator,
-		Func<T, TKey> keySelector,
-		Func<T, TValue> valueSelector
-	) where TKey : notnull
-		=> generator.Refine(e => e.ToDictionary(keySelector, valueSelector));
+	/// <typeparam name="T">The type of items in the enumerable.</typeparam>
+	extension<T>(Generator<IEnumerable<T>> generator)
+	{
+		/// <summary>
+		/// Converts enumerables from a generator to dictionaries.
+		/// </summary>
+		/// <typeparam name="TKey">The type of dictionary keys.</typeparam>
+		/// <typeparam name="TValue">The type of dictionary values.</typeparam>
+		/// <param name="keySelector">A function to extract the key from each item.</param>
+		/// <param name="valueSelector">A function to extract the value from each item.</param>
+		/// <returns>A generator that produces dictionaries.</returns>
+		public Generator<Dictionary<TKey, TValue>> AsDictionary<TKey, TValue>(Func<T, TKey> keySelector,
+			Func<T, TValue> valueSelector
+		) where TKey : notnull
+			=> generator.Refine(e => e.ToDictionary(keySelector, valueSelector));
+
+
+		/// <summary>
+		/// Creates a generator that produces shuffled versions of the enumerable generated by the given generator.
+		/// </summary>
+		/// <typeparam name="T">The type of elements in the enumerable being shuffled.</typeparam>
+		/// <returns>A generator that produces shuffled enumerables.</returns>
+		public Generator<IEnumerable<T>> Shuffle()
+			=> new ShuffleGenerator<T>(generator, generator.Forge);
+	}
+
 }

Forged.Core/Generators/Temporal/DateOnlyInFutureGenerator.cs

@@ -0,0 +1,23 @@
+namespace Forged.Core.Generators.Temporal;
+
+/// <summary>
+/// Generates random <see cref="DateTimeOffset"/> values within a specified range.
+/// </summary>
+/// <param name="min">The minimum date/time offset (inclusive). If null, uses <see cref="DateTimeOffset.MinValue"/>. </param>
+/// <param name="max">The maximum date/time offset (inclusive). If null, uses <see cref="DateTimeOffset.MaxValue"/>. </param>
+/// <param name="forge">The Forge instance to use.</param>
+public sealed class DateTimeOffsetGenerator(DateTimeOffset? min, DateTimeOffset? max, Forge forge) : Generator<DateTimeOffset>(forge)
+{
+	private readonly long _minTicks = (min ?? DateTimeOffset.MinValue).Ticks;
+	private readonly long _maxTicks = (max ?? DateTimeOffset.MaxValue).Ticks;
+
+	/// <summary>
+	/// Generates a random <see cref="DateTimeOffset"/> value.
+	/// </summary>
+	/// <returns>A random <see cref="DateTimeOffset"/> between the specified minimum and maximum.</returns>
+	public override DateTimeOffset Generate()
+	{
+		var ticks = Rng.NextInt64(_minTicks, _maxTicks);
+		return new DateTimeOffset(ticks, TimeSpan.Zero);
+	}
+}

Forged.Core/Generators/Temporal/DateOnlyInPastGenerator.cs

@@ -0,0 +1,23 @@
+namespace Forged.Core.Generators.Temporal;
+
+/// <summary>
+/// Generates random <see cref="TimeSpan"/> values within a specified range.
+/// </summary>
+/// <param name="min">The minimum time span (inclusive). If null, uses <see cref="TimeSpan.MinValue"/>. </param>
+/// <param name="max">The maximum time span (inclusive). If null, uses <see cref="TimeSpan.MaxValue"/>. </param>
+/// <param name="forge">The Forge instance to use.</param>
+public sealed class TimeSpanGenerator(TimeSpan? min, TimeSpan? max, Forge forge) : Generator<TimeSpan>(forge)
+{
+	private readonly long _minTicks = (min ?? TimeSpan.MinValue).Ticks;
+	private readonly long _maxTicks = (max ?? TimeSpan.MaxValue).Ticks;
+
+	/// <summary>
+	/// Generates a random <see cref="TimeSpan"/> value.
+	/// </summary>
+	/// <returns>A random <see cref="TimeSpan"/> between the specified minimum and maximum.</returns>
+	public override TimeSpan Generate()
+	{
+		var ticks = Rng.NextInt64(_minTicks, _maxTicks);
+		return new TimeSpan(ticks);
+	}
+}