private void Should_be_able_to_remove_file_without_properties_from_project(string projectRelativePath)
{
var projectTool = TempCopyAndGetProject(projectRelativePath);
var scanFilesInProjectFolderBefore = projectTool.ScanFilesInProjectFolder();
var compileFilesBefore = scanFilesInProjectFolderBefore
.Where(f => f.IncludeType == "Compile")
.Select(f => $"{f.IncludeType}:{f.Name}:{f.Properties.Get("prop1")}:{f.Properties.Get("prop2")}")
.ToArray();
var removeFilePath = PathExtensions.GetAbsolutePath(projectTool.FolderPath, $"SampleClass1IncludedInproject.cs");
projectTool.RemoveFileFromProject(removeFilePath);
projectTool.Save();
var newProjectTool = new ProjectTool(projectTool.FilePath, new ConsoleDebugLogger(true));
var scanFilesInProjectFolderAfter = newProjectTool.ScanFilesInProjectFolder();
var compileFilesAfter = scanFilesInProjectFolderAfter
.Where(f => f.IncludeType == "Compile")
.Select(f => $"{f.IncludeType}:{f.Name}:{f.Properties.Get("prop1")}:{f.Properties.Get("prop2")}")
.OrderBy(o => o)
.ToArray()
.Debug(new ConsoleDebugLogger(true))
;
compileFilesAfter.Should().BeEquivalentTo(
compileFilesBefore.Except(new string[] { "Compile:SampleClass1IncludedInproject.cs::" })
.OrderBy(o => o)
.ToArray()
.Debug(new ConsoleDebugLogger(true))
);
}
private void Should_be_able_to_add_file_to_project(string projectRelativePath)
{
var projectTool = TempCopyAndGetProject(projectRelativePath);
var scanFilesInProjectFolderBefore = projectTool.ScanFilesInProjectFolder();
var compileFilesBefore = scanFilesInProjectFolderBefore
.Where(f => f.IncludeType == "Compile")
.Select(f => $"{f.IncludeType}:{f.Name}")
.ToArray();
var newFilePath = PathExtensions.GetAbsolutePath(projectTool.FolderPath, $"newCompileFile.cs");
projectTool.AddFileToProject(newFilePath, "Compile");
projectTool.Save();
var newProjectTool = new ProjectTool(projectTool.FilePath, new ConsoleDebugLogger(true));
var scanFilesInProjectFolderAfter = newProjectTool.ScanFilesInProjectFolder();
var compileFilesAfter = scanFilesInProjectFolderAfter
.Where(f => f.IncludeType == "Compile")
.Select(f => $"{f.IncludeType}:{f.Name}")
.OrderBy(o => o)
.Debug(new ConsoleDebugLogger(true))
.ToArray();
compileFilesAfter.Should().BeEquivalentTo(
// Admittedly this does nothing, as the file actually doesn't exist on disk for CPS projects. But the change to the project should be this (none)
projectTool.IsCpsDocument ? compileFilesBefore : compileFilesBefore.Union(new string[] { "Compile:newCompileFile.cs" })
.OrderBy(o => o)
.Debug(new ConsoleDebugLogger(true))
.ToArray()
);
}
private void Should_be_able_to_add_excluded_file_with_properties_to_project(string projectRelativePath)
{
var projectTool = TempCopyAndGetProject(projectRelativePath);
var scanFilesInProjectFolderBefore = projectTool.ScanFilesInProjectFolder();
var compileFilesBefore = scanFilesInProjectFolderBefore
.Where(f => f.IncludeType == "Compile")
.Select(f => $"{f.IncludeType}:{f.Name}:{f.Properties.Get("prop1")}:{f.Properties.Get("prop2")}")
.ToArray();
var newFilePath = PathExtensions.GetAbsolutePath(projectTool.FolderPath, $"SampleClass3NotIncludedInproject.cs");
var fileProperties = new Dictionary <string, string>()
{
{ "prop1", "value1" }, { "prop2", "value2" }
};
projectTool.AddFileToProject(newFilePath, "Compile", fileProperties);
projectTool.Save();
var newProjectTool = new ProjectTool(projectTool.FilePath, new ConsoleDebugLogger(true));
var scanFilesInProjectFolderAfter = newProjectTool.ScanFilesInProjectFolder();
var compileFilesAfter = scanFilesInProjectFolderAfter
.Where(f => f.IncludeType == "Compile")
.Select(f => $"{f.IncludeType}:{f.Name}:{f.Properties.Get("prop1")}:{f.Properties.Get("prop2")}")
.OrderBy(o => o)
.Debug(new ConsoleDebugLogger(true))
.ToArray();
compileFilesAfter.Should().BeEquivalentTo(
compileFilesBefore.Union(new string[] { "Compile:SampleClass3NotIncludedInproject.cs:value1:value2" })
.OrderBy(o => o)
.Debug(new ConsoleDebugLogger(true))
.ToArray()
);
}
public void GetAbsolutePath()
{
Assert.AreEqual(Environment.CurrentDirectory, PathExtensions.GetAbsolutePath(null));
Assert.AreEqual(Environment.CurrentDirectory, PathExtensions.GetAbsolutePath(""));
Assert.AreEqual(Path.Combine(Environment.CurrentDirectory, "File.ext"),
PathExtensions.GetAbsolutePath("File.ext"));
}
private ProjectTool GetProjectTool(string projectRelativePath)
{
var currentFolder = System.IO.Path.GetDirectoryName(new Uri(this.GetType().Assembly.CodeBase).LocalPath);
var csProjAbsolutePath = PathExtensions.GetAbsolutePath(currentFolder, projectRelativePath);
var projectTool = new ProjectTool(csProjAbsolutePath, new DebugLogger(true));
return(projectTool);
}
private void LoadAndBuildEventSource(Project project, ProjectItem <EventSourceModel> eventSourceDefinitionProjectItem)
{
var eventSourceModel = eventSourceDefinitionProjectItem.Content;
var sourceFileName = System.IO.Path.GetFileName(eventSourceDefinitionProjectItem.Name);
var name = sourceFileName.Replace(".eventsource.json", "");
var implementationFileName = $"{name}.cs";
var fileRelativePath = eventSourceDefinitionProjectItem.Name
.RemoveFromStart(project.ProjectBasePath + System.IO.Path.DirectorySeparatorChar)
.Replace(sourceFileName, implementationFileName);
var fileRelateiveFolderPath = System.IO.Path.GetDirectoryName(fileRelativePath);
var eventSourceNamespace = fileRelateiveFolderPath.Length > 0
? $"{eventSourceDefinitionProjectItem.RootNamespace}.{fileRelateiveFolderPath.Replace(System.IO.Path.DirectorySeparatorChar, '.')}"
: eventSourceDefinitionProjectItem.RootNamespace;
if (eventSourceModel == null)
{
var content = System.IO.File.ReadAllText(eventSourceDefinitionProjectItem.Name);
var converters = new List <JsonConverter> {
new KeywordModelJsonConverter()
};
eventSourceModel = Newtonsoft.Json.JsonConvert.DeserializeObject <EventSourceModel>(content, new JsonSerializerSettings()
{
NullValueHandling = NullValueHandling.Ignore,
Converters = converters
});
eventSourceModel.Include = fileRelativePath;
}
eventSourceModel.Name = name;
eventSourceModel.Namespace = eventSourceModel.Namespace ?? eventSourceNamespace;
eventSourceModel.ProviderName = eventSourceModel.ProviderName ?? $"{eventSourceModel.Namespace.Replace('.', '-')}-{name}";
eventSourceModel.ClassName = name.GetUpperCasedInitial();
eventSourceModel.SourceFilePath = eventSourceDefinitionProjectItem.Include;
var filePath = PathExtensions.GetAbsolutePath(System.IO.Path.GetDirectoryName(eventSourceDefinitionProjectItem.Name), implementationFileName);
eventSourceDefinitionProjectItem.Content = eventSourceModel;
BuildEventSource(project, eventSourceDefinitionProjectItem);
var newProjectItem = new ProjectItem <EventSourceModel>(
type: ProjectItemType.EventSource,
name: filePath,
content: eventSourceModel,
include: eventSourceModel.Include)
{
DependentUpon = eventSourceDefinitionProjectItem,
};
project.AddProjectItem(newProjectItem);
}
private void TryLaunchApp(AppInfo app)
{
string exeFilePath = Path.Combine(GetAppExtractionDirectory(app), app.Name + ".exe");
string exeDirectory = PathExtensions.GetAbsolutePath(Path.GetDirectoryName(exeFilePath));
var processRunner = new ProcessRunner(exeFilePath)
{
WorkingDirectory = exeDirectory
};
processRunner.Start();
}
private ProjectTool TempCopyAndGetProject(string projectRelativePath)
{
var currentFolder = System.IO.Path.GetDirectoryName(new Uri(this.GetType().Assembly.CodeBase).LocalPath);
var csProjAbsolutePath = PathExtensions.GetAbsolutePath(currentFolder, projectRelativePath);
var projectFolder = System.IO.Path.GetDirectoryName(csProjAbsolutePath);
var projectTempCopyName = $"{System.IO.Path.GetRandomFileName()}.csproj";
var projectTempCopyPath = PathExtensions.GetAbsolutePath(projectFolder, projectTempCopyName);
System.IO.File.Copy(csProjAbsolutePath, projectTempCopyPath);
_temporaryProjectFileCopies.Add(projectTempCopyPath);
var projectTool = new ProjectTool(projectTempCopyPath, new DebugLogger(true));
return(projectTool);
}
public void Build(Project model)
{
LogMessage($"Scanning project {model.ProjectFilePath} for eventsource definitions");
model.ProjectBasePath = System.IO.Path.GetDirectoryName(model.ProjectFilePath);
var projectItems = new List <ProjectItem>();
if (model.ProjectFilePath == null)
{
LogMessage($"Could not find basePath of {model.ProjectFilePath}");
}
if (model.ProjectBasePath != null)
{
var projectName = System.IO.Path.GetFileNameWithoutExtension(model.ProjectFilePath);
var configuration = "Debug";
var projectTool = new FG.Utils.BuildTools.ProjectTool(model.ProjectFilePath, null);
var projectFiles = projectTool.ScanFilesInProjectFolder();
var projectReferences = projectTool.GetProjectReferences();
var projectProperties = projectTool.GetProjectProperties(configuration, model.Platform);
LogMessage($"Loaded project {model.ProjectFilePath} from XML with {projectFiles.Count()} items");
var rootNamespace = projectProperties.ContainsKey("RootNamespace") ? projectProperties["RootNamespace"] : projectName;
var assemblyName = projectProperties.ContainsKey("AssemblyName") ? projectProperties["AssemblyName"] : projectName;
model.RootNamespace = rootNamespace;
model.AssemblyName = assemblyName;
var hasEventSource = false;
foreach (var projectItem in projectFiles.Where(item =>
item.Name.EndsWith(@".eventsource.json", StringComparison.InvariantCultureIgnoreCase)))
{
projectItems.Add(new ProjectItem <EventSourceModel>(ProjectItemType.EventSourceDefinition, projectItem.Path)
{
Include = projectItem.Name,
RootNamespace = rootNamespace,
AssemblyName = assemblyName,
});
hasEventSource = true;
}
foreach (var projectItem in projectFiles.Where(item =>
item.Name.Matches(@"*.eventsource.output.json", StringComparison.InvariantCultureIgnoreCase, useWildcards: true) &&
item.IncludeType == "Content"))
{
var projectItemFilePath = projectItem.Path;
projectItems.Add(new ProjectItem <ProjectSummary>(ProjectItemType.ProjectSummary, projectItemFilePath)
{
Include = projectItem.Name,
});
}
var autogeneratedMetadataTypes = new[]
{
ProjectItemType.ProjectSummary,
ProjectItemType.DefaultGeneratedEventSourceDefinition,
ProjectItemType.EventSource,
ProjectItemType.EventSourceLoggerPartial,
ProjectItemType.LoggerImplementation
}
.Select(metadata => Enum.GetName(typeof(ProjectItemType), metadata))
.ToArray();
foreach (var projectItem in projectFiles.Where(item =>
item.Name.Matches(@"(^|\\)I[^\\]*Logger.cs", StringComparison.InvariantCultureIgnoreCase, useWildcards: false) &&
item.IncludeType == "Compile" &&
!autogeneratedMetadataTypes.Contains((item.Properties.ContainsKey("AutoGenerated") ? item.Properties["AutoGenerated"] : "") ?? "")))
{
var projectItemFilePath = projectItem.Path;
projectItems.Add(new ProjectItem <LoggerTemplateModel>(ProjectItemType.LoggerInterface, projectItemFilePath)
{
Include = projectItem.Name
});
}
foreach (var projectItem in projectFiles.Where(item =>
item.Name.Matches(@"(^|\\)[^\\]*Extension.cs", StringComparison.InvariantCultureIgnoreCase, useWildcards: false) &&
item.IncludeType == "Compile" &&
!autogeneratedMetadataTypes.Contains((item.Properties.ContainsKey("AutoGenerated") ? item.Properties["AutoGenerated"] : "") ?? "")))
{
var projectItemFilePath = projectItem.Path;
projectItems.Add(new ProjectItem(ProjectItemType.BuilderExtension, projectItemFilePath)
{
Include = projectItem.Name
});
}
var outputPath = projectTool.GetProjectOutputPath(configuration, null);
var buildOutputPath = PathExtensions.GetAbsolutePath(model.ProjectBasePath, outputPath);
var outputPathExists = System.IO.Directory.Exists(buildOutputPath);
if (!outputPathExists)
{
outputPath = projectTool.GetProjectOutputPath(configuration, "x64");
buildOutputPath = PathExtensions.GetAbsolutePath(model.ProjectBasePath, outputPath);
outputPathExists = System.IO.Directory.Exists(buildOutputPath);
}
if (outputPathExists)
{
var outputFiles = System.IO.Directory.GetFiles(buildOutputPath, "*.*", SearchOption.AllDirectories);
foreach (var outputFile in outputFiles)
{
var outputFileType = System.IO.Path.GetExtension(outputFile);
if (outputFileType == ".dll" || outputFileType == ".exe")
{
var referenceFilePath = outputFile;
var referenceName = System.IO.Path.GetFileNameWithoutExtension(outputFile);
projectItems.Add(
new ProjectItem(ProjectItemType.Reference, referenceFilePath)
{
Include = referenceName
});
}
}
}
if (!hasEventSource)
{
var defaultEventSourceName = $"{assemblyName}EventSource";
defaultEventSourceName = defaultEventSourceName.RemoveNonWordCharacters();
var include = $"{defaultEventSourceName}.eventsource.json";
var projectItemFilePath = System.IO.Path.Combine(model.ProjectBasePath, include);
projectItems.Add(new ProjectItem <EventSourceModel>(ProjectItemType.DefaultGeneratedEventSourceDefinition, projectItemFilePath)
{
Include = include,
RootNamespace = rootNamespace,
AssemblyName = assemblyName,
});
}
}
model.ProjectItems = projectItems.ToArray();
}
public IEnumerable <ProjectItem> GetProjectItems(string projectFilePath)
{
LogMessage($"Scanning project {projectFilePath} for eventsource definitions");
var basePath = System.IO.Path.GetDirectoryName(projectFilePath);
if (basePath == null)
{
LogMessage($"Could not find basePath of {projectFilePath}");
}
if (basePath != null)
{
var projectName = System.IO.Path.GetFileNameWithoutExtension(projectFilePath);
Project project = null;
using (var projectFileReader = XmlReader.Create(projectFilePath))
{
project = new Project(projectFileReader);
LogMessage($"Loaded project {projectFilePath} from XML with {project.Items.Count} items");
}
var hasEventSource = false;
foreach (
var projectItem in project.Items.Where(item => item.EvaluatedInclude.EndsWith(@".eventsource", StringComparison.InvariantCultureIgnoreCase))
)
{
var rootNamespace = project.Properties.FirstOrDefault(property => property.Name.Equals("RootNamespace"))?.EvaluatedValue ?? projectName;
var projectItemFilePath = System.IO.Path.Combine(basePath, projectItem.EvaluatedInclude);
yield return(new ProjectItem(ProjectItemType.EventSourceDefinition, projectItemFilePath)
{
Include = projectItem.EvaluatedInclude, RootNamespace = rootNamespace
});
hasEventSource = true;
}
foreach (var projectItem in project.Items.Where(item =>
item.EvaluatedInclude.Matches(@"(^|\\)I[^\\]*Logger.cs", StringComparison.InvariantCultureIgnoreCase, useWildcards: false) &&
item.ItemType == "Compile"))
{
var projectItemFilePath = System.IO.Path.Combine(basePath, projectItem.EvaluatedInclude);
yield return(new ProjectItem(ProjectItemType.LoggerInterface, projectItemFilePath)
{
Include = projectItem.EvaluatedInclude
});
}
foreach (var projectItem in project.Items.Where(item =>
item.EvaluatedInclude.Matches(@"(^|\\)[^\\]*BuilderExtension.cs", StringComparison.InvariantCultureIgnoreCase, useWildcards: false) &&
item.ItemType == "Compile"))
{
var projectItemFilePath = System.IO.Path.Combine(basePath, projectItem.EvaluatedInclude);
yield return(new ProjectItem(ProjectItemType.BuilderExtension, projectItemFilePath)
{
Include = projectItem.EvaluatedInclude
});
}
var anyHintPath = "";
foreach (var projectItem in project.Items.Where(item => item.ItemType == "Reference"))
{
var hintPath = projectItem.HasMetadata("HintPath") ? projectItem.GetMetadataValue("HintPath") : null;
hintPath = hintPath != null?PathExtensions.GetAbsolutePath(basePath, hintPath) : null;
anyHintPath = hintPath ?? anyHintPath;
var projectItemFilePath = hintPath == null ? $"{projectItem.EvaluatedInclude}.dll" : System.IO.Path.Combine(basePath, hintPath);
yield return(new ProjectItem(ProjectItemType.Reference, projectItemFilePath)
{
Include = projectItem.EvaluatedInclude
});
}
var outputPath =
project.Items.FirstOrDefault(item => item.ItemType.Equals("_OutputPathItem", StringComparison.InvariantCultureIgnoreCase))?.EvaluatedInclude;
foreach (var projectItem in project.Items.Where(item => item.ItemType == "ProjectReference"))
{
var referencedProjectPath = PathExtensions.GetAbsolutePath(basePath, projectItem.EvaluatedInclude);
var referencedProjectName = System.IO.Path.GetFileNameWithoutExtension(projectItem.EvaluatedInclude);
var expectedDllName = $"{referencedProjectName}.dll";
var referencedProjectOutputPath = PathExtensions.GetAbsolutePath(System.IO.Path.GetDirectoryName(referencedProjectPath), outputPath);
var projectItemFilePath = System.IO.Path.Combine(referencedProjectOutputPath, expectedDllName);
if (System.IO.File.Exists(projectItemFilePath))
{
yield return(new ProjectItem(ProjectItemType.Reference, projectItemFilePath)
{
Include = projectItem.EvaluatedInclude
});
}
}
if (!hasEventSource)
{
var rootNamespace = project.Properties.FirstOrDefault(property => property.Name.Equals("RootNamespace"))?.EvaluatedValue ?? projectName;
var include = $"DefaultEventSource.eventsource";
var projectItemFilePath = System.IO.Path.Combine(basePath, include);
yield return(new ProjectItem(ProjectItemType.DefaultGeneratedEventSource, projectItemFilePath)
{
Include = include, RootNamespace = rootNamespace
});
}
}
}
private void TryInstallPackage(AndroidDevice device, string apkFilePath)
{
RunAdbProcess("-s " + device.AdbId + " install -r " +
PathExtensions.GetAbsolutePath(apkFilePath));
}
public void Build(Project model)
{
LogMessage($"Scanning project {model.ProjectFilePath} for eventsource definitions");
model.ProjectBasePath = System.IO.Path.GetDirectoryName(model.ProjectFilePath);
var projectItems = new List <ProjectItem>();
if (model.ProjectFilePath == null)
{
LogMessage($"Could not find basePath of {model.ProjectFilePath}");
}
if (model.ProjectBasePath != null)
{
var projectName = System.IO.Path.GetFileNameWithoutExtension(model.ProjectFilePath);
Microsoft.Build.Evaluation.Project project = null;
using (var projectFileReader = XmlReader.Create(model.ProjectFilePath))
{
project = new Microsoft.Build.Evaluation.Project(projectFileReader);
LogMessage($"Loaded project {model.ProjectFilePath} from XML with {project.Items.Count} items");
}
var hasEventSource = false;
foreach (
var projectItem in project.Items.Where(item => item.EvaluatedInclude.EndsWith(@".eventsource.json", StringComparison.InvariantCultureIgnoreCase))
)
{
var rootNamespace = project.Properties.FirstOrDefault(property => property.Name.Equals("RootNamespace"))?.EvaluatedValue ?? projectName;
var projectItemFilePath = System.IO.Path.Combine(model.ProjectBasePath, projectItem.EvaluatedInclude);
projectItems.Add(new ProjectItem <EventSourceModel>(ProjectItemType.EventSourceDefinition, projectItemFilePath)
{
Include = projectItem.EvaluatedInclude,
RootNamespace = rootNamespace
});
hasEventSource = true;
}
var platformProperty = project.Properties.FirstOrDefault(p => p.Name == "PlatformTarget")?.EvaluatedValue ?? "AnyCPU";
model.Platform = platformProperty;
var summaryHash = project.Properties.FirstOrDefault(p => p.Name == "EventSourceGeneratorSummaryHash")?.EvaluatedValue ?? "";
model.SummaryHash = summaryHash;
foreach (var projectItem in project.Items.Where(item =>
item.EvaluatedInclude.Matches(@"(^|\\)I[^\\]*Logger.cs", StringComparison.InvariantCultureIgnoreCase, useWildcards: false) &&
item.ItemType == "Compile"))
{
var projectItemFilePath = System.IO.Path.Combine(model.ProjectBasePath, projectItem.EvaluatedInclude);
projectItems.Add(new ProjectItem <LoggerTemplateModel>(ProjectItemType.LoggerInterface, projectItemFilePath)
{
Include = projectItem.EvaluatedInclude
});
}
foreach (var projectItem in project.Items.Where(item =>
item.EvaluatedInclude.Matches(@"(^|\\)[^\\]*Extension.cs", StringComparison.InvariantCultureIgnoreCase, useWildcards: false) &&
item.ItemType == "Compile"))
{
var projectItemFilePath = System.IO.Path.Combine(model.ProjectBasePath, projectItem.EvaluatedInclude);
projectItems.Add(new ProjectItem(ProjectItemType.BuilderExtension, projectItemFilePath)
{
Include = projectItem.EvaluatedInclude
});
}
var anyHintPath = "";
foreach (var projectItem in project.Items.Where(item => item.ItemType == "Reference"))
{
var hintPath = projectItem.HasMetadata("HintPath") ? projectItem.GetMetadataValue("HintPath") : null;
hintPath = hintPath != null?PathExtensions.GetAbsolutePath(model.ProjectBasePath, hintPath) : null;
anyHintPath = hintPath ?? anyHintPath;
var projectItemFilePath = hintPath == null ? $"{projectItem.EvaluatedInclude}.dll" : System.IO.Path.Combine(model.ProjectBasePath, hintPath);
projectItems.Add(new ProjectItem(ProjectItemType.Reference, projectItemFilePath)
{
Include = projectItem.EvaluatedInclude
});
}
var outputPath =
project.Items.FirstOrDefault(item => item.ItemType.Equals("_OutputPathItem", StringComparison.InvariantCultureIgnoreCase))?.EvaluatedInclude;
foreach (var projectItem in project.Items.Where(item => item.ItemType == "ProjectReference"))
{
var referencedProjectPath = PathExtensions.GetAbsolutePath(model.ProjectBasePath, projectItem.EvaluatedInclude);
var referencedProjectName = System.IO.Path.GetFileNameWithoutExtension(projectItem.EvaluatedInclude);
var expectedDllName = $"{referencedProjectName}.dll";
var referencedProjectOutputPath = PathExtensions.GetAbsolutePath(System.IO.Path.GetDirectoryName(referencedProjectPath), outputPath);
var projectItemFilePath = System.IO.Path.Combine(referencedProjectOutputPath, expectedDllName);
if (System.IO.File.Exists(projectItemFilePath))
{
projectItems.Add(new ProjectItem(ProjectItemType.Reference, projectItemFilePath)
{
Include = projectItem.EvaluatedInclude
});
}
else
{
var referencedProject = QuickLoadProjectReference(referencedProjectPath);
var referencedProjectSubOutputPath =
referencedProject.Items.FirstOrDefault(item => item.ItemType.Equals("_OutputPathItem", StringComparison.InvariantCultureIgnoreCase))?
.EvaluatedInclude;
referencedProjectOutputPath = PathExtensions.GetAbsolutePath(System.IO.Path.GetDirectoryName(referencedProjectPath), referencedProjectSubOutputPath);
projectItemFilePath = System.IO.Path.Combine(referencedProjectOutputPath, expectedDllName);
if (System.IO.File.Exists(projectItemFilePath))
{
projectItems.Add(new ProjectItem(ProjectItemType.Reference, projectItemFilePath)
{
Include = projectItem.EvaluatedInclude
});
}
}
}
if (!hasEventSource)
{
var rootNamespace = project.Properties.FirstOrDefault(property => property.Name.Equals("RootNamespace"))?.EvaluatedValue ?? projectName;
var include = $"DefaultEventSource.eventsource.json";
var projectItemFilePath = System.IO.Path.Combine(model.ProjectBasePath, include);
projectItems.Add(new ProjectItem <EventSourceModel>(ProjectItemType.DefaultGeneratedEventSourceDefinition, projectItemFilePath)
{
Include = include,
RootNamespace = rootNamespace
});
}
}
model.ProjectItems = projectItems.ToArray();
}
static void Main(string[] args)
{
if (args == null || args.Length == 0)
{
LogMessage("Enter arguments for program:");
var line = Console.ReadLine();
if (string.IsNullOrWhiteSpace(line))
{
line = "-o -s -g";
}
args = line.Split(' ');
}
var options = Parser.Default.ParseArguments <ConsoleOptions>(args);
options.WithParsed(t =>
{
if (t.Verbose)
{
LogMessage($"Filename: {t.ProjectFile}");
}
if (t.ProjectFile == null)
{
var possibleProjectFiles = System.IO.Directory.GetFiles("*.csproj");
if (possibleProjectFiles.Any())
{
t.ProjectFile = possibleProjectFiles.First();
}
}
if (!System.IO.File.Exists(t.ProjectFile))
{
LogMessage($"The project file {t.ProjectFile} could not be found", EventLevel.Critical);
return;
}
if (!System.IO.Path.IsPathRooted(t.ProjectFile))
{
t.ProjectFile = PathExtensions.GetAbsolutePath(t.ProjectFile);
}
var projectFilePath = t.ProjectFile;
var projectEventSourceGenerator = new ProjectEventSourceGenerator();
projectEventSourceGenerator.SetLogMessage(m => LogMessage(m, EventLevel.Informational));
projectEventSourceGenerator.SetLogWarning(w => LogMessage(w, EventLevel.Warning));
projectEventSourceGenerator.SetLogError(e => LogMessage(e, EventLevel.Error));
var baseDirectory = AppDomain.CurrentDomain.BaseDirectory;
var roslynDirectory = System.IO.Path.Combine(baseDirectory, "roslyn");
var project = projectEventSourceGenerator.Run(projectFilePath, roslynDirectory, t.SaveChanges, t.ForceUpdate);
if (t.DisplayOutput)
{
foreach (var output in project.ProjectItems.OfType(
ProjectItemType.EventSource,
ProjectItemType.DefaultGeneratedEventSourceDefinition,
ProjectItemType.EventSourceLoggerPartial,
ProjectItemType.LoggerImplementation))
{
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine($"{"".PadRight(40, '_')}");
Console.WriteLine($"{"".PadRight(40, '=')}");
Console.WriteLine($"File: {output.Name}");
Console.WriteLine($"{"".PadRight(40, '_')}");
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine(output.Output);
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine($"{"".PadRight(40, '_')}");
Console.WriteLine($"{"".PadRight(40, '=')}");
}
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine($"{"".PadRight(40, '_')}");
Console.WriteLine($"{"".PadRight(40, '=')}");
Console.WriteLine($"File: {projectFilePath}");
Console.WriteLine($"{"".PadRight(40, '_')}");
Console.ForegroundColor = ConsoleColor.White;
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine($"{"".PadRight(40, '_')}");
Console.WriteLine($"{"".PadRight(40, '=')}");
}
if (t.GenerateSchema)
{
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine($"Generating JSON Schema");
var output = SchemaWriter.GenerateSchema(t.SaveChanges).GetAwaiter().GetResult();
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine($"{"".PadRight(40, '_')}");
Console.WriteLine($"{"".PadRight(40, '=')}");
Console.WriteLine($"File: {output.Name}");
Console.WriteLine($"{"".PadRight(40, '_')}");
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine(output.Output);
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine($"{"".PadRight(40, '_')}");
Console.WriteLine($"{"".PadRight(40, '=')}");
Console.WriteLine($"Done generating JSON Schema");
}
});
Console.ReadKey();
}
private void LoadAndBuildEventSource(Project project, ProjectItem <EventSourceModel> eventSourceDefinitionProjectItem)
{
var eventSourceModel = eventSourceDefinitionProjectItem.Content;
var sourceFileName = System.IO.Path.GetFileName(eventSourceDefinitionProjectItem.Name);
var name = sourceFileName.Replace(".eventsource.json", "");
var implementationFileName = $"{name}.cs";
var fileRelativePath = eventSourceDefinitionProjectItem.Name
.RemoveFromStart(project.ProjectBasePath + System.IO.Path.DirectorySeparatorChar)
.Replace(sourceFileName, implementationFileName);
var fileRelateiveFolderPath = System.IO.Path.GetDirectoryName(fileRelativePath);
var eventSourceNamespace = fileRelateiveFolderPath.Length > 0
? $"{eventSourceDefinitionProjectItem.RootNamespace}.{fileRelateiveFolderPath.Replace(System.IO.Path.DirectorySeparatorChar, '.')}"
: eventSourceDefinitionProjectItem.RootNamespace;
if (eventSourceModel == null)
{
var content = System.IO.File.ReadAllText(eventSourceDefinitionProjectItem.Name);
var converters = new List <JsonConverter> {
new KeywordModelJsonConverter()
};
eventSourceModel = Newtonsoft.Json.JsonConvert.DeserializeObject <EventSourceModel>(content, new JsonSerializerSettings()
{
NullValueHandling = NullValueHandling.Ignore,
Converters = converters
});
eventSourceModel.Include = fileRelativePath;
}
eventSourceModel.Name = name;
eventSourceModel.Namespace = eventSourceModel.Namespace ?? eventSourceNamespace;
eventSourceModel.ProviderName = eventSourceModel.ProviderName ?? $"{eventSourceModel.Namespace.Replace('.', '-')}-{name}";
eventSourceModel.ClassName = name.GetUpperCasedInitial();
eventSourceModel.SourceFilePath = eventSourceDefinitionProjectItem.Include;
if (eventSourceModel.Settings == null)
{
eventSourceModel.Settings = new EventSourceModel.EventSourceSettings();
}
if (eventSourceModel.Settings.UseReferencedHelpers)
{
var referenceAssemblyName = typeof(EventArgumentModel).Assembly.GetName().Name;
var referenceToAutoLoggerModel = project.DynamicAssembly.GetReferencedAssemblies().FirstOrDefault(r =>
r.Name == referenceAssemblyName);
if (referenceToAutoLoggerModel == null)
{
LogWarning($"The 'UseReferencedHelpers' setting for EventSource '{eventSourceModel.Name}' can only be specified if the project references '{referenceAssemblyName}'");
}
}
var filePath = PathExtensions.GetAbsolutePath(System.IO.Path.GetDirectoryName(eventSourceDefinitionProjectItem.Name), implementationFileName);
eventSourceDefinitionProjectItem.Content = eventSourceModel;
BuildEventSource(project, eventSourceDefinitionProjectItem);
var newProjectItem = new ProjectItem <EventSourceModel>(
type: ProjectItemType.EventSource,
name: filePath,
content: eventSourceModel,
include: eventSourceModel.Include)
{
DependentUpon = eventSourceDefinitionProjectItem,
};
project.AddProjectItem(newProjectItem);
}
