Added support for [Faker<T>] attribute

- That way, there's now a way to generate a faker that doesn't pollute the model itself

Author: Atulin

.scripts/Bump.cs

@@ -52,13 +52,29 @@
 		: version.Release;
 }
 
-var newVersion = new SemanticVersion(
-	version.Major + (part == "Major" ? 1 : 0),
-	version.Minor + (part == "Minor" ? 1 : 0),
-	version.Patch + (part == "Patch" ? 1 : 0),
-	tag,
-	null
-);
+var major = version.Major;
+var minor = version.Minor;
+var patch = version.Patch;
+
+switch (part)
+{
+	case "Major":
+		major++;
+		minor = 0;
+		patch = 0;
+		break;
+	case "Minor":
+		minor++;
+		patch = 0;
+		break;
+	case "Patch":
+		patch++;
+		break;
+	case "Build":
+		break;
+}
+
+var newVersion = new SemanticVersion(major, minor, patch, tag, null);
 
 AnsiConsole.MarkupLine($"[green]Bumping to: [bold]{newVersion}[/][/]");
 

Forged.Core/FakeAttribute.cs

@@ -4,6 +4,4 @@ namespace Forged.Core;
 /// Marker attribute for classes or structs that represent fake data models.
 /// </summary>
 [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct)]
-public sealed class FakeAttribute : Attribute
-{
-}
+public sealed class FakeAttribute : Attribute;

Forged.Core/FakerAttribute.cs

@@ -0,0 +1,7 @@
+namespace Forged.Core;
+
+/// <summary>
+/// Marker attribute for classes or structs that represent fakers.
+/// </summary>
+[AttributeUsage(AttributeTargets.Class)]
+public sealed class FakerAttribute<TModel> : Attribute;

Forged.Demo/Models.cs

@@ -16,4 +16,14 @@ public class Person
 	public DateTime? DateOfBirth { get; set; }
 	public string? Bio { get; set; }
 	public required int Luck { get; init; }
-}
+}
+
+public class Address
+{
+	public required string StreetName { get; init; }
+	public required string StreetNumber { get; init; }
+	public required string City { get; init; }
+}
+
+[Faker<Address>]
+public partial class AddressGenerator;

Forged.Generator/Forged.Generator.csproj

@@ -11,8 +11,12 @@
 
     <PropertyGroup>
         <MeziantouPolyfill_IncludedPolyfills>
+            T:System.Runtime.CompilerServices.CompilerRequiredAttribute;
+            T:System.Diagnostics.CodeAnalysis.DoesNotReturnAttribute;
             T:System.Diagnostics.CodeAnalysis.NotNullWhenAttribute;
             T:System.Runtime.CompilerServices.IsExternalInit;
+            T:System.Index;
+            T:System.Range;
         </MeziantouPolyfill_IncludedPolyfills>
     </PropertyGroup>
 

Forged.Generator/ForgedGenerator.cs

@@ -32,18 +32,39 @@ public class ForgedGenerator : IIncrementalGenerator
 
 	public void Initialize(IncrementalGeneratorInitializationContext context)
 	{
-		var typesToGenerate = context.SyntaxProvider
+		var typesToFake = context.SyntaxProvider
 			.ForAttributeWithMetadataName(
 				"Forged.Core.FakeAttribute",
 				predicate: static (s, _) => s is ClassDeclarationSyntax or RecordDeclarationSyntax or StructDeclarationSyntax,
-				transform: static (ctx, _) => GetSemanticTargetForGeneration(ctx.SemanticModel, ctx.TargetNode)
+				transform: static (ctx, _) => GetFakedTypes(ctx.SemanticModel, ctx.TargetNode)
 			)
-			.Where(static m => m is not null);
+			.Where(static m => m is not null)
+			.Select(static (m, _) => m!)
+			.Collect();
 
-		context.RegisterSourceOutput(typesToGenerate, static (spc, source) => Execute(spc, source));
+		var fakersToGenerate = context.SyntaxProvider
+			.ForAttributeWithMetadataName(
+				"Forged.Core.FakerAttribute`1",
+				predicate: static (s, _) => s is ClassDeclarationSyntax,
+				transform: static (ctx, _) => GetFakers(ctx.SemanticModel, ctx.TargetNode)
+			)
+			.Where(static m => m is not null)
+			.Select(static (m, _) => m!)
+			.Collect();
+		
+		var combined = typesToFake
+			.Combine(fakersToGenerate);
+
+		context.RegisterSourceOutput(combined, static (spc, source) => {
+			var (types, fakers) = source;
+			foreach (var ttg in types.Concat(fakers))
+			{
+				Execute(spc, ttg);
+			}
+		});
 	}
 
