public static void TestEmptyDictionaryReturnNoNamingStylePreferencesObjectReturnsFalse() { var editorConfigStorageLocation = new NamingStylePreferenceEditorConfigStorageLocation(); var result = editorConfigStorageLocation.TryGetOption(StructuredAnalyzerConfigOptions.Create(DictionaryAnalyzerConfigOptions.EmptyDictionary), typeof(NamingStylePreferences), out _); Assert.False(result, "Expected TryParseReadonlyDictionary to return 'false' for empty dictionary"); }
public static void TestObjectTypeThrowsInvalidOperationException() { var editorConfigStorageLocation = new NamingStylePreferenceEditorConfigStorageLocation(); Assert.Throws <InvalidOperationException>(() => { editorConfigStorageLocation.TryGetOption(StructuredAnalyzerConfigOptions.Create(DictionaryAnalyzerConfigOptions.EmptyDictionary), typeof(object), out var @object); }); }
public void TestParseEditorConfigEndOfLine(string configurationString, string newLine) { var storageLocation = FormattingOptions.NewLine.StorageLocations .OfType <EditorConfigStorageLocation <string> >() .Single(); var allRawConventions = StructuredAnalyzerConfigOptions.Create(DictionaryAnalyzerConfigOptions.EmptyDictionary.Add(storageLocation.KeyName, configurationString)); Assert.True(storageLocation.TryGetOption(allRawConventions, typeof(string), out var parsedNewLine)); Assert.Equal(newLine, (string?)parsedNewLine); }
public bool TryGetOption(StructuredAnalyzerConfigOptions options, Type type, out object result) { if (type == typeof(NamingStylePreferences)) { var preferences = options.GetNamingStylePreferences(); result = preferences; return(!preferences.IsEmpty); } throw ExceptionUtilities.UnexpectedValue(type); }
public bool TryGetOption(StructuredAnalyzerConfigOptions options, Type type, out object?result) { if (options.TryGetValue(KeyName, out var value)) { var ret = TryGetOption(value, type, out var typedResult); result = typedResult; return(ret); } result = null; return(false); }
public void TestParseEditorConfigAccessibilityModifiers(string args, int value, ReportDiagnostic severity) { var storageLocation = CodeStyleOptions2.RequireAccessibilityModifiers.StorageLocations .OfType <EditorConfigStorageLocation <CodeStyleOption2 <AccessibilityModifiersRequired> > >() .Single(); var allRawConventions = StructuredAnalyzerConfigOptions.Create(DictionaryAnalyzerConfigOptions.EmptyDictionary.Add(storageLocation.KeyName, args)); Assert.True(storageLocation.TryGetOption(allRawConventions, typeof(CodeStyleOption2 <AccessibilityModifiersRequired>), out var parsedCodeStyleOption)); var codeStyleOption = (CodeStyleOption2 <AccessibilityModifiersRequired>)parsedCodeStyleOption !; Assert.Equal((AccessibilityModifiersRequired)value, codeStyleOption.Value); Assert.Equal(severity, codeStyleOption.Notification.Severity); }
public static void TestNonEmptyDictionaryReturnsTrue() { var editorConfigStorageLocation = new NamingStylePreferenceEditorConfigStorageLocation(); var options = StructuredAnalyzerConfigOptions.Create(new Dictionary <string, string>() { ["dotnet_naming_rule.methods_and_properties_must_be_pascal_case.severity"] = "error", ["dotnet_naming_rule.methods_and_properties_must_be_pascal_case.symbols"] = "method_and_property_symbols", ["dotnet_naming_rule.methods_and_properties_must_be_pascal_case.style"] = "pascal_case_style", ["dotnet_naming_symbols.method_and_property_symbols.applicable_kinds"] = "method,property", ["dotnet_naming_symbols.method_and_property_symbols.applicable_accessibilities"] = "*", ["dotnet_naming_style.pascal_case_style.capitalization"] = "pascal_case" }.ToImmutableDictionary(AnalyzerConfigOptions.KeyComparer)); var result = editorConfigStorageLocation.TryGetOption(options, typeof(NamingStylePreferences), out var value); Assert.True(result, "Expected non-empty dictionary to return true"); var namingStylePreferences = Assert.IsAssignableFrom <NamingStylePreferences>(value); Assert.Equal(ReportDiagnostic.Error, namingStylePreferences.Rules.NamingRules[0].EnforcementLevel); }
private static bool TryGetEditorConfigOption <T>(this AnalyzerConfigOptions analyzerConfigOptions, TOption option, Optional <T?> defaultValue, out T?value) { var hasEditorConfigStorage = false; foreach (var storageLocation in option.StorageLocations) { // This code path will avoid allocating a Dictionary wrapper since we can get direct access to the KeyName. if (storageLocation is EditorConfigStorageLocation <T> editorConfigStorageLocation && analyzerConfigOptions.TryGetValue(editorConfigStorageLocation.KeyName, out var stringValue) && editorConfigStorageLocation.TryGetOption(stringValue, typeof(T), out value)) { return(true); } if (storageLocation is not IEditorConfigStorageLocation configStorageLocation) { continue; } // This option has .editorconfig storage defined, even if the current configuration does not provide a // value for it. hasEditorConfigStorage = true; if (StructuredAnalyzerConfigOptions.TryGetStructuredOptions(analyzerConfigOptions, out var structuredOptions) && configStorageLocation.TryGetOption(structuredOptions, option.Type, out var objectValue)) { value = (T?)objectValue; return(true); } } if (defaultValue.HasValue) { value = defaultValue.Value; return(hasEditorConfigStorage); } else { value = default; return(false); } }
public AnalyzerConfigData(AnalyzerConfigOptionsResult result) { ConfigOptions = StructuredAnalyzerConfigOptions.Create(result.AnalyzerOptions); AnalyzerOptions = result.AnalyzerOptions; TreeOptions = result.TreeOptions; }