public void Match_TestPatternsPhp_MatchedAllDefault()
{
var path = Path.Combine(TestUtility.TestsDataPath, "Patterns.php");
var sourceCodeRep = new FileCodeRepository(path);
var workflow = new Workflow(sourceCodeRep, Global.PatternsRepository);
WorkflowResult workflowResult = workflow.Process();
IEnumerable <MatchResultDto> matchResults = workflowResult.MatchResults
.ToDto()
.OrderBy(r => r.PatternKey);
IEnumerable <PatternDto> patternDtos = Global.PatternsRepository.GetAll()
.Where(patternDto => patternDto.Languages.Contains("Php"));
foreach (PatternDto dto in patternDtos)
{
Assert.Greater(matchResults.Count(p => p.PatternKey == dto.Key), 0, dto.Description);
}
Assert.AreEqual(1, matchResults.Count(r =>
r.MatchedCode.Contains("Configure") &&
r.MatchedCode.Contains("write") &&
r.MatchedCode.Contains("3")));
Assert.AreEqual(0, matchResults.Count(r =>
r.MatchedCode.Contains("Configure") &&
r.MatchedCode.Contains("write") &&
r.MatchedCode.Contains("50")));
}
public static SourceCodeRepository CreateSourceCodeRepository(string path, string tempDir)
{
SourceCodeRepository sourceCodeRepository;
if (string.IsNullOrWhiteSpace(path))
{
sourceCodeRepository = DummyCodeRepository.Instance;
}
else if (Directory.Exists(path))
{
sourceCodeRepository = new DirectoryCodeRepository(path);
}
else if (File.Exists(path))
{
string extensions = Path.GetExtension(path);
if (extensions.EqualsIgnoreCase(".zip"))
{
sourceCodeRepository = new ZipCachingRepository(path)
{
ExtractPath = tempDir
};
}
else
{
sourceCodeRepository = new FileCodeRepository(path);
sourceCodeRepository.LoadJson = extensions.EqualsIgnoreCase(".json");
}
}
else
{
string url = path;
string projectName = null;
string urlWithoutHttp = TextUtils.HttpRegex.Replace(url, "");
if (!url.EndsWith(".zip", StringComparison.OrdinalIgnoreCase))
{
if (urlWithoutHttp.StartsWith("github.com", StringComparison.OrdinalIgnoreCase))
{
url = url + "/archive/master.zip";
}
}
if (urlWithoutHttp.StartsWith("github.com", StringComparison.OrdinalIgnoreCase))
{
projectName = urlWithoutHttp.Split('/').ElementAtOrDefault(2);
}
var zipAtUrlCachedCodeRepository = new ZipAtUrlCachingRepository(url, projectName)
{
DownloadPath = tempDir
};
sourceCodeRepository = zipAtUrlCachedCodeRepository;
}
return(sourceCodeRepository);
}
static void Main(string[] args)
{
var fileRepository = new FileCodeRepository("code.php");
var patternsRepostiory = new FilePatternsRepository("patterns.json");
var workflow = new Workflow(fileRepository, patternsRepostiory);
workflow.IsIncludeIntermediateResult = true;
WorkflowResult result = workflow.Process();
var lineTokenDict = new Dictionary <int, List <string> >();
foreach (var matchingResult in result.MatchingResults)
{
var matchedNode = matchingResult.Nodes.Last();
UstNode[] descendants = matchedNode.GetAllDescendants();
foreach (UstNode descendant in descendants)
{
string text = null;
if (descendant.NodeType == NodeType.InvocationExpression)
{
text = "Method invocation: " + ((InvocationExpression)descendant).Target;
}
else if (descendant.NodeType == NodeType.IndexerDeclaration)
{
text = "Arrays with user input: " + ((IndexerExpression)descendant).Target;
}
else if (descendant.NodeType == NodeType.CastExpression)
{
text = "Cast to type: " + ((CastExpression)descendant).Type;
}
if (!string.IsNullOrEmpty(text))
{
SourceCodeFile sourceCodeFile = result.SourceCodeFiles.Single(file => file.FullPath == descendant.FileNode.FileName.Text);
LineColumnTextSpan lineColumnTextSpan = sourceCodeFile.GetLineColumnTextSpan(descendant.TextSpan);
List <string> strs;
if (!lineTokenDict.TryGetValue(lineColumnTextSpan.BeginLine, out strs))
{
strs = new List <string>();
lineTokenDict[lineColumnTextSpan.BeginLine] = strs;
}
strs.Add(text);
}
}
}
foreach (var item in lineTokenDict)
{
Console.WriteLine(String.Format("{0}: {1}", item.Key, string.Join(", ", item.Value)));
}
Console.ReadLine();
}
public void Match_TestPatternsAspx_MatchedExpected()
{
var path = Path.Combine(TestHelper.TestsDataPath, "Patterns.aspx");
var sourceCodeRep = new FileCodeRepository(path);
var workflow = new Workflow(sourceCodeRep, Language.CSharp, patternsRepository);
MatchingResultDto[] matchingResults = workflow.Process().MatchingResults.ToDto(workflow.SourceCodeRepository);
Assert.IsTrue(matchingResults[0].MatchedCode.Contains("Password"));
Assert.IsTrue(matchingResults[1].MatchedCode.Contains("try"));
}
public void Match_TestPatternsAspx_MatchedExpected()
{
var path = Path.Combine(TestUtility.TestsDataPath, "Patterns.aspx");
var sourceCodeRep = new FileCodeRepository(path);
var workflow = new Workflow(sourceCodeRep, Global.PatternsRepository);
IEnumerable <MatchResultDto> matchResults = workflow.Process().MatchResults.ToDto();
Assert.IsTrue(matchResults.ElementAt(0).MatchedCode.Contains("Password"));
Assert.IsTrue(matchResults.ElementAt(1).MatchedCode.Contains("Random"));
Assert.IsTrue(matchResults.ElementAt(2).MatchedCode.Contains("try"));
}
public void Match_HardcodedPasswordAspx_WithoutException()
{
var hardcodedPassRepository = new DslPatternRepository("<[(?i)password]> = <[\"\\w*\"]>", LanguageFlags.CSharp);
var sourceCodeRep = new FileCodeRepository(Path.Combine(TestHelper.TestsDataPath, "HardcodedPassword.aspx"));
var workflow = new Workflow(sourceCodeRep, Language.CSharp, hardcodedPassRepository);
MatchingResultDto[] matchingResults = workflow.Process().MatchingResults.ToDto(workflow.SourceCodeRepository);
Assert.IsTrue(matchingResults[0].MatchedCode.Contains("password = \"hardcoded\""));
Assert.IsTrue(matchingResults[1].MatchedCode.Contains("PASSWORD = \"hardcoded\""));
}
public void FileCodeRepository_TestPath_CorrectPathsAndNames()
{
string fullName = Path.Combine(TestUtility.TestsDataPath, "Test Project", "1.cs");
var fileCodeRepository = new FileCodeRepository(fullName);
IEnumerable <string> fileNames = fileCodeRepository.GetFileNames();
CodeFile sourceCode = fileCodeRepository.ReadFile(fileNames.Single());
Assert.AreEqual("1.cs", sourceCode.Name);
Assert.AreEqual("", sourceCode.RelativePath);
Assert.AreEqual(Path.GetDirectoryName(fullName), sourceCode.RootPath);
Assert.AreEqual(fullName, sourceCode.FullName);
}
public void Match_HardcodedPasswordAspx_WithoutException()
{
var hardcodedPassRepository = new DslPatternRepository("<[(?i)password]> = <[\"\\w*\"]>", "CSharp");
var sourceCodeRep = new FileCodeRepository(Path.Combine(TestUtility.TestsDataPath, "HardcodedPassword.aspx"));
var workflow = new Workflow(sourceCodeRep, hardcodedPassRepository);
IEnumerable <MatchResultDto> matchResults = workflow.Process().MatchResults.ToDto();
string match = matchResults.ElementAt(0).MatchedCode;
Assert.IsTrue(match.Contains("password") && match.Contains("hardcoded"));
match = matchResults.ElementAt(1).MatchedCode;
Assert.IsTrue(match.Contains("PASSWORD") && match.Contains("hardcoded"));
}
public void Match_TestPatternsCSharp_MatchedAllDefault()
{
var path = Path.Combine(TestUtility.TestsDataPath, "Patterns.cs");
var sourceCodeRep = new FileCodeRepository(path);
var workflow = new Workflow(sourceCodeRep, Global.PatternsRepository);
IEnumerable <MatchResultDto> matchResults = workflow.Process().MatchResults.ToDto();
var patternDtos = Global.PatternsRepository.GetAll()
.Where(patternDto => patternDto.Languages.Contains("CSharp")).ToArray();
foreach (PatternDto dto in patternDtos)
{
Assert.Greater(matchResults.Count(p => p.PatternKey == dto.Key), 0, dto.Description);
}
}
public void Match_TestPatternsCSharp_MatchedAllDefault()
{
var path = Path.Combine(TestHelper.TestsDataPath, "Patterns.cs");
var sourceCodeRep = new FileCodeRepository(path);
var workflow = new Workflow(sourceCodeRep, Language.CSharp, patternsRepository);
MatchingResultDto[] matchingResults = workflow.Process().MatchingResults.ToDto(workflow.SourceCodeRepository);
var patternDtos = patternsRepository.GetAll()
.Where(patternDto => patternDto.Languages.Is(LanguageFlags.CSharp)).ToArray();
foreach (var dto in patternDtos)
{
Assert.Greater(matchingResults.Count(p => p.PatternKey == dto.Key), 0, dto.Description);
}
}
public void Render_Ust_PngGraph(string fileName)
{
var codeRepository = new FileCodeRepository(Path.Combine(TestHelper.TestsDataPath, fileName));
var language = (Language)LanguageExt.GetLanguageFromFileName(fileName);
var workflow = new Workflow(codeRepository, language);
workflow.Stage = Stage.Convert;
WorkflowResult workflowResult = workflow.Process();
var astSerializer = new UstDotRenderer();
var dotString = astSerializer.Render(workflowResult.Usts.First().Root);
fileName = fileName.Replace(".txt", "") + ".ust";
TestHelper.RenderGraphvizGraph(TestHelper.CombineWithOutputDir(fileName), dotString);
}
public void Match_TestPatternsJava_MatchedAllDefault()
{
var path = Path.Combine(TestUtility.TestsDataPath, "Patterns.java");
var sourceCodeRep = new FileCodeRepository(path);
var workflow = new Workflow(sourceCodeRep, Global.PatternsRepository);
WorkflowResult workflowResult = workflow.Process();
IEnumerable <MatchResultDto> matchResults = workflowResult.MatchResults
.ToDto()
.OrderBy(r => r.PatternKey);
IEnumerable <PatternDto> patternDtos = Global.PatternsRepository.GetAll()
.Where(patternDto => patternDto.Languages.Contains("Java")).ToArray();
foreach (PatternDto dto in patternDtos)
{
Assert.Greater(matchResults.Count(p => p.PatternKey == dto.Key), 0, dto.Description);
}
var improperValidationEmptyMethodPartial = patternDtos.Single(dto => dto.Description.StartsWith("ImproperValidationEmptyMethodPartial"));
Assert.AreEqual(1, matchResults.Count(r => r.PatternKey == improperValidationEmptyMethodPartial.Key));
var improperValidationEmptyMethodFull = patternDtos.Single(dto => dto.Description.StartsWith("ImproperValidationEmptyMethodFull"));
Assert.AreEqual(3, matchResults.Count(r => r.PatternKey == improperValidationEmptyMethodFull.Key));
var missingReceiverPermission = patternDtos.Single(dto => dto.Description.StartsWith("MissingReceiverPermission"));
Assert.AreEqual(1, matchResults.Count(r => r.PatternKey == missingReceiverPermission.Key));
var missingBroadcasterPermission = patternDtos.Single(dto => dto.Description.StartsWith("MissingBroadcasterPermission"));
Assert.AreEqual(1, matchResults.Count(r => r.PatternKey == missingBroadcasterPermission.Key));
var cookieNotSentOverSslDto = patternDtos.Single(dto => dto.Description.StartsWith("CookieNotSentOverSSL"));
var cookieNotSentOverSslResults =
matchResults.Where(r => r.PatternKey == cookieNotSentOverSslDto.Key).ToArray();
Assert.AreEqual(1, cookieNotSentOverSslResults.Count(r => r.MatchedCode.Contains("emailCookieExistsSimple")));
Assert.AreEqual(1, cookieNotSentOverSslResults.Count(r => r.MatchedCode.Contains("emailCookieExistsComplex")));
Assert.AreEqual(1, cookieNotSentOverSslResults.Count(r => r.MatchedCode.Contains("emailCookieExistsAnotherVarName")));
var useOfNullPointerException = patternDtos.Single(dto => dto.Description.StartsWith("Use of NullPointerException"));
Assert.AreEqual(1, matchResults.Count(r => r.PatternKey == useOfNullPointerException.Key));
}
private void Match_TestPatternsSql_MatchedAllDefault(Language language, string patternsFileName)
{
var path = Path.Combine(TestUtility.TestsDataPath, patternsFileName.NormDirSeparator());
var sourceCodeRep = new FileCodeRepository(path);
var workflow = new Workflow(sourceCodeRep, Global.PatternsRepository);
WorkflowResult workflowResult = workflow.Process();
IEnumerable <MatchResultDto> matchResults = workflowResult.MatchResults
.ToDto()
.OrderBy(r => r.PatternKey);
IEnumerable <PatternDto> patternDtos = Global.PatternsRepository.GetAll()
.Where(patternDto => patternDto.Languages.Contains(language.Key));
foreach (var dto in patternDtos)
{
Assert.Greater(matchResults.Count(p => p.PatternKey == dto.Key), 0, dto.Description);
}
}
private void Match_TestPatternsSql_MatchedAllDefault(Language language, string patternsFileName)
{
var path = Path.Combine(TestHelper.TestsDataPath, patternsFileName.NormDirSeparator());
var sourceCodeRep = new FileCodeRepository(path);
var workflow = new Workflow(sourceCodeRep, language, patternsRepository);
WorkflowResult workflowResult = workflow.Process();
MatchingResultDto[] matchingResults = workflowResult.MatchingResults
.ToDto(workflow.SourceCodeRepository)
.OrderBy(r => r.PatternKey).ToArray();
var patternDtos = patternsRepository.GetAll()
.Where(patternDto => patternDto.Languages.Is(language)).ToArray();
foreach (var dto in patternDtos)
{
Assert.Greater(matchingResults.Count(p => p.PatternKey == dto.Key), 0, dto.Description);
}
}
public void Match_TestPatternsPhp_MatchedAllDefault()
{
var path = Path.Combine(TestHelper.TestsDataPath, "Patterns.php");
var sourceCodeRep = new FileCodeRepository(path);
var workflow = new Workflow(sourceCodeRep, Language.Php, patternsRepository);
WorkflowResult workflowResult = workflow.Process();
MatchingResultDto[] matchingResults = workflowResult.MatchingResults
.ToDto(workflow.SourceCodeRepository)
.OrderBy(r => r.PatternKey)
.ToArray();
PatternDto[] patternDtos = patternsRepository.GetAll()
.Where(patternDto => patternDto.Languages.Is(LanguageFlags.Php)).ToArray();
foreach (var dto in patternDtos)
{
Assert.Greater(matchingResults.Count(p => p.PatternKey == dto.Key), 0, dto.Description);
}
Assert.AreEqual(1, matchingResults.Count(r => r.MatchedCode.Contains("Configure::write") && r.MatchedCode.Contains("3")));
Assert.AreEqual(0, matchingResults.Count(r => r.MatchedCode.Contains("Configure::write") && r.MatchedCode.Contains("50")));
}
public void Match_TestPatternsJava_MatchedAllDefault()
{
var path = Path.Combine(TestHelper.TestsDataPath, "Patterns.java");
var sourceCodeRep = new FileCodeRepository(path);
var workflow = new Workflow(sourceCodeRep, Language.Java, patternsRepository);
WorkflowResult workflowResult = workflow.Process();
MatchingResultDto[] matchingResults = workflowResult.MatchingResults.ToDto(workflow.SourceCodeRepository)
.OrderBy(r => r.PatternKey)
.ToArray();
var patternDtos = patternsRepository.GetAll()
.Where(patternDto => patternDto.Languages.Is(LanguageFlags.Java)).ToArray();
foreach (var dto in patternDtos)
{
Assert.Greater(matchingResults.Count(p => p.PatternKey == dto.Key), 0, dto.Description);
}
var missingReceiverPermission = patternDtos.Single(dto => dto.Description.StartsWith("MissingReceiverPermission"));
Assert.AreEqual(1, matchingResults.Count(r => r.PatternKey == missingReceiverPermission.Key));
var missingBroadcasterPermission = patternDtos.Single(dto => dto.Description.StartsWith("MissingBroadcasterPermission"));
Assert.AreEqual(1, matchingResults.Count(r => r.PatternKey == missingBroadcasterPermission.Key));
var cookieNotSentOverSslDto = patternDtos.Single(dto => dto.Description.StartsWith("CookieNotSentOverSSL"));
var cookieNotSentOverSslResults =
matchingResults.Where(r => r.PatternKey == cookieNotSentOverSslDto.Key).ToArray();
Assert.AreEqual(0, cookieNotSentOverSslResults.Count(r => r.MatchedCode.Contains("emailCookieNotExistsSimple")));
Assert.AreEqual(0, cookieNotSentOverSslResults.Count(r => r.MatchedCode.Contains("emailCookieNotExistsComplex")));
Assert.AreEqual(1, cookieNotSentOverSslResults.Count(r => r.MatchedCode.Contains("emailCookieExistsTwoPatterns1")));
Assert.AreEqual(1, cookieNotSentOverSslResults.Count(r => r.MatchedCode.Contains("emailCookieExistsSimple")));
Assert.AreEqual(1, cookieNotSentOverSslResults.Count(r => r.MatchedCode.Contains("emailCookieExistsComplex")));
Assert.AreEqual(1, cookieNotSentOverSslResults.Count(r => r.MatchedCode.Contains("emailCookieExistsAnotherVarName")));
}
private static void CheckJsonSerialization(string inputFileName, bool linearTextSpans = false,
bool includeTextSpans = true, bool indented = true, bool includeCode = false,
bool checkStrict = false, bool strict = true, bool checkPatternSerialization = false)
{
string path = Path.Combine(TestUtility.TestsDataPath, inputFileName);
// Serialization
string[] files = File.Exists(path)
? new string[] { path }
: Directory.GetFiles(path);
var codeRepository = new FileCodeRepository(files);
var workflow = new Workflow(codeRepository)
{
DumpStages = new HashSet <Stage>()
{
Stage.Ust
},
DumpDir = TestUtility.TestsOutputPath,
IncludeCodeInDump = includeCode,
IndentedDump = indented,
StrictJson = strict,
DumpWithTextSpans = includeTextSpans,
LineColumnTextSpans = !linearTextSpans,
Stage = Stage.Ust,
IsDumpPatterns = checkPatternSerialization
};
WorkflowResult result = workflow.Process();
CodeFile preprocessedFile = result.SourceCodeFiles.FirstOrDefault(f => f.Name == "preprocessed.php");
CodeFile originFile = result.SourceCodeFiles.FirstOrDefault(f => f.Name == "origin.php");
LineColumnTextSpan lcPreprocessedTextSpan = new LineColumnTextSpan(4, 1, 4, 3);
LineColumnTextSpan lcOriginTextSpan = new LineColumnTextSpan(3, 1, 3, 3, originFile);
var jsonFiles = new List <string>();
foreach (string file in files)
{
string shortFileName = Path.GetFileName(file) + ".ust.json";
string jsonFile = Path.Combine(TestUtility.TestsOutputPath, shortFileName);
if (file.Contains("preprocessed.php") || checkStrict)
{
string json = File.ReadAllText(jsonFile);
if (file.Contains("preprocessed.php"))
{
string preprocessedTextSpanString, originTextSpanString;
if (linearTextSpans)
{
preprocessedTextSpanString = preprocessedFile.GetTextSpan(lcPreprocessedTextSpan).ToString();
originTextSpanString = originFile.GetTextSpan(lcOriginTextSpan).ToString();
}
else
{
preprocessedTextSpanString = lcPreprocessedTextSpan.ToString();
originTextSpanString = lcOriginTextSpan.ToString();
}
json = json.Replace($"\"{preprocessedTextSpanString}\"", $"[ \"{lcPreprocessedTextSpan}\", \"{originTextSpanString}\" ]");
}
if (checkStrict)
{
json = json.Replace("\"Kind\": \"IntLiteral\"", "\"Kind\": \"IntLiteral\", \"ExcessProperty\": \"value\"");
}
File.WriteAllText(jsonFile, json);
}
jsonFiles.Add(jsonFile);
}
// Deserialization
var logger = new LoggerMessageCounter();
var newCodeRepository = new FileCodeRepository(jsonFiles)
{
LoadJson = true
};
var newPatternsRepository = checkPatternSerialization
? new JsonPatternsRepository(File.ReadAllText(Path.Combine(TestUtility.TestsOutputPath, "patterns.json")))
: inputFileName == "MultiTextSpan"
? (IPatternsRepository) new DslPatternRepository("a", "php")
: new DefaultPatternRepository();
var newWorkflow = new Workflow(newCodeRepository, newPatternsRepository)
{
StartStage = Stage.Ust,
IndentedDump = indented,
StrictJson = strict,
DumpWithTextSpans = includeTextSpans,
LineColumnTextSpans = !linearTextSpans,
Logger = logger,
};
WorkflowResult newResult = newWorkflow.Process();
if (checkStrict && strict)
{
Assert.IsTrue(logger.ErrorsString.Contains("ExcessProperty"));
}
else
{
Assert.AreEqual(0, logger.ErrorCount, logger.ErrorsString);
Assert.GreaterOrEqual(newResult.MatchResults.Count, 1);
if (includeTextSpans)
{
if (inputFileName == "MultiTextSpan")
{
var matchResult = (MatchResult)newResult.MatchResults[1];
Assert.AreEqual(2, matchResult.TextSpans.Length);
LineColumnTextSpan actualOriginTextSpan = originFile.GetLineColumnTextSpan(matchResult.TextSpans[1]);
Assert.AreEqual(lcOriginTextSpan, actualOriginTextSpan);
LineColumnTextSpan actualPreprocessedTextSpan = preprocessedFile.GetLineColumnTextSpan(matchResult.TextSpans[0]);
Assert.AreEqual(lcPreprocessedTextSpan, actualPreprocessedTextSpan);
}
else
{
var match = (MatchResult)newResult.MatchResults.FirstOrDefault();
Assert.AreEqual(new LineColumnTextSpan(2, 1, 3, 25), result.SourceCodeFiles.First().GetLineColumnTextSpan(match.TextSpan));
}
}
}
}
static void Main(string[] args)
{
Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
var parser = new FluentCommandLineParser();
string fileName = "";
string escapedPatterns = "";
int threadCount = 1;
string languagesString = "";
Stage stage = Stage.Match;
int maxStackSize = 0;
int maxTimespan = 0;
int memoryConsumptionMb = 300;
string logsDir = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "PT.PM", "Logs");
bool logErrors = false;
bool logDebugs = false;
bool showVersion = true;
bool isDumpUst = false;
bool isIndentedUst = false;
bool isIncludeTextSpansInUst = true;
bool isPreprocess = true;
parser.Setup <string>('f', "files").Callback(f => fileName = f.NormDirSeparator());
parser.Setup <string>('l', "languages").Callback(l => languagesString = l);
parser.Setup <string>('p', "patterns").Callback(p =>
escapedPatterns = p.EndsWith(".json", StringComparison.OrdinalIgnoreCase)
? p.NormDirSeparator()
: p.Replace('\\', '/')
);
parser.Setup <int>('t', "threads").Callback(t => threadCount = t);
parser.Setup <Stage>('s', "stage").Callback(s => stage = s);
parser.Setup <int>("max-stack-size").Callback(mss => maxStackSize = mss);
parser.Setup <int>("max-timespan").Callback(mt => maxTimespan = mt);
parser.Setup <int>('m', "memory").Callback(m => memoryConsumptionMb = m);
parser.Setup <string>("logs-dir").Callback(lp => logsDir = lp.NormDirSeparator());
parser.Setup <bool>("log-errors").Callback(le => logErrors = le);
parser.Setup <bool>("log-debugs").Callback(ld => logDebugs = ld);
parser.Setup <bool>('v', "version").Callback(v => showVersion = v);
parser.Setup <bool>("dump-ust").Callback(param => isDumpUst = param);
parser.Setup <bool>("indented-ust").Callback(param => isIndentedUst = param);
parser.Setup <bool>("text-spans-ust").Callback(param => isIncludeTextSpansInUst = param);
parser.Setup <bool>("preprocess-ust").Callback(param => isPreprocess = param);
ILogger logger = new ConsoleLogger();
string commandLineArguments = "Command line arguments" + (args.Length > 0
? ": " + string.Join(" ", args)
: " are not defined.");
var version = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.ToString();
var argsWithUsualSlashes = args.Select(arg => arg.Replace('/', '\\')).ToArray(); // TODO: bug in FluentCommandLineParser.
var parsingResult = parser.Parse(argsWithUsualSlashes);
if (!parsingResult.HasErrors)
{
if (isDumpUst)
{
stage = Stage.Convert;
logger = new DummyLogger();
}
try
{
if (showVersion)
{
logger.LogInfo($"PT.PM version: {version}");
}
var abstractLogger = logger as AbstractLogger;
if (abstractLogger != null)
{
abstractLogger.LogsDir = logsDir;
abstractLogger.IsLogErrors = logErrors;
abstractLogger.IsLogDebugs = logDebugs;
abstractLogger.LogInfo(commandLineArguments);
}
if (string.IsNullOrEmpty(fileName) && string.IsNullOrEmpty(escapedPatterns))
{
throw new ArgumentException("at least --files or --patterns parameter required");
}
if (string.IsNullOrEmpty(fileName))
{
stage = Stage.Patterns;
}
LanguageFlags languages = LanguageExt.ParseLanguages(languagesString);
ISourceCodeRepository sourceCodeRepository;
if (Directory.Exists(fileName))
{
sourceCodeRepository = new FilesAggregatorCodeRepository(fileName, LanguageExt.GetExtensions(languages));
}
else
{
sourceCodeRepository = new FileCodeRepository(fileName);
}
logger.SourceCodeRepository = sourceCodeRepository;
IPatternsRepository patternsRepository;
if (string.IsNullOrEmpty(escapedPatterns))
{
patternsRepository = new DefaultPatternRepository();
}
else if (escapedPatterns.EndsWith(".json"))
{
patternsRepository = new FilePatternsRepository(escapedPatterns);
}
else
{
var patterns = StringCompressorEscaper.UnescapeDecompress(escapedPatterns);
patternsRepository = new JsonPatternsRepository(patterns);
}
var workflow = new Workflow(sourceCodeRepository, languages, patternsRepository, stage)
{
Logger = logger,
ThreadCount = threadCount,
MaxStackSize = maxStackSize,
MaxTimespan = maxTimespan,
MemoryConsumptionMb = memoryConsumptionMb,
IsIncludePreprocessing = isPreprocess
};
var stopwatch = Stopwatch.StartNew();
WorkflowResult workflowResult = workflow.Process();
stopwatch.Stop();
if (isDumpUst)
{
DumpUst(isIndentedUst, isIncludeTextSpansInUst, workflowResult);
}
if (stage != Stage.Patterns)
{
logger.LogInfo("Scan completed.");
if (stage == Stage.Match)
{
logger.LogInfo($"{"Matches count: ",-22} {workflowResult.MatchingResults.Count()}");
}
}
else
{
logger.LogInfo("Patterns checked.");
}
logger.LogInfo($"{"Errors count: ",-22} {workflowResult.ErrorCount}");
var workflowLoggerHelper = new WorkflowLoggerHelper(logger, workflowResult);
workflowLoggerHelper.LogStatistics();
logger.LogInfo($"{"Time elapsed:",-22} {stopwatch.Elapsed}");
}
catch (Exception ex)
{
if (logger != null)
{
var abstractLogger = logger as AbstractLogger;
if (abstractLogger != null)
{
abstractLogger.IsLogErrors = true;
}
logger.LogError(ex);
}
}
finally
{
var disposableLogger = logger as IDisposable;
if (disposableLogger != null)
{
disposableLogger.Dispose();
}
}
}
else
{
Console.WriteLine($"PT.PM version: {version}");
Console.WriteLine(commandLineArguments);
Console.WriteLine("Command line arguments processing error: " + parsingResult.ErrorText);
}
}