-	private static TypeToGenerate? GetSemanticTargetForGeneration(SemanticModel semanticModel, SyntaxNode node)
+	private static TypeToGenerate? GetFakedTypes(SemanticModel semanticModel, SyntaxNode node)
 	{
 		if (semanticModel.GetDeclaredSymbol(node) is not INamedTypeSymbol symbol)
 		{
@@ -66,16 +87,46 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
 			Properties: properties.ToEquatableReadOnlyList()
 		);
 	}
-
-	private static void Execute(SourceProductionContext context, TypeToGenerate? typeToGenerate)
+	
+	private static TypeToGenerate? GetFakers(SemanticModel semanticModel, SyntaxNode node)
 	{
-		if (typeToGenerate is null) return;
+		if (semanticModel.GetDeclaredSymbol(node) is not INamedTypeSymbol symbol)
+		{
+			return null;
+		}
+		
+		var attribute = symbol.GetAttributes().FirstOrDefault(a => a.AttributeClass?.Name == "FakerAttribute");
+		if (attribute is not { AttributeClass: { IsGenericType: true, TypeArguments: [ INamedTypeSymbol targetType ] }  })
+		{
+			return null;
+		}
+		
+		var properties = targetType.GetMembers()
+			.OfType<IPropertySymbol>()
+			.Where(p => p.SetMethod is not null && p.DeclaredAccessibility == Accessibility.Public)
+			.Select(p => new PropertyToGenerate(
+				Name: p.Name,
+				Type: p.Type.ToDisplayString(),
+				IsRequired: p.IsRequired
+			))
+			.ToList();
+
+		return new TypeToGenerate(
+			Namespace: targetType.ContainingNamespace.IsGlobalNamespace ? string.Empty : targetType.ContainingNamespace.ToDisplayString(),
+			Name: targetType.Name,
+			Properties: properties.ToEquatableReadOnlyList(),
+			FakerName: symbol.Name
+		);
+	}
 
+	private static void Execute(SourceProductionContext context, TypeToGenerate typeToGenerate)
+	{
 		var w = new IndentedWriter();
 		w.WriteLine(Header);
 		w.WriteLine("#nullable enable");
-
-
+		
+		var fakerName = typeToGenerate.FakerName ?? $"{typeToGenerate.Name}Faker";
+		
 		if (!string.IsNullOrEmpty(typeToGenerate.Namespace))
 		{
 			w.WriteLine();
@@ -85,7 +136,7 @@ private static void Execute(SourceProductionContext context, TypeToGenerate? typ
 		w.WriteLine();
 		w.WriteLine(Attributes);
 
-		w.WriteLine($"public partial class {typeToGenerate.Name}Faker : global::Forged.Core.Faker<{typeToGenerate.Name}>");
+		w.WriteLine($"public partial class {fakerName} : global::Forged.Core.Faker<{typeToGenerate.Name}>");
 		w.BodyBlock(() => {
 
 			foreach (var prop in typeToGenerate.Properties)
@@ -105,7 +156,7 @@ private static void Execute(SourceProductionContext context, TypeToGenerate? typ
 
 			w.WriteLine();
 			w.WriteLine("// Constructor");
-			w.WriteLine($"public {typeToGenerate.Name}Faker(global::System.Random? random = null, global::System.Globalization.CultureInfo? locale = null) : base(random, locale) {{ }}");
+			w.WriteLine($"public {fakerName}(global::System.Random? random = null, global::System.Globalization.CultureInfo? locale = null) : base(random, locale) {{ }}");
 
 			w.WriteLine();
 			w.WriteLine($"public override {typeToGenerate.Name} Get()");
@@ -132,16 +183,16 @@ private static void Execute(SourceProductionContext context, TypeToGenerate? typ
 				});
 			});
 		});
-
-		context.AddSource($"{typeToGenerate.Name}Faker.g.cs", SourceText.From(w.ToString(), Encoding.UTF8));
+		
+		context.AddSource($"{fakerName}.g.cs", SourceText.From(w.ToString(), Encoding.UTF8));
 	}
 
 	private static string Decapitalize(string input)
 	{
 		var span = input.AsSpan();
 		Span<char> result = stackalloc char[span.Length];
 		result[0] = char.ToLowerInvariant(span[0]);
-		span.Slice(1).CopyTo(result.Slice(1));
+		span[1..].CopyTo(result[1..]);
 		return result.ToString();
 	}
 }

