private static IProject GetProjectFromNDependFile(string pathToNDependProject)
{
var projectManager = new NDependServicesProvider().ProjectManager;
var project = projectManager.LoadProject(pathToNDependProject.ToAbsoluteFilePath());
return(project);
}
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()
{
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 static Result <IProject> GetOrCreateProjectFromVisualStudioSolution(string slnAbsolutePath, string outputDirectory, string outputFileName)
{
var ndependProjectPath = FileNameConventions.BuildNDependProjectFilePath(outputDirectory, outputFileName);
if (File.Exists(ndependProjectPath))
{
return(Result.Success(GetProjectFromNDependFile(ndependProjectPath)));
}
var ndependServicesProvider = new NDependServicesProvider();
List <IAbsoluteFilePath> assemblies = GetAssembliesFromSolution(slnAbsolutePath, ndependServicesProvider);
if (!assemblies.Any())
{
return(Result.Failure <IProject>("Could not find any assemblies for the solution. Please make sure that the solution is built before running the CodeAnalyzer"));
}
var projectManager = ndependServicesProvider.ProjectManager;
var project = projectManager.CreateBlankProject(
ndependProjectPath.ToAbsoluteFilePath(),
outputFileName);
project.CodeToAnalyze.SetApplicationAssemblies(assemblies);
projectManager.SaveProject(project);
return(Result.Success(project));
}
public static void Go()
{
var projectManager = new NDependServicesProvider().ProjectManager;
var project = projectManager.LoadProject(@"C:\Dir\NDependProject.ndproj".ToAbsoluteFilePath());
Console.WriteLine("Load newer analysis result");
IAnalysisResultRef mostRecentAnalysisResultRef;
if (!project.TryGetMostRecentAnalysisResultRef(out mostRecentAnalysisResultRef))
{
Console.WriteLine("Can't find most recent analysis result for project " + project.Properties.FilePath.ToString());
return;
}
var mostRecentAnalysisResult = mostRecentAnalysisResultRef.Load();
Console.WriteLine("load old analysis result");
IAnalysisResultRef analysisResultToCompareWithRef;
if (project.BaselineInUI.TryGetAnalysisResultRefToCompareWith(out analysisResultToCompareWithRef) != TryGetAnalysisResultRefToCompareWithResult.DoCompareWith)
{
Console.WriteLine("Can't find baseline UI analysis to compare with");
return;
}
var analysisResultToCompareWith = analysisResultToCompareWithRef.Load();
Console.WriteLine("Create compare context");
var compareContext = mostRecentAnalysisResult.CodeBase.CreateCompareContextWithOlder(analysisResultToCompareWith.CodeBase);
foreach (var m in compareContext.NewerCodeBase.Namespaces.Where(compareContext.WasAdded))
{
Console.WriteLine(m.Name);
}
}
internal static int GetNDependLocCount( DevelopmentInstallation installation, bool debug )
{
var servicesProvider = new NDependServicesProvider();
var projectManager = servicesProvider.ProjectManager;
var project =
projectManager.CreateTemporaryProject(
getAssemblyPaths( installation, debug ).Select( i => Path.GetFullPath( i ).ToAbsoluteFilePath() ).ToArray(),
TemporaryProjectMode.Temporary );
StatusStatics.SetStatus( "Performing NDepend analysis." );
var analysisResult = project.RunAnalysis();
StatusStatics.SetStatus( "Performed NDepend analysis." );
var codeBase = analysisResult.CodeBase;
var generatedCodeAttribute = codeBase.Types.WithFullName( "System.CodeDom.Compiler.GeneratedCodeAttribute" ).SingleOrDefault();
var methods = from n in codeBase.Application.Namespaces
where !n.Name.StartsWith( EwlStatics.EwfFolderBaseNamespace )
from t in n.ChildTypes
where generatedCodeAttribute == null || !t.HasAttribute( generatedCodeAttribute )
from m in t.MethodsAndContructors
where generatedCodeAttribute == null || !m.HasAttribute( generatedCodeAttribute )
// We've considered excluding .designer.cs files here, but decided that they should remain part of the count since they still represent
// logic that must be maintained (in the designer).
where m.SourceFileDeclAvailable && m.SourceDecls.Any( s => s.SourceFile.FilePath.ParentDirectoryPath.DirectoryName != "Generated Code" )
select m;
return methods.Where( i => i.NbLinesOfCode.HasValue ).Sum( i => Convert.ToInt32( i.NbLinesOfCode.Value ) );
}
internal static int GetNDependLocCount(DevelopmentInstallation installation, bool debug)
{
var servicesProvider = new NDependServicesProvider();
var projectManager = servicesProvider.ProjectManager;
var project =
projectManager.CreateTemporaryProject(getAssemblyPaths(installation, debug).Select(i => Path.GetFullPath(i).ToAbsoluteFilePath()).ToArray(),
TemporaryProjectMode.Temporary);
StatusStatics.SetStatus("Performing NDepend analysis.");
var analysisResult = project.RunAnalysis();
StatusStatics.SetStatus("Performed NDepend analysis.");
var codeBase = analysisResult.CodeBase;
var generatedCodeAttribute = codeBase.Types.WithFullName("System.CodeDom.Compiler.GeneratedCodeAttribute").SingleOrDefault();
var methods = from n in codeBase.Application.Namespaces
where !n.Name.StartsWith(StandardLibraryMethods.EwfFolderBaseNamespace)
from t in n.ChildTypes
where generatedCodeAttribute == null || !t.HasAttribute(generatedCodeAttribute)
from m in t.MethodsAndContructors
where generatedCodeAttribute == null || !m.HasAttribute(generatedCodeAttribute)
where m.SourceFileDeclAvailable && m.SourceDecls.Any(s => s.SourceFile.FilePath.ParentDirectoryPath.DirectoryName != "Generated Code")
select m;
return(methods.Where(i => i.NbLinesOfCode.HasValue).Sum(i => Convert.ToInt32(i.NbLinesOfCode.Value)));
}
internal static int GetNDependLocCount(DevelopmentInstallation installation, bool debug)
{
var servicesProvider = new NDependServicesProvider();
var projectManager = servicesProvider.ProjectManager;
var project = projectManager.CreateTemporaryProject(
getAssemblyPaths(installation, debug).Select(i => Path.GetFullPath(i).ToAbsoluteFilePath()).ToArray(),
TemporaryProjectMode.Temporary);
StatusStatics.SetStatus("Performing NDepend analysis.");
var analysisResult = project.RunAnalysis();
StatusStatics.SetStatus("Performed NDepend analysis.");
var codeBase = analysisResult.CodeBase;
var generatedCodeAttribute = codeBase.Types.WithFullName("System.CodeDom.Compiler.GeneratedCodeAttribute").SingleOrDefault();
var methods = from n in codeBase.Application.Namespaces
from t in n.ChildTypes
where generatedCodeAttribute == null || !t.HasAttribute(generatedCodeAttribute)
from m in t.MethodsAndContructors
where generatedCodeAttribute == null || !m.HasAttribute(generatedCodeAttribute)
// We've considered excluding .designer.cs files here, but decided that they should remain part of the count since they still represent
// logic that must be maintained (in the designer).
where m.SourceFileDeclAvailable && m.SourceDecls.Any(s => s.SourceFile.FilePath.ParentDirectoryPath.DirectoryName != "Generated Code")
select m;
return(methods.Where(i => i.NbLinesOfCode.HasValue).Sum(i => Convert.ToInt32(i.NbLinesOfCode.Value)));
}
public AnalysisHistoryManager(string nDpendProjectpath)
{
NDependServicesProvider nDependServicesProvider = new NDependServicesProvider();
var projectManager = nDependServicesProvider.ProjectManager;
IAbsoluteFilePath pathToNDependProject = PathHelpers.ToAbsoluteFilePath(nDpendProjectpath);
IProject nDependProject = projectManager.LoadProject(pathToNDependProject);
ICollection<IAnalysisResultRef> analysisResultRefs = nDependProject.GetAvailableAnalysisResultsRefs();
analysisResultRefsList = analysisResultRefs.OrderBy(analysisResultRef => analysisResultRef.Date).ToList();
}
public AnalysisHistoryManager(string nDpendProjectpath)
{
NDependServicesProvider nDependServicesProvider = new NDependServicesProvider();
var projectManager = nDependServicesProvider.ProjectManager;
IAbsoluteFilePath pathToNDependProject = PathHelpers.ToAbsoluteFilePath(nDpendProjectpath);
IProject nDependProject = projectManager.LoadProject(pathToNDependProject);
ICollection <IAnalysisResultRef> analysisResultRefs = nDependProject.GetAvailableAnalysisResultsRefs();
analysisResultRefsList = analysisResultRefs.OrderBy(analysisResultRef => analysisResultRef.Date).ToList();
}
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 projectManager = new NDependServicesProvider().ProjectManager;
IProject project;
if (!projectManager.ShowDialogChooseAnExistingProject(ConsoleUtils.MainWindowHandle, out project))
{
return;
}
// Get the trend store object
var trendStore = project.Trend.TrendStoreDirectory.GetTrendStoreFromDirectory();
var years = trendStore.GetYearsContainingValuesDescending();
if (!years.Any())
{
Console.WriteLine("No trend values stored for the project {" + project.Properties.Name + "}.");
return;
}
var lastYear = years.Last();
var yearsStringBuilder = new StringBuilder();
foreach (var year in years)
{
yearsStringBuilder.Append(year.ToString());
if (lastYear != year)
{
yearsStringBuilder.Append(", ");
}
}
Console.WriteLine("The project {" + project.Properties.Name + "} has trend values stored for years " + yearsStringBuilder.ToString());
// Load all values in one call
var historyData = trendStore.Load(years);
var metricHistory = historyData.MetricsHistories.First().Value; // Only list the trend values for the first metric
Console.WriteLine("Trend values for the metric {" + metricHistory.Metric.Name + "}");
var unit = metricHistory.Metric.Unit;
foreach (var datedValue in metricHistory.DatedValuesDescending)
{
Console.WriteLine(datedValue.Date.ToString() + " " + datedValue.Value.ToString() + " " + unit);
}
}
public void Run()
{
var projectManager = new NDependServicesProvider().ProjectManager;
var dotNetManager = new NDependServicesProvider().DotNetManager;
// Check installation
var versions = new[] { new Version(3, 5), new Version(4, 0) };
foreach (var version in versions)
{
if (dotNetManager.IsInstalled(DotNetProfile.DotNetFramework, version))
{
continue;
}
Console.WriteLine(".NET fx v" + version.ToString() + " not installed!");
return;
}
//
// Gather core assemblies paths
//
var olderAssembliesPaths = GetCoreAssembliesPath(versions[0], dotNetManager);
var newerAssembliesPaths = GetCoreAssembliesPath(versions[1], dotNetManager);
//
// Do analysis
//
var olderCodeBase = DoAnalysisGetCodeBase(versions[0], olderAssembliesPaths, TemporaryProjectMode.TemporaryOlder, projectManager);
var newerCodeBase = DoAnalysisGetCodeBase(versions[1], newerAssembliesPaths, TemporaryProjectMode.TemporaryNewer, projectManager);
//
// Create compare context
//
var compareContext = newerCodeBase.CreateCompareContextWithOlder(olderCodeBase);
ConsoleUtils.ShowNLinesOnConsole(3, ConsoleColor.Black);
Console.WriteLine("2 temporary projects have been created.");
Console.WriteLine("The .NET Fx older and newer analysis results can now be consummed live from the NDepend UI.");
Console.WriteLine("Note that .NET Fx types API Breaking Changes represents types moved from System to mscorlib.");
//
// Show API Changes!
//
APIChangesDisplayer.Go(compareContext);
}
internal static bool TryChooseProject(out IProject project)
{
var ndependServicesProvider = new NDependServicesProvider();
var projectManager = ndependServicesProvider.ProjectManager;
var visualStudioManager = ndependServicesProvider.VisualStudioManager;
CHOOSE_PROJECT:
var top = Console.CursorTop;
Console.CursorLeft = 0;
Console.WriteLine("Please choose...");
Console.WriteLine(" a) an existing NDepend project");
Console.WriteLine(" b) one or several Visual Studio solutions to analyze");
Console.WriteLine(" c) one or several .NET assemblies to analyze");
Console.WriteLine("");
var c = Char.ToLower(Console.ReadKey().KeyChar);
Console.WriteLine();
switch (c)
{
case 'a':
if (!projectManager.ShowDialogChooseAnExistingProject(ConsoleUtils.MainWindowHandle, out project))
{
goto TRY_AGAIN;
}
break;
case 'b': {
ICollection <IAbsoluteFilePath> solutions;
if (!visualStudioManager.ShowDialogSelectVisualStudioSolutionsOrProjects(ConsoleUtils.MainWindowHandle, out solutions))
{
goto TRY_AGAIN;
}
var assemblies = new List <IAbsoluteFilePath>();
foreach (var solution in solutions)
{
assemblies.AddRange(visualStudioManager.GetAssembliesFromVisualStudioSolutionOrProject(solution));
}
project = projectManager.CreateTemporaryProject(assemblies, TemporaryProjectMode.Temporary);
break;
}
case 'c': {
ICollection <IAbsoluteFilePath> assemblies;
if (!projectManager.ShowDialogSelectAssemblies(ConsoleUtils.MainWindowHandle, out assemblies))
{
goto TRY_AGAIN;
}
project = projectManager.CreateTemporaryProject(assemblies, TemporaryProjectMode.Temporary);
break;
}
case (char)Keys.Escape: // ESC to exit!
project = null;
return(false);
default:
TRY_AGAIN:
var nbLinesToErase = Console.CursorTop - top;
Console.CursorTop = top;
Console.CursorLeft = 0;
ConsoleUtils.ShowNLinesOnConsole(nbLinesToErase, ConsoleColor.Black);
Console.WriteLine("(ESC to exit)");
Console.CursorTop = top;
Console.CursorLeft = 0;
goto CHOOSE_PROJECT;
}
Debug.Assert(project != null);
Console.ForegroundColor = ConsoleColor.DarkGray;
Console.Write("Project selected: ");
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine(project.Properties.Name);
Console.WriteLine();
return(true);
}
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 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 + "\"");
}
internal static ICompareContext GetProjectsToCompareAndAnalyzeThem()
{
var analysisManager = new NDependServicesProvider().AnalysisManager;
var top = Console.CursorTop;
Console.CursorLeft = 0;
IProject projectOlder, projectNewer;
IAnalysisResultRef analysisResultRefOlder, analysisResultRefNewer;
while (true)
{
Console.WriteLine("Please choose older and newer versions of the code base...");
bool dialogOk = analysisManager.ShowDialogBuildComparison(ConsoleUtils.MainWindowHandle, out projectOlder, out analysisResultRefOlder, out projectNewer, out analysisResultRefNewer);
var nbLinesToErase = Console.CursorTop - top;
Console.CursorTop = top;
Console.CursorLeft = 0;
ConsoleUtils.ShowNLinesOnConsole(nbLinesToErase, ConsoleColor.Black);
Console.CursorTop = top;
Console.CursorLeft = 0;
if (dialogOk)
{
break;
}
}
//
// Load or analyze
//
IAnalysisResult analysisResultOlder, analysisResultNewer;
if (analysisResultRefOlder == null)
{
Debug.Assert(projectOlder != null);
Console.WriteLine("Analyze older version of projects");
analysisResultOlder = RunAnalysisShowProgressOnConsole(projectOlder);
}
else
{
Console.WriteLine("Load older analysis result");
analysisResultOlder = LoadAnalysisShowProgressOnConsole(analysisResultRefOlder);
}
if (analysisResultRefNewer == null)
{
Debug.Assert(projectNewer != null);
Console.WriteLine("Analyze newer version of projects");
analysisResultNewer = RunAnalysisShowProgressOnConsole(projectNewer);
}
else
{
Console.WriteLine("Load newer analysis result");
analysisResultNewer = LoadAnalysisShowProgressOnConsole(analysisResultRefNewer);
}
//
// Re-erase
//
var nbLinesToErase2 = Console.CursorTop - top;
Console.CursorTop = top;
Console.CursorLeft = 0;
ConsoleUtils.ShowNLinesOnConsole(nbLinesToErase2, ConsoleColor.Black);
Console.CursorTop = top;
Console.CursorLeft = 0;
//
// Show compare description
//
Console.ForegroundColor = ConsoleColor.DarkGray;
Console.Write("Comparing: ");
Console.ForegroundColor = ConsoleColor.White;
ShowAnalysisResultRefDescription(analysisResultOlder.AnalysisResultRef);
Console.WriteLine();
Console.ForegroundColor = ConsoleColor.DarkGray;
Console.Write(" with: ");
Console.ForegroundColor = ConsoleColor.White;
ShowAnalysisResultRefDescription(analysisResultNewer.AnalysisResultRef);
return(analysisResultNewer.CodeBase.CreateCompareContextWithOlder(analysisResultOlder.CodeBase));
}
public MetricsViewer()
{
InitializeComponent();
nDependServicesProvider = new NDependServicesProvider();
}
internal static IProject ChooseProject()
{
var projectManager = new NDependServicesProvider().ProjectManager;
var visualStudioManager = new NDependServicesProvider().VisualStudioManager;
var top = Console.CursorTop;
Console.CursorLeft = 0;
while (true)
{
Console.WriteLine("Please choose...");
Console.WriteLine(" a) an existing CppDepend project");
Console.WriteLine(" b) one or several Visual Studio solutions to analyze");
Console.WriteLine(" c) one or several C/C++ projects to analyze");
Console.WriteLine("");
var c = Char.ToLower(Console.ReadKey().KeyChar);
Console.WriteLine();
IProject project = null;
switch (c)
{
case 'a':
if (!projectManager.ShowDialogChooseAnExistingProject(ConsoleUtils.MainWindowHandle, out project))
{
break;
}
break;
case 'b': {
ICollection <IAbsoluteFilePath> solutions;
if (!visualStudioManager.ShowDialogSelectVisualStudioSolutionsOrProjects(ConsoleUtils.MainWindowHandle, out solutions))
{
break;
}
var projects = new List <IAbsoluteFilePath>();
foreach (var solution in solutions)
{
projects.Add(solution);
}
project = projectManager.CreateTemporaryProject(projects, TemporaryProjectMode.Temporary);
break;
}
default: {
ICollection <IAbsoluteFilePath> projects;
if (!projectManager.ShowDialogSelectProjects(ConsoleUtils.MainWindowHandle, out projects))
{
break;
}
project = projectManager.CreateTemporaryProject(projects, TemporaryProjectMode.Temporary);
break;
}
}
var nbLinesToErase = Console.CursorTop - top;
Console.CursorTop = top;
Console.CursorLeft = 0;
ConsoleUtils.ShowNLinesOnConsole(nbLinesToErase, ConsoleColor.Black);
Console.CursorTop = top;
Console.CursorLeft = 0;
if (project == null)
{
continue;
}
Console.ForegroundColor = ConsoleColor.DarkGray;
Console.Write("Project selected: ");
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine(project.Properties.Name);
Console.WriteLine();
return(project);
}
}
public MetricsViewer()
{
InitializeComponent();
nDependServicesProvider = new NDependServicesProvider();
TagAllDataGridViews();
}
static void Main()
{
//-------------------------------------------------------------------------------------
//
// 0) Creates a NDependServicesProvider object
//
var ndependServicesProvider = new NDependServicesProvider();
//-------------------------------------------------------------------------------------
//
// 1) obtain some VS solution or project file path
//
var visualStudioManager = ndependServicesProvider.VisualStudioManager;
ICollection <IAbsoluteFilePath> vsSlnOrProjFilePaths;
visualStudioManager.ShowDialogSelectVisualStudioSolutionsOrProjects(Process.GetCurrentProcess().MainWindowHandle, out vsSlnOrProjFilePaths);
// Could also use: visualStudioManager.GetMostRecentlyUsedVisualStudioSolutionOrProject() can also be used
//-------------------------------------------------------------------------------------
//
// 2) obtains assemblies file path to analyze
//
var assembliesFilePath = (from vsSlnOrProjFilePath in vsSlnOrProjFilePaths
from assembliesFilePathTmp in visualStudioManager.GetAssembliesFromVisualStudioSolutionOrProject(vsSlnOrProjFilePath)
select assembliesFilePathTmp).Distinct().ToArray();
//-------------------------------------------------------------------------------------
//
// 3) gets or create a IProject object
//
var projectManager = ndependServicesProvider.ProjectManager;
var project = projectManager.CreateTemporaryProject(assembliesFilePath, TemporaryProjectMode.Temporary);
// Or, to get a IProject object, could also use
// projectManager.CreateBlankProject() to create a persisten project
// and then project.CodeToAnalyze.SetApplicationAssemblies()
// and then projectManager.SaveProject(project); o save the project file
//
// Or, to get an existing IProject object, could also use
// projectManager.ShowDialogChooseAnExistingProject(out project)
// Or programmatically list most recently used NDepend projects on this machine through
// projectManager.GetMostRecentlyUsedProjects()
//-------------------------------------------------------------------------------------
//
// 4) gets an IAnalysisResult object from the IProject object
//
var analysisResult = project.RunAnalysis(); // *** This particular method works only with a Build Machine license ***
// Or project.RunAnalysisAndBuildReport() // *** This particular method works only with a Build Machine license ***
// Or, to get a IAnalysisResult object, first gets a IAnalysisResultRef object, that represents a reference to a persisted IAnalysisResult object
// project.TryGetMostRecentAnalysisResultRef() or project.GetAvailableAnalysisResultsRefs() or project.GetAvailableAnalysisResultsRefsGroupedPerMonth()
// and then analysisResultRef.Load()
//-------------------------------------------------------------------------------------
//
// 5) gets a ICodeBase object from the IAnalysisResult object
//
var codeBase = analysisResult.CodeBase;
// Or eventually a ICompareContext object if you wish to analyze diff
// codeBase.CreateCompareContextWithOlder(olderCodeBase)
//-------------------------------------------------------------------------------------
//
// 6) use the code model API to query code and do develop any algorithm you need!
//
// For example here we are looking for complex methods
var complexMethods = (from m in codeBase.Application.Methods
where m.ILCyclomaticComplexity > 10
orderby m.ILCyclomaticComplexity descending
select m).ToArray();
if (complexMethods.Length == 0)
{
return;
}
Console.WriteLine("Press a key to show the " + complexMethods.Length + " most complex methods");
Console.ReadKey();
foreach (var m in complexMethods)
{
Console.WriteLine(m.FullName + " has a IL cyclomatic complexity of " + m.ILCyclomaticComplexity);
}
//-------------------------------------------------------------------------------------
//
// 7) eventually lets the user opens source file declaration
//
if (complexMethods.First().SourceFileDeclAvailable)
{
var mostComplexMethod = complexMethods.First();
Console.WriteLine("Press a key to open the source code decl of the most complex method?");
Console.ReadKey();
mostComplexMethod.TryOpenSource();
// Eventually use ExtensionMethodsTooling.TryCompareSourceWith(NDepend.CodeModel.ISourceFileLine,NDepend.CodeModel.ISourceFileLine)
// to compare 2 different versions of a code element
}
}
public MetricsViewer()
{
InitializeComponent();
nDependServicesProvider = new NDependServicesProvider();
TagAllDataGridViews();
}
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()
{
//
// 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);
}
static void MainSub()
{
//AppDomain.CurrentDomain.AssemblyResolve += AssemblyResolverHelper.AssemblyResolveHandler;
//var projectFilePath = NDEPEND_PROJECT_FILE_PATH.ToAbsoluteFilePath();
//Console.WriteLine("*** Load NDepend Project from {" + projectFilePath.ToString() + @"}***");
// 0) Creates a NDependServicesProvider object
var ndependServicesProvider = new NDependServicesProvider();
// 1) obtain some VS solution or project file path
var visualStudioManager = ndependServicesProvider.VisualStudioManager;
ICollection<IAbsoluteFilePath> vsSlnOrProjFilePaths;
IntPtr ownerWindowHandle = Process.GetCurrentProcess().MainWindowHandle; // get a non IntPtr.Zero owner Window Handle. If you are in a System.Console try this
visualStudioManager.ShowDialogSelectVisualStudioSolutionsOrProjects(ownerWindowHandle, out vsSlnOrProjFilePaths);
// Could also use: visualStudioManager.GetMostRecentlyUsedVisualStudioSolutionOrProject() can also be used
// 2) obtains assemblies file path to analyze
var assembliesFilePath = (from vsSlnOrProjFilePath in vsSlnOrProjFilePaths
from assembliesFilePathTmp in visualStudioManager.GetAssembliesFromVisualStudioSolutionOrProject(vsSlnOrProjFilePath)
select assembliesFilePathTmp).Distinct().ToArray();
// 3) gets or create a IProject object
var projectManager = ndependServicesProvider.ProjectManager;
//var path = NDepend.Path.PathHelpers.ToAbsoluteFilePath(@"C:\projetos\estudoipt\dapperdotnet\dapper-dot-net\");
//IProject project = projectManager.CreateBlankProject(assembliesFilePath.FirstOrDefault(), "metricsproject");
IProject project = projectManager.CreateTemporaryProject(assembliesFilePath, TemporaryProjectMode.Temporary);
// Or, to get a IProject object, could also use
// projectManager.CreateBlankProject() to create a persisten project
// and then project.CodeToAnalyze.SetApplicationAssemblies()
// and then projectManager.SaveProject(project); o save the project file
//
// Or, to get an existing IProject object, could also use
// projectManager.ShowDialogChooseAnExistingProject(out project)
// Or programmatically list most recently used NDepend projects on this machine through
// projectManager.GetMostRecentlyUsedProjects()
// 4) gets an IAnalysisResult object from the IProject object
IAnalysisResult analysisResult = project.RunAnalysis(); // *** This particular method works only with a Build Machine license ***
// Or project.RunAnalysisAndBuildReport() // *** This particular method works only with a Build Machine license ***
// Or, to get a IAnalysisResult object, first gets a IAnalysisResultRef object, that represents a reference to a persisted IAnalysisResult object
// project.TryGetMostRecentAnalysisResultRef() or project.GetAvailableAnalysisResultsRefs() or project.GetAvailableAnalysisResultsRefsGroupedPerMonth()
// and then analysisResultRef.Load()
// 5) gets a ICodeBase object from the IAnalysisResult object
ICodeBase codeBase = analysisResult.CodeBase;
// Or eventually a ICompareContext object if you wish to analyze diff
// codeBase.CreateCompareContextWithOlder(olderCodeBase)
Calculator.ICalculate calc = new Calculator.NumberOfChildren();
var result = calc.Calculate(codeBase);
IMetricPrinter m = new ExcelPrinter();
m.Print("NumberOfChildren",result);
calc = new Calculator.CouplingBetweenObjectClasses();
result = calc.Calculate(codeBase);
m = new ExcelPrinter();
m.Print("CouplingBetweenObject", result);
calc = new Calculator.DepthOfInheritanceTree();
result = calc.Calculate(codeBase);
m = new ExcelPrinter();
m.Print("DepthOfInheritanceTree", result);
calc = new Calculator.LackOfCohesionInMethods();
result = calc.Calculate(codeBase);
m = new ExcelPrinter();
m.Print("LackOfCohesionInMethods", result);
calc = new Calculator.ResponseForAClass();
result = calc.Calculate(codeBase);
m = new ExcelPrinter();
m.Print("ResponseForAClass", result);
calc = new Calculator.WeightedMethodsPerClass();
result = calc.Calculate(codeBase);
m = new ExcelPrinter();
m.Print("WeightedMethodsPerClass", result);
// 6) use the code model API to query code and do develop any algorithm you need!
// For example here we are looking for complex methods
/*var complexMethods = (from m in codeBase.Application.Methods
where m.ILCyclomaticComplexity > 1
orderby m.ILCyclomaticComplexity descending
select m).ToArray();
if (complexMethods.Length == 0) { return; }
Console.WriteLine("Press a key to show the " + complexMethods.Length + " most complex methods");
Console.ReadKey();
foreach (var m in complexMethods)
{
Console.WriteLine(m.FullName + " has a IL cyclomatic complexity of " + m.ILCyclomaticComplexity);
}
// 7) eventually lets the user opens source file declaration
if (complexMethods.First().SourceFileDeclAvailable)
{
var mostComplexMethod = complexMethods.First();
Console.WriteLine("Press a key to open the source code decl of the most complex method?");
Console.ReadKey();
mostComplexMethod.TryOpenSource();
// Eventually use ExtensionMethodsTooling.TryCompareSourceWith(NDepend.CodeModel.ISourceFileLine,NDepend.CodeModel.ISourceFileLine)
// to compare 2 different versions of a code element
}*/
}
static void MainSub()
{
//AppDomain.CurrentDomain.AssemblyResolve += AssemblyResolverHelper.AssemblyResolveHandler;
//var projectFilePath = NDEPEND_PROJECT_FILE_PATH.ToAbsoluteFilePath();
//Console.WriteLine("*** Load NDepend Project from {" + projectFilePath.ToString() + @"}***");
// 0) Creates a NDependServicesProvider object
var ndependServicesProvider = new NDependServicesProvider();
// 1) obtain some VS solution or project file path
var visualStudioManager = ndependServicesProvider.VisualStudioManager;
ICollection <IAbsoluteFilePath> vsSlnOrProjFilePaths;
IntPtr ownerWindowHandle = Process.GetCurrentProcess().MainWindowHandle; // get a non IntPtr.Zero owner Window Handle. If you are in a System.Console try this
visualStudioManager.ShowDialogSelectVisualStudioSolutionsOrProjects(ownerWindowHandle, out vsSlnOrProjFilePaths);
// Could also use: visualStudioManager.GetMostRecentlyUsedVisualStudioSolutionOrProject() can also be used
// 2) obtains assemblies file path to analyze
var assembliesFilePath = (from vsSlnOrProjFilePath in vsSlnOrProjFilePaths
from assembliesFilePathTmp in visualStudioManager.GetAssembliesFromVisualStudioSolutionOrProject(vsSlnOrProjFilePath)
select assembliesFilePathTmp).Distinct().ToArray();
// 3) gets or create a IProject object
var projectManager = ndependServicesProvider.ProjectManager;
//var path = NDepend.Path.PathHelpers.ToAbsoluteFilePath(@"C:\projetos\estudoipt\dapperdotnet\dapper-dot-net\");
//IProject project = projectManager.CreateBlankProject(assembliesFilePath.FirstOrDefault(), "metricsproject");
IProject project = projectManager.CreateTemporaryProject(assembliesFilePath, TemporaryProjectMode.Temporary);
// Or, to get a IProject object, could also use
// projectManager.CreateBlankProject() to create a persisten project
// and then project.CodeToAnalyze.SetApplicationAssemblies()
// and then projectManager.SaveProject(project); o save the project file
//
// Or, to get an existing IProject object, could also use
// projectManager.ShowDialogChooseAnExistingProject(out project)
// Or programmatically list most recently used NDepend projects on this machine through
// projectManager.GetMostRecentlyUsedProjects()
// 4) gets an IAnalysisResult object from the IProject object
IAnalysisResult analysisResult = project.RunAnalysis(); // *** This particular method works only with a Build Machine license ***
// Or project.RunAnalysisAndBuildReport() // *** This particular method works only with a Build Machine license ***
// Or, to get a IAnalysisResult object, first gets a IAnalysisResultRef object, that represents a reference to a persisted IAnalysisResult object
// project.TryGetMostRecentAnalysisResultRef() or project.GetAvailableAnalysisResultsRefs() or project.GetAvailableAnalysisResultsRefsGroupedPerMonth()
// and then analysisResultRef.Load()
// 5) gets a ICodeBase object from the IAnalysisResult object
ICodeBase codeBase = analysisResult.CodeBase;
// Or eventually a ICompareContext object if you wish to analyze diff
// codeBase.CreateCompareContextWithOlder(olderCodeBase)
Calculator.ICalculate calc = new Calculator.NumberOfChildren();
var result = calc.Calculate(codeBase);
IMetricPrinter m = new ExcelPrinter();
m.Print("NumberOfChildren", result);
calc = new Calculator.CouplingBetweenObjectClasses();
result = calc.Calculate(codeBase);
m = new ExcelPrinter();
m.Print("CouplingBetweenObject", result);
calc = new Calculator.DepthOfInheritanceTree();
result = calc.Calculate(codeBase);
m = new ExcelPrinter();
m.Print("DepthOfInheritanceTree", result);
calc = new Calculator.LackOfCohesionInMethods();
result = calc.Calculate(codeBase);
m = new ExcelPrinter();
m.Print("LackOfCohesionInMethods", result);
calc = new Calculator.ResponseForAClass();
result = calc.Calculate(codeBase);
m = new ExcelPrinter();
m.Print("ResponseForAClass", result);
calc = new Calculator.WeightedMethodsPerClass();
result = calc.Calculate(codeBase);
m = new ExcelPrinter();
m.Print("WeightedMethodsPerClass", result);
// 6) use the code model API to query code and do develop any algorithm you need!
// For example here we are looking for complex methods
/*var complexMethods = (from m in codeBase.Application.Methods
* where m.ILCyclomaticComplexity > 1
* orderby m.ILCyclomaticComplexity descending
* select m).ToArray();
* if (complexMethods.Length == 0) { return; }
* Console.WriteLine("Press a key to show the " + complexMethods.Length + " most complex methods");
* Console.ReadKey();
* foreach (var m in complexMethods)
* {
* Console.WriteLine(m.FullName + " has a IL cyclomatic complexity of " + m.ILCyclomaticComplexity);
* }
*
*
* // 7) eventually lets the user opens source file declaration
* if (complexMethods.First().SourceFileDeclAvailable)
* {
* var mostComplexMethod = complexMethods.First();
* Console.WriteLine("Press a key to open the source code decl of the most complex method?");
* Console.ReadKey();
* mostComplexMethod.TryOpenSource();
* // Eventually use ExtensionMethodsTooling.TryCompareSourceWith(NDepend.CodeModel.ISourceFileLine,NDepend.CodeModel.ISourceFileLine)
* // to compare 2 different versions of a code element
* }*/
}
private static List <IAbsoluteFilePath> GetAssembliesFromSolution(string slnAbsolutePath, NDependServicesProvider ndependServicesProvider)
{
var visualStudioManager = ndependServicesProvider.VisualStudioManager;
ICollection <IAbsoluteFilePath> solutions = new List <IAbsoluteFilePath>();
solutions.Add(slnAbsolutePath.ToAbsoluteFilePath());
var assemblies = new List <IAbsoluteFilePath>();
foreach (var solution in solutions)
{
assemblies.AddRange(visualStudioManager.GetAssembliesFromVisualStudioSolutionOrProject(solution));
}
return(assemblies);
}
