Bunch of new generators, Internet module

- Added domain generator
- Added email generator
- Moved username generator to Internet module from Person
- Added range and replace utils generators for strings
- Added a locale parameter to the generated faker
- Added a whole slew of words to the lorem ipsum generator
- Moved lorem ipsum corpus to a locale file
- Added options to the lorem ipsum generator. So far, they allow the user to specify how many words at the beginning of the generated text should follow the classic "lorem ipsum"

Author: Atulin

Forged.Core/Forge.cs

@@ -42,9 +42,9 @@ public sealed class Forge
     public ForgeBasic Basic { get; }
 
     /// <summary>
-    /// Gets the module for generating person-related data.
+    /// Gets the module for generating internet data.
     /// </summary>
-    public ForgePerson Person { get; }
+    public ForgeInternet Internet { get; }
 
     /// <summary>
     /// Initializes a new instance of the <see cref="Forge"/> class.
@@ -60,6 +60,6 @@ public Forge(Random? random, CultureInfo? locale)
 	    Temporal = new ForgeTemporal(this);
 	    Text = new ForgeText(this);
         Basic = new ForgeBasic(this);
-        Person = new ForgePerson(this);
+        Internet = new ForgeInternet(this);
     }
 }

Forged.Core/Generators/Extensions/StringGeneratorExtensions.cs

@@ -1,4 +1,5 @@
 using System.Globalization;
+using System.Text.RegularExpressions;
 using Forged.Core.Generators.Utility.Text;
 
 namespace Forged.Core.Generators.Extensions;
@@ -26,6 +27,45 @@ public Generator<string> ToUpper()
 		/// <returns>A generator that produces lowercase strings.</returns>
 		public Generator<string> ToLower()
 			=> new LowercaseGenerator(generator, generator.Forge);
+
+		/// <summary>
+		/// Creates a generator that produces substrings of a specified range of characters.
+		/// </summary>
+		/// <param name="start">The starting index of the range, inclusive.</param>
+		/// <param name="end">
+		/// The ending index of the range, exclusive. If null, the generator will include all characters up to the length of the string.
+		/// </param>
+		/// <returns>A generator that produces substrings within the specified range.</returns>
+		public Generator<string> Range(int start, int? end = null)
+			=> new RangeGenerator(generator, start, end, generator.Forge);
+
+		/// <summary>
+		/// Creates a generator that replaces all occurrences of a specified string in the generated text with another string.
+		/// </summary>
+		/// <param name="oldValue">The string to be replaced in the generated text.</param>
+		/// <param name="newValue">The string that will replace all occurrences of <paramref name="oldValue"/>.</param>
+		/// <returns>A generator that produces strings with the specified replacements applied.</returns>
+		public Generator<string> Replace(string oldValue, string newValue)
+			=> new ReplaceGenerator(generator, oldValue, newValue, generator.Forge);
+
+		/// <summary>
+		/// Creates a generator that replaces all occurrences of a specified char in the generated text with another char.
+		/// </summary>
+		/// <param name="oldValue">The char to be replaced in the generated text.</param>
+		/// <param name="newValue">The char that will replace all occurrences of <paramref name="oldValue"/>.</param>
+		/// <returns>A generator that produces strings with the specified replacements applied.</returns>
+		public Generator<string> Replace(char oldValue, char newValue)
+			=> new ReplaceGenerator(generator, oldValue.ToString(), newValue.ToString(), generator.Forge);
+
+		/// <summary>
+		/// Creates a generator that replaces substrings in the generated strings
+		/// based on a provided regular expression.
+		/// </summary>
+		/// <param name="regex">The regular expression used to find substrings to replace.</param>
+		/// <param name="newValue">The value to replace matched substrings with.</param>
+		/// <returns>A generator that produces strings with substrings replaced according to the specified regular expression and replacement value.</returns>
+		public Generator<string> Replace(Regex regex, string newValue)
+			=> new RegexReplaceGenerator(generator, regex, newValue, generator.Forge);
 
 		/// <summary>
 		/// Creates a generator that converts strings to title case.

Forged.Core/Generators/Internet/DomainGenerator.cs