Forged.Generator/EquatableReadOnlyList.cs …nerator/Helpers/EquatableReadOnlyList.csForged.Generator/EquatableReadOnlyList.cs renamed to Forged.Generator/Helpers/EquatableReadOnlyList.cs Forged.Generator/EquatableReadOnlyList.cs renamed to Forged.Generator/Helpers/EquatableReadOnlyList.cs

@@ -1,8 +1,8 @@
-namespace Forged.Generator;
-
-using System.Collections;
+using System.Collections;
 using System.Diagnostics.CodeAnalysis;
 
+namespace Forged.Generator.Helpers;
+
 [ExcludeFromCodeCoverage]
 public static class EquatableReadOnlyList
 {

Forged.Generator/Models/TypeToGenerate.cs

@@ -1,7 +1,10 @@
-namespace Forged.Generator.Models;
+using Forged.Generator.Helpers;
+
+namespace Forged.Generator.Models;
 
 public sealed record TypeToGenerate(
 	string Namespace, 
-	string Name, 
-	EquatableReadOnlyList<PropertyToGenerate> Properties
+	string Name,
+	EquatableReadOnlyList<PropertyToGenerate> Properties,
+	string? FakerName = null
 );

Forged/Forged.csproj

@@ -6,7 +6,7 @@
         <Nullable>enable</Nullable>
 
         <PackageId>Atulin.Forged</PackageId>
-        <PackageVersion>0.4.0</PackageVersion>
+        <PackageVersion>1.0.0</PackageVersion>
         <Title>Atulin.Forged</Title>
         <Description>A fast, strict, and strongly-typed data generator (faker) for C# powered by Source Generators.</Description>
         <Authors>Atulin</Authors>

README.md

@@ -21,10 +21,6 @@ Forged allows you to declaratively define how your models should be faked, lever
 2. Decorate your model with `[Fake]`:
 
 ```csharp
-using Forged.Core;
-
-namespace MyProject;
-
 [Fake]
 public class Person
 {
@@ -37,6 +33,13 @@ public class Person
 }
 ```
 
+or create a partial class with `[Faker<T>]` attribute:
+
+```csharp
+[Faker<Person>]
+public partial class PersonFaker;
+```
+
 3. The source generator will automatically create a `{ModelName}Faker` class for you. Configure it and generate data!
 
 ```csharp
@@ -68,9 +71,13 @@ var person = faker.Get();
 var people = faker.Get(5);
 ```
 
+> [!INFO]
+> When using the `Faker<T>` attribute, the generated faker will have the same name,
+> not `{ModelName}Faker`.
+
 ### Deterministic Generation
 
-If you need reproducible results (e.g., in unit tests), you can provide a seeded `Random` instance to the faker:
+If you need reproducible results (e.g. in unit tests), you can provide a seeded `Random` instance to the faker:
 
 ```csharp
 var faker = new PersonFaker(new Random(12345))