public void Run()
{
var codeBase = ProjectAnalysisUtils.ChooseAnalysisResult().CodeBase;
var types = codeBase.Application.Types;
var matchEditor = new MatchEditor();
var resultDisplayer = new ResultDisplayer();
var resultSelector = new ResultSelector(resultDisplayer);
matchEditor.Display();
while (true)
{
ConsoleKeyInfo consoleKeyInfo;
bool matchersChanged;
matchEditor.ReadKey(out consoleKeyInfo, out matchersChanged);
if (!matchersChanged)
{
switch (consoleKeyInfo.Key)
{
case ConsoleKey.Escape:
return;
case ConsoleKey.UpArrow:
resultSelector.UpArrow();
continue;
case ConsoleKey.DownArrow:
resultSelector.DownArrow();
continue;
case ConsoleKey.Enter:
resultSelector.Enter();
continue;
}
continue;
}
var matchersLowerCase = matchEditor.GetMatchersLowerCase();
var typesMatched = SearchTypes(types, matchersLowerCase);
resultDisplayer.Display(typesMatched, matchersLowerCase);
}
}
//
// A bit of code to test if DebuggerDisplay works well
//
internal static void Go()
{
// DebuggerDisplay of IAnalysisResult
var analysisResult = ProjectAnalysisUtils.ChooseAnalysisResult();
// DebuggerDisplay of IAnalysisResultRef
var analysisResultRef = analysisResult.AnalysisResultRef;
// DebuggerDisplay of IProject
var project = analysisResultRef.Project;
// DebuggerDisplay of IQuery
var query = project.CodeQueries.CodeQueriesSet.AllQueriesRecursive.First();
// DebuggerDisplay of ICodeBase
var codeBase = analysisResult.CodeBase;
// DebuggerDisplay of IAssembly
var assembly = codeBase.Projects.First();
// DebuggerDisplay of INamespace
var @namespace = codeBase.Namespaces.First();
// DebuggerDisplay of IType
var type = codeBase.Types.First();
// DebuggerDisplay of IField
var field = codeBase.Fields.First();
// DebuggerDisplay of IMethod
var method = codeBase.Methods.First();
// DebuggerDisplay of ISourceFileLine
var sourceFileLine = method.SourceDecls.First();
// DebuggerDisplay of ISourceFile
var sourceFile = sourceFileLine.SourceFile;
// DebuggerDisplay of IQueryCompiledError
var queryCompiledError = "query not compilable".Compile(codeBase).QueryCompiledError;
// DebuggerDisplay of IQueryCompilationError
var queryCompilationError = queryCompiledError.Errors.First();
}
public void Run()
{
var analysisResult = ProjectAnalysisUtils.ChooseAnalysisResult();
var codeBase = analysisResult.CodeBase;
Console.CursorVisible = false;
if (codeBase.NbLinesOfCode > 5000 * 1000)
{
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine(" *** The search for duplicate can take a few seconds to a few minutes for large application *** ");
Console.ForegroundColor = ConsoleColor.White;
}
var stopwatch = new Stopwatch();
stopwatch.Start();
//
// 1) Find pairs of methods that call N or more same methods/fields.
//
Console.WriteLine("1) Find pairs of methods that call N or more same methods/fields.");
var suspectSetsWith2Callers = SuspectSetsWith2CallersComputer.Go(codeBase, N);
//
// 2) Merge suspectSets with 2 methods callers methods into some suspectSets with 2 or more methods callers.
//
Console.WriteLine("2) Merge suspectSets with 2 methods callers methods into some suspectSets with 2 or more methods callers.");
var suspectSetsMerged = SuspectSetsMerger.Go(suspectSetsWith2Callers, N);
//
// 3) Sort suspectSets, to try showing most suspect ones first.
//
Console.WriteLine("3) Sort suspectSets, to try showing most suspect ones first.");
SuspectSetsSorter.Go(suspectSetsMerged);
Console.WriteLine("Search for duplicate duration:" + stopwatch.Elapsed.ToString());
//
// 4) Show results!
//
ShowSuspectSet(suspectSetsMerged);
}
public void Run()
{
var analysisResult = ProjectAnalysisUtils.ChooseAnalysisResult();
var project = analysisResult.AnalysisResultRef.Project;
CreateBackupProjectFile(project);
//
// Convert all CQL queries compiled successfully!
//
var queriesSet = project.CodeQueries.CodeQueriesSet;
var queriesController = queriesSet.Controller;
var allQueries = queriesSet.AllQueriesRecursive;
var allQueriesString = allQueries.Select(q => q.QueryString).ToArray();
var allQueriesCompiled = allQueriesString.CompileMany(analysisResult.CodeBase);
// Do the conversion and build an association dictionary, CQL to CQLinq queryString
var dicoCQLToCQLinq = new Dictionary <string, string>();
foreach (var queryCompiled in allQueriesCompiled)
{
if (queryCompiled.HasErrors)
{
continue;
}
if (queryCompiled.KindOfCodeQuerySyntax != KindOfCodeQuerySyntax.CQL)
{
continue;
}
if (dicoCQLToCQLinq.ContainsKey(queryCompiled.OriginalQueryString))
{
continue;
}
var queryCompiledSuccess = queryCompiled.QueryCompiledSuccess;
Debug.Assert(queryCompiledSuccess != null);
var cqlinqQueryString = queryCompiledSuccess.ConvertToCQLinq(); // <-- The conversion is performed here!
dicoCQLToCQLinq.Add(queryCompiledSuccess.OriginalQueryString, cqlinqQueryString);
}
// Update CQL queries converted to CQLinq
int nbQueriesConverted = 0;
foreach (var query in allQueries)
{
var queryString = query.QueryString;
string cqlinqQueryString;
if (!dicoCQLToCQLinq.TryGetValue(queryString, out cqlinqQueryString))
{
continue;
}
var newQuery = queriesController.CreateQuery(
query.IsActive,
cqlinqQueryString,
query.DisplayStatInReport,
query.DisplayListInReport,
query.DisplaySelectionViewInReport,
query.IsCriticalRule);
nbQueriesConverted++;
queriesController.DoUpdateQueryObject(query, newQuery);
}
// Updating queries objects in queriesSet, made it so that the queriesSet parent object has been updated as well.
var groupToSave = queriesController.RootParent.ChildGroups.Single();
// This call provokes saving queries in project file
project.CodeQueries.CodeQueriesSet = groupToSave;
Console.WriteLine(nbQueriesConverted + " queries converted!");
}
public void Run()
{
var analysisResult = ProjectAnalysisUtils.ChooseAnalysisResult();
var codeBase = analysisResult.CodeBase;
Func <string, IQueryCompiled> compileQueryProc = queryString => queryString.Compile(codeBase);
// ... but if we can get a compareContext, then compile and execute the query against the compareContext
ICompareContext compareContext;
if (ProjectAnalysisUtils.TryGetCompareContextDefinedByBaseline(analysisResult, out compareContext))
{
Debug.Assert(compareContext != null);
compileQueryProc = queryString => queryString.Compile(compareContext);
}
//
// Fill queriesPreviouslyEdited with current project queries
//
IPreviousNextStack <string> queriesPreviouslyEdited = new PreviousNextStack <string>(
analysisResult.AnalysisResultRef.Project.CodeQueries.CodeQueriesSet.AllQueriesRecursive.Reverse().Select(q => q.QueryString),
"",
(s1, s2) => s1 == s2);
// With this line, make sure to begin with the first queries of the project.
queriesPreviouslyEdited.GetPrevious();
//
// Loop for each query edition
//
while (true)
{
IQueryCompiled queryCompiled;
using (var queryEditSession = new QueryEditSession(queriesPreviouslyEdited)) {
var queryString = queryEditSession.GetQueryString();
COMPILE_QUERY:
Console.BackgroundColor = ConsoleColor.Black;
Console.ForegroundColor = ConsoleColor.White;
if (queryString == null)
{
break;
}
// Try compile query
queryCompiled = compileQueryProc(queryString);
var queryCompiledError = queryCompiled.QueryCompiledError;
if (queryCompiledError != null)
{
queryString = queryEditSession.ShowCompilatioErrorsAndThenGetQueryString(queryCompiledError);
goto COMPILE_QUERY;
}
}
// Execute query compiled
var queryCompiledSuccess = queryCompiled.QueryCompiledSuccess;
Debug.Assert(queryCompiledSuccess != null);
var result = queryCompiledSuccess.Execute();
if (result.Status != QueryExecutionStatus.Success)
{
var exception = result.Exception;
// The error must be an Exception thrown by the query, since we don't use the Execute(...) overload with time-out!
Debug.Assert(exception != null);
DisplayQueryThrowAnException(exception);
continue;
}
QueryExecutionResultDisplayer.Go(result.SuccessResult);
Console.WriteLine();
}
}
public void Run()
{
var analysisResult = ProjectAnalysisUtils.ChooseAnalysisResult();
var codeBase = analysisResult.CodeBase;
//
// Get weight for each identifier
//
var identifierWeights = codeBase.Projects.Select(IdentifierWeightComputer.GetWeigth).ToList();
identifierWeights.AddRange(codeBase.Namespaces.Select(IdentifierWeightComputer.GetWeigth).ToList());
identifierWeights.AddRange(codeBase.Types.Select(IdentifierWeightComputer.GetWeigth).ToList());
identifierWeights.AddRange(codeBase.Methods.Select(IdentifierWeightComputer.GetWeigth).ToList());
identifierWeights.AddRange(codeBase.Fields.Select(IdentifierWeightComputer.GetWeigth).ToList());
//
// Extract words and their weight from identifier
//
var dico = new Dictionary <string, float>();
foreach (var identifierWeight in identifierWeights)
{
if (identifierWeight == null)
{
continue;
}
var weightNullable = identifierWeight.Weight;
if (weightNullable == null || weightNullable == 0)
{
continue;
}
var weight = weightNullable.Value;
var words = WordExtracter.ExtractWordsFromIdentifier(identifierWeight.Identifier);
foreach (var word in words)
{
if (!dico.ContainsKey(word))
{
dico.Add(word, weight);
continue;
}
dico[word] += weight;
}
}
//
// Sort weigh descendant
//
var wordWeights = dico.Select(pair => new IdentifierWeight(pair.Key, pair.Value)).ToList();
wordWeights.Sort((w1, w2) => w1.Weight <w2.Weight ? 1 : w1.Weight> w2.Weight ? -1 : 0);
//
// show result
//
var listOfLines = (from wordWeight in wordWeights
let identifier = wordWeight.Identifier
select identifier + (identifier.Length < 30 ? new string(' ', 30 - identifier.Length) : " ") + "Weight: " + wordWeight.Weight).ToList();
ShowConsoleListOfLines(listOfLines);
}
public void Run()
{
var codeBase = ProjectAnalysisUtils.ChooseAnalysisResult().CodeBase;
// make usage of the default NDepend attribute: CppDepend.Attributes.IsNotDeadCodeAttribute
var isNotDeadCodeAttribute = codeBase.Types.WithFullName("CppDepend.Attributes.IsNotDeadCodeAttribute").SingleOrDefault();
//
// Apply dead code algo!
//
var deadTypesMetric = DeadCodeAlgo.FindDeadTypes(codeBase);
var deadMethodsMetric = DeadCodeAlgo.FindDeadMethods(codeBase);
var deadFields = DeadCodeAlgo.FindDeadFields(codeBase);
var deadCodeRecords = new List <DeadCodeRecord>();
deadCodeRecords.Add(new DeadCodeRecord(" unused types", deadTypesMetric.Where(v => v.Value == 0).Select(v => v.CodeElement).Cast <IMember>().ToArray()));
deadCodeRecords.Add(new DeadCodeRecord(" types used only by unused types", deadTypesMetric.Where(v => v.Value > 0).Select(v => v.CodeElement).Cast <IMember>().ToArray()));
deadCodeRecords.Add(new DeadCodeRecord(" unused methods", deadMethodsMetric.Where(v => v.Value == 0).Select(v => v.CodeElement).Cast <IMember>().ToArray()));
deadCodeRecords.Add(new DeadCodeRecord(" methods used only by unused methods", deadMethodsMetric.Where(v => v.Value > 0).Select(v => v.CodeElement).Cast <IMember>().ToArray()));
deadCodeRecords.Add(new DeadCodeRecord(" unused fields", deadFields.Cast <IMember>().ToArray()));
//
// No dead code found!
//
var deadCodeFound = deadCodeRecords.Where(record => record.m_Members.Count() > 0).Count() > 0;
if (!deadCodeFound)
{
Console.ForegroundColor = COLOR_NO_WARNING;
Console.WriteLine("No dead code found!");
return;
}
//
// Show dead code
//
while (true)
{
ConsoleUtils.ShowNLinesOnConsole(3, ConsoleColor.Black);
if (deadCodeRecords.Where(record => record.m_Members.Count() > 0).Count() == 0)
{
Console.ForegroundColor = COLOR_NO_WARNING;
Console.WriteLine("No dead code found!");
}
else
{
Console.ForegroundColor = COLOR_WARNING;
Console.WriteLine("Dead code found! (in Yellow)");
}
//
// Show dead code menu
//
var aCharNumber = Convert.ToInt16('a');
for (var i = 0; i <= deadCodeRecords.Count; i++)
{
var description = "Exit";
if (i != deadCodeRecords.Count)
{
var record = deadCodeRecords[i];
Console.ForegroundColor = record.m_Members.Count() == 0 ? COLOR_NO_WARNING : COLOR_WARNING;
description = record.m_Members.Count() + record.m_Description;
}
Console.WriteLine(" " + Convert.ToChar(aCharNumber + i) + ") " + description);
}
Console.ForegroundColor = COLOR_DEFAULT;
//
// Get user choice
//
int deadCodeIndex;
while (true)
{
Console.Write("Enter key:");
var keyChar = Char.ToLower(Console.ReadKey().KeyChar);
Console.WriteLine("");
deadCodeIndex = Convert.ToInt16(keyChar) - aCharNumber;
if (deadCodeIndex < 0 || deadCodeIndex > deadCodeRecords.Count)
{
Console.Write(keyChar + " is not a valid key!");
continue;
}
break;
}
if (deadCodeIndex == deadCodeRecords.Count)
{
break;
}
var recordTmp = deadCodeRecords[deadCodeIndex];
//
// Show dead members
//
var membersDisplayer = new MembersDisplayer(recordTmp.m_Members.ToList());
membersDisplayer.Display();
}
}