@@ -0,0 +1,56 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using JetBrains.Annotations;
+
+namespace Forged.Core.Generators.Internet;
+
+/// <summary>
+/// Generates random domain.
+/// </summary>
+public sealed class DomainGenerator : Generator<string>
+{
+	private readonly float _ccSldChance;
+	private readonly Lazy<DomainData> _cache;
+
+	/// <summary>
+	/// Generates random domain.
+	/// </summary>
+	/// <param name="ccSldChance">Chance to prepend the domain with a functional second-level domain</param>
+	/// <param name="forge">The Forge instance to use.</param>
+	public DomainGenerator(float ccSldChance, Forge forge) : base(forge)
+	{
+		_ccSldChance = ccSldChance;
+		_cache = new(() => FileLoader.LoadData("en", "internet/domains", DomainDataContext.Default.DomainData));
+	}
+
+	/// <summary>
+	/// Generates a random domain.
+	/// </summary>
+	/// <returns>A random domain.</returns>
+	public override string Generate()
+	{
+		var data = _cache.Value;
+
+		var domain = Rng.GetItems(data.Tld, 1)[0];
+		if (_ccSldChance <= float.Epsilon || Rng.NextDouble() <= _ccSldChance)
+		{
+			return domain;
+		}
+
+		var slds = data.CcSld.Except([domain]).ToArray();
+		var sld = Rng.GetItems(slds, 1)[0];
+
+		return $"{sld}.{domain}";
+	}
+}
+
+internal sealed record DomainData(string[] Tld, string[] CcSld);
+
+[UsedImplicitly]
+[JsonSerializable(typeof(DomainData))]
+[JsonSourceGenerationOptions(
+	AllowTrailingCommas = true,
+	ReadCommentHandling = JsonCommentHandling.Skip,
+	PropertyNameCaseInsensitive = true
+)]
+internal sealed partial class DomainDataContext : JsonSerializerContext;

Forged.Core/Generators/Internet/EmailGenerator.cs

@@ -0,0 +1,71 @@
+using System.Collections.Concurrent;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using JetBrains.Annotations;
+using NetEscapades.EnumGenerators;
+
+namespace Forged.Core.Generators.Internet;
+
+/// <summary>
+/// Represents a generator for creating email addresses based on the specified kind and optional parameters.
+/// </summary>
+/// <param name="kind">The type of email address to generate.</param>
+/// <param name="nameGenerator">An optional generator to supply email address usernames. Defaults to null, which uses a username generator.</param>
+/// <param name="forge">The Forge instance to use.</param>
+/// <exception cref="ArgumentOutOfRangeException">Thrown if an invalid <see cref="EmailKind"/> is provided.</exception>
+public sealed class EmailGenerator(EmailKind kind, IGenerator<string>? nameGenerator, Forge forge) : Generator<string>(forge)
+{
+	private static ConcurrentBag<string>? _providers;
+
+	public override string Generate()
+	{
+		_providers ??= new(FileLoader.LoadData(Locale.Name, "internet/email", EmailDataContext.Default.ListString));
+
+		var name = (nameGenerator ?? Forge.Internet.Username(leetChance: 0)).Generate();
+
+		var domain = kind switch
+		{
+			EmailKind.Known => Rng.GetItems(_providers.ToArray(), 1)[0],
+			EmailKind.Example => Rng.GetItems(["example.com", "example.org", "example.net"], 1)[0],
+			EmailKind.Random => $"{Forge.Text.Pronounceable(1, 3)}.{Forge.Internet.Domain()}",
+			_ => throw new ArgumentOutOfRangeException(nameof(kind), kind, null)
+		};
+		
+		return $"{name}@{domain}";
+	}
+}
+
+/// <summary>
+/// Represents the type of email address to generate, dictating the format and domain selection process.
+/// </summary>
+/// <remarks>
+/// This enum is used to specify the strategy for generating email addresses. There are three possible kinds:
+/// - Known: Email addresses with domains from a predefined list of commonly used providers.
+/// - Example: Email addresses with domains explicitly designed for testing, such as "example.com".
+/// - Random: Email addresses with randomly generated domain names.
+/// </remarks>
+[EnumExtensions]
+public enum EmailKind
+{
+	/// <summary>
+	/// Email addresses with domains from a predefined list of commonly used providers.
+	/// </summary>
+	Known,
+	/// <summary>
+	/// Email addresses with domains explicitly designed for testing, such as "example.com".
+	/// </summary>
+	Example,
+	/// <summary>
+	/// Email addresses with randomly generated domain names.
+	/// </summary>
+	Random,
+}
+
+[UsedImplicitly]
+[JsonSerializable(typeof(List<string>))]
+[JsonSourceGenerationOptions(
+	AllowTrailingCommas = true,
+	ReadCommentHandling = JsonCommentHandling.Skip,
+	PropertyNameCaseInsensitive = true
+)]
+internal sealed partial class EmailDataContext : JsonSerializerContext;

