Merge pull request #28

* Initial

* Adding out parameters to mock factory

* Pre merge cleanup

* Namespace fix

* Update to version 0.9.13

* Cleanup ConstructorBuilder

* Cleanup warnings

* Cleanup code and adding documentation

* Adding documentation to files

Author: oswaldsql

.editorconfig

@@ -1,6 +1,6 @@
 # MiniMock
 
-Mini mock offers a _minimalistic_ approach to mocking in .Net. It is designed to be simple to use and easy to understand. 
+Mini mock offers a _minimalistic_ approach to mocking in .Net. It is designed to be simple to use and easy to understand.
 It is not as feature rich as other mocking frameworks, but aims to solve __95%__ of the use cases. For the remaining __5%__ you should consider creating a custom mock.
 
 Mini mock is __extremely strict__ requiring you to specify all features you want to mock. This is by design to make sure you are aware of what you are mocking.
@@ -64,7 +64,7 @@ public void MyTest {
 }
 ```
 
-Create a mock by using the mock factory 
+Create a mock by using the mock factory
 
 ```csharp
 var mockRepository = Mock.IMyRepository();
@@ -207,7 +207,7 @@ Mocking indexers is supported either by overloading the get and set methods or b
     }
 ```
 
-### Raising events 
+### Raising events
 
 Raise events using an event trigger.
 
@@ -223,15 +223,15 @@ Raise events using an event trigger.
 
 ### Argument matching
 
-MiniMock does not support argument matching using matchers like other mocking frameworks. 
+MiniMock does not support argument matching using matchers like other mocking frameworks.
 Instead, you can use the call parameter to match arguments using predicates or internal functions.
 
 ```csharp
     var versionLibrary = Mock.IVersionLibrary(config => config
             .DownloadExists(call: version => version is { Major: 2, Minor: 0 }) // Returns true for version 2.0.x based on a version parameter
         );
 ```
-        
+
 __using internal functions__
 
 ```csharp

README.md

@@ -2,11 +2,11 @@
 
 ### New Rules
 
