From 5ea127488b4f84a66847d9a256be77a6e8b93403 Mon Sep 17 00:00:00 2001 From: Martin Oehlert Date: Tue, 15 Jul 2025 13:20:18 +0200 Subject: [PATCH 1/2] Feature: Implement Maximum Public Methods Per Class Check - Added new configurable setting for maximum public methods per class - Added string resources for UI and warning messages - Created TooManyPublicMethods feature with highlighting - Implemented C# and VB analyzers to detect classes with too many public methods - Integrated the new check into the Single Responsibility section of options page This feature helps enforce better encapsulation and adherence to the Single Responsibility Principle by limiting the public API surface of classes. --- .config/dotnet-tools.json | 12 ++ .../TooManyPublicMethodsCheck.cs | 41 ++++++ .../TooManyPublicMethodsCheckCs.cs | 28 ++++ .../TooManyPublicMethodsCheckVb.cs | 28 ++++ .../TooManyPublicMethodsHighlighting.cs | 48 +++++++ .../Resources/Settings.Designer.cs | 24 +--- .../MO.CleanCode/Resources/Settings.resx | 3 + .../Resources/Warnings.Designer.cs | 9 ++ .../MO.CleanCode/Resources/Warnings.resx | 3 + .../Settings/CleanCodeOptionsPage.cs | 120 +++++++++++++----- .../Settings/CleanCodeSettings.cs | 10 +- 11 files changed, 268 insertions(+), 58 deletions(-) create mode 100644 .config/dotnet-tools.json create mode 100644 src/dotnet/MO.CleanCode/Features/TooManyPublicMethods/TooManyPublicMethodsCheck.cs create mode 100644 src/dotnet/MO.CleanCode/Features/TooManyPublicMethods/TooManyPublicMethodsCheckCs.cs create mode 100644 src/dotnet/MO.CleanCode/Features/TooManyPublicMethods/TooManyPublicMethodsCheckVb.cs create mode 100644 src/dotnet/MO.CleanCode/Features/TooManyPublicMethods/TooManyPublicMethodsHighlighting.cs diff --git a/.config/dotnet-tools.json b/.config/dotnet-tools.json new file mode 100644 index 0000000..96b59af --- /dev/null +++ b/.config/dotnet-tools.json @@ -0,0 +1,12 @@ +{ + "version": 1, + "isRoot": true, + "tools": { + "csharpier": { + "version": "1.0.1", + "commands": [ + "csharpier" + ] + } + } +} diff --git a/src/dotnet/MO.CleanCode/Features/TooManyPublicMethods/TooManyPublicMethodsCheck.cs b/src/dotnet/MO.CleanCode/Features/TooManyPublicMethods/TooManyPublicMethodsCheck.cs new file mode 100644 index 0000000..111dc03 --- /dev/null +++ b/src/dotnet/MO.CleanCode/Features/TooManyPublicMethods/TooManyPublicMethodsCheck.cs @@ -0,0 +1,41 @@ +using System; +using System.Linq; +using CleanCode.Settings; +using JetBrains.ReSharper.Feature.Services.Daemon; +using JetBrains.ReSharper.Psi.Tree; + +namespace CleanCode.Features.TooManyPublicMethods +{ + public abstract class TooManyPublicMethodsCheck : ElementProblemAnalyzer + { + protected static void CheckIfClassHasTooManyPublicMethods( + ITreeNode declaration, + ITreeNode element, + ElementProblemAnalyzerData data, + IHighlightingConsumer consumer, + Func isPublicMethod + ) + where TMethodDeclaration : ITreeNode + { + var maxPublicMethods = data.SettingsStore.GetValue( + (CleanCodeSettings s) => s.MaximumPublicMethodsInClass + ); + + var publicMethodCount = element + .Children() + .OfType() + .Count(isPublicMethod); + + if (publicMethodCount <= maxPublicMethods) + return; + + var documentRange = declaration.GetDocumentRange(); + var highlighting = new TooManyPublicMethodsHighlighting( + documentRange, + maxPublicMethods, + publicMethodCount + ); + consumer.AddHighlighting(highlighting); + } + } +} diff --git a/src/dotnet/MO.CleanCode/Features/TooManyPublicMethods/TooManyPublicMethodsCheckCs.cs b/src/dotnet/MO.CleanCode/Features/TooManyPublicMethods/TooManyPublicMethodsCheckCs.cs new file mode 100644 index 0000000..5bb5cd1 --- /dev/null +++ b/src/dotnet/MO.CleanCode/Features/TooManyPublicMethods/TooManyPublicMethodsCheckCs.cs @@ -0,0 +1,28 @@ +using JetBrains.ReSharper.Feature.Services.Daemon; +using JetBrains.ReSharper.Psi; +using JetBrains.ReSharper.Psi.CSharp.Tree; + +namespace CleanCode.Features.TooManyPublicMethods +{ + [ElementProblemAnalyzer( + typeof(IClassDeclaration), + HighlightingTypes = new[] { typeof(TooManyPublicMethodsHighlighting) } + )] + public class TooManyPublicMethodsCheckCs : TooManyPublicMethodsCheck + { + protected override void Run( + IClassDeclaration element, + ElementProblemAnalyzerData data, + IHighlightingConsumer consumer + ) + { + CheckIfClassHasTooManyPublicMethods( + element.NameIdentifier, + element, + data, + consumer, + method => method.GetAccessRights() == AccessRights.PUBLIC + ); + } + } +} diff --git a/src/dotnet/MO.CleanCode/Features/TooManyPublicMethods/TooManyPublicMethodsCheckVb.cs b/src/dotnet/MO.CleanCode/Features/TooManyPublicMethods/TooManyPublicMethodsCheckVb.cs new file mode 100644 index 0000000..2ed5ba7 --- /dev/null +++ b/src/dotnet/MO.CleanCode/Features/TooManyPublicMethods/TooManyPublicMethodsCheckVb.cs @@ -0,0 +1,28 @@ +using JetBrains.ReSharper.Feature.Services.Daemon; +using JetBrains.ReSharper.Psi; +using JetBrains.ReSharper.Psi.VB.Tree; + +namespace CleanCode.Features.TooManyPublicMethods +{ + [ElementProblemAnalyzer( + typeof(IClassDeclaration), + HighlightingTypes = new[] { typeof(TooManyPublicMethodsHighlighting) } + )] + public class TooManyPublicMethodsCheckVb : TooManyPublicMethodsCheck + { + protected override void Run( + IClassDeclaration element, + ElementProblemAnalyzerData data, + IHighlightingConsumer consumer + ) + { + CheckIfClassHasTooManyPublicMethods( + element.Name, + element, + data, + consumer, + method => method.GetAccessRights() == AccessRights.PUBLIC + ); + } + } +} diff --git a/src/dotnet/MO.CleanCode/Features/TooManyPublicMethods/TooManyPublicMethodsHighlighting.cs b/src/dotnet/MO.CleanCode/Features/TooManyPublicMethods/TooManyPublicMethodsHighlighting.cs new file mode 100644 index 0000000..cef72ca --- /dev/null +++ b/src/dotnet/MO.CleanCode/Features/TooManyPublicMethods/TooManyPublicMethodsHighlighting.cs @@ -0,0 +1,48 @@ +using System.Globalization; +using CleanCode.Resources; +using JetBrains.DocumentModel; +using JetBrains.ReSharper.Feature.Services.Daemon; +using JetBrains.ReSharper.Psi.CSharp; +using JetBrains.ReSharper.Psi.VB; + +namespace CleanCode.Features.TooManyPublicMethods +{ + [RegisterConfigurableSeverity( + SeverityID, + null, + CleanCodeHighlightingGroupIds.CleanCode, + "Too many public methods", + "This class exposes too many public methods", + Severity.SUGGESTION + )] + [ConfigurableSeverityHighlighting(SeverityID, CSharpLanguage.Name + "," + VBLanguage.Name)] + public class TooManyPublicMethodsHighlighting : IHighlighting + { + internal const string SeverityID = "TooManyPublicMethods"; + + private readonly DocumentRange _documentRange; + + public TooManyPublicMethodsHighlighting( + DocumentRange documentRange, + int threshold, + int currentValue + ) + { + ToolTip = string.Format( + CultureInfo.CurrentCulture, + Warnings.TooManyPublicMethods, + currentValue, + threshold + ); + _documentRange = documentRange; + } + + public DocumentRange CalculateRange() => _documentRange; + + public string ToolTip { get; } + + public string ErrorStripeToolTip => ToolTip; + + public bool IsValid() => !string.IsNullOrWhiteSpace(ToolTip); + } +} diff --git a/src/dotnet/MO.CleanCode/Resources/Settings.Designer.cs b/src/dotnet/MO.CleanCode/Resources/Settings.Designer.cs index 09e92a4..9d11ef0 100644 --- a/src/dotnet/MO.CleanCode/Resources/Settings.Designer.cs +++ b/src/dotnet/MO.CleanCode/Resources/Settings.Designer.cs @@ -133,29 +133,11 @@ internal static string MaximumMethodsPerClass { } /// - /// Looks up a localized string similar to Maximum statements per method. + /// Looks up a localized string similar to Maximum public methods per class. /// - internal static string MaximumStatementsPerMethod { + internal static string MaximumPublicMethodsPerClass { get { - return ResourceManager.GetString("MaximumStatementsPerMethod", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to List of meaningless suffixes. - /// - internal static string MeaninglessNameSuffixes { - get { - return ResourceManager.GetString("MeaninglessNameSuffixes", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Separate items with commas. - /// - internal static string MeaninglessNameSuffixesTooltip { - get { - return ResourceManager.GetString("MeaninglessNameSuffixesTooltip", resourceCulture); + return ResourceManager.GetString("MaximumPublicMethodsPerClass", resourceCulture); } } diff --git a/src/dotnet/MO.CleanCode/Resources/Settings.resx b/src/dotnet/MO.CleanCode/Resources/Settings.resx index df9a0a3..20711ea 100644 --- a/src/dotnet/MO.CleanCode/Resources/Settings.resx +++ b/src/dotnet/MO.CleanCode/Resources/Settings.resx @@ -153,4 +153,7 @@ Is flag analysis active. + + Maximum public methods per class + \ No newline at end of file diff --git a/src/dotnet/MO.CleanCode/Resources/Warnings.Designer.cs b/src/dotnet/MO.CleanCode/Resources/Warnings.Designer.cs index 51f7ae1..3d4d8fa 100644 --- a/src/dotnet/MO.CleanCode/Resources/Warnings.Designer.cs +++ b/src/dotnet/MO.CleanCode/Resources/Warnings.Designer.cs @@ -158,5 +158,14 @@ internal static string TooManyMethodArguments { return ResourceManager.GetString("TooManyMethodArguments", resourceCulture); } } + + /// + /// Looks up a localized string similar to Class contains too many public methods. This might be violating the Single Responsibility Principle and exposing too much of its implementation. ({0} / {1}). + /// + internal static string TooManyPublicMethods { + get { + return ResourceManager.GetString("TooManyPublicMethods", resourceCulture); + } + } } } diff --git a/src/dotnet/MO.CleanCode/Resources/Warnings.resx b/src/dotnet/MO.CleanCode/Resources/Warnings.resx index 387deee..bd6bf36 100644 --- a/src/dotnet/MO.CleanCode/Resources/Warnings.resx +++ b/src/dotnet/MO.CleanCode/Resources/Warnings.resx @@ -150,4 +150,7 @@ This method has too many declarations. ({0} / {1}) + + Class contains too many public methods. This might be violating the Single Responsibility Principle and exposing too much of its implementation. ({0} / {1}) + \ No newline at end of file diff --git a/src/dotnet/MO.CleanCode/Settings/CleanCodeOptionsPage.cs b/src/dotnet/MO.CleanCode/Settings/CleanCodeOptionsPage.cs index f948159..6c5d2dd 100644 --- a/src/dotnet/MO.CleanCode/Settings/CleanCodeOptionsPage.cs +++ b/src/dotnet/MO.CleanCode/Settings/CleanCodeOptionsPage.cs @@ -12,7 +12,12 @@ namespace CleanCode.Settings { - [OptionsPage(PageId, "Clean Code", typeof(SettingsThemedIcons.CleanCode), ParentId = CodeInspectionPage.PID)] + [OptionsPage( + PageId, + "Clean Code", + typeof(SettingsThemedIcons.CleanCode), + ParentId = CodeInspectionPage.PID + )] public class CleanCodeOptionsPage : BeSimpleOptionsPage { private const string PageId = "CleanCodeAnalysisOptionsPage"; @@ -20,7 +25,8 @@ public class CleanCodeOptionsPage : BeSimpleOptionsPage public CleanCodeOptionsPage( Lifetime lifetime, OptionsPageContext optionsPageContext, - OptionsSettingsSmartContext optionsSettingsSmartContext) + OptionsSettingsSmartContext optionsSettingsSmartContext + ) : base(lifetime, optionsPageContext, optionsSettingsSmartContext) { CreateSettingsArea("Single Responsibility", CreateSingleResponsibilitySettings); @@ -34,81 +40,125 @@ public CleanCodeOptionsPage( private void CreateFooterArea() { AddSpacer(); - AddRichText(CreateItalicText( - "Note: All references to Clean Code, including but not limited to the Clean Code icon are used with permission of Robert C. Martin (a.k.a. UncleBob)")); + AddRichText( + CreateItalicText( + "Note: All references to Clean Code, including but not limited to the Clean Code icon are used with permission of Robert C. Martin (a.k.a. UncleBob)" + ) + ); } - private static RichText CreateItalicText(string value) => new(value, new TextStyle(JetFontStyles.Italic)); + private static RichText CreateItalicText(string value) => + new(value, new TextStyle(JetFontStyles.Italic)); private void CreateComplexitySettingsArea() { AddText("Reduce complexity in individual statements."); - AddIntOption((CleanCodeSettings s) => s.MaximumExpressionsInCondition, - Resources.Settings.MaximumExpressionsInsideACondition); + AddIntOption( + (CleanCodeSettings s) => s.MaximumExpressionsInCondition, + Resources.Settings.MaximumExpressionsInsideACondition + ); } private void CreateLegibilitySettingsArea() { AddText("Names should be meaningful."); - AddIntOption((CleanCodeSettings s) => s.MinimumMeaningfulMethodNameLength, - Resources.Settings.MinimumMethodNameLength); - AddStringOption((CleanCodeSettings s) => s.MeaninglessClassNameSuffixes, - Resources.Settings.MeaninglessNameSuffixes); + AddIntOption( + (CleanCodeSettings s) => s.MinimumMeaningfulMethodNameLength, + Resources.Settings.MinimumMethodNameLength + ); + AddStringOption( + (CleanCodeSettings s) => s.MeaninglessClassNameSuffixes, + Resources.Settings.MeaninglessNameSuffixes + ); } private void CreateCouplingSettingsArea() { AddText("Avoid excessive coupling between classes."); - AddIntOption((CleanCodeSettings s) => s.MaximumConstructorDependencies, - Resources.Settings.MaximumConstructorDependencies); - AddIntOption((CleanCodeSettings s) => s.MaximumChainedReferences, - Resources.Settings.MaximumChainedReferences); + AddIntOption( + (CleanCodeSettings s) => s.MaximumConstructorDependencies, + Resources.Settings.MaximumConstructorDependencies + ); + AddIntOption( + (CleanCodeSettings s) => s.MaximumChainedReferences, + Resources.Settings.MaximumChainedReferences + ); } private void CreateSingleResponsibilitySettings() { - AddText("A class should only have a single responsibility. Do not do too much in a class or method."); - - AddIntOption((CleanCodeSettings s) => s.MaximumMethodsInClass, - Resources.Settings.MaximumMethodsPerClass); - AddIntOption((CleanCodeSettings s) => s.MaximumMethodParameters, - Resources.Settings.MaximumMethodDeclarationParameters); - AddIntOption((CleanCodeSettings s) => s.MaximumMethodStatements, - Resources.Settings.MaximumStatementsPerMethod); - AddIntOption((CleanCodeSettings s) => s.MaximumDeclarationsInMethod, - Resources.Settings.DeclarationsMaximum); - AddIntOption((CleanCodeSettings s) => s.MaximumIndentationDepth, - Resources.Settings.MaximumLevelOfNestingInAMethod); + AddText( + "A class should only have a single responsibility. Do not do too much in a class or method." + ); + + AddIntOption( + (CleanCodeSettings s) => s.MaximumMethodsInClass, + Resources.Settings.MaximumMethodsPerClass + ); + AddIntOption( + (CleanCodeSettings s) => s.MaximumPublicMethodsInClass, + Resources.Settings.MaximumPublicMethodsPerClass + ); + AddIntOption( + (CleanCodeSettings s) => s.MaximumMethodParameters, + Resources.Settings.MaximumMethodDeclarationParameters + ); + AddIntOption( + (CleanCodeSettings s) => s.MaximumMethodStatements, + Resources.Settings.MaximumStatementsPerMethod + ); + AddIntOption( + (CleanCodeSettings s) => s.MaximumDeclarationsInMethod, + Resources.Settings.DeclarationsMaximum + ); + AddIntOption( + (CleanCodeSettings s) => s.MaximumIndentationDepth, + Resources.Settings.MaximumLevelOfNestingInAMethod + ); AddSpacer(); - AddBoolOption((CleanCodeSettings cleanCodeSettings) => cleanCodeSettings.IsFlagAnalysisEnabled, - Resources.Settings.IsFlagAnalysisEnabled); + AddBoolOption( + (CleanCodeSettings cleanCodeSettings) => cleanCodeSettings.IsFlagAnalysisEnabled, + Resources.Settings.IsFlagAnalysisEnabled + ); } private void CreateSettingsArea(string headerText, Action createSettingsArea) { AddHeader(headerText); - using (Indent()) createSettingsArea(); + using (Indent()) + createSettingsArea(); } - private void AddIntOption(Expression> expression, string description) + private void AddIntOption( + Expression> expression, + string description + ) { var valueProperty = OptionsSettingsSmartContext.GetValueProperty(Lifetime, expression); - AddControl(valueProperty.GetBeSpinner(Lifetime, 0, 1000).WithDescription(description, Lifetime)); + AddControl( + valueProperty.GetBeSpinner(Lifetime, 0, 1000).WithDescription(description, Lifetime) + ); } - private void AddStringOption(Expression> expression, string description) + private void AddStringOption( + Expression> expression, + string description + ) { var valueProperty = OptionsSettingsSmartContext.GetValueProperty(Lifetime, expression); AddControl(valueProperty.GetBeTextBox(Lifetime).WithDescription(description, Lifetime)); } - private void AddBoolOption(Expression> expression, string description) + private void AddBoolOption( + Expression> expression, + string description + ) { var valueProperty = OptionsSettingsSmartContext.GetValueProperty(Lifetime, expression); AddControl(valueProperty.GetBeCheckBox(Lifetime, description)); } } -} \ No newline at end of file +} diff --git a/src/dotnet/MO.CleanCode/Settings/CleanCodeSettings.cs b/src/dotnet/MO.CleanCode/Settings/CleanCodeSettings.cs index 854382f..1e07aca 100644 --- a/src/dotnet/MO.CleanCode/Settings/CleanCodeSettings.cs +++ b/src/dotnet/MO.CleanCode/Settings/CleanCodeSettings.cs @@ -30,7 +30,10 @@ public class CleanCodeSettings [SettingsEntry(4, nameof(MinimumMeaningfulMethodNameLength))] public int MinimumMeaningfulMethodNameLength { get; set; } - [SettingsEntry("Handler,Manager,Processor,Controller,Helper", nameof(MeaninglessClassNameSuffixes))] + [SettingsEntry( + "Handler,Manager,Processor,Controller,Helper", + nameof(MeaninglessClassNameSuffixes) + )] public string MeaninglessClassNameSuffixes { get; set; } [SettingsEntry(1, nameof(MaximumExpressionsInCondition))] @@ -38,5 +41,8 @@ public class CleanCodeSettings [SettingsEntry(true, nameof(IsFlagAnalysisEnabled))] public bool IsFlagAnalysisEnabled { get; set; } + + [SettingsEntry(15, nameof(MaximumPublicMethodsInClass))] + public int MaximumPublicMethodsInClass { get; set; } } -} \ No newline at end of file +} From 8345b784fe03c2a54c7c4ce39c593ba9cb47af3f Mon Sep 17 00:00:00 2001 From: Martin Oehlert Date: Tue, 15 Jul 2025 13:49:21 +0200 Subject: [PATCH 2/2] fix --- global.json | 2 +- gradle.properties | 2 +- src/dotnet/Directory.Build.props | 7 - .../CleanCodeHighlightingGroupIds.cs | 2 +- .../MO.CleanCode/Extension/ExpressionExt.cs | 5 +- .../ChainedReferencesCheck.cs | 35 ++++- .../ChainedReferencesCheckCs.cs | 25 ++-- .../ChainedReferencesCheckVb.cs | 20 ++- .../MaximumChainedReferencesHighlighting.cs | 20 ++- .../Features/ClassTooBig/ClassTooBigCheck.cs | 19 ++- .../ClassTooBig/ClassTooBigCheckCs.cs | 23 +++- .../ClassTooBig/ClassTooBigCheckVb.cs | 16 ++- .../ClassTooBig/ClassTooBigHighlighting.cs | 15 ++- .../ComplexConditionExpressionCheckCs.cs | 49 ++++--- .../ComplexConditionExpressionCheckVb.cs | 64 ++++++---- .../ComplexConditionExpressionHighlighting.cs | 21 ++- .../ExcessiveIndentHighlighting.cs | 21 ++- .../ExcessiveIndentationCheckCs.cs | 27 ++-- .../Features/ExtensionMethodsCsharp.cs | 28 ++-- .../Features/ExtensionMethodsVb.cs | 8 +- .../FlagArguments/FlagArgumentsCheckCs.cs | 64 ++++++---- .../FlagArgumentsHighlighting.cs | 8 +- .../Features/HollowNames/HollowNamesCheck.cs | 26 +++- .../HollowNames/HollowNamesCheckCs.cs | 17 ++- .../HollowNames/HollowNamesCheckVb.cs | 18 +-- .../HollowNames/HollowTypeNameHighlighting.cs | 8 +- .../MethodNameNotMeaningfulCheck.cs | 18 ++- .../MethodNameNotMeaningfulCheckCs.cs | 16 ++- .../MethodNameNotMeaningfulCheckVb.cs | 16 ++- .../MethodNameNotMeaningfulHighlighting.cs | 8 +- .../MethodTooLong/MethodTooLongCheck.cs | 79 ++++++++---- .../MethodTooLong/MethodTooLongCheckCs.cs | 16 ++- .../MethodTooLong/MethodTooLongCheckVb.cs | 13 +- .../MethodTooLongHighlighting.cs | 21 ++- .../MethodTooManyDeclarationsHighlighting.cs | 21 ++- .../TooManyDependenciesCheckCs.cs | 30 +++-- .../TooManyDependenciesCheckVb.cs | 30 +++-- .../TooManyDependenciesHighlighting.cs | 21 ++- .../TooManyArgumentsHighlighting.cs | 20 ++- .../TooManyMethodArgumentsCheckCs.cs | 26 ++-- .../TooManyMethodArgumentsCheckVb.cs | 26 ++-- .../InvalidateOnSettingsChange.cs | 14 +- .../MO.CleanCode/MO.CleanCode.Rider.csproj | 118 +++++++++-------- src/dotnet/MO.CleanCode/MO.CleanCode.csproj | 120 +++++++++--------- .../MO.CleanCode/Properties/AssemblyInfo.cs | 2 +- .../Resources/Settings.Designer.cs | 37 +++++- src/dotnet/MO.CleanCode/ZoneMarker.cs | 6 +- src/dotnet/Plugin.props | 2 +- 48 files changed, 783 insertions(+), 427 deletions(-) diff --git a/global.json b/global.json index 969172a..4d5cd63 100644 --- a/global.json +++ b/global.json @@ -1,6 +1,6 @@ { "sdk": { - "version": "6.0.100", + "version": "8.0.100", "rollForward": "latestMinor" } } diff --git a/gradle.properties b/gradle.properties index 9e6cab0..85ea832 100644 --- a/gradle.properties +++ b/gradle.properties @@ -16,7 +16,7 @@ PublishToken="_PLACEHOLDER_" # EAP: 2020.3-EAP2-SNAPSHOT # Nightly: 2020.3-SNAPSHOT ProductVersion=2025.1 -PluginVersion=2025.1.0 +PluginVersion=2025.1.1 # Kotlin 1.4 will bundle the stdlib dependency by default, causing problems with the version bundled with the IDE # https://blog.jetbrains.com/kotlin/2020/07/kotlin-1-4-rc-released/#stdlib-default diff --git a/src/dotnet/Directory.Build.props b/src/dotnet/Directory.Build.props index e389508..7f9dc40 100644 --- a/src/dotnet/Directory.Build.props +++ b/src/dotnet/Directory.Build.props @@ -1,30 +1,23 @@ - Latest true false None - obj\$(MSBuildProjectName)\ $(DefaultItemExcludes);obj\** bin\$(MSBuildProjectName)\$(Configuration)\ - TRACE;DEBUG;JET_MODE_ASSERT - - $(SdkVersion.Substring(2,2))$(SdkVersion.Substring(5,1)).0.0 - JetResourceGenerator - diff --git a/src/dotnet/MO.CleanCode/CleanCodeHighlightingGroupIds.cs b/src/dotnet/MO.CleanCode/CleanCodeHighlightingGroupIds.cs index 0e3f2c9..3a21f3c 100644 --- a/src/dotnet/MO.CleanCode/CleanCodeHighlightingGroupIds.cs +++ b/src/dotnet/MO.CleanCode/CleanCodeHighlightingGroupIds.cs @@ -7,4 +7,4 @@ public static class CleanCodeHighlightingGroupIds { public const string CleanCode = "CleanCode"; } -} \ No newline at end of file +} diff --git a/src/dotnet/MO.CleanCode/Extension/ExpressionExt.cs b/src/dotnet/MO.CleanCode/Extension/ExpressionExt.cs index cd82f34..2a1e96b 100644 --- a/src/dotnet/MO.CleanCode/Extension/ExpressionExt.cs +++ b/src/dotnet/MO.CleanCode/Extension/ExpressionExt.cs @@ -6,6 +6,7 @@ namespace CleanCode.Extension { public static class ExpressionExt { - public static int GetExpressionCount(this IExpression expression) where T : ITreeNode => expression.GetChildrenRecursive().Count(); + public static int GetExpressionCount(this IExpression expression) + where T : ITreeNode => expression.GetChildrenRecursive().Count(); } -} \ No newline at end of file +} diff --git a/src/dotnet/MO.CleanCode/Features/ChainedReferences/ChainedReferencesCheck.cs b/src/dotnet/MO.CleanCode/Features/ChainedReferences/ChainedReferencesCheck.cs index 272d20e..3ee5c9d 100644 --- a/src/dotnet/MO.CleanCode/Features/ChainedReferences/ChainedReferencesCheck.cs +++ b/src/dotnet/MO.CleanCode/Features/ChainedReferences/ChainedReferencesCheck.cs @@ -8,7 +8,11 @@ namespace CleanCode.Features.ChainedReferences; public abstract class ChainedReferencesCheck : ElementProblemAnalyzer { - protected static void HighlightMethodChainsThatAreTooLong(ITreeNode statement, IHighlightingConsumer consumer, int threshold) + protected static void HighlightMethodChainsThatAreTooLong( + ITreeNode statement, + IHighlightingConsumer consumer, + int threshold + ) { var children = statement.Children(); @@ -25,7 +29,11 @@ protected static void HighlightMethodChainsThatAreTooLong(ITreeNode statement, I } } - private static void HighlightReferenceExpressionIfNeeded(IReferenceExpression referenceExpression, IHighlightingConsumer consumer, int threshold) + private static void HighlightReferenceExpressionIfNeeded( + IReferenceExpression referenceExpression, + IHighlightingConsumer consumer, + int threshold + ) { var types = new HashSet(); @@ -34,7 +42,9 @@ private static void HighlightReferenceExpressionIfNeeded(IReferenceExpression re while (nextReferenceExpression != null) { - var childReturnType = ExtensionMethodsCsharp.TryGetClosedReturnTypeFrom(nextReferenceExpression); + var childReturnType = ExtensionMethodsCsharp.TryGetClosedReturnTypeFrom( + nextReferenceExpression + ); if (childReturnType != null) { @@ -42,7 +52,9 @@ private static void HighlightReferenceExpressionIfNeeded(IReferenceExpression re chainLength++; } - nextReferenceExpression = ExtensionMethodsVb.TryGetFirstReferenceExpression(nextReferenceExpression); + nextReferenceExpression = ExtensionMethodsVb.TryGetFirstReferenceExpression( + nextReferenceExpression + ); } var isFluentChain = types.Count == 1; @@ -52,11 +64,20 @@ private static void HighlightReferenceExpressionIfNeeded(IReferenceExpression re } } - private static void AddHighlighting(IReferenceExpression reference, IHighlightingConsumer consumer, int threshold, int currentValue) + private static void AddHighlighting( + IReferenceExpression reference, + IHighlightingConsumer consumer, + int threshold, + int currentValue + ) { var nameIdentifier = reference.NameIdentifier; var documentRange = nameIdentifier.GetDocumentRange(); - var highlighting = new MaximumChainedReferencesHighlighting(documentRange, threshold, currentValue); + var highlighting = new MaximumChainedReferencesHighlighting( + documentRange, + threshold, + currentValue + ); consumer.AddHighlighting(highlighting); } -} \ No newline at end of file +} diff --git a/src/dotnet/MO.CleanCode/Features/ChainedReferences/ChainedReferencesCheckCs.cs b/src/dotnet/MO.CleanCode/Features/ChainedReferences/ChainedReferencesCheckCs.cs index 6866541..bad9371 100644 --- a/src/dotnet/MO.CleanCode/Features/ChainedReferences/ChainedReferencesCheckCs.cs +++ b/src/dotnet/MO.CleanCode/Features/ChainedReferences/ChainedReferencesCheckCs.cs @@ -4,18 +4,25 @@ namespace CleanCode.Features.ChainedReferences { - [ElementProblemAnalyzer(typeof(ICSharpStatement), HighlightingTypes = new[] - { - typeof(MaximumChainedReferencesHighlighting) - })] + [ElementProblemAnalyzer( + typeof(ICSharpStatement), + HighlightingTypes = new[] { typeof(MaximumChainedReferencesHighlighting) } + )] public class ChainedReferencesCheckCs : ChainedReferencesCheck { - protected override void Run(ICSharpStatement element, ElementProblemAnalyzerData data, IHighlightingConsumer consumer) + protected override void Run( + ICSharpStatement element, + ElementProblemAnalyzerData data, + IHighlightingConsumer consumer + ) { - if (element.CanBeEmbedded) return; - - var threshold = data.SettingsStore.GetValue((CleanCodeSettings s) => s.MaximumChainedReferences); + if (element.CanBeEmbedded) + return; + + var threshold = data.SettingsStore.GetValue( + (CleanCodeSettings s) => s.MaximumChainedReferences + ); HighlightMethodChainsThatAreTooLong(element, consumer, threshold); } } -} \ No newline at end of file +} diff --git a/src/dotnet/MO.CleanCode/Features/ChainedReferences/ChainedReferencesCheckVb.cs b/src/dotnet/MO.CleanCode/Features/ChainedReferences/ChainedReferencesCheckVb.cs index 5b9bc37..38a963e 100644 --- a/src/dotnet/MO.CleanCode/Features/ChainedReferences/ChainedReferencesCheckVb.cs +++ b/src/dotnet/MO.CleanCode/Features/ChainedReferences/ChainedReferencesCheckVb.cs @@ -4,16 +4,22 @@ namespace CleanCode.Features.ChainedReferences { - [ElementProblemAnalyzer(typeof(IVBStatement), HighlightingTypes = new[] - { - typeof(MaximumChainedReferencesHighlighting) - })] + [ElementProblemAnalyzer( + typeof(IVBStatement), + HighlightingTypes = new[] { typeof(MaximumChainedReferencesHighlighting) } + )] public class ChainedReferencesCheckVb : ChainedReferencesCheck { - protected override void Run(IVBStatement element, ElementProblemAnalyzerData data, IHighlightingConsumer consumer) + protected override void Run( + IVBStatement element, + ElementProblemAnalyzerData data, + IHighlightingConsumer consumer + ) { - var threshold = data.SettingsStore.GetValue((CleanCodeSettings s) => s.MaximumChainedReferences); + var threshold = data.SettingsStore.GetValue( + (CleanCodeSettings s) => s.MaximumChainedReferences + ); HighlightMethodChainsThatAreTooLong(element, consumer, threshold); } } -} \ No newline at end of file +} diff --git a/src/dotnet/MO.CleanCode/Features/ChainedReferences/MaximumChainedReferencesHighlighting.cs b/src/dotnet/MO.CleanCode/Features/ChainedReferences/MaximumChainedReferencesHighlighting.cs index a0f429c..d52819d 100644 --- a/src/dotnet/MO.CleanCode/Features/ChainedReferences/MaximumChainedReferencesHighlighting.cs +++ b/src/dotnet/MO.CleanCode/Features/ChainedReferences/MaximumChainedReferencesHighlighting.cs @@ -7,12 +7,14 @@ namespace CleanCode.Features.ChainedReferences { - [RegisterConfigurableSeverity(SeverityID, + [RegisterConfigurableSeverity( + SeverityID, null, CleanCodeHighlightingGroupIds.CleanCode, "Too many chained references", "Too many chained references can break the Law of Demeter.", - Severity.WARNING)] + Severity.WARNING + )] [ConfigurableSeverityHighlighting(SeverityID, CSharpLanguage.Name + "," + VBLanguage.Name)] public class MaximumChainedReferencesHighlighting : IHighlighting { @@ -20,12 +22,18 @@ public class MaximumChainedReferencesHighlighting : IHighlighting private readonly DocumentRange _documentRange; - public MaximumChainedReferencesHighlighting(DocumentRange documentRange, int threshold, int currentValue) + public MaximumChainedReferencesHighlighting( + DocumentRange documentRange, + int threshold, + int currentValue + ) { - ToolTip = string.Format(CultureInfo.CurrentCulture, + ToolTip = string.Format( + CultureInfo.CurrentCulture, Warnings.ChainedReferences, currentValue, - threshold); + threshold + ); _documentRange = documentRange; } @@ -38,4 +46,4 @@ public MaximumChainedReferencesHighlighting(DocumentRange documentRange, int thr public bool IsValid() => !string.IsNullOrWhiteSpace(ToolTip); } -} \ No newline at end of file +} diff --git a/src/dotnet/MO.CleanCode/Features/ClassTooBig/ClassTooBigCheck.cs b/src/dotnet/MO.CleanCode/Features/ClassTooBig/ClassTooBigCheck.cs index 92406c2..576fc48 100644 --- a/src/dotnet/MO.CleanCode/Features/ClassTooBig/ClassTooBigCheck.cs +++ b/src/dotnet/MO.CleanCode/Features/ClassTooBig/ClassTooBigCheck.cs @@ -6,19 +6,24 @@ namespace CleanCode.Features.ClassTooBig; public abstract class ClassTooBigCheck : ElementProblemAnalyzer { - protected static void CheckIfClassIsTooBig(ITreeNode declaration, + protected static void CheckIfClassIsTooBig( + ITreeNode declaration, ITreeNode element, - ElementProblemAnalyzerData data, - IHighlightingConsumer consumer) + ElementProblemAnalyzerData data, + IHighlightingConsumer consumer + ) where TMethodDeclaration : ITreeNode { - var maxLength = data.SettingsStore.GetValue((CleanCodeSettings s) => s.MaximumMethodsInClass); + var maxLength = data.SettingsStore.GetValue( + (CleanCodeSettings s) => s.MaximumMethodsInClass + ); var statementCount = element.CountChildren(); - if (statementCount <= maxLength) return; - + if (statementCount <= maxLength) + return; + var documentRange = declaration.GetDocumentRange(); var highlighting = new ClassTooBigHighlighting(documentRange, maxLength, statementCount); consumer.AddHighlighting(highlighting); } -} \ No newline at end of file +} diff --git a/src/dotnet/MO.CleanCode/Features/ClassTooBig/ClassTooBigCheckCs.cs b/src/dotnet/MO.CleanCode/Features/ClassTooBig/ClassTooBigCheckCs.cs index 7c0b2bb..8a4eaba 100644 --- a/src/dotnet/MO.CleanCode/Features/ClassTooBig/ClassTooBigCheckCs.cs +++ b/src/dotnet/MO.CleanCode/Features/ClassTooBig/ClassTooBigCheckCs.cs @@ -3,15 +3,24 @@ namespace CleanCode.Features.ClassTooBig { - [ElementProblemAnalyzer(typeof(IClassDeclaration), HighlightingTypes = new[] - { - typeof(ClassTooBigHighlighting) - })] + [ElementProblemAnalyzer( + typeof(IClassDeclaration), + HighlightingTypes = new[] { typeof(ClassTooBigHighlighting) } + )] public class ClassTooBigCheckCs : ClassTooBigCheck { - protected override void Run(IClassDeclaration element, ElementProblemAnalyzerData data, IHighlightingConsumer consumer) + protected override void Run( + IClassDeclaration element, + ElementProblemAnalyzerData data, + IHighlightingConsumer consumer + ) { - CheckIfClassIsTooBig(element.NameIdentifier, element, data, consumer); + CheckIfClassIsTooBig( + element.NameIdentifier, + element, + data, + consumer + ); } } -} \ No newline at end of file +} diff --git a/src/dotnet/MO.CleanCode/Features/ClassTooBig/ClassTooBigCheckVb.cs b/src/dotnet/MO.CleanCode/Features/ClassTooBig/ClassTooBigCheckVb.cs index d095b22..375ed51 100644 --- a/src/dotnet/MO.CleanCode/Features/ClassTooBig/ClassTooBigCheckVb.cs +++ b/src/dotnet/MO.CleanCode/Features/ClassTooBig/ClassTooBigCheckVb.cs @@ -3,15 +3,19 @@ namespace CleanCode.Features.ClassTooBig { - [ElementProblemAnalyzer(typeof(IClassDeclaration), HighlightingTypes = new[] - { - typeof(ClassTooBigHighlighting) - })] + [ElementProblemAnalyzer( + typeof(IClassDeclaration), + HighlightingTypes = new[] { typeof(ClassTooBigHighlighting) } + )] public class ClassTooBigCheckVb : ClassTooBigCheck { - protected override void Run(IClassDeclaration element, ElementProblemAnalyzerData data, IHighlightingConsumer consumer) + protected override void Run( + IClassDeclaration element, + ElementProblemAnalyzerData data, + IHighlightingConsumer consumer + ) { CheckIfClassIsTooBig(element.Name, element, data, consumer); } } -} \ No newline at end of file +} diff --git a/src/dotnet/MO.CleanCode/Features/ClassTooBig/ClassTooBigHighlighting.cs b/src/dotnet/MO.CleanCode/Features/ClassTooBig/ClassTooBigHighlighting.cs index c6ede07..377a1d1 100644 --- a/src/dotnet/MO.CleanCode/Features/ClassTooBig/ClassTooBigHighlighting.cs +++ b/src/dotnet/MO.CleanCode/Features/ClassTooBig/ClassTooBigHighlighting.cs @@ -7,12 +7,14 @@ namespace CleanCode.Features.ClassTooBig { - [RegisterConfigurableSeverity(SeverityID, + [RegisterConfigurableSeverity( + SeverityID, null, CleanCodeHighlightingGroupIds.CleanCode, "Class too big", "This class contains too many methods", - Severity.SUGGESTION)] + Severity.SUGGESTION + )] [ConfigurableSeverityHighlighting(SeverityID, CSharpLanguage.Name + "," + VBLanguage.Name)] public class ClassTooBigHighlighting : IHighlighting { @@ -22,7 +24,12 @@ public class ClassTooBigHighlighting : IHighlighting public ClassTooBigHighlighting(DocumentRange documentRange, int threshold, int currentValue) { - ToolTip = string.Format(CultureInfo.CurrentCulture, Warnings.ClassTooBig, currentValue, threshold); + ToolTip = string.Format( + CultureInfo.CurrentCulture, + Warnings.ClassTooBig, + currentValue, + threshold + ); _documentRange = documentRange; } @@ -34,4 +41,4 @@ public ClassTooBigHighlighting(DocumentRange documentRange, int threshold, int c public bool IsValid() => !string.IsNullOrWhiteSpace(ToolTip); } -} \ No newline at end of file +} diff --git a/src/dotnet/MO.CleanCode/Features/ComplexExpression/ComplexConditionExpressionCheckCs.cs b/src/dotnet/MO.CleanCode/Features/ComplexExpression/ComplexConditionExpressionCheckCs.cs index 369007c..12f70a5 100644 --- a/src/dotnet/MO.CleanCode/Features/ComplexExpression/ComplexConditionExpressionCheckCs.cs +++ b/src/dotnet/MO.CleanCode/Features/ComplexExpression/ComplexConditionExpressionCheckCs.cs @@ -6,19 +6,21 @@ namespace CleanCode.Features.ComplexExpression { - [ElementProblemAnalyzer(typeof(IIfStatement), + [ElementProblemAnalyzer( + typeof(IIfStatement), typeof(ILoopWithConditionStatement), typeof(IConditionalTernaryExpression), typeof(IAssignmentExpression), typeof(IExpressionInitializer), - HighlightingTypes = new[] - { - typeof(ComplexConditionExpressionHighlighting) - })] + HighlightingTypes = new[] { typeof(ComplexConditionExpressionHighlighting) } + )] public class ComplexConditionExpressionCheckCs : ElementProblemAnalyzer { - protected override void Run(ICSharpTreeNode element, ElementProblemAnalyzerData data, - IHighlightingConsumer consumer) + protected override void Run( + ICSharpTreeNode element, + ElementProblemAnalyzerData data, + IHighlightingConsumer consumer + ) { var expression = GetExpression(element); if (expression != null) @@ -29,27 +31,42 @@ private static IExpression GetExpression(ITreeNode node) { switch (node) { - case ILoopWithConditionStatement loopWithConditionStatement: return loopWithConditionStatement.Condition; - case IIfStatement ifStatement: return ifStatement.Condition; - case IConditionalTernaryExpression conditionalTernaryExpression: return conditionalTernaryExpression.ConditionOperand; - case IAssignmentExpression assignmentExpression: return assignmentExpression.Source; - case IExpressionInitializer expressionInitializer: return expressionInitializer.Value; + case ILoopWithConditionStatement loopWithConditionStatement: + return loopWithConditionStatement.Condition; + case IIfStatement ifStatement: + return ifStatement.Condition; + case IConditionalTernaryExpression conditionalTernaryExpression: + return conditionalTernaryExpression.ConditionOperand; + case IAssignmentExpression assignmentExpression: + return assignmentExpression.Source; + case IExpressionInitializer expressionInitializer: + return expressionInitializer.Value; default: return null; } } - private static void CheckExpression(IExpression expression, ElementProblemAnalyzerData data, IHighlightingConsumer consumer) + private static void CheckExpression( + IExpression expression, + ElementProblemAnalyzerData data, + IHighlightingConsumer consumer + ) { - var maxExpressions = data.SettingsStore.GetValue((CleanCodeSettings s) => s.MaximumExpressionsInCondition); + var maxExpressions = data.SettingsStore.GetValue( + (CleanCodeSettings s) => s.MaximumExpressionsInCondition + ); var expressionCount = expression.GetChildrenRecursive().Count(); if (expressionCount > maxExpressions) { var documentRange = expression.GetDocumentRange(); - var highlighting = new ComplexConditionExpressionHighlighting(documentRange, maxExpressions, expressionCount); + var highlighting = new ComplexConditionExpressionHighlighting( + documentRange, + maxExpressions, + expressionCount + ); consumer.AddHighlighting(highlighting); } } } -} \ No newline at end of file +} diff --git a/src/dotnet/MO.CleanCode/Features/ComplexExpression/ComplexConditionExpressionCheckVb.cs b/src/dotnet/MO.CleanCode/Features/ComplexExpression/ComplexConditionExpressionCheckVb.cs index c89fa0d..6bd11f1 100644 --- a/src/dotnet/MO.CleanCode/Features/ComplexExpression/ComplexConditionExpressionCheckVb.cs +++ b/src/dotnet/MO.CleanCode/Features/ComplexExpression/ComplexConditionExpressionCheckVb.cs @@ -6,7 +6,8 @@ namespace CleanCode.Features.ComplexExpression { - [ElementProblemAnalyzer(typeof(IBlockIfStatement), + [ElementProblemAnalyzer( + typeof(IBlockIfStatement), typeof(IElseIfStatement), typeof(IWhileStatement), typeof(IForEachStatement), @@ -14,14 +15,15 @@ namespace CleanCode.Features.ComplexExpression typeof(IConditionalExpression), typeof(IExpressionStatement), typeof(ILineIfStatement), - HighlightingTypes = new[] - { - typeof(ComplexConditionExpressionHighlighting) - })] + HighlightingTypes = new[] { typeof(ComplexConditionExpressionHighlighting) } + )] public class ComplexConditionExpressionCheckVb : ElementProblemAnalyzer { - protected override void Run(IVBTreeNode element, ElementProblemAnalyzerData data, - IHighlightingConsumer consumer) + protected override void Run( + IVBTreeNode element, + ElementProblemAnalyzerData data, + IHighlightingConsumer consumer + ) { var expression = GetExpression(element); if (expression != null) @@ -32,37 +34,55 @@ private static IExpression GetExpression(ITreeNode node) { switch (node) { - case IBlockIfStatement blockIfStatement: return blockIfStatement.Expression; - case IElseIfStatement elseIfStatement: return elseIfStatement.Expression; - case IWhileStatement whileStatement: return whileStatement.Expression; - case IForEachStatement forEachStatement: return forEachStatement.Expression; - case IForStatement forStatement: return forStatement.StepExpression; - case IConditionalExpression conditionalExpression: return conditionalExpression.Condition; - case IExpressionStatement expressionStatement: return expressionStatement.Expression; - case ILineIfStatement lineIfStatement: return lineIfStatement.Expression; + case IBlockIfStatement blockIfStatement: + return blockIfStatement.Expression; + case IElseIfStatement elseIfStatement: + return elseIfStatement.Expression; + case IWhileStatement whileStatement: + return whileStatement.Expression; + case IForEachStatement forEachStatement: + return forEachStatement.Expression; + case IForStatement forStatement: + return forStatement.StepExpression; + case IConditionalExpression conditionalExpression: + return conditionalExpression.Condition; + case IExpressionStatement expressionStatement: + return expressionStatement.Expression; + case ILineIfStatement lineIfStatement: + return lineIfStatement.Expression; default: return null; } } - private static void CheckExpression(IExpression expression, ElementProblemAnalyzerData data, IHighlightingConsumer consumer) + private static void CheckExpression( + IExpression expression, + ElementProblemAnalyzerData data, + IHighlightingConsumer consumer + ) { - var maxExpressions = data.SettingsStore.GetValue((CleanCodeSettings s) => s.MaximumExpressionsInCondition); + var maxExpressions = data.SettingsStore.GetValue( + (CleanCodeSettings s) => s.MaximumExpressionsInCondition + ); var expressionCount = GetExpressionCount(expression); if (expressionCount > maxExpressions) { var documentRange = expression.GetDocumentRange(); - var highlighting = new ComplexConditionExpressionHighlighting(documentRange, maxExpressions, expressionCount); + var highlighting = new ComplexConditionExpressionHighlighting( + documentRange, + maxExpressions, + expressionCount + ); consumer.AddHighlighting(highlighting); } } private static int GetExpressionCount(IExpression expression) { - return expression.GetExpressionCount() + - expression.GetExpressionCount() + - expression.GetExpressionCount(); + return expression.GetExpressionCount() + + expression.GetExpressionCount() + + expression.GetExpressionCount(); } } -} \ No newline at end of file +} diff --git a/src/dotnet/MO.CleanCode/Features/ComplexExpression/ComplexConditionExpressionHighlighting.cs b/src/dotnet/MO.CleanCode/Features/ComplexExpression/ComplexConditionExpressionHighlighting.cs index 2a8000c..8fa0191 100644 --- a/src/dotnet/MO.CleanCode/Features/ComplexExpression/ComplexConditionExpressionHighlighting.cs +++ b/src/dotnet/MO.CleanCode/Features/ComplexExpression/ComplexConditionExpressionHighlighting.cs @@ -7,12 +7,14 @@ namespace CleanCode.Features.ComplexExpression { - [RegisterConfigurableSeverity(SeverityID, + [RegisterConfigurableSeverity( + SeverityID, null, CleanCodeHighlightingGroupIds.CleanCode, "Condition expression too complex", "The expression in the condition is too complex.", - Severity.WARNING)] + Severity.WARNING + )] [ConfigurableSeverityHighlighting(SeverityID, CSharpLanguage.Name + "," + VBLanguage.Name)] public class ComplexConditionExpressionHighlighting : IHighlighting { @@ -20,9 +22,18 @@ public class ComplexConditionExpressionHighlighting : IHighlighting private readonly DocumentRange _documentRange; - public ComplexConditionExpressionHighlighting(DocumentRange documentRange, int threshold, int currentValue) + public ComplexConditionExpressionHighlighting( + DocumentRange documentRange, + int threshold, + int currentValue + ) { - ToolTip = string.Format(CultureInfo.CurrentCulture, Warnings.ExpressionTooComplex, currentValue, threshold); + ToolTip = string.Format( + CultureInfo.CurrentCulture, + Warnings.ExpressionTooComplex, + currentValue, + threshold + ); _documentRange = documentRange; } @@ -34,4 +45,4 @@ public ComplexConditionExpressionHighlighting(DocumentRange documentRange, int t public bool IsValid() => !string.IsNullOrWhiteSpace(ToolTip); } -} \ No newline at end of file +} diff --git a/src/dotnet/MO.CleanCode/Features/ExcessiveIndentation/ExcessiveIndentHighlighting.cs b/src/dotnet/MO.CleanCode/Features/ExcessiveIndentation/ExcessiveIndentHighlighting.cs index 9c5886b..88cb767 100644 --- a/src/dotnet/MO.CleanCode/Features/ExcessiveIndentation/ExcessiveIndentHighlighting.cs +++ b/src/dotnet/MO.CleanCode/Features/ExcessiveIndentation/ExcessiveIndentHighlighting.cs @@ -6,21 +6,32 @@ namespace CleanCode.Features.ExcessiveIndentation { - [RegisterConfigurableSeverity(SeverityID, + [RegisterConfigurableSeverity( + SeverityID, null, CleanCodeHighlightingGroupIds.CleanCode, "Excessive indentation", "The nesting in this method is excessive.", - Severity.WARNING)] + Severity.WARNING + )] [ConfigurableSeverityHighlighting(SeverityID, CSharpLanguage.Name)] public class ExcessiveIndentHighlighting : IHighlighting { internal const string SeverityID = "ExcessiveIndentation"; private readonly DocumentRange _documentRange; - public ExcessiveIndentHighlighting(DocumentRange documentRange, int threshold, int currentValue) + public ExcessiveIndentHighlighting( + DocumentRange documentRange, + int threshold, + int currentValue + ) { - ToolTip = string.Format(CultureInfo.CurrentCulture, Warnings.ExcessiveDepth, currentValue, threshold); + ToolTip = string.Format( + CultureInfo.CurrentCulture, + Warnings.ExcessiveDepth, + currentValue, + threshold + ); _documentRange = documentRange; } @@ -32,4 +43,4 @@ public ExcessiveIndentHighlighting(DocumentRange documentRange, int threshold, i public bool IsValid() => !string.IsNullOrWhiteSpace(ToolTip); } -} \ No newline at end of file +} diff --git a/src/dotnet/MO.CleanCode/Features/ExcessiveIndentation/ExcessiveIndentationCheckCs.cs b/src/dotnet/MO.CleanCode/Features/ExcessiveIndentation/ExcessiveIndentationCheckCs.cs index 291a9a8..20f9214 100644 --- a/src/dotnet/MO.CleanCode/Features/ExcessiveIndentation/ExcessiveIndentationCheckCs.cs +++ b/src/dotnet/MO.CleanCode/Features/ExcessiveIndentation/ExcessiveIndentationCheckCs.cs @@ -5,24 +5,33 @@ namespace CleanCode.Features.ExcessiveIndentation { - [ElementProblemAnalyzer(typeof(IMethodDeclaration), - HighlightingTypes = new[] - { - typeof(ExcessiveIndentHighlighting) - })] + [ElementProblemAnalyzer( + typeof(IMethodDeclaration), + HighlightingTypes = new[] { typeof(ExcessiveIndentHighlighting) } + )] public class ExcessiveIndentationCheckCs : ElementProblemAnalyzer { - protected override void Run(IMethodDeclaration element, ElementProblemAnalyzerData data, IHighlightingConsumer consumer) + protected override void Run( + IMethodDeclaration element, + ElementProblemAnalyzerData data, + IHighlightingConsumer consumer + ) { - var maxIndentation = data.SettingsStore.GetValue((CleanCodeSettings s) => s.MaximumIndentationDepth); + var maxIndentation = data.SettingsStore.GetValue( + (CleanCodeSettings s) => s.MaximumIndentationDepth + ); var childrenDepth = element.GetChildrenDepth(); if (childrenDepth > maxIndentation) { var documentRange = element.GetNameDocumentRange(); - var highlighting = new ExcessiveIndentHighlighting(documentRange, maxIndentation, childrenDepth); + var highlighting = new ExcessiveIndentHighlighting( + documentRange, + maxIndentation, + childrenDepth + ); consumer.AddHighlighting(highlighting); } } } -} \ No newline at end of file +} diff --git a/src/dotnet/MO.CleanCode/Features/ExtensionMethodsCsharp.cs b/src/dotnet/MO.CleanCode/Features/ExtensionMethodsCsharp.cs index 1780755..c858688 100644 --- a/src/dotnet/MO.CleanCode/Features/ExtensionMethodsCsharp.cs +++ b/src/dotnet/MO.CleanCode/Features/ExtensionMethodsCsharp.cs @@ -11,7 +11,8 @@ namespace CleanCode.Features { public static class ExtensionMethodsCsharp { - public static int CountChildren(this ITreeNode node) where T : ITreeNode + public static int CountChildren(this ITreeNode node) + where T : ITreeNode { var treeNodes = node.Children().ToList(); @@ -25,7 +26,6 @@ public static int CountChildren(this ITreeNode node) where T : ITreeNode return count; } - public static int GetChildrenDepth(this ITreeNode node) { var childrenDepth = 0; @@ -43,7 +43,8 @@ public static int GetChildrenDepth(this ITreeNode node) return childrenDepth; } - public static IEnumerable GetFlattenedHierarchyOfType(this ITreeNode root) where T : class, ITreeNode + public static IEnumerable GetFlattenedHierarchyOfType(this ITreeNode root) + where T : class, ITreeNode { var list = new List(); if (root is T rootAsType) @@ -54,7 +55,8 @@ public static IEnumerable GetFlattenedHierarchyOfType(this ITreeNode root) return list; } - public static IEnumerable GetChildrenRecursive(this ITreeNode node) where T : ITreeNode + public static IEnumerable GetChildrenRecursive(this ITreeNode node) + where T : ITreeNode { var nodeChildren = node.Children().ToList(); @@ -97,7 +99,8 @@ public static IType TryGetClosedReturnTypeFrom(ITreeNode treeNode) return TryGetClosedReturnTypeFromReference(reference.Reference); case IInvocationExpression invocationExpression: return TryGetClosedReturnTypeFromReference(invocationExpression.Reference); - default: return null; + default: + return null; } } @@ -109,8 +112,8 @@ public static IReferenceExpression TryGetFirstReferenceExpression(ITreeNode curr if (firstChildNode == null) return null; - return firstChildNode as IReferenceExpression ?? - TryGetFirstReferenceExpression(firstChildNode); + return firstChildNode as IReferenceExpression + ?? TryGetFirstReferenceExpression(firstChildNode); } private static IType TryGetClosedReturnTypeFromReference(IReference reference) @@ -121,13 +124,18 @@ private static IType TryGetClosedReturnTypeFromReference(IReference reference) if (declaredElement is IParametersOwner parametersOwner) { var returnType = parametersOwner.ReturnType; - return returnType.IsOpenType ? GetClosedType(resolveResultWithInfo, returnType) : returnType; + return returnType.IsOpenType + ? GetClosedType(resolveResultWithInfo, returnType) + : returnType; } return null; } - private static IType GetClosedType(ResolveResultWithInfo resolveResultWithInfo, IType returnType) + private static IType GetClosedType( + ResolveResultWithInfo resolveResultWithInfo, + IType returnType + ) { return resolveResultWithInfo.Result.Substitution.Apply(returnType); } @@ -137,4 +145,4 @@ public static ResolveResultWithInfo GetResolveResult(this IReference reference) return reference.Resolve(); } } -} \ No newline at end of file +} diff --git a/src/dotnet/MO.CleanCode/Features/ExtensionMethodsVb.cs b/src/dotnet/MO.CleanCode/Features/ExtensionMethodsVb.cs index 86a47f3..c8f6608 100644 --- a/src/dotnet/MO.CleanCode/Features/ExtensionMethodsVb.cs +++ b/src/dotnet/MO.CleanCode/Features/ExtensionMethodsVb.cs @@ -1,6 +1,6 @@ using System.Linq; -using JetBrains.ReSharper.Psi.VB.Tree; using JetBrains.ReSharper.Psi.Tree; +using JetBrains.ReSharper.Psi.VB.Tree; namespace CleanCode.Features { @@ -14,8 +14,8 @@ public static IReferenceExpression TryGetFirstReferenceExpression(ITreeNode curr if (firstChildNode == null) return null; - return firstChildNode as IReferenceExpression ?? - TryGetFirstReferenceExpression(firstChildNode); + return firstChildNode as IReferenceExpression + ?? TryGetFirstReferenceExpression(firstChildNode); } } -} \ No newline at end of file +} diff --git a/src/dotnet/MO.CleanCode/Features/FlagArguments/FlagArgumentsCheckCs.cs b/src/dotnet/MO.CleanCode/Features/FlagArguments/FlagArgumentsCheckCs.cs index 22e695c..6e0e738 100644 --- a/src/dotnet/MO.CleanCode/Features/FlagArguments/FlagArgumentsCheckCs.cs +++ b/src/dotnet/MO.CleanCode/Features/FlagArguments/FlagArgumentsCheckCs.cs @@ -9,30 +9,39 @@ namespace CleanCode.Features.FlagArguments { - [ElementProblemAnalyzer(typeof(IMethodDeclaration), - HighlightingTypes = new[] - { - typeof(FlagArgumentsHighlighting) - })] + [ElementProblemAnalyzer( + typeof(IMethodDeclaration), + HighlightingTypes = new[] { typeof(FlagArgumentsHighlighting) } + )] public class FlagArgumentsCheckCs : ElementProblemAnalyzer { - protected override void Run(IMethodDeclaration element, ElementProblemAnalyzerData data, - IHighlightingConsumer consumer) + protected override void Run( + IMethodDeclaration element, + ElementProblemAnalyzerData data, + IHighlightingConsumer consumer + ) { - var isFlagAnalysisEnabled = data.SettingsStore.GetValue((CleanCodeSettings s) => s.IsFlagAnalysisEnabled); - if (!isFlagAnalysisEnabled) return; + var isFlagAnalysisEnabled = data.SettingsStore.GetValue( + (CleanCodeSettings s) => s.IsFlagAnalysisEnabled + ); + if (!isFlagAnalysisEnabled) + return; var parameterDeclarations = element.ParameterDeclarations.Where(parameterDeclaration => - IsFlagArgument(parameterDeclaration, element.Body)); + IsFlagArgument(parameterDeclaration, element.Body) + ); foreach (var parameterDeclaration in parameterDeclarations) AddHighlighting(consumer, parameterDeclaration); } - private static bool IsFlagArgument(ITypeOwnerDeclaration typeOwnerDeclaration, ITreeNode node) + private static bool IsFlagArgument( + ITypeOwnerDeclaration typeOwnerDeclaration, + ITreeNode node + ) { - return IsOfTypeThatCanBeUsedAsFlag(typeOwnerDeclaration) && - GetReferencesTo(typeOwnerDeclaration.DeclaredElement, node).Any(); + return IsOfTypeThatCanBeUsedAsFlag(typeOwnerDeclaration) + && GetReferencesTo(typeOwnerDeclaration.DeclaredElement, node).Any(); } private static bool IsOfTypeThatCanBeUsedAsFlag(ITypeOwnerDeclaration arg) @@ -41,25 +50,34 @@ private static bool IsOfTypeThatCanBeUsedAsFlag(ITypeOwnerDeclaration arg) return type.IsBool() || type.IsEnumType(); } - private static IEnumerable GetReferencesTo(IDeclaredElement declaredElement, - ITreeNode body) + private static IEnumerable GetReferencesTo( + IDeclaredElement declaredElement, + ITreeNode body + ) { var ifStatements = body.GetChildrenRecursive(); var allConditions = ifStatements.Select(statement => statement.Condition); var allReferencesInConditions = allConditions.SelectMany(expression => - expression.GetFlattenedHierarchyOfType()); + expression.GetFlattenedHierarchyOfType() + ); return GetReferencesToArgument(allReferencesInConditions, declaredElement); } private static IEnumerable GetReferencesToArgument( - IEnumerable allReferencesInConditions, IDeclaredElement declaredElementInArgument) + IEnumerable allReferencesInConditions, + IDeclaredElement declaredElementInArgument + ) { return allReferencesInConditions.Where(reference => - IsReferenceToArgument(reference, declaredElementInArgument)); + IsReferenceToArgument(reference, declaredElementInArgument) + ); } - private static bool IsReferenceToArgument(IReferenceExpression referenceExpression, IDeclaredElement toFind) + private static bool IsReferenceToArgument( + IReferenceExpression referenceExpression, + IDeclaredElement toFind + ) { if (referenceExpression == null) { @@ -72,12 +90,14 @@ private static bool IsReferenceToArgument(IReferenceExpression referenceExpressi return declaredElement != null && declaredElement.ShortName == toFind.ShortName; } - private static void AddHighlighting(IHighlightingConsumer consumer, - ICSharpParameterDeclaration parameterDeclaration) + private static void AddHighlighting( + IHighlightingConsumer consumer, + ICSharpParameterDeclaration parameterDeclaration + ) { var documentRange = parameterDeclaration.GetDocumentRange(); var highlighting = new FlagArgumentsHighlighting(documentRange); consumer.AddHighlighting(highlighting); } } -} \ No newline at end of file +} diff --git a/src/dotnet/MO.CleanCode/Features/FlagArguments/FlagArgumentsHighlighting.cs b/src/dotnet/MO.CleanCode/Features/FlagArguments/FlagArgumentsHighlighting.cs index 2a2e141..52c5775 100644 --- a/src/dotnet/MO.CleanCode/Features/FlagArguments/FlagArgumentsHighlighting.cs +++ b/src/dotnet/MO.CleanCode/Features/FlagArguments/FlagArgumentsHighlighting.cs @@ -5,12 +5,14 @@ namespace CleanCode.Features.FlagArguments { - [RegisterConfigurableSeverity(SeverityID, + [RegisterConfigurableSeverity( + SeverityID, null, CleanCodeHighlightingGroupIds.CleanCode, "Flag argument", "An argument that is used as a flag.", - Severity.WARNING)] + Severity.WARNING + )] [ConfigurableSeverityHighlighting(SeverityID, CSharpLanguage.Name)] public class FlagArgumentsHighlighting : IHighlighting { @@ -30,4 +32,4 @@ public FlagArgumentsHighlighting(DocumentRange documentRange) public bool IsValid() => !string.IsNullOrWhiteSpace(ToolTip); } -} \ No newline at end of file +} diff --git a/src/dotnet/MO.CleanCode/Features/HollowNames/HollowNamesCheck.cs b/src/dotnet/MO.CleanCode/Features/HollowNames/HollowNamesCheck.cs index 79f6e98..32149ca 100644 --- a/src/dotnet/MO.CleanCode/Features/HollowNames/HollowNamesCheck.cs +++ b/src/dotnet/MO.CleanCode/Features/HollowNames/HollowNamesCheck.cs @@ -14,7 +14,11 @@ public abstract class HollowNamesCheck : ElementProblemAnalyzer { private static readonly string[] Separator = { "," }; - protected static void CheckAndAddHighlighting(IDeclaration element, ElementProblemAnalyzerData data, IHighlightingConsumer consumer) + protected static void CheckAndAddHighlighting( + IDeclaration element, + ElementProblemAnalyzerData data, + IHighlightingConsumer consumer + ) { var suffixes = GetSuffixes(data.SettingsStore); @@ -22,10 +26,12 @@ protected static void CheckAndAddHighlighting(IDeclaration element, ElementProbl if (match != null) AddHighlighting(match, consumer, element); } - + private static string[] GetSuffixes(IContextBoundSettingsStore dataSettingsStore) { - var suffixes = dataSettingsStore.GetValue((CleanCodeSettings s) => s.MeaninglessClassNameSuffixes); + var suffixes = dataSettingsStore.GetValue( + (CleanCodeSettings s) => s.MeaninglessClassNameSuffixes + ); return suffixes.Split(Separator, StringSplitOptions.RemoveEmptyEntries); } @@ -34,11 +40,19 @@ private static string GetFirstMatchOrDefault(string declaredName, IEnumerable { - protected override void Run(IClassDeclaration element, ElementProblemAnalyzerData data, IHighlightingConsumer consumer) + protected override void Run( + IClassDeclaration element, + ElementProblemAnalyzerData data, + IHighlightingConsumer consumer + ) { CheckAndAddHighlighting(element, data, consumer); } } -} \ No newline at end of file +} diff --git a/src/dotnet/MO.CleanCode/Features/HollowNames/HollowNamesCheckVb.cs b/src/dotnet/MO.CleanCode/Features/HollowNames/HollowNamesCheckVb.cs index 10aa898..ddccc5a 100644 --- a/src/dotnet/MO.CleanCode/Features/HollowNames/HollowNamesCheckVb.cs +++ b/src/dotnet/MO.CleanCode/Features/HollowNames/HollowNamesCheckVb.cs @@ -3,17 +3,19 @@ namespace CleanCode.Features.HollowNames { - [ElementProblemAnalyzer(typeof(IClassDeclaration), - HighlightingTypes = new[] - { - typeof(HollowTypeNameHighlighting) - })] + [ElementProblemAnalyzer( + typeof(IClassDeclaration), + HighlightingTypes = new[] { typeof(HollowTypeNameHighlighting) } + )] public class HollowNamesCheckVb : HollowNamesCheck { - - protected override void Run(IClassDeclaration element, ElementProblemAnalyzerData data, IHighlightingConsumer consumer) + protected override void Run( + IClassDeclaration element, + ElementProblemAnalyzerData data, + IHighlightingConsumer consumer + ) { CheckAndAddHighlighting(element, data, consumer); } } -} \ No newline at end of file +} diff --git a/src/dotnet/MO.CleanCode/Features/HollowNames/HollowTypeNameHighlighting.cs b/src/dotnet/MO.CleanCode/Features/HollowNames/HollowTypeNameHighlighting.cs index 44f234b..37eb39f 100644 --- a/src/dotnet/MO.CleanCode/Features/HollowNames/HollowTypeNameHighlighting.cs +++ b/src/dotnet/MO.CleanCode/Features/HollowNames/HollowTypeNameHighlighting.cs @@ -5,12 +5,14 @@ namespace CleanCode.Features.HollowNames { - [RegisterConfigurableSeverity(SeverityID, + [RegisterConfigurableSeverity( + SeverityID, null, CleanCodeHighlightingGroupIds.CleanCode, "Hollow type name", "This type has a name that doesn't express its intent.", - Severity.SUGGESTION)] + Severity.SUGGESTION + )] [ConfigurableSeverityHighlighting(SeverityID, CSharpLanguage.Name + "," + VBLanguage.Name)] public class HollowTypeNameHighlighting : IHighlighting { @@ -31,4 +33,4 @@ public HollowTypeNameHighlighting(string toolTip, DocumentRange documentRange) public bool IsValid() => !string.IsNullOrWhiteSpace(ToolTip); } -} \ No newline at end of file +} diff --git a/src/dotnet/MO.CleanCode/Features/MethodNameNotMeaningful/MethodNameNotMeaningfulCheck.cs b/src/dotnet/MO.CleanCode/Features/MethodNameNotMeaningful/MethodNameNotMeaningfulCheck.cs index cb80e27..26a035a 100644 --- a/src/dotnet/MO.CleanCode/Features/MethodNameNotMeaningful/MethodNameNotMeaningfulCheck.cs +++ b/src/dotnet/MO.CleanCode/Features/MethodNameNotMeaningful/MethodNameNotMeaningfulCheck.cs @@ -6,19 +6,25 @@ namespace CleanCode.Features.MethodNameNotMeaningful; public abstract class MethodNameNotMeaningfulCheck : ElementProblemAnalyzer { - protected static void CheckAndAddHighlighting(IDeclaration element, ElementProblemAnalyzerData data, - IHighlightingConsumer consumer) + protected static void CheckAndAddHighlighting( + IDeclaration element, + ElementProblemAnalyzerData data, + IHighlightingConsumer consumer + ) { if (element == null) return; - var minimumMethodNameLength = data.SettingsStore.GetValue((CleanCodeSettings s) => s.MinimumMeaningfulMethodNameLength); + var minimumMethodNameLength = data.SettingsStore.GetValue( + (CleanCodeSettings s) => s.MinimumMeaningfulMethodNameLength + ); var name = element.GetText(); - if (name.Length >= minimumMethodNameLength) return; - + if (name.Length >= minimumMethodNameLength) + return; + var documentRange = element.GetNameDocumentRange(); var highlighting = new MethodNameNotMeaningfulHighlighting(documentRange); consumer.AddHighlighting(highlighting); } -} \ No newline at end of file +} diff --git a/src/dotnet/MO.CleanCode/Features/MethodNameNotMeaningful/MethodNameNotMeaningfulCheckCs.cs b/src/dotnet/MO.CleanCode/Features/MethodNameNotMeaningful/MethodNameNotMeaningfulCheckCs.cs index adc9a76..6ed7b31 100644 --- a/src/dotnet/MO.CleanCode/Features/MethodNameNotMeaningful/MethodNameNotMeaningfulCheckCs.cs +++ b/src/dotnet/MO.CleanCode/Features/MethodNameNotMeaningful/MethodNameNotMeaningfulCheckCs.cs @@ -3,15 +3,19 @@ namespace CleanCode.Features.MethodNameNotMeaningful { - [ElementProblemAnalyzer(typeof(IMethodDeclaration), HighlightingTypes = new[] - { - typeof(MethodNameNotMeaningfulHighlighting) - })] + [ElementProblemAnalyzer( + typeof(IMethodDeclaration), + HighlightingTypes = new[] { typeof(MethodNameNotMeaningfulHighlighting) } + )] public class MethodNameNotMeaningfulCheckCs : MethodNameNotMeaningfulCheck { - protected override void Run(IMethodDeclaration element, ElementProblemAnalyzerData data, IHighlightingConsumer consumer) + protected override void Run( + IMethodDeclaration element, + ElementProblemAnalyzerData data, + IHighlightingConsumer consumer + ) { CheckAndAddHighlighting(element, data, consumer); } } -} \ No newline at end of file +} diff --git a/src/dotnet/MO.CleanCode/Features/MethodNameNotMeaningful/MethodNameNotMeaningfulCheckVb.cs b/src/dotnet/MO.CleanCode/Features/MethodNameNotMeaningful/MethodNameNotMeaningfulCheckVb.cs index 0511d65..23f258f 100644 --- a/src/dotnet/MO.CleanCode/Features/MethodNameNotMeaningful/MethodNameNotMeaningfulCheckVb.cs +++ b/src/dotnet/MO.CleanCode/Features/MethodNameNotMeaningful/MethodNameNotMeaningfulCheckVb.cs @@ -3,15 +3,19 @@ namespace CleanCode.Features.MethodNameNotMeaningful { - [ElementProblemAnalyzer(typeof(IMethodDeclaration), HighlightingTypes = new[] - { - typeof(MethodNameNotMeaningfulHighlighting) - })] + [ElementProblemAnalyzer( + typeof(IMethodDeclaration), + HighlightingTypes = new[] { typeof(MethodNameNotMeaningfulHighlighting) } + )] public class MethodNameNotMeaningfulCheckVb : MethodNameNotMeaningfulCheck { - protected override void Run(IMethodDeclaration element, ElementProblemAnalyzerData data, IHighlightingConsumer consumer) + protected override void Run( + IMethodDeclaration element, + ElementProblemAnalyzerData data, + IHighlightingConsumer consumer + ) { CheckAndAddHighlighting(element, data, consumer); } } -} \ No newline at end of file +} diff --git a/src/dotnet/MO.CleanCode/Features/MethodNameNotMeaningful/MethodNameNotMeaningfulHighlighting.cs b/src/dotnet/MO.CleanCode/Features/MethodNameNotMeaningful/MethodNameNotMeaningfulHighlighting.cs index 593ccf0..1ee2a19 100644 --- a/src/dotnet/MO.CleanCode/Features/MethodNameNotMeaningful/MethodNameNotMeaningfulHighlighting.cs +++ b/src/dotnet/MO.CleanCode/Features/MethodNameNotMeaningful/MethodNameNotMeaningfulHighlighting.cs @@ -6,12 +6,14 @@ namespace CleanCode.Features.MethodNameNotMeaningful { - [RegisterConfigurableSeverity(SeverityID, + [RegisterConfigurableSeverity( + SeverityID, null, CleanCodeHighlightingGroupIds.CleanCode, "Method name not meaningful", "This method name is too short to be meaningful.", - Severity.WARNING)] + Severity.WARNING + )] [ConfigurableSeverityHighlighting(SeverityID, CSharpLanguage.Name + "," + VBLanguage.Name)] public class MethodNameNotMeaningfulHighlighting : IHighlighting { @@ -31,4 +33,4 @@ public MethodNameNotMeaningfulHighlighting(DocumentRange documentRange) public bool IsValid() => !string.IsNullOrWhiteSpace(ToolTip); } -} \ No newline at end of file +} diff --git a/src/dotnet/MO.CleanCode/Features/MethodTooLong/MethodTooLongCheck.cs b/src/dotnet/MO.CleanCode/Features/MethodTooLong/MethodTooLongCheck.cs index e89d11a..b34de01 100644 --- a/src/dotnet/MO.CleanCode/Features/MethodTooLong/MethodTooLongCheck.cs +++ b/src/dotnet/MO.CleanCode/Features/MethodTooLong/MethodTooLongCheck.cs @@ -8,63 +8,98 @@ namespace CleanCode.Features.MethodTooLong; public abstract class MethodTooLongCheck : ElementProblemAnalyzer { - protected static void CheckAndAddHighlight(TMethodDeclaration element, ElementProblemAnalyzerData data, IHighlightingConsumer consumer) + protected static void CheckAndAddHighlight( + TMethodDeclaration element, + ElementProblemAnalyzerData data, + IHighlightingConsumer consumer + ) where TMethodDeclaration : IDeclaration { var highlighting = GetHighlighting(element, data); if (highlighting != null) consumer.AddHighlighting(highlighting); } - - private static IHighlighting GetHighlighting(TMethodDeclaration element, ElementProblemAnalyzerData data) + + private static IHighlighting GetHighlighting( + TMethodDeclaration element, + ElementProblemAnalyzerData data + ) where TMethodDeclaration : IDeclaration { - var maxStatements = data.SettingsStore.GetValue((CleanCodeSettings s) => s.MaximumMethodStatements); - var maxDeclarations = data.SettingsStore.GetValue((CleanCodeSettings s) => s.MaximumDeclarationsInMethod); + var maxStatements = data.SettingsStore.GetValue( + (CleanCodeSettings s) => s.MaximumMethodStatements + ); + var maxDeclarations = data.SettingsStore.GetValue( + (CleanCodeSettings s) => s.MaximumDeclarationsInMethod + ); var highlight = CheckStatementCount(element, maxStatements); - if (highlight != null) return highlight; + if (highlight != null) + return highlight; return element switch { - JetBrains.ReSharper.Psi.CSharp.Tree.IMethodDeclaration declaration => CheckDeclarationCount(declaration, - maxDeclarations), - JetBrains.ReSharper.Psi.VB.Tree.IMethodDeclaration declaration => CheckDeclarationCount(declaration, - maxDeclarations), - _ => throw new ArgumentOutOfRangeException(nameof(element), element, null) + JetBrains.ReSharper.Psi.CSharp.Tree.IMethodDeclaration declaration => + CheckDeclarationCount(declaration, maxDeclarations), + JetBrains.ReSharper.Psi.VB.Tree.IMethodDeclaration declaration => CheckDeclarationCount( + declaration, + maxDeclarations + ), + _ => throw new ArgumentOutOfRangeException(nameof(element), element, null), }; } [CanBeNull] - private static MethodTooLongHighlighting CheckStatementCount(IDeclaration element, int maxStatements) + private static MethodTooLongHighlighting CheckStatementCount( + IDeclaration element, + int maxStatements + ) { var statementCount = element.CountChildren(); - return statementCount > maxStatements - ? new MethodTooLongHighlighting(element.GetNameDocumentRange(), maxStatements, statementCount) + return statementCount > maxStatements + ? new MethodTooLongHighlighting( + element.GetNameDocumentRange(), + maxStatements, + statementCount + ) : null; } [CanBeNull] - private static MethodTooManyDeclarationsHighlighting CheckDeclarationCount(JetBrains.ReSharper.Psi.CSharp.Tree.IMethodDeclaration element, int maxDeclarations) + private static MethodTooManyDeclarationsHighlighting CheckDeclarationCount( + JetBrains.ReSharper.Psi.CSharp.Tree.IMethodDeclaration element, + int maxDeclarations + ) { // Only look in the method body for declarations, otherwise we see // parameters + type parameters. We can ignore arrow expressions, as // they must be a single expression and won't have declarations var declarationCount = element.Body?.CountChildren() ?? 0; - return declarationCount > maxDeclarations - ? new MethodTooManyDeclarationsHighlighting(element.GetNameDocumentRange(), maxDeclarations, declarationCount) + return declarationCount > maxDeclarations + ? new MethodTooManyDeclarationsHighlighting( + element.GetNameDocumentRange(), + maxDeclarations, + declarationCount + ) : null; } - + [CanBeNull] - private static MethodTooManyDeclarationsHighlighting CheckDeclarationCount(JetBrains.ReSharper.Psi.VB.Tree.IMethodDeclaration element, int maxDeclarations) + private static MethodTooManyDeclarationsHighlighting CheckDeclarationCount( + JetBrains.ReSharper.Psi.VB.Tree.IMethodDeclaration element, + int maxDeclarations + ) { // Only look in the method body for declarations, otherwise we see // parameters + type parameters. We can ignore arrow expressions, as // they must be a single expression and won't have declarations var declarationCount = element.Block?.CountChildren() ?? 0; - return declarationCount > maxDeclarations - ? new MethodTooManyDeclarationsHighlighting(element.GetNameDocumentRange(), maxDeclarations, declarationCount) + return declarationCount > maxDeclarations + ? new MethodTooManyDeclarationsHighlighting( + element.GetNameDocumentRange(), + maxDeclarations, + declarationCount + ) : null; } -} \ No newline at end of file +} diff --git a/src/dotnet/MO.CleanCode/Features/MethodTooLong/MethodTooLongCheckCs.cs b/src/dotnet/MO.CleanCode/Features/MethodTooLong/MethodTooLongCheckCs.cs index d84fcd9..43f532e 100644 --- a/src/dotnet/MO.CleanCode/Features/MethodTooLong/MethodTooLongCheckCs.cs +++ b/src/dotnet/MO.CleanCode/Features/MethodTooLong/MethodTooLongCheckCs.cs @@ -3,15 +3,19 @@ namespace CleanCode.Features.MethodTooLong { - [ElementProblemAnalyzer(typeof(IMethodDeclaration), HighlightingTypes = new[] - { - typeof(MethodTooLongHighlighting) - })] + [ElementProblemAnalyzer( + typeof(IMethodDeclaration), + HighlightingTypes = new[] { typeof(MethodTooLongHighlighting) } + )] public class MethodTooLongCheckCs : MethodTooLongCheck { - protected override void Run(IMethodDeclaration element, ElementProblemAnalyzerData data, IHighlightingConsumer consumer) + protected override void Run( + IMethodDeclaration element, + ElementProblemAnalyzerData data, + IHighlightingConsumer consumer + ) { CheckAndAddHighlight(element, data, consumer); } } -} \ No newline at end of file +} diff --git a/src/dotnet/MO.CleanCode/Features/MethodTooLong/MethodTooLongCheckVb.cs b/src/dotnet/MO.CleanCode/Features/MethodTooLong/MethodTooLongCheckVb.cs index e0d1a6c..a06fcba 100644 --- a/src/dotnet/MO.CleanCode/Features/MethodTooLong/MethodTooLongCheckVb.cs +++ b/src/dotnet/MO.CleanCode/Features/MethodTooLong/MethodTooLongCheckVb.cs @@ -3,12 +3,19 @@ namespace CleanCode.Features.MethodTooLong { - [ElementProblemAnalyzer(typeof(IMethodDeclaration), HighlightingTypes = new[] { typeof(MethodTooLongHighlighting) })] + [ElementProblemAnalyzer( + typeof(IMethodDeclaration), + HighlightingTypes = new[] { typeof(MethodTooLongHighlighting) } + )] public class MethodTooLongCheckVb : MethodTooLongCheck { - protected override void Run(IMethodDeclaration element, ElementProblemAnalyzerData data, IHighlightingConsumer consumer) + protected override void Run( + IMethodDeclaration element, + ElementProblemAnalyzerData data, + IHighlightingConsumer consumer + ) { CheckAndAddHighlight(element, data, consumer); } } -} \ No newline at end of file +} diff --git a/src/dotnet/MO.CleanCode/Features/MethodTooLong/MethodTooLongHighlighting.cs b/src/dotnet/MO.CleanCode/Features/MethodTooLong/MethodTooLongHighlighting.cs index 197143d..87e5e89 100644 --- a/src/dotnet/MO.CleanCode/Features/MethodTooLong/MethodTooLongHighlighting.cs +++ b/src/dotnet/MO.CleanCode/Features/MethodTooLong/MethodTooLongHighlighting.cs @@ -7,21 +7,32 @@ namespace CleanCode.Features.MethodTooLong { - [RegisterConfigurableSeverity(SeverityID, + [RegisterConfigurableSeverity( + SeverityID, null, CleanCodeHighlightingGroupIds.CleanCode, "Method too long", "The method is bigger than it should be.", - Severity.SUGGESTION)] + Severity.SUGGESTION + )] [ConfigurableSeverityHighlighting(SeverityID, CSharpLanguage.Name + "," + VBLanguage.Name)] public class MethodTooLongHighlighting : IHighlighting { internal const string SeverityID = "MethodTooLong"; private readonly DocumentRange _documentRange; - public MethodTooLongHighlighting(DocumentRange documentRange, int threshold, int currentValue) + public MethodTooLongHighlighting( + DocumentRange documentRange, + int threshold, + int currentValue + ) { - ToolTip = string.Format(CultureInfo.CurrentCulture, Warnings.MethodTooLong, currentValue, threshold); + ToolTip = string.Format( + CultureInfo.CurrentCulture, + Warnings.MethodTooLong, + currentValue, + threshold + ); _documentRange = documentRange; } @@ -33,4 +44,4 @@ public MethodTooLongHighlighting(DocumentRange documentRange, int threshold, int public bool IsValid() => !string.IsNullOrWhiteSpace(ToolTip); } -} \ No newline at end of file +} diff --git a/src/dotnet/MO.CleanCode/Features/MethodTooLong/MethodTooManyDeclarationsHighlighting.cs b/src/dotnet/MO.CleanCode/Features/MethodTooLong/MethodTooManyDeclarationsHighlighting.cs index 7f13ac2..04a9143 100644 --- a/src/dotnet/MO.CleanCode/Features/MethodTooLong/MethodTooManyDeclarationsHighlighting.cs +++ b/src/dotnet/MO.CleanCode/Features/MethodTooLong/MethodTooManyDeclarationsHighlighting.cs @@ -7,21 +7,32 @@ namespace CleanCode.Features.MethodTooLong { - [RegisterConfigurableSeverity(SeverityID, + [RegisterConfigurableSeverity( + SeverityID, null, CleanCodeHighlightingGroupIds.CleanCode, "Too many Declarations", "The method has more declarations than there should be.", - Severity.SUGGESTION)] + Severity.SUGGESTION + )] [ConfigurableSeverityHighlighting(SeverityID, CSharpLanguage.Name + "," + VBLanguage.Name)] public class MethodTooManyDeclarationsHighlighting : IHighlighting { internal const string SeverityID = "TooManyDeclarations"; private readonly DocumentRange _documentRange; - public MethodTooManyDeclarationsHighlighting(DocumentRange documentRange, int threshold, int currentValue) + public MethodTooManyDeclarationsHighlighting( + DocumentRange documentRange, + int threshold, + int currentValue + ) { - ToolTip = string.Format(CultureInfo.CurrentCulture, Warnings.TooManyDeclarations, currentValue, threshold); + ToolTip = string.Format( + CultureInfo.CurrentCulture, + Warnings.TooManyDeclarations, + currentValue, + threshold + ); _documentRange = documentRange; } @@ -33,4 +44,4 @@ public MethodTooManyDeclarationsHighlighting(DocumentRange documentRange, int th public bool IsValid() => !string.IsNullOrWhiteSpace(ToolTip); } -} \ No newline at end of file +} diff --git a/src/dotnet/MO.CleanCode/Features/TooManyDependencies/TooManyDependenciesCheckCs.cs b/src/dotnet/MO.CleanCode/Features/TooManyDependencies/TooManyDependenciesCheckCs.cs index 885e55a..ef18b4b 100644 --- a/src/dotnet/MO.CleanCode/Features/TooManyDependencies/TooManyDependenciesCheckCs.cs +++ b/src/dotnet/MO.CleanCode/Features/TooManyDependencies/TooManyDependenciesCheckCs.cs @@ -7,23 +7,35 @@ namespace CleanCode.Features.TooManyDependencies { - [ElementProblemAnalyzer(typeof(IConstructorDeclaration), HighlightingTypes = new[] - { - typeof(TooManyDependenciesHighlighting) - })] + [ElementProblemAnalyzer( + typeof(IConstructorDeclaration), + HighlightingTypes = new[] { typeof(TooManyDependenciesHighlighting) } + )] public class TooManyDependenciesCheckCs : ElementProblemAnalyzer { - protected override void Run(IConstructorDeclaration element, ElementProblemAnalyzerData data, IHighlightingConsumer consumer) + protected override void Run( + IConstructorDeclaration element, + ElementProblemAnalyzerData data, + IHighlightingConsumer consumer + ) { - var maxDependencies = data.SettingsStore.GetValue((CleanCodeSettings s) => s.MaximumConstructorDependencies); - var dependencies = element.ParameterDeclarations.Select(declaration => (declaration.DeclaredElement?.Type).IsInterfaceType()); + var maxDependencies = data.SettingsStore.GetValue( + (CleanCodeSettings s) => s.MaximumConstructorDependencies + ); + var dependencies = element.ParameterDeclarations.Select(declaration => + (declaration.DeclaredElement?.Type).IsInterfaceType() + ); var dependenciesCount = dependencies.Count(); if (dependenciesCount > maxDependencies) { - var highlighting = new TooManyDependenciesHighlighting(element.GetNameDocumentRange(), maxDependencies, dependenciesCount); + var highlighting = new TooManyDependenciesHighlighting( + element.GetNameDocumentRange(), + maxDependencies, + dependenciesCount + ); consumer.AddHighlighting(highlighting); } } } -} \ No newline at end of file +} diff --git a/src/dotnet/MO.CleanCode/Features/TooManyDependencies/TooManyDependenciesCheckVb.cs b/src/dotnet/MO.CleanCode/Features/TooManyDependencies/TooManyDependenciesCheckVb.cs index 3f8016e..b746976 100644 --- a/src/dotnet/MO.CleanCode/Features/TooManyDependencies/TooManyDependenciesCheckVb.cs +++ b/src/dotnet/MO.CleanCode/Features/TooManyDependencies/TooManyDependenciesCheckVb.cs @@ -7,23 +7,35 @@ namespace CleanCode.Features.TooManyDependencies { - [ElementProblemAnalyzer(typeof(IConstructorDeclaration), HighlightingTypes = new[] - { - typeof(TooManyDependenciesHighlighting) - })] + [ElementProblemAnalyzer( + typeof(IConstructorDeclaration), + HighlightingTypes = new[] { typeof(TooManyDependenciesHighlighting) } + )] public class TooManyDependenciesCheckVb : ElementProblemAnalyzer { - protected override void Run(IConstructorDeclaration element, ElementProblemAnalyzerData data, IHighlightingConsumer consumer) + protected override void Run( + IConstructorDeclaration element, + ElementProblemAnalyzerData data, + IHighlightingConsumer consumer + ) { - var maxDependencies = data.SettingsStore.GetValue((CleanCodeSettings s) => s.MaximumConstructorDependencies); - var dependencies = element.ParameterDeclarations.Select(declaration => (declaration.DeclaredElement?.Type).IsInterfaceType()); + var maxDependencies = data.SettingsStore.GetValue( + (CleanCodeSettings s) => s.MaximumConstructorDependencies + ); + var dependencies = element.ParameterDeclarations.Select(declaration => + (declaration.DeclaredElement?.Type).IsInterfaceType() + ); var dependenciesCount = dependencies.Count(); if (dependenciesCount > maxDependencies) { - var highlighting = new TooManyDependenciesHighlighting(element.GetNameDocumentRange(), maxDependencies, dependenciesCount); + var highlighting = new TooManyDependenciesHighlighting( + element.GetNameDocumentRange(), + maxDependencies, + dependenciesCount + ); consumer.AddHighlighting(highlighting); } } } -} \ No newline at end of file +} diff --git a/src/dotnet/MO.CleanCode/Features/TooManyDependencies/TooManyDependenciesHighlighting.cs b/src/dotnet/MO.CleanCode/Features/TooManyDependencies/TooManyDependenciesHighlighting.cs index 3523eb0..8320eea 100644 --- a/src/dotnet/MO.CleanCode/Features/TooManyDependencies/TooManyDependenciesHighlighting.cs +++ b/src/dotnet/MO.CleanCode/Features/TooManyDependencies/TooManyDependenciesHighlighting.cs @@ -7,21 +7,32 @@ namespace CleanCode.Features.TooManyDependencies { - [RegisterConfigurableSeverity(SeverityID, + [RegisterConfigurableSeverity( + SeverityID, null, CleanCodeHighlightingGroupIds.CleanCode, "Too many dependencies", "Too many dependencies passed into constructor.", - Severity.WARNING)] + Severity.WARNING + )] [ConfigurableSeverityHighlighting(SeverityID, CSharpLanguage.Name + "," + VBLanguage.Name)] public class TooManyDependenciesHighlighting : IHighlighting { internal const string SeverityID = "TooManyDependencies"; private readonly DocumentRange _documentRange; - public TooManyDependenciesHighlighting(DocumentRange documentRange, int threshold, int currentValue) + public TooManyDependenciesHighlighting( + DocumentRange documentRange, + int threshold, + int currentValue + ) { - ToolTip = string.Format(CultureInfo.CurrentCulture, Warnings.TooManyDependencies, currentValue, threshold); + ToolTip = string.Format( + CultureInfo.CurrentCulture, + Warnings.TooManyDependencies, + currentValue, + threshold + ); _documentRange = documentRange; } @@ -33,4 +44,4 @@ public TooManyDependenciesHighlighting(DocumentRange documentRange, int threshol public bool IsValid() => !string.IsNullOrWhiteSpace(ToolTip); } -} \ No newline at end of file +} diff --git a/src/dotnet/MO.CleanCode/Features/TooManyMethodArguments/TooManyArgumentsHighlighting.cs b/src/dotnet/MO.CleanCode/Features/TooManyMethodArguments/TooManyArgumentsHighlighting.cs index 35fc0a7..0e032bd 100644 --- a/src/dotnet/MO.CleanCode/Features/TooManyMethodArguments/TooManyArgumentsHighlighting.cs +++ b/src/dotnet/MO.CleanCode/Features/TooManyMethodArguments/TooManyArgumentsHighlighting.cs @@ -7,24 +7,32 @@ namespace CleanCode.Features.TooManyMethodArguments { - [RegisterConfigurableSeverity(SeverityID, + [RegisterConfigurableSeverity( + SeverityID, null, CleanCodeHighlightingGroupIds.CleanCode, "Too many arguments", "Too many arguments passed to a method.", - Severity.WARNING)] + Severity.WARNING + )] [ConfigurableSeverityHighlighting(SeverityID, CSharpLanguage.Name + "," + VBLanguage.Name)] public class TooManyArgumentsHighlighting : IHighlighting { internal const string SeverityID = "TooManyArguments"; private readonly DocumentRange _documentRange; - public TooManyArgumentsHighlighting(DocumentRange documentRange, int threshold, int currentValue) + public TooManyArgumentsHighlighting( + DocumentRange documentRange, + int threshold, + int currentValue + ) { - ToolTip = string.Format(CultureInfo.CurrentCulture, + ToolTip = string.Format( + CultureInfo.CurrentCulture, Warnings.TooManyMethodArguments, currentValue, - threshold); + threshold + ); _documentRange = documentRange; } @@ -37,4 +45,4 @@ public TooManyArgumentsHighlighting(DocumentRange documentRange, int threshold, public bool IsValid() => !string.IsNullOrWhiteSpace(ToolTip); } -} \ No newline at end of file +} diff --git a/src/dotnet/MO.CleanCode/Features/TooManyMethodArguments/TooManyMethodArgumentsCheckCs.cs b/src/dotnet/MO.CleanCode/Features/TooManyMethodArguments/TooManyMethodArgumentsCheckCs.cs index 3733191..6350f34 100644 --- a/src/dotnet/MO.CleanCode/Features/TooManyMethodArguments/TooManyMethodArgumentsCheckCs.cs +++ b/src/dotnet/MO.CleanCode/Features/TooManyMethodArguments/TooManyMethodArgumentsCheckCs.cs @@ -5,23 +5,33 @@ namespace CleanCode.Features.TooManyMethodArguments { - [ElementProblemAnalyzer(typeof(IMethodDeclaration), HighlightingTypes = new[] - { - typeof(TooManyArgumentsHighlighting) - })] + [ElementProblemAnalyzer( + typeof(IMethodDeclaration), + HighlightingTypes = new[] { typeof(TooManyArgumentsHighlighting) } + )] public class TooManyMethodArgumentsCheckCs : ElementProblemAnalyzer { - protected override void Run(IMethodDeclaration element, ElementProblemAnalyzerData data, IHighlightingConsumer consumer) + protected override void Run( + IMethodDeclaration element, + ElementProblemAnalyzerData data, + IHighlightingConsumer consumer + ) { - var maxParameters = data.SettingsStore.GetValue((CleanCodeSettings s) => s.MaximumMethodParameters); + var maxParameters = data.SettingsStore.GetValue( + (CleanCodeSettings s) => s.MaximumMethodParameters + ); var parameterDeclarations = element.ParameterDeclarations; var parameterCount = parameterDeclarations.Count; if (parameterCount > maxParameters) { - var highlighting = new TooManyArgumentsHighlighting(element.GetNameDocumentRange(), maxParameters, parameterCount); + var highlighting = new TooManyArgumentsHighlighting( + element.GetNameDocumentRange(), + maxParameters, + parameterCount + ); consumer.AddHighlighting(highlighting); } } } -} \ No newline at end of file +} diff --git a/src/dotnet/MO.CleanCode/Features/TooManyMethodArguments/TooManyMethodArgumentsCheckVb.cs b/src/dotnet/MO.CleanCode/Features/TooManyMethodArguments/TooManyMethodArgumentsCheckVb.cs index ed854b2..3de4473 100644 --- a/src/dotnet/MO.CleanCode/Features/TooManyMethodArguments/TooManyMethodArgumentsCheckVb.cs +++ b/src/dotnet/MO.CleanCode/Features/TooManyMethodArguments/TooManyMethodArgumentsCheckVb.cs @@ -5,23 +5,33 @@ namespace CleanCode.Features.TooManyMethodArguments { - [ElementProblemAnalyzer(typeof(IMethodDeclaration), HighlightingTypes = new[] - { - typeof(TooManyArgumentsHighlighting) - })] + [ElementProblemAnalyzer( + typeof(IMethodDeclaration), + HighlightingTypes = new[] { typeof(TooManyArgumentsHighlighting) } + )] public class TooManyMethodArgumentsCheckVb : ElementProblemAnalyzer { - protected override void Run(IMethodDeclaration element, ElementProblemAnalyzerData data, IHighlightingConsumer consumer) + protected override void Run( + IMethodDeclaration element, + ElementProblemAnalyzerData data, + IHighlightingConsumer consumer + ) { - var maxParameters = data.SettingsStore.GetValue((CleanCodeSettings s) => s.MaximumMethodParameters); + var maxParameters = data.SettingsStore.GetValue( + (CleanCodeSettings s) => s.MaximumMethodParameters + ); var parameterDeclarations = element.ParameterDeclarations; var parameterCount = parameterDeclarations.Count; if (parameterCount > maxParameters) { - var highlighting = new TooManyArgumentsHighlighting(element.GetNameDocumentRange(), maxParameters, parameterCount); + var highlighting = new TooManyArgumentsHighlighting( + element.GetNameDocumentRange(), + maxParameters, + parameterCount + ); consumer.AddHighlighting(highlighting); } } } -} \ No newline at end of file +} diff --git a/src/dotnet/MO.CleanCode/InvalidateOnSettingsChange.cs b/src/dotnet/MO.CleanCode/InvalidateOnSettingsChange.cs index c8f456c..191a9de 100644 --- a/src/dotnet/MO.CleanCode/InvalidateOnSettingsChange.cs +++ b/src/dotnet/MO.CleanCode/InvalidateOnSettingsChange.cs @@ -9,10 +9,18 @@ namespace CleanCode [SolutionComponent(JetBrains.Application.Parts.Instantiation.DemandAnyThreadSafe)] public class InvalidateOnSettingsChange { - public InvalidateOnSettingsChange(Lifetime lifetime, IDaemon daemon, ISettingsStore settingsStore) + public InvalidateOnSettingsChange( + Lifetime lifetime, + IDaemon daemon, + ISettingsStore settingsStore + ) { var settingsKey = settingsStore.Schema.GetKey(); - settingsStore.AdviseChange(lifetime, settingsKey, () => daemon.Invalidate("settings have changed")); + settingsStore.AdviseChange( + lifetime, + settingsKey, + () => daemon.Invalidate("settings have changed") + ); } } -} \ No newline at end of file +} diff --git a/src/dotnet/MO.CleanCode/MO.CleanCode.Rider.csproj b/src/dotnet/MO.CleanCode/MO.CleanCode.Rider.csproj index 9746977..1886c62 100644 --- a/src/dotnet/MO.CleanCode/MO.CleanCode.Rider.csproj +++ b/src/dotnet/MO.CleanCode/MO.CleanCode.Rider.csproj @@ -1,62 +1,58 @@  - - - net472 - MO.CleanCode - CleanCode - false - false - CleanCode.ruleset - - - - - - all - runtime; build; native; contentfiles; analyzers; buildtransitive - - - - - - - - - - - - - True - True - Settings.resx - - - True - True - Warnings.resx - - - - - - ResXFileCodeGenerator - Settings.Designer.cs - - - ResXFileCodeGenerator - Warnings.Designer.cs - - - - - - Designer - MSBuild:Compile - - - - - - - - \ No newline at end of file + + net472 + MO.CleanCode + CleanCode + false + false + CleanCode.ruleset + + + + + all + runtime; build; native; contentfiles; analyzers; buildtransitive + + + + + + + + + + + True + True + Settings.resx + + + True + True + Warnings.resx + + + + + ResXFileCodeGenerator + Settings.Designer.cs + + + ResXFileCodeGenerator + Warnings.Designer.cs + + + + + Designer + MSBuild:Compile + + + + + + diff --git a/src/dotnet/MO.CleanCode/MO.CleanCode.csproj b/src/dotnet/MO.CleanCode/MO.CleanCode.csproj index 10124ec..325606c 100644 --- a/src/dotnet/MO.CleanCode/MO.CleanCode.csproj +++ b/src/dotnet/MO.CleanCode/MO.CleanCode.csproj @@ -1,63 +1,59 @@  - - - net472 - MO.CleanCode - CleanCode - false - CleanCode.ruleset - - - - - - all - runtime; build; native; contentfiles; analyzers; buildtransitive - - - - - - - - - - - - - - - True - True - Settings.resx - - - True - True - Warnings.resx - - - - - - ResXFileCodeGenerator - Settings.Designer.cs - - - ResXFileCodeGenerator - Warnings.Designer.cs - - - - - - Designer - MSBuild:Compile - - - - - - - - \ No newline at end of file + + net472 + MO.CleanCode + CleanCode + false + CleanCode.ruleset + + + + + all + runtime; build; native; contentfiles; analyzers; buildtransitive + + + + + + + + + + + + + True + True + Settings.resx + + + True + True + Warnings.resx + + + + + ResXFileCodeGenerator + Settings.Designer.cs + + + ResXFileCodeGenerator + Warnings.Designer.cs + + + + + Designer + MSBuild:Compile + + + + + + diff --git a/src/dotnet/MO.CleanCode/Properties/AssemblyInfo.cs b/src/dotnet/MO.CleanCode/Properties/AssemblyInfo.cs index 43a2830..416c34e 100644 --- a/src/dotnet/MO.CleanCode/Properties/AssemblyInfo.cs +++ b/src/dotnet/MO.CleanCode/Properties/AssemblyInfo.cs @@ -13,4 +13,4 @@ [assembly: Guid("97927FF9-8C9C-4DC5-A309-29C23F41DA47")] [assembly: AssemblyVersion("5.6.7.0")] -[assembly: AssemblyFileVersion("5.6.7.0")] \ No newline at end of file +[assembly: AssemblyFileVersion("5.6.7.0")] diff --git a/src/dotnet/MO.CleanCode/Resources/Settings.Designer.cs b/src/dotnet/MO.CleanCode/Resources/Settings.Designer.cs index 9d11ef0..1384232 100644 --- a/src/dotnet/MO.CleanCode/Resources/Settings.Designer.cs +++ b/src/dotnet/MO.CleanCode/Resources/Settings.Designer.cs @@ -131,12 +131,43 @@ internal static string MaximumMethodsPerClass { return ResourceManager.GetString("MaximumMethodsPerClass", resourceCulture); } } - + /// - /// Looks up a localized string similar to Maximum public methods per class. + /// Looks up a localized string similar to Maximum statements per method. + /// + internal static string MaximumStatementsPerMethod + { + get + { + return ResourceManager.GetString("MaximumStatementsPerMethod", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to List of meaningless suffixes. + /// + internal static string MeaninglessNameSuffixes { + get { + return ResourceManager.GetString("MeaninglessNameSuffixes", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Separate items with commas. /// - internal static string MaximumPublicMethodsPerClass { + internal static string MeaninglessNameSuffixesTooltip { get { + return ResourceManager.GetString("MeaninglessNameSuffixesTooltip", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Maximum public methods per class. + /// + internal static string MaximumPublicMethodsPerClass + { + get + { return ResourceManager.GetString("MaximumPublicMethodsPerClass", resourceCulture); } } diff --git a/src/dotnet/MO.CleanCode/ZoneMarker.cs b/src/dotnet/MO.CleanCode/ZoneMarker.cs index 4bafde4..a6e0a65 100644 --- a/src/dotnet/MO.CleanCode/ZoneMarker.cs +++ b/src/dotnet/MO.CleanCode/ZoneMarker.cs @@ -3,7 +3,5 @@ namespace CleanCode { [ZoneMarker] - public class ZoneMarker - { - } -} \ No newline at end of file + public class ZoneMarker { } +} diff --git a/src/dotnet/Plugin.props b/src/dotnet/Plugin.props index 6bbf85a..6cfb386 100644 --- a/src/dotnet/Plugin.props +++ b/src/dotnet/Plugin.props @@ -10,4 +10,4 @@ https://raw.github.com/MO2k4/CleanCode/master/license.txt https://raw.githubusercontent.com/MO2k4/CleanCode/master/logo.png - \ No newline at end of file +