public void Run() { var projectManager = new NDependServicesProvider().ProjectManager; var dotNetManager = new NDependServicesProvider().DotNetManager; // Gather most recent .NET Fx + directories containing assemblies var mostRecentVersion = dotNetManager.GetDotNetProfileVersionsInstalled(DotNetProfile.DotNetFramework).First(); var dirs = dotNetManager.GetDotNetProfileDirectories(DotNetProfile.DotNetFramework, mostRecentVersion); Console.WriteLine(".NET Fx v" + mostRecentVersion + " directories that contains assemblies to analyze:"); foreach (var dir in dirs) { Console.WriteLine(" -> " + dir.ToString()); } // Gather all .NET Fx assembly var dotNetFxAssemblies = (from dir in dirs from file in dir.ChildrenFilesPath where dotNetManager.IsAssembly(file) select file).ToList(); Console.WriteLine(dotNetFxAssemblies.Count + " .NET Fx assemblies found"); // Create temporary NDepend project and analyze it var project = projectManager.CreateTemporaryProject(dotNetFxAssemblies, TemporaryProjectMode.Temporary); var analysisResult = ProjectAnalysisUtils.RunAnalysisShowProgressOnConsole(project); // Show results ProjectAnalysisUtils.ShowConsoleAnalysisResult(analysisResult.CodeBase); Console.WriteLine("The .NET Fx analysis result produced can now be consummed live from the NDepend project named \"" + project.Properties.Name + "\""); }
public void Run() { var projectManager = new NDependServicesProvider().ProjectManager; IProject project; if (!projectManager.ShowDialogChooseAnExistingProject(ConsoleUtils.MainWindowHandle, out project)) { return; } Debug.Assert(project != null); var analysisResult = ProjectAnalysisUtils.RunAnalysisShowProgressOnConsole(project); Console.WriteLine("Begin Compute and Store Trend Metrics Values"); // LogTrendMetrics() is an extension method declared by NDepend.Analysis.ExtensionMethodsProjectAnalysis // Two overloads are available: // void LogTrendMetrics(this IAnalysisResult analysisResult, DateTime logDateTime) // void LogTrendMetrics(this IAnalysisResult analysisResult, ICompareContext compareContext, DateTime logDateTime) analysisResult.LogTrendMetrics(DateTime.Now); // <- Here any past or future date can be used! Console.WriteLine("End Compute and Store Trend Metrics Values"); // // Also, from trendStore, any metric value can be persisted, with any date. // //var trendStore = project.Trend.TrendStoreDirectory.GetTrendStoreFromDirectory(); //trendStore.SaveMetricValues(DateTime.Now, new [] { // new MetricValue(new Metric("Metric1", "Unit1"), 1.0f), // new MetricValue(new Metric("Metric2", "Unit2"), 2.0f), //}); // // The method RemoveMetricValues() can also be used to remove all metric values logged at a certain date. // The date equality is defined by the same dated second, no matter the number of miliseconds. //trendStore.RemoveMetricValues(DateTime.Now); }
public void Run() { ICompareContext compareContext; if (!ProjectAnalysisUtils.TryGetAssembliesToCompareAndAnalyzeThem(out compareContext)) { return; } Debug.Assert(compareContext != null); APIChangesDisplayer.Go(compareContext); }
public void Run() { IAnalysisResult analysisResult; if (!ProjectAnalysisUtils.TryChooseAnalysisResult(out analysisResult)) { return; } Debug.Assert(analysisResult != null); var codeBase = analysisResult.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 IAnalysisResult analysisResult; if (!ProjectAnalysisUtils.TryChooseAnalysisResult(out analysisResult)) { return; } Debug.Assert(analysisResult != null); // 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.Assemblies.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.Where(m => m.SourceFileDeclAvailable).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 projectManager = new NDependServicesProvider().ProjectManager; var visualStudioManager = new NDependServicesProvider().VisualStudioManager; // // Gather all Most Recent Used VS solutions and projects file path referenced in registry // var vsFilesPath = new List <IAbsoluteFilePath>(); foreach (var vsVersion in new[] { VisualStudioVersion.V7_2003, VisualStudioVersion.V8_2005, VisualStudioVersion.V9_2008, VisualStudioVersion.V10_2010 }) { if (!visualStudioManager.IsVisualStudioVersionIntalled(vsVersion)) { continue; } vsFilesPath.AddRange(visualStudioManager.GetMostRecentlyUsedVisualStudioSolutionOrProject(vsVersion)); } Console.WriteLine(vsFilesPath.Count + " VS sln or proj files found"); // // Gather all Debug projects built from these VS solutions and projects // var projectsPath = new List <IAbsoluteFilePath>(); foreach (var vsFilePath in vsFilesPath) { projectsPath.Add(vsFilePath); } // // Create temporary project // var project = projectManager.CreateTemporaryProject(projectsPath, TemporaryProjectMode.Temporary); // // Run analysis // var analysisResult = ProjectAnalysisUtils.RunAnalysisShowProgressOnConsole(project); // // Show results // ProjectAnalysisUtils.ShowConsoleAnalysisResult(analysisResult.CodeBase); Console.WriteLine("The analysis result produced can now be consummed from the CppDepend project \"" + project.Properties.Name + "\""); }
public void Run() { var compareContext = ProjectAnalysisUtils.GetProjectsToCompareAndAnalyzeThem(); var methodsChanged = compareContext.NewerCodeBase.Methods.Where(compareContext.CodeWasChanged).Cast <IMember>().ToArray(); Console.WriteLine(); Console.ForegroundColor = ConsoleColor.Green; Console.WriteLine(methodsChanged.Length + " method" + (methodsChanged.Length > 1 ? "s" : "") + " where code has been changed"); Console.WriteLine(); var methodsChangedDisplayer = new MethodsChangedDisplayer(methodsChanged, compareContext); methodsChangedDisplayer.Display(); }
private static ICodeBase DoAnalysisGetCodeBase( Version version, ICollection <IAbsoluteFilePath> assembliesPaths, TemporaryProjectMode temporaryProjectMode, IProjectManager projectManager) { Debug.Assert(version != null); Debug.Assert(assembliesPaths != null); Debug.Assert(projectManager != null); Console.WriteLine("Analyze .NET fx v" + version.ToString() + " core assemblies"); var project = projectManager.CreateTemporaryProject(assembliesPaths, temporaryProjectMode); var analysisResult = ProjectAnalysisUtils.RunAnalysisShowProgressOnConsole(project); return(analysisResult.CodeBase); }
public void Run() { IAnalysisResult analysisResult; if (!ProjectAnalysisUtils.TryChooseAnalysisResult(out analysisResult)) { return; } Debug.Assert(analysisResult != null); var codeBase = analysisResult.CodeBase; Console.CursorVisible = false; if (codeBase.NbILInstructions > 500 * 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() { ICompareContext compareContext; if (!ProjectAnalysisUtils.TryGetAssembliesToCompareAndAnalyzeThem(out compareContext)) { return; } Debug.Assert(compareContext != null); var methodsChanged = compareContext.NewerCodeBase.Methods.Where(compareContext.CodeWasChanged).Cast <IMember>().ToArray(); Console.WriteLine(); Console.ForegroundColor = ConsoleColor.Green; Console.WriteLine(methodsChanged.Length + " method" + (methodsChanged.Length > 1 ? "s" : "") + " where code has been changed"); Console.WriteLine(); var methodsChangedDisplayer = new MethodsChangedDisplayer(methodsChanged, compareContext); methodsChangedDisplayer.Display(); }
public void Run() { var projectManager = new NDependServicesProvider().ProjectManager; IProject project; if (!projectManager.ShowDialogChooseAnExistingProject(ConsoleUtils.MainWindowHandle, out project)) { return; } // Fetch analysis results reference for the choosen project var analysisResultRefs = project.GetAvailableAnalysisResultsRefs(); // Need at least 2 analysis results if (analysisResultRefs.Count < 2) { Console.BackgroundColor = ConsoleColor.Black; Console.ForegroundColor = ConsoleColor.Yellow; Console.WriteLine("Cannot find at least 2 historic analysis results for the project {" + project.Properties.Name + "}"); return; } bool showAll = false; Console.BackgroundColor = ConsoleColor.Black; Console.ForegroundColor = ConsoleColor.White; // Sort by analysis date ascending analysisResultRefs = analysisResultRefs.OrderBy(analysisResultRef => analysisResultRef.Date).ToReadOnlyClonedList(); // TODO --> use .NET 4 System.Windows.Forms.DataVisualization.dll (if available), to plot chart?? // // For each analysisResultRef found for this project // foreach (var analysisResultRef in analysisResultRefs) { var analysisResult = ProjectAnalysisUtils.LoadAnalysisShowProgressOnConsole(analysisResultRef); Console.WriteLine(); Console.WriteLine("Analysis result produced on " + analysisResultRef.Date); // // -->If you wish to follow the evolution of a particular code element (a type for example) // just retrieve the IType in each code base by type.FullName // var type = codeBase.Types.WithFullName("Namespace.TypeName"). // // You can also build a ICompareContext for each 2 consecutive analysis result loaded. // analysisResultNext.CodeBase.CreateCompareContextWithOlder(analysisResultPrevious.CodeBase) // and use the methods // ICompareContext.OlderVersion(ICodeElement):ICodeElement // ICompareContext.NewerVersion(ICodeElement):ICodeElement // to retrieve the newer versions of the particular code element, from its older version. ProjectAnalysisUtils.ShowConsoleAnalysisResult(analysisResult.CodeBase); // Ask all/next/quit? if (showAll) { continue; } switch (ConsoleUtils.ConsoleAskShowNextAllStop()) { case AllNextQuit.Next: continue; case AllNextQuit.All: showAll = true; continue; default: // Quit return; } } }
public void Run() { IAnalysisResult analysisResult; if (!ProjectAnalysisUtils.TryChooseAnalysisResult(out analysisResult)) { return; } Debug.Assert(analysisResult != null); var codeBase = analysisResult.CodeBase; // make usage of the default NDepend attribute: NDepend.Attributes.IsNotDeadCodeAttribute var isNotDeadCodeAttribute = codeBase.Types.WithFullName("NDepend.Attributes.IsNotDeadCodeAttribute").SingleOrDefault(); var funcHasAttribute = new Func <IMember, bool>(member => (isNotDeadCodeAttribute != null && member.HasAttribute(isNotDeadCodeAttribute)) ); // // Apply dead code algo! // var deadTypesMetric = DeadCodeAlgo.FindDeadTypes(codeBase, funcHasAttribute); var deadMethodsMetric = DeadCodeAlgo.FindDeadMethods(codeBase, funcHasAttribute); var deadFields = DeadCodeAlgo.FindDeadFields(codeBase, funcHasAttribute); 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(); } }
public void Run() { // // Get dir // var folderBrowserDialog = new FolderBrowserDialog { ShowNewFolderButton = false }; if (folderBrowserDialog.ShowDialog() != DialogResult.OK) { return; } var dir = folderBrowserDialog.SelectedPath.ToAbsoluteDirectoryPath(); // // Get recursive // bool recursive = false; Console.BackgroundColor = ConsoleColor.Black; Console.ForegroundColor = ConsoleColor.Yellow; Console.WriteLine("Search assemblies recursive under {" + dir.ToString() + "} ?"); Console.WriteLine("Yes? y or No? (another key)"); var consoleKeyInfo = Console.ReadKey(); if (consoleKeyInfo.KeyChar == 'y') { recursive = true; } Console.ForegroundColor = ConsoleColor.White; // // Get assembliesPath // var dotNetManager = new NDependServicesProvider().DotNetManager; var assembliesPath = new List <IAbsoluteFilePath>(); var cursorTop = Console.CursorTop; if (!recursive) { ScanDir(dir, assembliesPath, dotNetManager, cursorTop); } else { ScanDirRecursive(dir, assembliesPath, dotNetManager, Console.CursorTop); } Console.CursorTop = cursorTop; Console.CursorLeft = 0; ConsoleUtils.ShowNLinesOnConsole(10, ConsoleColor.Black); Console.CursorTop = cursorTop; Console.CursorLeft = 0; // // Get project // Console.ForegroundColor = ConsoleColor.Yellow; Console.WriteLine(assembliesPath.Count + " assemblies found"); Console.WriteLine(assembliesPath.Select(path => path.FileNameWithoutExtension).Distinct(StringComparer.InvariantCultureIgnoreCase).Count() + " assemblies with distint names found"); Console.WriteLine("Create the NDepend temporary project."); var projectManager = new NDependServicesProvider().ProjectManager; var project = projectManager.CreateTemporaryProject(assembliesPath, TemporaryProjectMode.Temporary); // // Run analysis // Console.ForegroundColor = ConsoleColor.Yellow; Console.WriteLine("Run Analysis!"); var analysisResult = ProjectAnalysisUtils.RunAnalysisShowProgressOnConsole(project); // // Show results // ProjectAnalysisUtils.ShowConsoleAnalysisResult(analysisResult.CodeBase); }
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() { IAnalysisResult analysisResult; if (!ProjectAnalysisUtils.TryChooseAnalysisResult(out analysisResult)) { return; } Debug.Assert(analysisResult != null); 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; string baselineDesc; if (ProjectAnalysisUtils.TryGetCompareContextDefinedByBaseline(analysisResult, out compareContext, out baselineDesc)) { Debug.Assert(compareContext != null); compileQueryProc = queryString => queryString.Compile(compareContext); Console.BackgroundColor = ConsoleColor.Black; Console.ForegroundColor = ConsoleColor.White; Console.WriteLine(baselineDesc); } // // 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() { // Choose project and analysis result IAnalysisResult analysisResult; if (!ProjectAnalysisUtils.TryChooseAnalysisResult(out analysisResult)) { return; } Debug.Assert(analysisResult != null); var project = analysisResult.AnalysisResultRef.Project; // Try load the project baseline ICompareContext compareContext; string baselineDesc; if (!ProjectAnalysisUtils.TryGetCompareContextDefinedByBaseline(analysisResult, out compareContext, out baselineDesc)) { Console.BackgroundColor = ConsoleColor.Black; Console.ForegroundColor = ConsoleColor.Yellow; Console.WriteLine("Cannot load a baseline for the project {" + project.Properties.Name + "}"); return; } Debug.Assert(compareContext != null); SetRegularColors(); Console.WriteLine(baselineDesc); // Compute issues-set-diff // To compute issue only on a single analysisResult just use: analysisResult.ComputeIssues() SetRegularColors(); Console.WriteLine("Computing issues on both now and baseline snapshots."); var issuesSetDiff = analysisResult.ComputeIssuesDiff(compareContext); var debtFormatter = project.DebtSettings.Values.CreateDebtFormatter(); // // Technical Debt // WriteTitle("Technical Debt"); ShowFromToLine("Technical debt", issuesSetDiff, issuesSet => debtFormatter.ToManDayString(issuesSet.AllDebt)); ShowFromToLine("Technical debt Rating", issuesSetDiff, issuesSet => { DebtRating?debtRatingNullable = issuesSet.DebtRating(issuesSet.CodeBase); if (!debtRatingNullable.HasValue) { return("N/A"); } DebtRating debtRating = debtRatingNullable.Value; // Possible to change color in this getValueProc because it is called just before outputing the value on console // However cannot use debtRating.ToForeColor() and debtRating.ToBackColor() to change the console // since console colors are fixed with the enum ConsoleColor. ConsoleColor foreColor, backColor; switch (debtRating) { default: backColor = ConsoleColor.Green; foreColor = ConsoleColor.White; break; // Case DebtRating.A case DebtRating.B: backColor = ConsoleColor.DarkGreen; foreColor = ConsoleColor.White; break; case DebtRating.C: backColor = ConsoleColor.Yellow; foreColor = ConsoleColor.Black; break; case DebtRating.D: backColor = ConsoleColor.DarkRed; foreColor = ConsoleColor.White; break; case DebtRating.E: backColor = ConsoleColor.Red; foreColor = ConsoleColor.White; break; } SetColors(backColor, foreColor); return(debtRatingNullable.Value.ToString()); }); ShowFromToLine("Annual Interest", issuesSetDiff, issuesSet => debtFormatter.ToManDayString(issuesSet.AllAnnualInterest)); // // Quality Gates // WriteTitle("Quality Gates"); ShowFromToLine("# Quality Gates Fail", issuesSetDiff, issuesSet => issuesSet.AllQualityGates.Count(qg => qg.Fail).ToString(), SetValueRedColors); ShowFromToLine("# Quality Gates Warn", issuesSetDiff, issuesSet => issuesSet.AllQualityGates.Count(qg => qg.Warn).ToString(), SetValueYellowColors); ShowFromToLine("# Quality Gates Pass", issuesSetDiff, issuesSet => issuesSet.AllQualityGates.Count(qg => qg.Pass).ToString(), SetValueGreenColors); SetInfoColors(); Console.WriteLine("Quality Gates that rely on diff since baseline are not counted in the 'from' number."); // // Rules // WriteTitle("Rules"); ShowFromToLine("# Critical Rules violated", issuesSetDiff, issuesSet => issuesSet.AllRules.Count(r => r.IsCritical && issuesSet.IsViolated(r)).ToString(), SetValueRedColors); ShowFromToLine("# Rules violated", issuesSetDiff, issuesSet => issuesSet.AllRules.Count(issuesSet.IsViolated).ToString(), SetValueDarkRedColors); ShowFromToLine("# Rules non violated", issuesSetDiff, issuesSet => issuesSet.AllRules.Count(r => !issuesSet.IsViolated(r)).ToString(), SetValueGreenColors); SetInfoColors(); Console.WriteLine("Rules that rely on diff since baseline are not counted in the 'from' number."); // // Issues // WriteTitle("Issues"); ShowFromToLineForIssues("# issues", issuesSetDiff, issuesSet => issuesSet.AllIssues.ToArray()); foreach (var severity in new[] { Severity.Blocker, Severity.Critical, Severity.High, Severity.Medium, Severity.Low }) { var severityTmp = severity; // Needed to avoid access foreach variable in closure! ShowFromToLineForIssues("# " + Enum.GetName(typeof(Severity), severityTmp) + " issues", issuesSetDiff, issuesSet => issuesSet.AllIssues.Where(i => i.Severity == severityTmp).ToArray()); } SetInfoColors(); Console.WriteLine("In red # issues added since baseline, in green # issues fixed since baseline."); Console.WriteLine("The severity of an issue can change. Hence a change in # total issues for a certain severity level"); Console.WriteLine("doesn't necessarily correspond to a change in # added / # fixed."); // // Quality Gates Details // WriteTitle("Quality Gates Details"); foreach (var qualityGate in issuesSetDiff.NewerIssuesSet.AllQualityGates) { WriteQualityGateDetails(qualityGate, issuesSetDiff.OlderVersion(qualityGate)); } SetInfoColors(); Console.WriteLine("Quality Gates that rely on diff don't have a value computed on baseline."); }
public void Run() { IProject project; if (!ProjectAnalysisUtils.TryChooseProject(out project)) { return; } Debug.Assert(project != null); IReadOnlyList <IAbsoluteFilePath> applicationAssemblies, thirdPartyAssemblies; IReadOnlyList <IAssemblyResolvingError> applicationAssembliesError, thirdPartyAssembliesError; project.CodeToAnalyze.Resolve(out applicationAssemblies, out thirdPartyAssemblies, out applicationAssembliesError, out thirdPartyAssembliesError); //-------------------------------------------------------------------------------------------- ShowConsoleNewCheck(ExtensionMethods.ToEnumerable("Show eventual assembly resolving errors")); ShowEventualAssemblyResolvingErrors(applicationAssemblies.Count, applicationAssembliesError); //-------------------------------------------------------------------------------------------- // Make sure there are enought application assemblies resolved if (applicationAssemblies.Count < 3) { Console.ForegroundColor = ConsoleColor.White; Console.WriteLine("Only " + applicationAssemblies.Count + " application assembly are resolved, this is not enought to try detect versionning issue."); return; } var dotNetManager = new NDependServicesProvider().DotNetManager; var applicationAssembliesInfos = applicationAssemblies.Select(dotNetManager.GetAssemblyInfo); var thirdPartyAssembliesInfos = thirdPartyAssemblies.Select(dotNetManager.GetAssemblyInfo); //-------------------------------------------------------------------------------------------- ShowConsoleNewCheck(new[] { "Try get the application version", "and check assemblies without the application version" }); CoherencyChecker.Go(applicationAssembliesInfos, assemblyInfo => assemblyInfo.Version, "application version"); //-------------------------------------------------------------------------------------------- ShowConsoleNewCheck(ExtensionMethods.ToEnumerable("Check that assemblies references have the same version than assemblies resolved")); AssembliesReferencesVersionningChecker.Go(applicationAssembliesInfos, thirdPartyAssembliesInfos); //-------------------------------------------------------------------------------------------- ShowConsoleNewCheck(new[] { "Try get the common target runtime version", "and check assemblies with a different target runtime version" }); CoherencyChecker.Go(applicationAssembliesInfos, assemblyInfo => assemblyInfo.TargetRuntime, "target runtime version"); //-------------------------------------------------------------------------------------------- ShowConsoleNewCheck(ExtensionMethods.ToEnumerable("Check that all application assemblies are strong named or not")); CoherencyChecker.Go(applicationAssembliesInfos, assemblyInfo => assemblyInfo.IsStrongNamed, "is strong named"); //-------------------------------------------------------------------------------------------- ShowConsoleNewCheck(new[] { "Check that all application assemblies share ", "a common target platform target (AnyCPU, x86, x64, Itanium)" }); CoherencyChecker.Go(applicationAssembliesInfos, assemblyInfo => assemblyInfo.PlatformTarget, "platform target"); //-------------------------------------------------------------------------------------------- ShowConsoleNewCheck(new[] { "Make sure all application assemblies", "PDB file available or not available" }); CoherencyChecker.Go(applicationAssembliesInfos, assemblyInfo => assemblyInfo.PDBAvailable, "PDB file available"); }
public void Run() { var compareContext = ProjectAnalysisUtils.GetProjectsToCompareAndAnalyzeThem(); APIChangesDisplayer.Go(compareContext); }
public void Run() { IAnalysisResult analysisResult; if (!ProjectAnalysisUtils.TryChooseAnalysisResult(out analysisResult)) { return; } Debug.Assert(analysisResult != null); var codeBase = analysisResult.CodeBase; // // Get weight for each identifier // var identifierWeights = codeBase.Assemblies.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 projectManager = new NDependServicesProvider().ProjectManager; var visualStudioManager = new NDependServicesProvider().VisualStudioManager; // // Gather all Most Recent Used VS solutions and projects file path referenced in registry // var vsFilesPath = new List <IAbsoluteFilePath>(); foreach (var vsVersion in new[] { VisualStudioVersion.V7_2003, VisualStudioVersion.V8_2005, VisualStudioVersion.V9_2008, VisualStudioVersion.V10_2010 }) { if (!visualStudioManager.IsVisualStudioVersionIntalled(vsVersion)) { continue; } vsFilesPath.AddRange(visualStudioManager.GetMostRecentlyUsedVisualStudioSolutionOrProject(vsVersion)); } Console.WriteLine(vsFilesPath.Count + " VS sln or proj files found"); // // Gather all Debug assemblies built from these VS solutions and projects // var assembliesPath = new List <IAbsoluteFilePath>(); foreach (var vsFilePath in vsFilesPath) { assembliesPath.AddRange(visualStudioManager.GetAssembliesFromVisualStudioSolutionOrProject(vsFilePath)); } // // Create temporary project // var project = projectManager.CreateTemporaryProject(assembliesPath, TemporaryProjectMode.Temporary); // // Inform about potential assembly resolving error // IReadOnlyList <IAbsoluteFilePath> applicationAssemblies, thirdPartyAssemblies; IReadOnlyList <IAssemblyResolvingError> applicationAssembliesError, thirdPartyAssembliesError; project.CodeToAnalyze.Resolve(out applicationAssemblies, out thirdPartyAssemblies, out applicationAssembliesError, out thirdPartyAssembliesError); if (applicationAssembliesError.Count > 0) { Console.ForegroundColor = ConsoleColor.Yellow; Console.WriteLine(applicationAssembliesError.Count + " assembly resolving error, assemblies with following names won't be analyzed:"); foreach (var assemblyResolvingError in applicationAssembliesError) { // You can use assemblyResolvingError.ErrorDescription to show error in plain english // most of the time it'll be several different assemblies with the same name found. Console.Write(assemblyResolvingError.AssemblyName + " ; "); } Console.ForegroundColor = ConsoleColor.White; } // // Run analysis // var analysisResult = ProjectAnalysisUtils.RunAnalysisShowProgressOnConsole(project); // // Show results // ProjectAnalysisUtils.ShowConsoleAnalysisResult(analysisResult.CodeBase); Console.WriteLine("The analysis result produced can now be consummed from the NDepend project \"" + project.Properties.Name + "\""); }