-Rule ID | Category | Severity | Notes
---------|----------|----------|--------------------
-MM0002  | Usage | Error    | Ref properties not supported, [Documentation](https://github.com/oswaldsql/MiniMock/blob/main/Documentation/AnalyzerRules/MM0002.md)          
-MM0003  | Usage | Error    | Ref return type not supported, [Documentation](https://github.com/oswaldsql/MiniMock/blob/main/Documentation/AnalyzerRules/MM0003.md)         
-MM0004  | Usage    | Error    | Generic method not supported, [Documentation](https://github.com/oswaldsql/MiniMock/blob/main/Documentation/AnalyzerRules/MM0004.md)
-MM0005  | Usage | Error    | Static abstract members not supported, [Documentation](https://github.com/oswaldsql/MiniMock/blob/main/Documentation/AnalyzerRules/MM0005.md)
-MM0006  | Usage | Error    | Can not create mock for a sealed class, [Documentation](https://github.com/oswaldsql/MiniMock/blob/main/Documentation/AnalyzerRules/MM0006.md)
+ Rule ID | Category | Severity | Notes                                                                                                                                          
+---------|----------|----------|------------------------------------------------------------------------------------------------------------------------------------------------
+ MM0002  | Usage    | Error    | Ref properties not supported, [Documentation](https://github.com/oswaldsql/MiniMock/blob/main/Documentation/AnalyzerRules/MM0002.md)           
+ MM0003  | Usage    | Error    | Ref return type not supported, [Documentation](https://github.com/oswaldsql/MiniMock/blob/main/Documentation/AnalyzerRules/MM0003.md)          
+ MM0004  | Usage    | Error    | Generic method not supported, [Documentation](https://github.com/oswaldsql/MiniMock/blob/main/Documentation/AnalyzerRules/MM0004.md)           
+ MM0005  | Usage    | Error    | Static abstract members not supported, [Documentation](https://github.com/oswaldsql/MiniMock/blob/main/Documentation/AnalyzerRules/MM0005.md)  
+ MM0006  | Usage    | Error    | Can not create mock for a sealed class, [Documentation](https://github.com/oswaldsql/MiniMock/blob/main/Documentation/AnalyzerRules/MM0006.md) 
 

src/MiniMock/AnalyzerReleases.Shipped.md

@@ -1,5 +1,5 @@
 ### Removed Rules
 
-Rule ID | Category | Severity | Notes
---------|----------|----------|--------------------
-MM0004  | Usage    | Error    | Generic method not supported, [Documentation](https://github.com/oswaldsql/MiniMock/blob/main/Documentation/AnalyzerRules/MM0004.md)
+ Rule ID | Category | Severity | Notes                                                                                                                                
+---------|----------|----------|--------------------------------------------------------------------------------------------------------------------------------------
+ MM0004  | Usage    | Error    | Generic method not supported, [Documentation](https://github.com/oswaldsql/MiniMock/blob/main/Documentation/AnalyzerRules/MM0004.md) 

src/MiniMock/AnalyzerReleases.Unshipped.md

@@ -1,15 +1,39 @@
-namespace MiniMock.Builders;
-
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using Microsoft.CodeAnalysis;
-
+using MiniMock;
+using MiniMock.Builders;
+using MiniMock.Util;
+
+/// <summary>
+/// ClassBuilder is responsible for generating mock classes for a given target symbol.
+/// </summary>
+/// <param name="target">The target symbol to build the mock class for.</param>
 internal class ClassBuilder(ISymbol target)
 {
+    /// <summary>
+    /// Array of builders for different member types.
+    /// </summary>
+    private static readonly ISymbolBuilder[] Builders = [new ConstructorBuilder(), new EventBuilder(), new MethodBuilder(), new PropertyBuilder(), new IndexBuilder()];
+
+    /// <summary>
+    /// Filter to determine if a member's accessibility is public or protected.
+    /// </summary>
+    private readonly Func<Accessibility, bool> accessibilityFilter = accessibility => accessibility == Accessibility.Public || accessibility == Accessibility.Protected;
+
+    /// <summary>
+    /// Builds a mock class for the given symbol.
+    /// </summary>
+    /// <param name="symbol">The symbol to build the mock class for.</param>
+    /// <returns>The generated mock class as a string.</returns>
     public static string Build(ISymbol symbol) =>
         new ClassBuilder(symbol).BuildClass();
 
+    /// <summary>
+    /// Generates the mock class code.
+    /// </summary>
+    /// <returns>The generated mock class as a string.</returns>
     private string BuildClass()
     {
         if (target.IsSealed && target is INamedTypeSymbol symbol)
@@ -35,6 +59,8 @@ private string BuildClass()
 
         var documentationName = fullName.Replace("<", "{").Replace(">", "}");
 
+        var hasConstructors = ((INamedTypeSymbol)target).Constructors.Any(c => this.accessibilityFilter(c.DeclaredAccessibility));
+
         builder.Add($$"""
                       // Generated by MiniMock on {{DateTime.Now}}
                       #nullable enable
@@ -50,18 +76,28 @@ internal class {{name}} : {{fullName}} {{constraints}}
                       private Config _config { get; }
                       internal void GetConfig(out Config config) => config = _config;
 
+                      /// <summary>
+                      /// Configuration class for the mock.
+                      /// </summary>
                       internal partial class Config
                       {
                           private readonly {{name}} target;
 
+                          /// <summary>
+                          /// Initializes a new instance of the <see cref="Config"/> class.
+                          /// </summary>
+                          /// <param name="target">The target mock class.</param>
                           public Config({{name}} target)
                           {
                               this.target = target;
                           }
                       }
                       """);
 
-        new ConstructorBuilder(target).Build(builder, fullName, name);
+        if (!hasConstructors)
+        {
+            builder.Add(ConstructorBuilder.BuildEmptyConstructor(target));
+        }
 
         this.BuildMembers(builder);
 
@@ -75,8 +111,10 @@ public Config({{name}} target)
         return builder.ToString();
     }
 
-    private readonly Func<Accessibility, bool> accessibilityFilter = accessibility => accessibility == Accessibility.Public || accessibility == Accessibility.Protected;
-
+    /// <summary>
+    /// Builds the members of the mock class.
+    /// </summary>
+    /// <param name="builder">The code builder to add the members to.</param>
     private void BuildMembers(CodeBuilder builder)
     {
         var memberCandidates = new List<ISymbol>(((INamedTypeSymbol)target).GetMembers().Where(t => this.accessibilityFilter(t.DeclaredAccessibility)));
@@ -91,24 +129,19 @@ private void BuildMembers(CodeBuilder builder)
         foreach (var members in memberGroups)
         {
             var symbol = members.First();
-            switch (symbol)
+            var wasBuild = Builders.FirstOrDefault(b => b.TryBuild(builder, members));
+            if (wasBuild == null)
             {
-                case IEventSymbol:
-                    EventBuilder.BuildEvents(builder, members.OfType<IEventSymbol>());
-                    break;
-                case IMethodSymbol { MethodKind: MethodKind.Ordinary }:
-                    MethodBuilder.BuildMethods(builder, members.OfType<IMethodSymbol>());
-                    break;
-                case IPropertySymbol { IsIndexer: false }:
-                    PropertyBuilder.BuildProperties(builder, members.OfType<IPropertySymbol>());
-                    break;
-                case IPropertySymbol { IsIndexer: true }:
-                    IndexBuilder.BuildIndexes(builder, members.OfType<IPropertySymbol>());
-                    break;
+                builder.Add("// Ignored " + symbol.Kind + " " + symbol);
             }
         }
     }
 
+    /// <summary>
+    /// Adds inherited interfaces to the member candidates list.
+    /// </summary>
+    /// <param name="memberCandidates">The list of member candidates.</param>
+    /// <param name="namedTypeSymbol">The named type symbol to add inherited interfaces from.</param>
     private void AddInheritedInterfaces(List<ISymbol> memberCandidates, INamedTypeSymbol namedTypeSymbol)
     {
         var allInterfaces = namedTypeSymbol.AllInterfaces;

src/MiniMock/Builders/ClassBuilder.cs

@@ -1,56 +1,111 @@
 namespace MiniMock.Builders;
 
-using System;
+using System.Collections.Generic;
 using System.Linq;
 using Microsoft.CodeAnalysis;
+using Util;
 
-internal class ConstructorBuilder(ISymbol target)
+/// <summary>
+/// Represents a builder for constructing mock constructors.
+/// </summary>
+internal class ConstructorBuilder : ISymbolBuilder
 {
-    private readonly Func<Accessibility, bool> accessibilityFilter = accessibility => accessibility == Accessibility.Public || accessibility == Accessibility.Protected;
+    /// <summary>
+    /// Tries to build constructors for the given symbols.
+    /// </summary>
+    /// <param name="builder">The code builder to add the constructors to.</param>
+    /// <param name="symbols">The symbols to build constructors for.</param>
+    /// <returns>True if constructors were built; otherwise, false.</returns>
+    public bool TryBuild(CodeBuilder builder, IGrouping<string, ISymbol> symbols)
+    {
+        var first = symbols.First();
+        if (first is IMethodSymbol { MethodKind: MethodKind.Constructor })
+        {
+            return BuildConstructors(builder, first.ContainingSymbol, symbols.OfType<IMethodSymbol>());
+        }
 
-    public void Build(CodeBuilder builder, string fullName, string name)
+        return false;
+    }
+
+    /// <summary>
+    /// Builds constructors for the specified target and adds them to the code builder.
+    /// </summary>
+    /// <param name="builder">The code builder to add the constructors to.</param>
+    /// <param name="target">The target symbol for which to build constructors.</param>
+    /// <param name="constructors">The constructors to build.</param>
+    /// <returns>True if constructors were built; otherwise, false.</returns>
+    private static bool BuildConstructors(CodeBuilder builder, ISymbol target, IEnumerable<IMethodSymbol> constructors)
     {
-        var symbol = (INamedTypeSymbol)target;
+        var fullName = target.ToString();
+        var name = "MockOf_" + target.Name;
 
-        var constructors = symbol.Constructors
-            .Where(c => this.accessibilityFilter(c.DeclaredAccessibility))
-            .ToArray();
+        var typeArguments = ((INamedTypeSymbol)target).TypeArguments;
+        if (typeArguments.Length > 0)
+        {
+            var types = string.Join(", ", typeArguments.Select(t => t.Name));
+            name = $"MockOf_{target.Name}<{types}>";
+        }
 
         builder.Add("#region Constructors");
 
-        if (constructors.Length == 0 || constructors.Any(t => t.Parameters.Length == 0))
+        foreach (var constructor in constructors)
         {
+            var parameterList = constructor.Parameters.ToString(p => $"{p.Type} {p.Name}, ", "");
+            var argumentList = constructor.Parameters.ToString(p => p.Name);
+
+            var parameterNames = constructor.Parameters.ToString(p => p.Name + ", ", "");
+
             builder.Add($$"""
-                          internal protected MockOf_{{target.Name}}(System.Action<Config>? config = null) {
+                          internal protected MockOf_{{target.Name}}({{parameterList}}System.Action<Config>? config = null) : base({{argumentList}}) {
                               var result = new Config(this);
                               config = config ?? new System.Action<Config>(t => { });
                               config.Invoke(result);
                               _config = result;
                           }
 
-                          public static {{fullName}} Create(System.Action<Config>? config = null) => new {{name}}(config);
+                          public static {{fullName}} Create({{parameterList}}System.Action<Config>? config = null) => new {{name}}({{parameterNames}}config);
                           """);
         }
 
-        foreach (var constructor in constructors.Where(t => t.Parameters.Length > 0))
-        {
-            var parameters = constructor.Parameters.Select(p => $"{p.Type} {p.Name}").ToArray();
-            var parameterList = string.Join(", ", parameters);
-            var parameterNames = constructor.Parameters.Select(p => p.Name).ToArray();
-            var parameterNamesList = string.Join(", ", parameterNames);
+        builder.Add("#endregion");
 
-            builder.Add($$"""
-                          internal protected MockOf_{{target.Name}}({{parameterList}}, System.Action<Config>? config = null) : base({{parameterNamesList}}) {
-                              var result = new Config(this);
-                              config = config ?? new System.Action<Config>(t => { });
-                              config.Invoke(result);
-                              _config = result;
-                          }
+        return true;
+    }
 
-                          public static {{fullName}} Create({{parameterList}}, System.Action<Config>? config = null) => new {{name}}({{parameterNamesList}}, config);
-                          """);
+    /// <summary>
+    /// Builds an empty constructor for the specified target.
+    /// </summary>
+    /// <param name="target">The target symbol for which to build an empty constructor.</param>
+    /// <returns>A code builder containing the empty constructor.</returns>
+    public static CodeBuilder BuildEmptyConstructor(ISymbol target)
+    {
+        var fullName = target.ToString();
+        var name = "MockOf_" + target.Name;
+
+        var typeArguments = ((INamedTypeSymbol)target).TypeArguments;
+        if (typeArguments.Length > 0)
+        {
+            var types = string.Join(", ", typeArguments.Select(t => t.Name));
+            name = $"MockOf_{target.Name}<{types}>";
         }
 
-        builder.Add("#endregion");
+        CodeBuilder builder = new();
+
+        builder.Add($$"""
+                      #region Constructor
+
+                      internal protected MockOf_{{target.Name}}(System.Action<Config>? config = null) {
+                          var result = new Config(this);
+                          config = config ?? new System.Action<Config>(t => { });
+                          config.Invoke(result);
+                          _config = result;
+                      }
+
+                      public static {{fullName}} Create(System.Action<Config>? config = null) => new {{name}}(config);
+
+                      #endregion
+                      """);
+
+        return builder;
     }
 }

src/MiniMock/Builders/ConstructorBuilder.cs

@@ -3,10 +3,16 @@ namespace MiniMock.Builders;
 internal static class Documentation
 {
     internal const string CallBack = "Configures the mock to execute the specified action when the method matching the signature is called.";
+
     internal const string AcceptAny = "Configures the mock to accept any call to the method.";
+
     internal const string ThrowsException = "Configures the mock to throw the specified exception when the method is called.";
+
     internal const string SpecificValue = "Configures the mock to return the specific value.";
+
     internal const string SpecificValueList = "Configures the mock to return the consecutive values from an enumeration of values.";
+
     internal const string GenericTaskObject = "Configures the mock to return the specific value in a task object.";
+
     internal const string GenericTaskFunction = "Configures the mock to call the specified function and return the value wrapped in a task object when the method matching the signature is called.";
 }