…e/Generators/Person/UsernameGenerator.cs …Generators/Internet/UsernameGenerator.csForged.Core/Generators/Person/UsernameGenerator.cs renamed to Forged.Core/Generators/Internet/UsernameGenerator.cs Forged.Core/Generators/Person/UsernameGenerator.cs renamed to Forged.Core/Generators/Internet/UsernameGenerator.cs

@@ -3,7 +3,7 @@
 using System.Text.Json.Serialization;
 using JetBrains.Annotations;
 
-namespace Forged.Core.Generators.Person;
+namespace Forged.Core.Generators.Internet;
 
 /// <summary>
 /// Generates random usernames with configurable options for prefixes, suffixes, and leet-speak substitutions.
@@ -50,7 +50,7 @@ public sealed class UsernameGenerator(float prefixChance, float suffixChance, fl
 	/// <returns>A randomly generated username that may include a prefix, suffix, and leet-speak substitutions based on the configured probabilities.</returns>
 	public override string Generate()
 	{
-		var data = FileLoader.LoadData(Locale.Name, "username", UserDataContext.Default.UserData);
+		var data = FileLoader.LoadData(Locale.Name, "internet/username", UserDataContext.Default.UserData);
 
 		var usePrefix = Rng.NextSingle() < prefixChance;
 		var useSuffix = Rng.NextSingle() < suffixChance;

Forged.Core/Generators/Text/LoremIpsumGenerator.cs

@@ -1,3 +1,8 @@
+using System.Collections.Concurrent;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using JetBrains.Annotations;
+
 namespace Forged.Core.Generators.Text;
 
 /// <summary>
@@ -6,48 +11,42 @@ namespace Forged.Core.Generators.Text;
 /// <param name="minWords">The minimum number of words to generate.</param>
 /// <param name="maxWords">The maximum number of words to generate.</param>
 /// <param name="forge">The Forge instance to use.</param>
-public sealed class LoremIpsumGenerator(int minWords, int maxWords, Forge forge) : Generator<string>(forge)
+public sealed class LoremIpsumGenerator(int minWords, int maxWords, LoremIpsumGenerator.Options? options, Forge forge) : Generator<string>(forge)
 {
-	private static readonly string[] Lipsum =
-	[
-		// repeat common words for higher chance
-		"lorem", "ipsum", "dolor", "sit", "amet",
-		"lorem", "ipsum", "dolor",
-		
-		// base lipsum corpus
-		"lorem", "ipsum", "dolor", "sit", "amet", "consectetur", "adipiscing", "elit",
-		"sed", "do", "eiusmod", "tempor", "incididunt", "ut", "labore", "et", "dolore",
-		"magna", "aliqua", "enim", "ad", "minim", "veniam", "quis", "nostrud",
-		"exercitation", "ullamco", "laboris", "nisi", "aliquip", "ex", "ea", "commodo",
-		"consequat", "duis", "aute", "irure", "in", "reprehenderit", "voluptate",
-		"velit", "esse", "cillum", "fugiat", "nulla", "pariatur", "excepteur",
-		"sint", "occaecat", "cupidatat", "non", "proident", "sunt", "culpa",
-		"qui", "officia", "deserunt", "mollit", "anim", "id", "est", "laborum",
-
-		// extended Latin-like filler vocabulary
-		"praesent", "venenatis", "lectus", "aenean", "scelerisque", "phasellus",
-		"viverra", "turpis", "massa", "ultricies", "faucibus", "pulvinar",
-		"elementum", "nunc", "lobortis", "facilisis", "iaculis", "gravida",
-		"porttitor", "congue", "placerat", "hendrerit", "integer", "neque",
-		"vehicula", "sagittis", "suscipit", "malesuada", "ornare", "condimentum",
-		"tincidunt", "augue", "risus", "bibendum", "phasellus", "euismod",
-		"interdum", "fermentum", "dictum", "nibh", "blandit", "curae",
-		"lacinia", "mauris", "accumsan", "imperdiet", "phasellus", "dapibus",
-		"eros", "cras", "sollicitudin", "habitasse", "platea", "dictumst",
-		"maecenas", "rutrum", "varius", "quam", "vitae", "sapien", "tellus",
-		"mauris", "pretium", "fusce", "ornare", "donec", "ullamcorper"
-	];
-
+	private static readonly string[] Lorem = ["lorem", "ipsum", "dolor", "sit", "amet"];
+	
+	private static ConcurrentBag<string>? _cache;
+	
 	/// <summary>
 	/// Generates a random Lorem Ipsum string.
 	/// </summary>
 	/// <returns>A random Lorem Ipsum string with the specified number of words.</returns>
 	public override string Generate()
 	{
+		_cache ??= new(FileLoader.LoadData("en", "text/lorem", LoremContext.Default.ListString));
+		
 		var length = minWords == maxWords
 			? minWords
 			: Rng.Next(minWords, maxWords + 1);
 
-		return string.Join(" ", Rng.GetItems(Lipsum, length));
+		if (options is not { Starter: > 0})
+		{
+			return string.Join(' ', Rng.GetItems(_cache.ToArray(), length));
+		}
+		
+		string[] words = [
+			..Lorem[..options.Starter], 
+			..Rng.GetItems(_cache.ToArray(), length)
+		];
+
+		return string.Join(' ', words);
 	}
+
+	[UsedImplicitly]
+	public sealed record Options(int Starter = 0);
 }
+
+[UsedImplicitly]
+[JsonSerializable(typeof(List<string>))]
+[JsonSourceGenerationOptions(AllowTrailingCommas = true, ReadCommentHandling = JsonCommentHandling.Skip)]
+internal sealed partial class LoremContext : JsonSerializerContext;

Forged.Core/Generators/Utility/Text/RangeGenerator.cs

@@ -0,0 +1,52 @@
+namespace Forged.Core.Generators.Utility.Text;
+
+/// <summary>
+/// Represents a generator that produces a substring of a specified range from a generated string value.
+/// </summary>
+/// <typeparam name="T">The type of the generated value, constrained to strings in this implementation. </typeparam>
+/// <remarks>
+/// The <c>RangeGenerator</c> class is a specialized generator for creating substrings from
+/// the output of an inner <c>Generator&lt;string&gt;</c>. It takes a range specified by a starting index
+/// and an optional ending index.
+/// </remarks>
+/// <exception cref="ArgumentOutOfRangeException">
+/// Thrown if the specified range is outside the bounds of the string generated by the inner generator.
+/// </exception>
+/// <param name="innerGenerator">
+/// The inner string generator whose output will be used to extract the range.
+/// </param>
+/// <param name="start">
+/// The starting index of the substring within the string generated by the inner generator.
+/// </param>
+/// <param name="end">
+/// The optional ending index of the substring within the generated string. If not supplied, the substring
+/// will include characters up to the end of the inner-generator's output.
+/// </param>
+/// <param name="forge">
+/// The <c>Forge</c> instance providing shared dependencies such as a random number generator
+/// and locale information.
+/// </param>
+public sealed class RangeGenerator(Generator<string> innerGenerator, int start, int? end, Forge forge) : Generator<string>(forge)
+{
+	public override string Generate()
+	{
+		var str = innerGenerator.Generate().AsSpan();
+
+		var newEnd = end ?? str.Length;
+
+		if (start >= newEnd)
+		{
+			return string.Empty;
+		}
+
+		if (start > str.Length || newEnd > str.Length)
+		{
+			throw new ArgumentOutOfRangeException();
+		}
+
+		var s = start < 0 ? str.Length - start : start;
+		var e = newEnd < 0 ? str.Length - newEnd : newEnd;
+
+		return str[s..e].ToString();
+	}
+}

Forged.Core/Generators/Utility/Text/RegexReplaceGenerator.cs

@@ -0,0 +1,16 @@
+using System.Text.RegularExpressions;
+
+namespace Forged.Core.Generators.Utility.Text;
+
+/// <summary>
+/// A generator that transforms the output of another string generator by replacing all occurrences
+/// of a specified substring with a given replacement string.
+/// </summary>
+public sealed class RegexReplaceGenerator(Generator<string> innerGenerator, Regex regex, string to, Forge forge) : Generator<string>(forge)
+{
+	public override string Generate()
+	{
+		var str = innerGenerator.Generate();
+		return regex.Replace(str, to);
+	}
+}

Forged.Core/Generators/Utility/Text/ReplaceGenerator.cs

@@ -0,0 +1,14 @@
+namespace Forged.Core.Generators.Utility.Text;
+
+/// <summary>
+/// A generator that transforms the output of another string generator by replacing all occurrences
+/// of a specified substring with a given replacement string.
+/// </summary>
+public sealed class ReplaceGenerator(Generator<string> innerGenerator, string from, string to, Forge forge) : Generator<string>(forge)
+{
+	public override string Generate()
+	{
+		var str = innerGenerator.Generate();
+		return str.Replace(from, to);
+	}
+}