/// <summary>
/// Gets the rules.
/// </summary>
/// <param name="analyzer">
/// The analyzer.
/// </param>
/// <returns>
/// A list of all the rules for the <see cref="SourceAnalyzer"/>.
/// </returns>
private static List <StyleCopRule> GetRules(SourceAnalyzer analyzer)
{
XmlDocument xmlDocument = StyleCopCore.LoadAddInResourceXml(analyzer.GetType(), null);
List <StyleCopRule> xmlDefinedRules = GetRulesFromXml(xmlDocument);
return(xmlDefinedRules);
}
/// <summary>
/// Initializes settings from specified document.
/// </summary>
public void Initialize(SourceAnalyzer analyzer, CodeDocument document)
{
IndentOptions = GetOptionsData <IndentOptionsData>(
analyzer,
document,
Rules.CheckAllowedIndentationCharacters);
LastLineOptions = GetOptionsData <LastLineOptionsData>(
analyzer,
document,
Rules.CheckWhetherLastCodeLineIsEmpty);
CharLimitOptions = GetOptionsData <CharLimitOptionsData>(
analyzer,
document,
Rules.CodeLineMustNotBeLongerThan);
MethodSizeOptions = GetOptionsData <LimitOptionsData>(
analyzer,
document,
Rules.MethodMustNotContainMoreLinesThan);
PropertySizeOptions = GetOptionsData <LimitOptionsData>(
analyzer,
document,
Rules.PropertyMustNotContainMoreLinesThan);
FileSizeOptions = GetOptionsData <LimitOptionsData>(
analyzer,
document,
Rules.FileMustNotContainMoreLinesThan);
}
/// <summary>
/// Initializes common settings.
/// </summary>
private void InitializeCommon(SourceAnalyzer analyzer, CodeDocument document)
{
m_names = new Dictionary <string, string>();
m_examples = new Dictionary <string, string>();
m_regulars = new Dictionary <string, Regex>();
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, words);
m_regulars.Add(setting, regex);
}
}
}
private void btnAnalyzeSources_Click(object sender, EventArgs e)
{
if (Lists.Sources.Count > 0)
{
SourceAnalyzer analyzer = new SourceAnalyzer();
analyzer.ShowDialog();
}
}
/// <summary>
/// Initializes settings from specified document.
/// </summary>
public void Initialize(SourceAnalyzer analyzer, CodeDocument document)
{
InitializeCommon(analyzer, document);
InitializeDerivings(analyzer, document);
InitializeBlockAt(analyzer, document);
InitializeEnglishOnly(analyzer, document);
InitializeCheckLength(analyzer, document);
}
/// <summary>
/// Initializes a new instance.
/// </summary>
public PropertyPage(SourceAnalyzer analyzer)
: this()
{
m_analyzer = analyzer;
namingRulesPage.Page = this;
customRulesPage.Page = this;
}
/// <summary>
/// Initializes setting for using English characters only.
/// </summary>
private void InitializeEnglishOnly(SourceAnalyzer analyzer, CodeDocument document)
{
string definition = SettingsManager.GetValue <string>(
analyzer,
document.Settings,
NamingSettings.EnglishOnly);
m_englishOnly = new EnglishOnly().ConvertTo(definition);
}
/// <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>
/// Initializes setting for blocking @ character.
/// </summary>
private void InitializeBlockAt(SourceAnalyzer analyzer, CodeDocument document)
{
string definition = SettingsManager.GetValue <string>(
analyzer,
document.Settings,
NamingSettings.BlockAt);
m_blockAt = new BlockAt().ConvertTo(definition);
}
/// <summary>
/// Gets property descriptor with existing check.
/// </summary>
private static PropertyDescriptor GetDescriptor(SourceAnalyzer analyzer, string settingName)
{
PropertyDescriptor descriptor = analyzer.PropertyDescriptors[settingName];
if (descriptor == null)
{
throw new InvalidDataException("Setting " + settingName + " is not registered as a known one.");
}
return(descriptor);
}
/// <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>
/// Gets options data for specified rule.
/// </summary>
private static T GetOptionsData <T>(SourceAnalyzer analyzer, CodeDocument document, Rules rule) where T : ICustomRuleOptionsData
{
CustomRule customRule = CustomRules.Get(rule);
T data = (T)customRule.CreateOptionsData();
string settingValue = SettingsManager.GetValue <string>(
analyzer,
document.Settings,
customRule.SettingName);
data.ConvertFromValue(settingValue);
return(data);
}
/// <summary>
/// Initializes setting for checking derived classes.
/// </summary>
private void InitializeDerivings(SourceAnalyzer analyzer, CodeDocument document)
{
m_derivings = new List <string>();
string derivings = SettingsManager.GetValue <string>(
analyzer,
document.Settings,
NamingSettings.Derivings);
m_derivings.AddRange(
derivings.Split(
new[] { ' ' },
StringSplitOptions.RemoveEmptyEntries));
}
/// <summary>
/// Initializes setting for checking name length.
/// </summary>
private void InitializeCheckLength(SourceAnalyzer analyzer, CodeDocument document)
{
string definition = SettingsManager.GetValue <string>(
analyzer,
document.Settings,
NamingSettings.CheckLength);
m_checkLength = new CheckLength().ConvertTo(definition);
string exceptions = SettingsManager.GetValue <string>(
analyzer,
document.Settings,
NamingSettings.CheckLengthExceptions);
m_checkLengthExceptions = new HashSet <string>(
exceptions
.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries)
.Select(word => word.ToLowerInvariant()));
}
/// <summary>
/// Gets property value for specified setting.
/// </summary>
public static T GetValue <T>(SourceAnalyzer analyzer, Settings settings, string settingName)
{
T customValue;
if (GetCustomValue(analyzer, settingName, out customValue))
{
return(customValue);
}
PropertyValue <T> setting = (PropertyValue <T>)analyzer.GetSetting(settings, settingName);
if (setting == null)
{
PropertyDescriptor <T> descriptor = (PropertyDescriptor <T>)GetDescriptor(analyzer, settingName);
return(descriptor.DefaultValue);
}
return(setting.Value);
}
/// <summary>
/// Gets customized value if it is possible.
/// </summary>
private static bool GetCustomValue <T>(SourceAnalyzer analyzer, string settingName, out T value)
{
if (analyzer is StyleCopPlusRules)
{
StyleCopPlusRules styleCopPlus = (StyleCopPlusRules)analyzer;
if (styleCopPlus.SpecialRunningParameters != null)
{
if (styleCopPlus.SpecialRunningParameters.CustomSettings != null)
{
if (styleCopPlus.SpecialRunningParameters.CustomSettings.ContainsKey(settingName))
{
value = (T)styleCopPlus.SpecialRunningParameters.CustomSettings[settingName];
return(true);
}
}
}
}
value = default(T);
return(false);
}
private void EnsureDiagnostics()
{
if (_diagnostics == null)
{
_diagnostics = new ObservableCollection <DiagnosticModel>();
switch (Type)
{
case ItemType.CSharp:
var analyzer = new SourceAnalyzer();
foreach (var d in analyzer.GetDiagnostics(AbsolutePath))
{
_diagnostics.Add(new DiagnosticModel(d));
}
break;
default:
// only C# files are supported (for now).
break;
}
}
}
/// <summary>
/// Analyzes rules tree directly from UI.
/// </summary>
public static void Initialize(PropertyControl tabControl)
{
IPropertyControlPage analyzersOptions = tabControl.Pages[0];
TreeView tree = (TreeView)analyzersOptions.GetType().InvokeMember(
"analyzeTree",
BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.GetField,
null,
analyzersOptions,
null);
s_ruleNodes = new Dictionary <string, Dictionary <string, TreeNode> >();
foreach (TreeNode parserNode in tree.Nodes)
{
foreach (TreeNode analyzerNode in parserNode.Nodes)
{
SourceAnalyzer analyzer = (SourceAnalyzer)analyzerNode.Tag;
s_ruleNodes[analyzer.Id] = new Dictionary <string, TreeNode>();
AnalyzeRuleNodes(s_ruleNodes[analyzer.Id], analyzerNode);
}
}
}
/// <summary>
/// Checks whether original rule is enabled.
/// </summary>
private void CheckOriginalRule(CodeDocument document, string analyzerId, Rules rule)
{
string ruleName = rule.ToString();
if (!m_parent.IsRuleEnabled(document, ruleName))
{
return;
}
SourceAnalyzer analyzer = m_parent.Core.GetAnalyzer(analyzerId);
if (!analyzer.IsRuleEnabled(document, ruleName))
{
return;
}
string message = String.Format(
Resources.ExtendedRuleConflictError,
m_parent.GetRule(ruleName).CheckId,
analyzer.GetRule(ruleName).CheckId);
throw new Exception(message);
}
/// <summary>
/// Gets the rules.
/// </summary>
/// <param name="analyzer">
/// The analyzer.
/// </param>
/// <returns>
/// A list of all the rules for the <see cref="SourceAnalyzer"/>.
/// </returns>
private static List<StyleCopRule> GetRules(SourceAnalyzer analyzer)
{
XmlDocument xmlDocument = StyleCopCore.LoadAddInResourceXml(analyzer.GetType(), null);
List<StyleCopRule> xmlDefinedRules = GetRulesFromXml(xmlDocument);
return xmlDefinedRules;
}
/// <summary>
/// Fills the given analyzer node with it's rules.
/// </summary>
/// <param name="analyzer">Source analyzer</param>
/// <param name="analyzerIter">Analyzer node iterator.</param>
private void FillAnalyzerRules(SourceAnalyzer analyzer, Gtk.TreeIter analyzerIter)
{
IEnumerable<Rule> addinRules = null;
// We must use reflection at the moment to get all analyzer rules.
PropertyInfo prop = analyzer.GetType().GetProperty("AddInRules", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
if (prop != null && prop.CanRead)
{
addinRules = prop.GetValue(analyzer, null) as IEnumerable<Rule>;
}
if (addinRules != null)
{
Dictionary<string, Gtk.TreeIter> tempRuleGroups = new Dictionary<string, Gtk.TreeIter>();
foreach (Rule rule in addinRules)
{
// Only show rules which can be disabled.
if (rule.CanDisable)
{
// Get or create the rule group node for this rule, if necessary.
Gtk.TreeIter ruleParentIter = analyzerIter;
if (!string.IsNullOrEmpty(rule.RuleGroup))
{
if (!tempRuleGroups.TryGetValue(rule.RuleGroup, out ruleParentIter))
{
ruleParentIter = this.rulesStore.AppendValues(analyzerIter, false, null, rule, null, false);
tempRuleGroups.Add(rule.RuleGroup, ruleParentIter);
}
}
bool isChecked = rule.EnabledByDefault;
BooleanProperty enabledDisabledSetting = analyzer.GetRuleSetting(this.SettingsHandler.MergedSettings, rule.Name, "Enabled") as BooleanProperty;
if (enabledDisabledSetting != null)
{
isChecked = enabledDisabledSetting.Value;
}
bool isOverridden = this.DetectRuleOverride(analyzer, rule, isChecked, false);
Gtk.TreeIter ruleIter = this.rulesStore.AppendValues(ruleParentIter, isChecked, null, rule, analyzer, isOverridden);
this.SetParentIterValues(ruleIter, isChecked, null);
if (isOverridden)
{
this.rulesStore.SetValue(ruleParentIter, (int)TreeStoreColumns.Overridden, true);
this.rulesStore.SetValue(analyzerIter, (int)TreeStoreColumns.Overridden, true);
}
}
}
}
}
/// <summary>
/// Checks if the given analyzer rule setting is overridden.
/// </summary>
/// <param name="analyzer">Source analyzer of the rule to check.</param>
/// <param name="ruleToCheck">The rule that should be checked.</param>
/// <param name="isChecked">Is the check box checked or unchecked?</param>
/// <param name="hasOverriddenChilds">Value that is used for cells that don't have a analyzer.</param>
/// <returns>True if the rule is overridden, false otherwise.</returns>
private bool DetectRuleOverride(SourceAnalyzer analyzer, Rule ruleToCheck, bool isChecked, bool hasOverriddenChilds)
{
bool overridden = false;
if (analyzer != null)
{
// Create a property representing the current value of the selection.
string propertyName = ruleToCheck.Name + "#Enabled";
BooleanProperty localValue = new BooleanProperty(analyzer, propertyName, isChecked);
// Compare this with the parent value.
overridden = this.SettingsHandler.SettingsComparer.IsAddInSettingOverwritten(analyzer, propertyName, localValue);
}
else
{
overridden = hasOverriddenChilds;
}
return overridden;
}
/// <summary>
/// Initializes a new instance of the CompanyInformation class.
/// </summary>
/// <param name="analyzer">The analyzer that this settings page is attached to.</param>
public CompanyInformation(DocumentationRules analyzer)
: this()
{
Param.RequireNotNull(analyzer, "analyzer");
this.analyzer = analyzer;
}
/// <summary>
/// Initializes a new instance of the ValidPrefixes class.
/// </summary>
/// <param name="analyzer">
/// The analyzer that this settings page is attached to.
/// </param>
public ValidPrefixes(NamingRules analyzer)
: this()
{
Param.AssertNotNull(analyzer, "analyzer");
this.analyzer = analyzer;
}
/// <summary>
/// Initializes a new instance of the CompanyInformation class.
/// </summary>
/// <param name="analyzer">
/// The analyzer that this settings page is attached to.
/// </param>
public CompanyInformation(DocumentationRules analyzer)
: this()
{
Param.RequireNotNull(analyzer, "analyzer");
this.analyzer = analyzer;
}
/// <summary>
/// Initializes a new instance of the ValidPrefixes class.
/// </summary>
/// <param name="analyzer">
/// The analyzer that this settings page is attached to.
/// </param>
public ValidPrefixes(NamingRules analyzer)
: this()
{
Param.AssertNotNull(analyzer, "analyzer");
this.analyzer = analyzer;
}
/// <summary>
/// Initializes a new instance of the <see cref="MonoDevelop.StyleCop.CompanyInformationOptionsPanel"/> class.
/// </summary>
public CompanyInformationOptionsPanel()
{
this.Build();
this.analyzer = ProjectUtilities.Instance.Core.GetAnalyzer("StyleCop.CSharp.DocumentationRules");
}
/// <summary>
/// Gets friendly name for specified setting.
/// </summary>
public static string GetFriendlyName(SourceAnalyzer analyzer, string settingName)
{
PropertyDescriptor descriptor = GetDescriptor(analyzer, settingName);
return(descriptor.FriendlyName);
}
private void menuItem7_Click(object sender, EventArgs e)
{
SourceAnalyzer snc = new SourceAnalyzer();
snc.Show();
}
/// <summary>
/// Initializes custom analyzer based on the standard one.
/// </summary>
public static void InitializeCustomAnalyzer(
StyleCopCore originalCore,
StyleCopCore customCore,
string originalAnalyzerId,
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[originalAnalyzerId];
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>
/// Initializes a new instance of the <see cref="MonoDevelop.StyleCop.ValidPrefixesOptionsPanel"/> class.
/// </summary>
public ValidPrefixesOptionsPanel()
{
this.Build();
this.analyzer = ProjectUtilities.Instance.Core.GetAnalyzer("StyleCop.CSharp.NamingRules");
}
