public void TestFixtureSetUp()
{
rootPath = TestUtils.CreateFoldersAndFiles(TestUtils.MockFileSystemDefinition);
repositoryInfo = new RepositoryInfo(rootPath);
fileSystemHelper = new FileSystemHelper();
fileSystemRuleParser = new FileSystemRuleParser(fileSystemHelper);
}
public RuleProcessor(string repoRootPath, SolutionValidatorConfigurationSection configuration, bool isReformatEnabled)
{
var projectFileHelper = Dependency.Resolve <IProjectFileHelper>();
_rules = new List <Rule>();
if (!Directory.Exists(repoRootPath))
{
Logger.Error(Resources.RuleProcessor_RuleProcessor_Repository_root_folder_does_not_exists, repoRootPath);
return;
}
_repositoryInfo = new RepositoryInfo(repoRootPath);
if (configuration.FolderStructure.Check)
{
var definitionFilePath = configuration.FolderStructure.EvaluatedDefinitionFilePath();
if (File.Exists(definitionFilePath))
{
var fileSystemHelper = Dependency.Resolve <IFileSystemHelper>();
var fileSystemRuleParser = new FileSystemRuleParser(fileSystemHelper);
_rules.AddRange(fileSystemRuleParser.Parse(definitionFilePath));
}
else
{
throw new ParseException(
string.Format(Resources.RuleProcessor_RuleProcessor_Folder_structure_definition_file_not_found,
definitionFilePath), 0, 0);
}
}
if (configuration.ProjectFile.OutputPath.Check)
{
var rule = new OutPutPathProjectFileRule(configuration.ProjectFile.OutputPath.Value, projectFileHelper);
_rules.Add(rule);
}
if (configuration.ProjectFile.RequiredConfigurations.Check)
{
foreach (var requiredConfigurationName in
configuration.ProjectFile.RequiredConfigurations.Cast <ConfigurationNameElement>().Select(e => e.Name))
{
var rule = new ConfigurationExistsProjectFileRule(requiredConfigurationName, projectFileHelper);
_rules.Add(rule);
}
}
if (configuration.ProjectFile.CheckIdentical.Check)
{
foreach (var propertiesToMatch in
configuration.ProjectFile.CheckIdentical.Cast <PropertiesToMatchElement>())
{
var rule = new CheckIdenticalProjectFileRule(propertiesToMatch.PropertyName, propertiesToMatch.OtherPropertyName, projectFileHelper);
_rules.Add(rule);
}
}
if (configuration.ProjectFile.CheckForValue.Check)
{
foreach (var propertyToCheck in
configuration.ProjectFile.CheckForValue.Cast <PropertyToCheckElement>())
{
var rule = new CheckForValueProjectFileRule(propertyToCheck.PropertyName, propertyToCheck.Value, projectFileHelper);
_rules.Add(rule);
}
}
if (configuration.CSharpFormatting.Check && isReformatEnabled)
{
var fileSystemHelper = Dependency.Resolve <IFileSystemHelper>();
ReformatRule rule;
var optionsFilePath = configuration.CSharpFormatting.EvaluatedOptionsFilePath();
if (File.Exists(optionsFilePath))
{
rule = new ReformatRule(optionsFilePath, configuration.CSharpFormatting.SourceFileFilters, fileSystemHelper);
}
else
{
if (configuration.CSharpFormatting.IsDefaultOptionsFilePath)
{
rule = new ReformatRule(null, configuration.CSharpFormatting.SourceFileFilters, fileSystemHelper);
}
else
{
throw new SolutionValidatorException(
string.Format(Resources.RuleProcessor_RuleProcessor_CSharp_formatting_check_was_set_to_true, optionsFilePath));
}
}
_rules.Add(rule);
}
if (configuration.CSharpFormatting.PrivateFieldRename.Check && isReformatEnabled)
{
var fileSystemHelper = Dependency.Resolve <IFileSystemHelper>();
_rules.Add(new RenamePrivateFieldsRefactorRule(
configuration.CSharpFormatting.PrivateFieldRename.Find,
configuration.CSharpFormatting.PrivateFieldRename.Replace,
configuration.CSharpFormatting.SourceFileFilters, fileSystemHelper));
}
if (configuration.CSharpFormatting.RemoveRedundantThisQualifier.Check && isReformatEnabled)
{
var fileSystemHelper = Dependency.Resolve <IFileSystemHelper>();
_rules.Add(new RemoveRedundantThisQualifierRule(
configuration.CSharpFormatting.SourceFileFilters, fileSystemHelper));
}
}
public void Setup()
{
parser = new FileSystemRuleParser(null);
}
