public static TaskRunnerResult Execute(string assemblyPath, string projectPath)
{
var assembly = Assembly.LoadFrom(assemblyPath);
Dictionary <Type, IPostCompileTask> tasks =
(from type in assembly.GetTypes()
where typeof(IPostCompileTask).IsAssignableFrom(type)
where !type.IsAbstract
where type.HasDefaultConstructor()
select type).ToDictionary(x => x, x => (IPostCompileTask)Activator.CreateInstance(x));
CheckTaskDependencies(tasks);
List <IPostCompileTask> sortedTaskInstances = tasks.Values.TopologicalSort(x => x.DependsOn.Select(y => tasks[y])).ToList();
AnalyzerManager manager = new AnalyzerManager();
ProjectAnalyzer analyzer = manager.GetProject(projectPath);
AdhocWorkspace workspace = analyzer.GetWorkspace();
Solution solution = workspace.CurrentSolution;
var log = new ConcreteLog(solution, Console.Out);
foreach (var taskInstance in sortedTaskInstances)
{
taskInstance.Log = log;
taskInstance.RunAsync().Wait();
}
// Return task types that need to be removed
return(new TaskRunnerResult
{
TaskTypes = tasks.Select(x => x.Key.FullName).ToList()
});
}
private static void RunDotNetCommand(string text, StringBuilder outputBuffer, StringBuilder errorBuffer)
{
if (!text.StartsWith("dotnet "))
{
throw new ArgumentException("Unexpected dotnet command: " + text, nameof(text));
}
using (Process dotnet = new Process())
{
dotnet.StartInfo.FileName = "dotnet";
dotnet.StartInfo.Arguments = text.Substring("dotnet ".Length);
dotnet.StartInfo.UseShellExecute = false;
dotnet.StartInfo.CreateNoWindow = true;
dotnet.StartInfo.RedirectStandardOutput = true;
dotnet.StartInfo.RedirectStandardError = true;
dotnet.OutputDataReceived += (sender, args) => outputBuffer.AppendLine(args.Data);
dotnet.ErrorDataReceived += (sender, args) => errorBuffer.AppendLine(args.Data);
dotnet.Start();
dotnet.BeginOutputReadLine();
dotnet.BeginErrorReadLine();
dotnet.WaitForExit();
dotnet.CancelOutputRead();
dotnet.CancelErrorRead();
}
AnalyzerManager manager = new AnalyzerManager();
ProjectAnalyzer analyzer = manager.GetProject(@"C:\Users\wafuqua\.replay\ReplaySession20190302153809\Session\Session.csproj");
var result = analyzer.Build();
;
}
private static async Task RunFormatItemAsync(IFormattingEngine engine, string item, string language, CancellationToken cancellationToken)
{
Console.WriteLine(Path.GetFileName(item));
string extension = Path.GetExtension(item);
if (StringComparer.OrdinalIgnoreCase.Equals(extension, ".rsp"))
{
using (var workspace = ResponseFileWorkspace.Create())
{
Project project = workspace.OpenCommandLineProject(item, language);
await engine.FormatProjectAsync(project, cancellationToken);
}
}
else if (StringComparer.OrdinalIgnoreCase.Equals(extension, ".sln"))
{
AnalyzerManager manager = new AnalyzerManager(item);
using (var workspace = manager.GetWorkspace())
{
var solution = workspace.CurrentSolution;
await engine.FormatSolutionAsync(solution, cancellationToken);
}
}
else
{
AnalyzerManager manager = new AnalyzerManager();
ProjectAnalyzer analyzer = manager.GetProject(item);
using (var workspace = analyzer.GetWorkspace())
{
var project = workspace.CurrentSolution.Projects.FirstOrDefault();
await engine.FormatProjectAsync(project, cancellationToken);
}
}
}
private IEnumerable <PackageReferenceInfo> LoadPackageReferences(ProjectAnalyzer projectAnalyzer)
{
AnalyzerResults project = projectAnalyzer.Build();
var packageReferenceInfo = new List <PackageReferenceInfo>();
var packagesRootFolder = GetPackagesRootFolder();
foreach (var result in project.Results)
{
packageReferenceInfo.AddRange(result.PackageReferences.Select(packageReference =>
{
var packageId = packageReference.Key;
var version = packageReference.Value.First().Value;
var packageFolderPath = Path.Combine(packagesRootFolder, packageId.ToLower(), version.ToLower());
return(new PackageReferenceInfo(
packageId,
version,
rootFolderPath: packageFolderPath,
libSubfolderPath: "lib"));
}));
}
return(packageReferenceInfo);
}
static void Main(string project, string[] transformers)
{
AnalyzerManager manager = new AnalyzerManager();
ProjectAnalyzer analyzer = manager.GetProject(project);
AdhocWorkspace workspace = new AdhocWorkspace();
analyzer.SetGlobalProperty("BuildingFromCodeGeneration", "true");
var Project = analyzer.AddToWorkspace(workspace, true);
if (Project is null)
{
throw new ArgumentException($"Project is null. ({project})");
}
var resolver = new CSharpAutofacResolver();
var Engine = new CSharpCodeGenerationEngine(Project, resolver);
foreach (var item in transformers)
{
var assembly = LoadAssembly(item);
var transformer = LoadTransformer(assembly, Engine);
transformer.Transform();
}
var changes = Engine.CurrentProject.GetChanges(Project);
Procces(Engine, project, changes.GetAddedDocuments(), "Added");
var changedDocs = changes.GetChangedDocuments(false).Where(x => Engine.CurrentProject.GetDocument(x).GetTextChangesAsync(Project.GetDocument(x)).Result.Any());
Procces(Engine, project, changedDocs, "Updated");
}
public void MultiTargetingBuildAllTargetFrameworksGetsSourceFiles()
{
// Given
StringWriter log = new StringWriter();
ProjectAnalyzer analyzer = GetProjectAnalyzer(@"SdkMultiTargetingProject\SdkMultiTargetingProject.csproj", log);
// When
AnalyzerResults results = analyzer.Build();
// Then
results.Count.ShouldBe(2);
results.TargetFrameworks.ShouldBe(new[] { "net462", "netstandard2.0" }, true, log.ToString());
new[]
{
#if Is_Windows
// Linux and Mac builds appear to omit the AssemblyAttributes.cs file
"AssemblyAttributes",
#endif
"Class1",
"AssemblyInfo"
}.ShouldBeSubsetOf(results["net462"].SourceFiles.Select(x => Path.GetFileName(x).Split('.').TakeLast(2).First()), log.ToString());
new[]
{
#if Is_Windows
// Linux and Mac builds appear to omit the AssemblyAttributes.cs file
"AssemblyAttributes",
#endif
"Class2",
"AssemblyInfo"
}.ShouldBeSubsetOf(results["netstandard2.0"].SourceFiles.Select(x => Path.GetFileName(x).Split('.').TakeLast(2).First()), log.ToString());
}
public AnalyzeCommand(IConsole console)
{
_console = console;
_builder = new ProjectBuilder(console);
_analyzer = new ProjectAnalyzer();
_reporter = new ProjectReporter(console);
}
public static string GetTargetFramework(string projectFile)
{
AnalyzerManager manager = new AnalyzerManager();
ProjectAnalyzer analyzer = manager.GetProject(projectFile);
return(analyzer.Project.GetPropertyValue("TargetFramework"));
}
public static FileInfo[] GetSourcesFromSolution(FileInfo solution)
{
List <FileInfo> ret = new List <FileInfo>();
//We are using Buildalyzer because it is xplat
AnalyzerManager manager = new AnalyzerManager(solution.FullName);
foreach (KeyValuePair <string, ProjectAnalyzer> proj in manager.Projects)
{
ProjectAnalyzer analyzer = proj.Value;
analyzer.IgnoreFaultyImports = true;
if (analyzer.ProjectFile.RequiresNetFramework)
{
throw new Exception(
".NET Framework Solutions not supported. Please use a .NET Core Solution instead.");
}
AnalyzerResults results = analyzer.Build();
foreach (string filePath in results.SelectMany(s => s.SourceFiles))
{
if (!File.Exists(filePath))
{
Log.Warn("Source file {0} is missing.");
}
ret.Add(new FileInfo(filePath));
}
}
return(ret.ToArray());
}
private Compilation AddProjectReferences(IExecutionContext context, List <ISymbol> symbols, Compilation compilation)
{
// Generate a single Workspace and add all of the projects to it
StringWriter log = new StringWriter();
AnalyzerManager manager = new AnalyzerManager(log);
AdhocWorkspace workspace = new AdhocWorkspace();
IEnumerable <IFile> projectFiles = context.FileSystem.GetInputFiles(_projectGlobs)
.Where(x => x.Path.Extension == ".csproj" && x.Exists);
List <Project> projects = new List <Project>();
foreach (IFile projectFile in projectFiles)
{
Project project = workspace.CurrentSolution.Projects.FirstOrDefault(x => new FilePath(x.FilePath).Equals(projectFile.Path));
if (project != null)
{
Trace.Verbose($"Project {projectFile.Path.FullPath} was already in the workspace");
}
else
{
Trace.Verbose($"Creating workspace project for {projectFile.Path.FullPath}");
ProjectAnalyzer analyzer = manager.GetProject(projectFile.Path.FullPath);
ReadWorkspace.CompileProjectAndTrace(analyzer, log);
project = analyzer.AddToWorkspace(workspace);
if (!project.Documents.Any())
{
Trace.Warning($"Project at {projectFile.Path.FullPath} contains no documents, which may be an error (check previous log output for any MSBuild warnings)");
}
}
projects.Add(project);
}
compilation = AddProjectReferences(projects, symbols, compilation);
return(compilation);
}
public static MetadataReference[] GetMetadataReferencesFromSolution(FileInfo solution)
{
List <MetadataReference> ret = new List <MetadataReference>();
//We are using Buildalyzer because it is xplat
AnalyzerManager manager = new AnalyzerManager(solution.FullName);
foreach (KeyValuePair <string, ProjectAnalyzer> proj in manager.Projects)
{
ProjectAnalyzer analyzer = proj.Value;
analyzer.IgnoreFaultyImports = true;
if (analyzer.ProjectFile.RequiresNetFramework)
{
throw new Exception(
".NET Framework Solutions not supported. Please use a .NET Core Solution instead.");
}
AnalyzerResults results = analyzer.Build();
foreach (string filePath in results.SelectMany(s => s.References))//TODO - are these all references? Research needed
{
if (!File.Exists(filePath))
{
Log.Warn("Library {0} is missing. Did you restore the Solution libraries?");
}
ret.Add(MetadataReference.CreateFromFile(filePath));
}
}
return(ret.ToArray());
}
public EventProcessor(AnalyzerManager manager, ProjectAnalyzer analyzer, IEnumerable <Microsoft.Build.Framework.ILogger> buildLoggers, IEventSource eventSource, bool analyze)
{
_manager = manager;
_analyzer = analyzer;
_logger = manager.LoggerFactory?.CreateLogger <EventProcessor>();
_buildLoggers = buildLoggers ?? Array.Empty <Microsoft.Build.Framework.ILogger>();
_eventSource = eventSource;
_analyze = analyze;
_projectFilePath = _analyzer?.ProjectFile.Path;
// Initialize the loggers
foreach (Microsoft.Build.Framework.ILogger buildLogger in _buildLoggers)
{
buildLogger.Initialize(eventSource);
}
// Send events to the tree constructor
if (analyze)
{
eventSource.ProjectStarted += ProjectStarted;
eventSource.ProjectFinished += ProjectFinished;
eventSource.TargetStarted += TargetStarted;
eventSource.TargetFinished += TargetFinished;
eventSource.MessageRaised += MessageRaised;
eventSource.BuildFinished += BuildFinished;
if (_logger != null)
{
eventSource.ErrorRaised += ErrorRaised;
}
}
}
public IEnumerable <FileInfo> GetSources(FileInfo solution)
{
List <FileInfo> ret = new List <FileInfo>();
AnalyzerManager manager = new AnalyzerManager(solution.FullName);
foreach (KeyValuePair <string, ProjectAnalyzer> proj in manager.Projects)
{
ProjectAnalyzer analyzer = proj.Value;
analyzer.IgnoreFaultyImports = true;
if (analyzer.ProjectFile.RequiresNetFramework)
{
throw new Exception(
".NET Framework Solutions not supported. Please use a .NET Core Solution instead.");
}
AnalyzerResults results = analyzer.Build();
foreach (string filePath in results.SelectMany(s => s.SourceFiles))
{
if (!File.Exists(filePath))
{
throw new Exception($"Source file {filePath} is missing!");
}
ret.Add(new FileInfo(filePath));
}
}
return(ret);
}
public void BuildTargetFrameworkGetsSourceFiles()
{
// Given
StringWriter log = new StringWriter();
ProjectAnalyzer analyzer = GetProjectAnalyzer(@"SdkMultiTargetingProject\SdkMultiTargetingProject.csproj", log);
// When
IReadOnlyList <string> sourceFiles = analyzer.Build("net462").GetSourceFiles();
// Then
sourceFiles.ShouldNotBeNull(log.ToString());
sourceFiles.Select(x => Path.GetFileName(x).Split('.').Reverse().Take(2).Reverse().First()).ShouldBe(new[]
{
"Class1",
"AssemblyAttributes",
"AssemblyInfo"
}, true, log.ToString());
// When
log.GetStringBuilder().Clear();
sourceFiles = analyzer.Build("netstandard2.0").GetSourceFiles();
// Then
sourceFiles.ShouldNotBeNull(log.ToString());
sourceFiles.Select(x => Path.GetFileName(x).Split('.').Reverse().Take(2).Reverse().First()).ShouldBe(new[]
{
"Class2",
"AssemblyAttributes",
"AssemblyInfo"
}, true, log.ToString());
}
private async Task PendOrSubmitRequests(ProjectAnalyzer analyzer, string path)
{
List <string> pendingRequests;
int originalCount;
lock (_containersLock) {
pendingRequests = _pendingRequests;
_pendingRequests.Add(path);
originalCount = _pendingRequests.Count;
if (originalCount > 50)
{
_pendingRequests = new List <string>();
}
}
await Task.Delay(100).ConfigureAwait(false);
lock (_containersLock) {
if (pendingRequests.Count != originalCount)
{
return;
}
if (_pendingRequests == pendingRequests)
{
_pendingRequests = new List <string>();
}
}
await UpdateTestCasesAsync(analyzer, pendingRequests, true).ConfigureAwait(false);
}
public void MultiTargetingBuildAllTargetFrameworksGetsSourceFiles()
{
// Given
StringWriter log = new StringWriter();
ProjectAnalyzer analyzer = GetProjectAnalyzer(@"SdkMultiTargetingProject\SdkMultiTargetingProject.csproj", log);
// When
AnalyzerResults results = analyzer.Build();
// Then
results.Count.ShouldBe(2);
results.TargetFrameworks.ShouldBe(new[] { "net462", "netstandard2.0" }, true, log.ToString());
results["net462"].GetSourceFiles().Select(x => Path.GetFileName(x).Split('.').Reverse().Take(2).Reverse().First()).ShouldBe(new[]
{
"Class1",
"AssemblyAttributes",
"AssemblyInfo"
}, true, log.ToString());
results["netstandard2.0"].GetSourceFiles().Select(x => Path.GetFileName(x).Split('.').Reverse().Take(2).Reverse().First()).ShouldBe(new[]
{
"Class2",
"AssemblyAttributes",
"AssemblyInfo"
}, true, log.ToString());
}
public void GetsSourceFiles(
[ValueSource(nameof(Preferences))] EnvironmentPreference preference,
[ValueSource(nameof(ProjectFiles))] string projectFile)
{
// Given
StringWriter log = new StringWriter();
ProjectAnalyzer analyzer = GetProjectAnalyzer(projectFile, log);
EnvironmentOptions options = new EnvironmentOptions
{
Preference = preference
};
// When
IReadOnlyList <string> sourceFiles = analyzer.Build(options).First().SourceFiles;
// Then
sourceFiles.ShouldNotBeNull(log.ToString());
new[]
{
#if Is_Windows
// Linux and Mac builds appear to omit the AssemblyAttributes.cs file
"AssemblyAttributes",
#endif
"Class1",
"AssemblyInfo"
}.ShouldBeSubsetOf(sourceFiles.Select(x => Path.GetFileName(x).Split('.').TakeLast(2).First()), log.ToString());
}
private static Task <IProjectAnalyzationResult> AnalyzeProject(ProjectData projectData, ILoggerFactory loggerFactory,
CancellationToken cancellationToken = default(CancellationToken))
{
var analyzer = new ProjectAnalyzer(projectData, loggerFactory);
return(analyzer.Analyze(cancellationToken));
}
internal MemberResult[] GetMemberNames(ProjectAnalyzer analyzer, string text)
{
_completionResultEvent.Reset();
_memberResults = null;
using (new SocketLock(this)) {
Socket.Send(GetMembersCommandBytes);
SendString(text);
}
if (_completionResultEvent.WaitOne(1000) && _memberResults != null)
{
MemberResult[] res = new MemberResult[_memberResults.TypeMembers.Count + _memberResults.InstanceMembers.Count];
int i = 0;
foreach (var member in _memberResults.TypeMembers)
{
res[i++] = CreateMemberResult(analyzer, member.Key, member.Value);
}
foreach (var member in _memberResults.InstanceMembers)
{
res[i++] = CreateMemberResult(analyzer, member.Key, member.Value);
}
_memberResults = null;
return(res);
}
return(null);
}
public AnalyzeCommand(IAnsiConsole console)
{
_console = console ?? throw new ArgumentNullException(nameof(console));
_builder = new ProjectBuilder(console);
_analyzer = new ProjectAnalyzer();
_reporter = new ProjectReporter(console);
}
public static Project CreateProject(UInt32 tag, PathDescriptor location, List <FileSystemDescriptor> files)
{
Project project = new Project(tag, location);
files.ParallelFor((file) =>
{
SharpReferenceNode node = new SharpReferenceNode(file as FileDescriptor);
node.FetchExports();
lock (project)
{
project.Files.Nodes.Add(node);
foreach (KeyValuePair <int, string> type in node.Declarations)
{
project.Files[type.Value].Add(node);
}
}
if (node.Flags.Count != 0)
{
lock (project)
project.AssemblyType = (OutputAssemblyType)node.Flags[0];
}
});
ProjectAnalyzer.AddProjectFiles(project);
return(project);
}
public void Exec(string projectFilePath)
{
//string projectFilePath = @"C:\Users\USER\source\repos\ClassLibrary1\ClassLibrary1\ClassLibrary1.csproj";
string projectDirectory = Path.GetDirectoryName(projectFilePath);
var manager = new AnalyzerManager();
ProjectAnalyzer analyzer = manager.GetProject(projectFilePath);
using (var workspace = new AdhocWorkspace())
{
Project roslynProject = analyzer.AddToWorkspace(workspace);
if (roslynProject.Language != LanguageNames.CSharp)
{
throw new NotSupportedException($"The language: {roslynProject.Language} is not supported.");
}
var sourceCode = "namespace Foo{public class Foo{ }}";
Compilation compilation = roslynProject.GetCompilationAsync().Result;
SyntaxTree stree = CSharpSyntaxTree.ParseText(sourceCode);
SyntaxNode root = stree.GetCompilationUnitRoot();
UsingDirectiveSyntax[] usings = (root as CompilationUnitSyntax).Usings.ToArray();
NamespaceDeclarationSyntax namespaceNode = root.DescendantNodes().OfType <NamespaceDeclarationSyntax>().FirstOrDefault();
root = namespaceNode.WithName(SyntaxFactory.ParseName(compilation.GetEntryPoint(System.Threading.CancellationToken.None).ContainingNamespace.ToString()));
root = (root as NamespaceDeclarationSyntax).AddUsings(usings);
string fileName = GetFileName(root);
fileName = Path.ChangeExtension(fileName, "cs");
string filePath = Path.Combine(projectDirectory, fileName);
File.WriteAllText(filePath, root.ToFullString());
var documentId = DocumentId.CreateNewId(roslynProject.Id);
var docInfo = DocumentInfo.Create(documentId, fileName, filePath: filePath);
//await _addDocumentToProjectService.AddDocumentToProject(docInfo, projectFilePath).ConfigureAwait(false);
}
}
public async Task ProjectAnalyzer_ReadProjectFile()
{
var analyzer = new ProjectAnalyzer(new FileUtilities());
var projectReferenceList = await analyzer.AnalyzeProject(@"C:\VS2015\pp-git\LocationService\U4PP.Service.Location.API\U4PP.Service.Location.API.csproj");
;
}
public SyntaxNode Format(SyntaxNode tree)
{
AnalyzerManager manager = new AnalyzerManager();
ProjectAnalyzer analyzer = manager.GetProject(projectFile);
var workspace = analyzer.GetWorkspace();
return(Formatter.Format(tree, workspace));
}
public void ThrowsForLegacyFrameworkProjectWithPackageReference()
{
// Given, When, Then
AnalyzerManager manager = new AnalyzerManager();
ProjectAnalyzer analyzer = manager.GetProject(GetProjectPath(@"LegacyFrameworkProjectWithPackageReference\LegacyFrameworkProjectWithPackageReference.csproj"));
Should.Throw <Exception>(() => analyzer.Load());
}
internal ProjectAnalyzer GetAnalyzer()
{
if (_analyzer == null)
{
_analyzer = CreateAnalyzer();
}
return(_analyzer);
}
/// <summary>
/// Adds a project to an existing Roslyn workspace.
/// </summary>
/// <param name="analyzer">The Buildalyzer project analyzer.</param>
/// <param name="workspace">A Roslyn workspace.</param>
/// <param name="addProjectReferences"><c>true</c> to add projects to the workspace for project references that exist in the same <see cref="AnalyzerManager"/>.</param>
/// <returns>The newly added Roslyn project.</returns>
public static Project AddToWorkspace(this ProjectAnalyzer analyzer, Workspace workspace, bool addProjectReferences = false)
{
if (analyzer == null)
{
throw new ArgumentNullException(nameof(analyzer));
}
if (workspace == null)
{
throw new ArgumentNullException(nameof(workspace));
}
// Get or create an ID for this project
string projectGuid = analyzer.CompiledProject?.GetPropertyValue("ProjectGuid");
ProjectId projectId = !string.IsNullOrEmpty(projectGuid) &&
Guid.TryParse(analyzer.CompiledProject?.GetPropertyValue("ProjectGuid"), out var projectIdGuid)
? ProjectId.CreateFromSerialized(projectIdGuid)
: ProjectId.CreateNewId();
// Create and add the project
ProjectInfo projectInfo = GetProjectInfo(analyzer, workspace, projectId);
Solution solution = workspace.CurrentSolution.AddProject(projectInfo);
// Check if this project is referenced by any other projects in the workspace
foreach (Project existingProject in solution.Projects.ToArray())
{
if (!existingProject.Id.Equals(projectId) &&
analyzer.Manager.Projects.TryGetValue(existingProject.FilePath, out ProjectAnalyzer existingAnalyzer) &&
(existingAnalyzer.GetProjectReferences()?.Contains(analyzer.ProjectFilePath) ?? false))
{
// Add the reference to the existing project
ProjectReference projectReference = new ProjectReference(projectId);
solution = solution.AddProjectReference(existingProject.Id, projectReference);
}
}
// Apply solution changes
if (!workspace.TryApplyChanges(solution))
{
throw new InvalidOperationException("Could not apply workspace solution changes");
}
// Add any project references not already added
if (addProjectReferences)
{
foreach (ProjectAnalyzer referencedAnalyzer in GetReferencedAnalyzerProjects(analyzer))
{
// Check if the workspace contains the project inside the loop since adding one might also add this one due to transitive references
if (!workspace.CurrentSolution.Projects.Any(x => x.FilePath == referencedAnalyzer.ProjectFilePath))
{
AddToWorkspace(referencedAnalyzer, workspace, addProjectReferences);
}
}
}
// Find and return this project
return(workspace.CurrentSolution.GetProject(projectId));
}
protected internal static void CompileProjectAndTrace(ProjectAnalyzer analyzer, StringWriter log)
{
log.GetStringBuilder().Clear();
if (analyzer.Compile() == null)
{
Trace.Error($"Could not compile project at {analyzer.ProjectFilePath}");
Trace.Warning(log.ToString());
}
}
public static Task <CodeGenerator> CreateAsync(string projectFilePath)
{
AnalyzerManager manager = new AnalyzerManager();
ProjectAnalyzer analyzer = manager.GetProject(projectFilePath);
AdhocWorkspace workspace = new AdhocWorkspace();
Project project = analyzer.AddToWorkspace(workspace);
return(Task.FromResult(new CodeGenerator(project)));
}
public void OneTimeSetup()
{
var workingDirectory = Environment.CurrentDirectory;
_testProjectPath = Directory.GetParent(workingDirectory).Parent.Parent.FullName;
var codeAnalyzer = CreateDefaultCodeAnalyzer();
// Get analyzer results from codelyzer (syntax trees, semantic models, package references, project references, etc)
var analyzerResult = codeAnalyzer.AnalyzeProject(DownloadTestProjectsFixture.EShopLegacyWebFormsProjectPath).Result;
var ctaArgs = new[]
{
"-p", DownloadTestProjectsFixture.EShopLegacyWebFormsProjectPath, // can hardcode for local use
"-v", "net5.0", // set the Target Framework version
"-d", "true", // use the default rules files (these will get downloaded from S3 and will tell CTA which packages to add to the new .csproj file)
"-m", "false", // this is the "mock run" flag. Setting it to false means rules will be applied if we do a full port.
};
// Handle argument assignment
PortCoreRulesCli cli = new PortCoreRulesCli();
cli.HandleCommand(ctaArgs);
if (cli.DefaultRules)
{
// Since we're using default rules, we want to specify where to find those rules (once they are downloaded)
cli.RulesDir = Constants.RulesDefaultPath;
}
var packageReferences = new Dictionary <string, Tuple <string, string> >
{
{ "Autofac", new Tuple <string, string>("4.9.1.0", "4.9.3") },
{ "EntityFramework", new Tuple <string, string>("6.0.0.0", "6.4.4") },
{ "log4net", new Tuple <string, string>("2.0.8.0", "2.0.12") },
{ "Microsoft.Extensions.Logging.Log4Net.AspNetCore", new Tuple <string, string>("1.0.0", "2.2.12") }
};
// Create a configuration object using the CLI and other arbitrary values
PortCoreConfiguration projectConfiguration = new PortCoreConfiguration()
{
ProjectPath = cli.FilePath,
RulesDir = cli.RulesDir,
IsMockRun = cli.IsMockRun,
UseDefaultRules = cli.DefaultRules,
PackageReferences = packageReferences,
PortCode = false,
PortProject = true,
TargetVersions = new List <string> {
cli.Version
}
};
var projectRewriter = new ProjectRewriter(analyzerResult, projectConfiguration);
ProjectResult projectResult = projectRewriter.Initialize();
_webFormsProjectAnalyzer = new ProjectAnalyzer(_testProjectPath, analyzerResult, projectConfiguration, projectResult);
_blazorWorkspaceManager = new WorkspaceManagerService();
}
