Esempio n. 1
0
        /// <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);
         }
     }
 }
Esempio n. 7
0
        /// <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);
                }
            }
        }