/// <summary> /// Initializes a new instance. /// </summary> public PropertyPage(SourceAnalyzer analyzer) : this() { m_analyzer = analyzer; namingRulesPage.Page = this; customRulesPage.Page = this; }
/// <summary> /// Initializes custom analyzer based on the standard one. /// </summary> public static void InitializeCustomAnalyzer( StyleCopCore originalCore, StyleCopCore customCore, string originalAnalyzerCode, SourceAnalyzer customAnalyzer) { Dictionary<string, SourceAnalyzer> originalAnalyzers = (Dictionary<string, SourceAnalyzer>)typeof(StyleCopCore).InvokeMember( "analyzers", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.GetField, null, originalCore, null); SourceAnalyzer originalAnalyzer = originalAnalyzers[originalAnalyzerCode]; Dictionary<string, Rule> originalRules = (Dictionary<string, Rule>)typeof(StyleCopAddIn).InvokeMember( "rules", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.GetField, null, originalAnalyzer, null); typeof(StyleCopAddIn).InvokeMember( "core", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.SetField, null, customAnalyzer, new object[] { customCore }); Dictionary<string, Rule> customRules = new Dictionary<string, Rule>(); foreach (KeyValuePair<string, Rule> pair in originalRules) { Rule originalRule = pair.Value; Rule customRule = (Rule)typeof(Rule).InvokeMember( "Rule", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.CreateInstance, null, customCore, new object[] { originalRule.Name, originalRule.Namespace, originalRule.CheckId, originalRule.Context, originalRule.Warning, originalRule.Description, originalRule.RuleGroup, true, false }); customRules[pair.Key] = customRule; } typeof(StyleCopAddIn).InvokeMember( "rules", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.SetField, null, customAnalyzer, new object[] { customRules }); CustomCsParser customParser = new CustomCsParser(); typeof(SourceAnalyzer).InvokeMember( "parser", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.SetField, null, customAnalyzer, new object[] { customParser }); }
/// <summary> /// Gets example summary text for destructor. /// </summary> public static string GetExampleSummaryTextForDestructor(SourceAnalyzer customDocumentationAnalyzer) { return (string)typeof(DocumentationRules).InvokeMember( "GetExampleSummaryTextForDestructor", BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.InvokeMethod, null, customDocumentationAnalyzer, null); }
/// <summary> /// Gets example summary text for constructor. /// </summary> public static string GetExampleSummaryTextForConstructor(SourceAnalyzer customDocumentationAnalyzer, ICodeUnit constructor) { string type = (constructor.Parent is Struct) ? "struct" : "class"; return (string)typeof(DocumentationRules).InvokeMember( "GetExampleSummaryTextForConstructorType", BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.InvokeMethod, null, customDocumentationAnalyzer, new object[] { constructor, type }); }
/// <summary> /// Initializes settings from specified document. /// </summary> public void Initialize(SourceAnalyzer analyzer, CodeDocument document) { m_names.Clear(); m_examples.Clear(); m_regulars.Clear(); m_derivings.Clear(); string abbreviations = SettingsManager.GetValue<string>( analyzer, document.Settings, NamingSettings.Abbreviations); string words = SettingsManager.GetValue<string>( analyzer, document.Settings, NamingSettings.Words); foreach (string setting in NamingSettings.GetCommon()) { string name = SettingsManager.GetFriendlyName(analyzer, setting); m_names.Add(setting, name); string value = SettingsManager.GetValue<string>(analyzer, document.Settings, setting); if (String.IsNullOrEmpty(value)) { m_examples.Add(setting, null); m_regulars.Add(setting, null); } else { string example = NamingMacro.BuildExample(value); m_examples.Add(setting, example); Regex regex = NamingMacro.BuildRegex(value, abbreviations, words); m_regulars.Add(setting, regex); } } string derivings = SettingsManager.GetValue<string>( analyzer, document.Settings, NamingSettings.Derivings); m_derivings.AddRange( derivings.Split( new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries)); }
private void FillAnalyzerRules(SourceAnalyzer analyzer, TreeNode analyzerNode) { foreach (Rule rule in analyzer.AddInRules) { if (rule.CanDisable) { TreeNode nodeToInsert = analyzerNode; if (!string.IsNullOrEmpty(rule.RuleGroup)) { nodeToInsert = FindMatchingRuleGroupNode(analyzerNode.Nodes, rule.RuleGroup); if (nodeToInsert == null) { nodeToInsert = new TreeNode(rule.RuleGroup); nodeToInsert.ImageKey = nodeToInsert.SelectedImageKey = "RuleGroupNode"; InsertIntoSortedTree(analyzerNode.Nodes, nodeToInsert); } } TreeNode node2 = new TreeNode(rule.CheckId + ": " + rule.Name); node2.ImageKey = node2.SelectedImageKey = "RuleNode"; node2.Tag = rule; InsertIntoSortedTree(nodeToInsert.Nodes, node2); this.InitializeRuleCheckedState(rule, node2); } } }
/// <summary> /// Gets a value indicating whether the given rule is enabled for the given document. /// </summary> /// <param name="analyzer">The analyzer which contains the rule.</param> /// <param name="ruleName">The rule to check.</param> /// <returns>Returns true if the rule is enabled; otherwise false.</returns> public bool IsRuleEnabled(SourceAnalyzer analyzer, string ruleName) { Param.RequireNotNull(analyzer, "analyzer"); Param.RequireValidString(ruleName, "ruleName"); this.enabledRulesLock.AcquireReaderLock(Timeout.Infinite); try { this.InitializeEnabledRules(); if (this.enabledRules != null) { Dictionary<string, Rule> enabledRulesForAnalyzer = null; if (this.enabledRules.TryGetValue(analyzer, out enabledRulesForAnalyzer) && enabledRulesForAnalyzer != null) { return enabledRulesForAnalyzer.ContainsKey(ruleName); } } } finally { this.enabledRulesLock.ReleaseReaderLock(); } return false; }
public CompanyInformation(DocumentationRules analyzer) : this() { Param.RequireNotNull(analyzer, "analyzer"); this.analyzer = analyzer; }
private void FillAnalyzerRules(SourceAnalyzer analyzer, TreeNode analyzerNode) { Param.AssertNotNull(analyzer, "analyzer"); Param.AssertNotNull(analyzerNode, "analyzerNode"); // Iterate through each rule in the analyzer and add a checkbox for each. foreach (Rule rule in analyzer.AddInRules) { // Only show rules which can be disabled. if (rule.CanDisable) { // Get or create the rule group node for this rule, if necessary. TreeNode ruleParentNode = analyzerNode; if (!string.IsNullOrEmpty(rule.RuleGroup)) { ruleParentNode = FindMatchingRuleGroupNode(analyzerNode.Nodes, rule.RuleGroup); if (ruleParentNode == null) { ruleParentNode = new TreeNode(rule.RuleGroup); ruleParentNode.ImageKey = ruleParentNode.SelectedImageKey = RuleGroupNode; InsertIntoSortedTree(analyzerNode.Nodes, ruleParentNode); } } // Create a node for this rule. TreeNode ruleNode = new TreeNode(string.Concat(rule.CheckId, ": ", rule.Name)); ruleNode.ImageKey = ruleNode.SelectedImageKey = RuleNode; ruleNode.Tag = rule; InsertIntoSortedTree(ruleParentNode.Nodes, ruleNode); this.InitializeRuleCheckedState(rule, ruleNode); } } }