public void TestFileStructureRule()
{
var project = new Project
{
Name = "TestProject1",
Path = @"D:\",
};
var context = new ExamContext(project);
var rule = new FileStructureRule { Template = "default.xml", IsEnabled = true, Name = "FileStructureRule", Description = "FileStructureRule Description" };
rule.Exam(context);
Assert.IsTrue(context.Outputs.Count > 0);
Assert.IsTrue(context.Results.Count > 0);
}
public void Update(Project project, Action<Project, Exception> onComplete)
{
var exception = null as Exception;
try
{
SaveProject(project, overrideExist: true);
}
catch (Exception xe)
{
exception = xe;
}
if (onComplete != null)
{
onComplete.Invoke(project, exception);
}
}
public void Delete(Project project, Action<bool, Exception> onComplete)
{
var exception = null as Exception;
try
{
SaveProject(project, delete: true);
}
catch (Exception xe)
{
exception = xe;
}
if (onComplete != null)
{
onComplete.Invoke(exception == null, exception);
}
}
public void Create(Project project, Action<Project, Exception> onComplete)
{
var exception = null as Exception;
try
{
SaveProject(project);
}
catch (Exception xe)
{
exception = xe;
}
if (onComplete != null)
{
onComplete.Invoke(project, exception);
}
}
/// <summary>
/// Program entry point.
/// </summary>
/// <example>
/// -r "f:\_E_\SolutionTool" -t default.xml -b "./output/$(Configuration)/" -i "f:\_E_\jb-cl\inspectcode.exe" -l slntool.log
/// </example>
/// <param name="args"></param>
static void Main(string[] args)
{
Debug.Listeners.Add(new ConsoleTraceListener());
var options = new Options();
var parser = new Parser();
if (!Parser.Default.ParseArguments(args, options))
{
return;
}
Console.WriteLine("Begin checking " + options.Repository);
var pathOfRepository = Path.GetFullPath(options.Repository);
var pathOfTemplate = Path.GetFullPath(options.Template);
if (!Directory.Exists(pathOfRepository))
{
Console.WriteLine("Repository directory does not exist: [" + options.Repository + "]");
}
if (!File.Exists(pathOfTemplate))
{
Console.WriteLine("Template File does not exist: [" + options.Repository + "]");
}
else
{
var di = new DirectoryInfo(pathOfRepository);
var fi = new DirectoryInfo(pathOfTemplate);
var project = new Project { Name = di.Name, Path = pathOfRepository, CreateTime = DateTime.Now, };
var ruleSet = new RuleSet
{
new FileStructureRule
{
Name = "File Structure Rule",
IsEnabled = true,
Template = fi.Name,
},
new OutputPathRule
{
Name = "Output Path Rule",
IsEnabled = true,
Path = options.OutputBuildPath,
},
};
if (!string.IsNullOrWhiteSpace(options.InspectCodeExePath))
{
ruleSet.Add(new CodeAnalysisRule
{
Name = "Code Analysis Rule",
IsEnabled = true,
Path = options.InspectCodeExePath,
});
}
var ruleRunner = new RuleRunner();
project.RuleSet = ruleSet;
ruleRunner.RunProject(project, (report,log) =>
{
if (report != null)
{
Console.WriteLine(report.GetText());
}
if (!string.IsNullOrWhiteSpace(options.LogFile))
{
var logFile = Path.GetFullPath(options.LogFile);
using (var sw = File.AppendText(logFile))
{
sw.Write(report.GetText());
}
}
});
}
Console.WriteLine("Checking is done. ");
Console.ReadKey();
}
private Exception SaveProject(Project project, bool overrideExist = false, bool delete = false)
{
if (project.CreateTime == DateTime.MinValue)
project.CreateTime = DateTime.Now;
if (!Directory.Exists(_dir))
{
Directory.CreateDirectory(_dir);
}
var path = Path.Combine(_dir, project.Name + ".xml");
var exception = null as Exception;
if (delete && File.Exists(path))
{
File.Delete(path);
}
else if (File.Exists(path) && !overrideExist)
{
throw new Exception("Project [" + project.Name + "] already exists. ");
}
else
{
if (overrideExist)
{
File.Delete(path);
}
using (var fs = XmlWriter.Create(path))
{
var xs = new XmlSerializer(typeof(Project));
xs.Serialize(fs, project);
}
list.Insert(0, project);
}
return exception;
}
void OnCreateComplete(Project project, Exception ex)
{
if (ex != null)
{
_shellService.MessageService.Show(ex.Message);
}
else
{
_shellService.Host.Close(CloseResult.Success | CloseResult.RefreshParent);
}
}
private void Init()
{
//throw new NotImplementedException();
Project = new Project() {};
_ruleManager.LoadRuleSet(OnRuleSetLoaded);
}
public void RunProject(Project project, Action<Report, RunLogItem> onComplete)
{
var log = new RunLogItem();
log.Start = DateTime.Now;
log.Project = project.Name;
if (project == null)
{
throw new ArgumentException();
}
if (project.RuleSet == null)
{
throw new Exception("RuleSet is not specified. ");
}
var context = new ExamContext(project);
foreach (var i in project.RuleSet)
{
try
{
i.Exam(context);
}
catch (Exception e)
{
context.WriteOutput(i.Name, new Output
{
Summary = e.Message,
Details = new List<string>
{
e.ToString(),
},
});
context.AddResult(new ExamResult()
{
RuleName = i.Name,
Status = ActionStatus.Failed,
});
context.AddViolation(new Violation
{
RuleName = i.Name,
Description = e.Message,
});
continue;
}
}
var report = context.GenerateReport();
var path = SaveReportToFile(report);
log.End = DateTime.Now;
log.Status = report.Status;
log.Report = path;
log.Rules = project.RuleSet.Count;
list.Insert(0, log);
SaveRunlog(log);
if (onComplete != null)
{
onComplete.Invoke(report, log);
}
}
public void Exam(Project project, Action<ExamResult> onComplete)
{
}
