feat: justifications for all

Author: latonz

docs/docs/configuration/analyzer-diagnostics/RMG096.mdx

@@ -1,30 +1,39 @@
 ---
 sidebar_label: RMG096
-description: 'Mapperly analyzer diagnostic RMG096 — Ignored mapping is missing Justification'
+description: 'Mapperly analyzer diagnostic RMG096 — Ignored mapping is missing justification'
 ---
 
-# RMG096 — Ignored mapping is missing Justification
+# RMG096 — Ignored mapping is missing justification
 
-If Mapperly detects a mapping ignore without a Justification, `RMG096` is emitted.
+If Mapperly detects a mapping ignore without a non-whitespace `Justification`, `RMG096` is emitted.
 
 The following attributes may raise this diagnostic:
- 
+
+- `MapperIgnore`
 - `MapperIgnoreSource`
 - `MapperIgnoreTarget`
 - `MapperIgnoreSourceValue`
 - `MapperIgnoreTargetValue`
 
-To fix this, add a Justification to the attribute, for example:
+To fix this, add a `Justification` to the attribute, for example:
 
 ```csharp
-public partial class Mapper {
-	[MapperIgnoreSource(nameof(SourceClass.IgnoredProperty), Justification = "This source member is not relevant for the target mapping")]
-	public partial TargetClass Map(SourceClass source);
+[Mapper]
+public partial class Mapper
+{
+    [MapperIgnoreSource(
+        nameof(SourceClass.IgnoredProperty),
+        Justification = "This source member is not relevant for the target mapping"
+    )]
+    public partial TargetClass Map(SourceClass source);
 }
 
-class SourceClass {
-	string IgnoredProperty { get; set; }
+class SourceClass
+{
+    public string IgnoredProperty { get; set; }
 }
 
-class TargetClass { }
-```
+class TargetClass
+{
+}
+```

src/Riok.Mapperly.Abstractions/MapperIgnoreAttribute.cs

@@ -11,4 +11,15 @@ namespace Riok.Mapperly.Abstractions;
 /// </remarks>
 [AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Method)]
 [Conditional("MAPPERLY_ABSTRACTIONS_SCOPE_RUNTIME")]
-public sealed class MapperIgnoreAttribute : Attribute;
+public sealed class MapperIgnoreAttribute : Attribute
+{
+    /// <summary>
+    /// Gets or sets the justification for ignoring the member or method.
+    /// This is only used for documentation purposes and does not have any effect on the mapping.
+    /// </summary>
+    /// <remarks>
+    /// You can enforce the presence of justifications by setting the diagnostic severity of <c>RMG096</c> in your
+    /// <c>.editorconfig</c> to any value other than <c>hidden</c>.
+    /// </remarks>
+    public string? Justification { get; set; }
+}

src/Riok.Mapperly.Abstractions/MapperIgnoreSourceAttribute.cs

@@ -22,13 +22,13 @@ public MapperIgnoreSourceAttribute(string source)
     /// Gets the source property name which should be ignored from the mapping.
     /// </summary>
     public string Source { get; }
-    
+
     /// <summary>
     /// Gets or sets the justification for ignoring the source property.
     /// This is only used for documentation purposes and does not have any effect on the mapping.
     /// </summary>
     /// <remarks>
-    /// You can enforce the presence of Justifications by setting the diagnostic severity of <c>RMG096</c> in your
+    /// You can enforce the presence of justifications by setting the diagnostic severity of <c>RMG096</c> in your
     /// <c>.editorconfig</c> to any value other than <c>hidden</c>.
     /// </remarks>
     public string? Justification { get; set; }

src/Riok.Mapperly.Abstractions/MapperIgnoreSourceValueAttribute.cs

@@ -22,4 +22,14 @@ public MapperIgnoreSourceValueAttribute(object source)
     /// Gets the source enum value which should be ignored from the mapping.
     /// </summary>
     public Enum? SourceValue { get; }
+
+    /// <summary>
+    /// Gets or sets the justification for ignoring the source enum value.
+    /// This is only used for documentation purposes and does not have any effect on the mapping.
+    /// </summary>
+    /// <remarks>
+    /// You can enforce the presence of justifications by setting the diagnostic severity of <c>RMG096</c> in your
+    /// <c>.editorconfig</c> to any value other than <c>hidden</c>.
+    /// </remarks>
+    public string? Justification { get; set; }
 }

src/Riok.Mapperly.Abstractions/MapperIgnoreTargetAttribute.cs

@@ -22,4 +22,14 @@ public MapperIgnoreTargetAttribute(string target)
     /// Gets the target property name which should be ignored from the mapping.
     /// </summary>
     public string Target { get; }
+
+    /// <summary>
+    /// Gets or sets the justification for ignoring the target property.
+    /// This is only used for documentation purposes and does not have any effect on the mapping.
+    /// </summary>
+    /// <remarks>
+    /// You can enforce the presence of justifications by setting the diagnostic severity of <c>RMG096</c> in your
+    /// <c>.editorconfig</c> to any value other than <c>hidden</c>.
+    /// </remarks>
+    public string? Justification { get; set; }
 }

src/Riok.Mapperly.Abstractions/MapperIgnoreTargetValueAttribute.cs

@@ -22,4 +22,14 @@ public MapperIgnoreTargetValueAttribute(object target)
     /// Gets the target enum value which should be ignored from the mapping.
     /// </summary>
     public Enum? TargetValue { get; }
+
+    /// <summary>
+    /// Gets or sets the justification for ignoring the target enum value.
+    /// This is only used for documentation purposes and does not have any effect on the mapping.
+    /// </summary>
+    /// <remarks>
+    /// You can enforce the presence of justifications by setting the diagnostic severity of <c>RMG096</c> in your
+    /// <c>.editorconfig</c> to any value other than <c>hidden</c>.
+    /// </remarks>
+    public string? Justification { get; set; }
 }

src/Riok.Mapperly/AnalyzerReleases.Shipped.md

@@ -213,5 +213,12 @@ RMG091 | Mapper | Error | Circular included mapping configuration detected
 RMG092 | Mapper | Error | Source type is not assignable to the included source type
 RMG093 | Mapper | Error | Target type is not assignable to the included target type
 RMG094 | Mapper | Error | Circular existing target mapping without setter detected
+
+## Release 5.0
+
+### New Rules
+
+Rule ID | Category | Severity | Notes
+--------|----------|----------|-------
 RMG095 | Mapper | Warning | Invalid MSBuild configuration option
-RMG096 | Mapper | Hidden | A MapperIgnore* attribute does not specify a Justification
+RMG096 | Mapper | Hidden | A MapperIgnore* attribute does not specify a justification

src/Riok.Mapperly/Configuration/MapperConfigurationReader.cs

@@ -218,15 +218,13 @@ private MembersMappingConfiguration BuildMembersConfig(MappingConfigurationRefer
             return MapperConfiguration.Members;
 
         var ignoreSourceMemberAttributes = _dataAccessor
-            .Access<MapperIgnoreSourceAttribute>(configRef.Method)
-            .WhereNotNullBy(static attr => attr.Source)
+            .Access<MapperIgnoreSourceAttribute, MapperIgnoreMemberConfiguration>(configRef.Method)
             .ToList();
-        var ignoredSourceMembers = ignoreSourceMemberAttributes.Select(x => x.Source).ToList();
+        var ignoredSourceMembers = ignoreSourceMemberAttributes.Select(x => x.Value).WhereNotNull().ToList();
         var ignoreTargetMemberAttributes = _dataAccessor
-            .Access<MapperIgnoreTargetAttribute>(configRef.Method)
-            .WhereNotNullBy(static attr => attr.Target)
+            .Access<MapperIgnoreTargetAttribute, MapperIgnoreMemberConfiguration>(configRef.Method)
             .ToList();
-        var ignoredTargetMembers = ignoreTargetMemberAttributes.Select(x => x.Target).ToList();
+        var ignoredTargetMembers = ignoreTargetMemberAttributes.Select(x => x.Value).WhereNotNull().ToList();
         var memberValueConfigurations = _dataAccessor.Access<MapValueAttribute, MemberValueMappingConfiguration>(configRef.Method).ToList();
         var memberConfigurations = _dataAccessor
             .Access<MapPropertyAttribute, MemberMappingConfiguration>(configRef.Method)
@@ -259,14 +257,8 @@ private MembersMappingConfiguration BuildMembersConfig(MappingConfigurationRefer
             return MapperConfiguration.Members;
         }
 
-        foreach (var missingIgnoreSourceJustificationAttribute in ignoreSourceMemberAttributes.Where(attr => attr.Justification is null))
-        {
-            _diagnostics.ReportDiagnostic(
-                DiagnosticDescriptors.MapperIgnoreAttributeMissingJustification,
-                configRef.Method,
-                missingIgnoreSourceJustificationAttribute.Source
-            );
-        }
+        ReportMissingJustificationDiagnostics(ignoreSourceMemberAttributes, static x => x.Value);
+        ReportMissingJustificationDiagnostics(ignoreTargetMemberAttributes, static x => x.Value);
 
         foreach (var invalidMemberConfig in memberValueConfigurations.Where(x => !x.IsValid))
         {
@@ -296,16 +288,19 @@ private EnumMappingConfiguration BuildEnumConfig(MappingConfigurationReference c
 
         var configData = _dataAccessor.AccessFirstOrDefault<MapEnumAttribute, EnumConfiguration>(configRef.Method);
         var explicitMappings = _dataAccessor.Access<MapEnumValueAttribute, EnumValueMappingConfiguration>(configRef.Method).ToList();
-        var ignoredSources = _dataAccessor
+        var ignoredSourceValueConfigurations = _dataAccessor
             .Access<MapperIgnoreSourceValueAttribute, MapperIgnoreEnumValueConfiguration>(configRef.Method)
-            .Select(x => x.Value)
             .ToList();
-        var ignoredTargets = _dataAccessor
+        var ignoredSources = ignoredSourceValueConfigurations.Select(x => x.Value).ToList();
+        var ignoredTargetValueConfigurations = _dataAccessor
             .Access<MapperIgnoreTargetValueAttribute, MapperIgnoreEnumValueConfiguration>(configRef.Method)
-            .Select(x => x.Value)
             .ToList();
+        var ignoredTargets = ignoredTargetValueConfigurations.Select(x => x.Value).ToList();
         var requiredMapping = _dataAccessor.AccessFirstOrDefault<MapperRequiredMappingAttribute>(configRef.Method)?.RequiredMappingStrategy;
 
+        ReportMissingJustificationDiagnostics(ignoredSourceValueConfigurations, static x => x.Value.Name);
+        ReportMissingJustificationDiagnostics(ignoredTargetValueConfigurations, static x => x.Value.Name);
+
         // ignore the required mapping as the same attribute is used for other mapping types
         // e.g. object to object
         var hasEnumConfigs = configData != null || explicitMappings.Count > 0 || ignoredSources.Count > 0 || ignoredTargets.Count > 0;
@@ -326,4 +321,23 @@ private EnumMappingConfiguration BuildEnumConfig(MappingConfigurationReference c
             configData?.NamingStrategy ?? MapperConfiguration.Enum.NamingStrategy
         );
     }
+
+    private void ReportMissingJustificationDiagnostics<TConfiguration>(
+        IEnumerable<TConfiguration> ignoreConfigurations,
+        Func<TConfiguration, string?> ignoredNameAccessor
+    )
+        where TConfiguration : MapperIgnoreConfigurationBase
+    {
+        foreach (var ignoreConfiguration in ignoreConfigurations)
+        {
+            if (!string.IsNullOrWhiteSpace(ignoreConfiguration.Justification))
+                continue;
+
+            var ignoredName = ignoredNameAccessor(ignoreConfiguration);
+            if (ignoredName == null)
+                continue;
+
+            _diagnostics.ReportDiagnostic(DiagnosticDescriptors.IgnoreMissingJustification, ignoreConfiguration.Location, ignoredName);
+        }
+    }
 }

src/Riok.Mapperly/Configuration/MapperIgnoreConfiguration.cs

@@ -0,0 +1,3 @@
+namespace Riok.Mapperly.Configuration;
+
+public record MapperIgnoreConfiguration : MapperIgnoreConfigurationBase;

src/Riok.Mapperly/Configuration/MapperIgnoreConfigurationBase.cs

@@ -0,0 +1,6 @@
+namespace Riok.Mapperly.Configuration;
+
+public abstract record MapperIgnoreConfigurationBase : HasSyntaxReference
+{
+    public string? Justification { get; set; }
+}