/// <inheritdoc />
public override bool Execute()
{
var funcLogManager = new FuncLogManager(type => new WrappingFullLogger(new WrappingPrefixLogger(new MsBuildLogger(Log, LogLevel.Debug), type)));
Locator.CurrentMutable.RegisterConstant(funcLogManager, typeof(ILogManager));
if (string.IsNullOrWhiteSpace(OutputFile))
{
Log.LogError($"{nameof(OutputFile)} is not set");
return(false);
}
if (string.IsNullOrWhiteSpace(TargetFramework))
{
Log.LogError($"{nameof(TargetFramework)} is not set");
return(false);
}
using (var writer = new StreamWriter(Path.Combine(OutputFile)))
{
ObservablesForEventGenerator.WriteHeader(writer, TargetFramework).ConfigureAwait(false).GetAwaiter().GetResult();
try
{
ObservablesForEventGenerator.ExtractEventsFromTargetFramework(writer, TargetFramework.ToFrameworks()).GetAwaiter().GetResult();
}
catch (Exception ex)
{
this.Log().Error(ex);
return(false);
}
}
return(true);
}
public async Task PlatformGeneratesCode(AutoPlatform autoPlatform)
{
var sourceDirectory = IntegrationTestHelper.GetOutputDirectory();
var referenceAssembliesLocation = ReferenceLocator.GetReferenceLocation();
await ObservablesForEventGenerator.ExtractEventsFromPlatforms(sourceDirectory, string.Empty, ".received.txt", referenceAssembliesLocation, new[] { autoPlatform }, TestUtilities.GetPackageDirectory()).ConfigureAwait(false);
}
public static async Task CheckResultsAgainstTemplate(PackageIdentity[] package, IReadOnlyList <NuGetFramework> frameworks, [CallerFilePath] string filePath = null, [CallerMemberName] string memberName = null)
{
using (var memoryStream = new MemoryStream())
{
using (var streamWriter = new StreamWriter(memoryStream, Encoding.UTF8, 1024, true))
{
await ObservablesForEventGenerator.ExtractEventsFromNuGetPackages(streamWriter, package, frameworks, TestUtilities.GetPackageDirectory(memberName, filePath)).ConfigureAwait(false);
}
CheckPackageIdentityContents(memoryStream, package[0], frameworks[0], filePath);
}
}
/// <inheritdoc />
public override bool Execute()
{
var lockFile = OutputFile + ".lock";
var funcLogManager = new FuncLogManager(type => new WrappingFullLogger(new WrappingPrefixLogger(new MsBuildLogger(Log, LogLevel.Debug), type)));
Locator.CurrentMutable.RegisterConstant(funcLogManager, typeof(ILogManager));
if (string.IsNullOrWhiteSpace(OutputFile))
{
Log.LogError($"{nameof(OutputFile)} is not set");
return(false);
}
var nugetFrameworks = GetTargetFrameworks();
if (nugetFrameworks == null)
{
Log.LogError("Neither TargetFramework nor ProjectTypeGuids have been correctly set.");
return(false);
}
var packages = GetPackages();
var lockPackages = ReadPackages(lockFile);
if (lockPackages != null && lockPackages.Count == packages.Count && lockPackages.All(packages.Contains))
{
return(true);
}
using (var writer = new StreamWriter(Path.Combine(OutputFile), false, Encoding.UTF8))
{
ObservablesForEventGenerator.WriteHeader(writer, packages).ConfigureAwait(false).GetAwaiter().GetResult();
try
{
ObservablesForEventGenerator.ExtractEventsFromNuGetPackages(writer, packages, nugetFrameworks).GetAwaiter().GetResult();
}
catch (Exception ex)
{
this.Log().Error(ex);
return(false);
}
}
WritePackages(packages, lockFile);
return(true);
}
public static async Task CheckResultsAgainstTemplate(LibraryRange[] package, IReadOnlyList <NuGetFramework> frameworks, [CallerFilePath] string filePath = null, [CallerMemberName] string memberName = null)
{
var sourceRepository = new SourceRepository(new PackageSource(NuGetPackageHelper.DefaultNuGetSource), NuGetPackageHelper.Providers);
var findResource = await sourceRepository.GetResourceAsync <FindPackageByIdResource>().ConfigureAwait(false);
var bestPackageIdentity = await NuGetPackageHelper.GetBestMatch(package[0], findResource, CancellationToken.None).ConfigureAwait(false);
using (var memoryStream = new MemoryStream())
{
using (var streamWriter = new StreamWriter(memoryStream, Encoding.UTF8, 1024, true))
{
await ObservablesForEventGenerator.ExtractEventsFromNuGetPackages(streamWriter, package, frameworks, TestUtilities.GetPackageDirectory(memberName, filePath)).ConfigureAwait(false);
}
CheckPackageIdentityContents(memoryStream, bestPackageIdentity, frameworks[0], filePath);
}
}
async Task CompileReactiveEvents()
{
var avaloniaBuildOutput = Path.Combine(RootDirectory, "packages", "Avalonia", "bin", Parameters.Configuration);
var avaloniaAssemblies = GlobFiles(avaloniaBuildOutput, "**/Avalonia*.dll")
.Where(file => !file.Contains("Avalonia.Build.Tasks") &&
!file.Contains("Avalonia.Remote.Protocol"));
var eventsDirectory = GlobDirectories($"{RootDirectory}/src/**/Avalonia.ReactiveUI.Events").First();
var eventsBuildFile = Path.Combine(eventsDirectory, "Events_Avalonia.cs");
if (File.Exists(eventsBuildFile))
{
File.Delete(eventsBuildFile);
}
using (var stream = File.Create(eventsBuildFile))
using (var writer = new StreamWriter(stream))
{
await ObservablesForEventGenerator.ExtractEventsFromAssemblies(
writer, avaloniaAssemblies, new string[0], "netstandard2.0"
);
}
var eventsProject = Path.Combine(eventsDirectory, "Avalonia.ReactiveUI.Events.csproj");
if (Parameters.IsRunningOnWindows)
{
MsBuildCommon(eventsProject, c => c
.SetArgumentConfigurator(a => a.Add("/r"))
.AddTargets("Build")
);
}
else
{
DotNetBuild(c => c
.SetProjectFile(eventsProject)
.AddProperty("PackageVersion", Parameters.Version)
.SetConfiguration(Parameters.Configuration)
);
}
}
public async Task IntegrationTestAssemblyTest()
{
using (var memoryStream = new MemoryStream())
{
var input = await NuGetPackageHelper.DownloadPackageFilesAndFolder(new[] { new PackageIdentity("NETStandard.Library", new NuGetVersion("2.0.0")) }).ConfigureAwait(false);
using (var streamWriter = new StreamWriter(memoryStream, Encoding.UTF8, 1024, true))
{
await ObservablesForEventGenerator.ExtractEventsFromAssemblies(streamWriter, input, FrameworkConstants.CommonFrameworks.NetStandard20).ConfigureAwait(false);
}
memoryStream.Flush();
memoryStream.Position = 0;
using (var sr = new StreamReader(memoryStream))
{
var contents = sr.ReadToEnd();
contents.ShouldNotBeEmpty();
}
}
}
public static async Task <int> Main(string[] args)
{
// allow app to be debugged in visual studio.
if (args.Length == 0 && Debugger.IsAttached)
{
args = "generate-platform --platforms=uwp --output-path=test.txt".Split(' ');
}
var funcLogManager = new FuncLogManager(type => new WrappingFullLogger(new WrappingPrefixLogger(new ConsoleLogger(), type)));
Locator.CurrentMutable.RegisterConstant(funcLogManager, typeof(ILogManager));
var parserResult = new Parser(parserSettings => parserSettings.CaseInsensitiveEnumValues = true)
.ParseArguments <CustomAssembliesCommandLineOptions, PlatformCommandLineOptions>(args);
var result = await parserResult.MapResult(
async (PlatformCommandLineOptions options) =>
{
try
{
var referenceAssembliesLocation = !string.IsNullOrWhiteSpace(options.ReferenceAssemblies)
? options.ReferenceAssemblies !
: ReferenceLocator.GetReferenceLocation();
if (string.IsNullOrWhiteSpace(options.OutputPath))
{
throw new Exception("Invalid output path for the event generation.");
}
if (string.IsNullOrWhiteSpace(options.OutputPrefix))
{
throw new Exception("Invalid output prefix for the event generation.");
}
if (options.Platforms == null)
{
throw new Exception("Invalid platforms for the event generation.");
}
await ObservablesForEventGenerator.ExtractEventsFromPlatforms(options.OutputPath !, options.OutputPrefix !, ".cs", referenceAssembliesLocation, options.Platforms).ConfigureAwait(false);
return(ExitCode.Success);
}
catch (Exception ex)
{
LogHost.Default.Fatal(ex);
return(ExitCode.Error);
}
},
async (CustomAssembliesCommandLineOptions options) =>
{
try
{
using (var writer = new StreamWriter(Path.Combine(options.OutputPath, options.OutputPrefix + ".cs")))
{
if (options.Assemblies == null)
{
throw new Exception("Invalid specified assemblies for observable generation.");
}
if (options.SearchDirectories == null)
{
throw new Exception("Invalid search directories specified for observable generation.");
}
if (string.IsNullOrWhiteSpace(options.TargetFramework))
{
throw new Exception("Invalid target framework for the event generation.");
}
await ObservablesForEventGenerator.WriteHeader(writer, options.Assemblies !).ConfigureAwait(false);
await ObservablesForEventGenerator.ExtractEventsFromAssemblies(writer, options.Assemblies !, options.SearchDirectories !, options.TargetFramework !).ConfigureAwait(false);
}
return(ExitCode.Success);
}
catch (Exception ex)
{
LogHost.Default.Fatal(ex);
return(ExitCode.Error);
}
},
async (NugetCommandLineOptions options) =>
{
try
{
using (var writer = new StreamWriter(Path.Combine(options.OutputPath, options.OutputPrefix + ".cs")))
{
if (string.IsNullOrWhiteSpace(options.TargetFramework))
{
throw new Exception("Invalid target framework for the event generation.");
}
var packageIdentity = new[] { new LibraryRange(options.NugetPackageName, VersionRange.Parse(options.NugetVersion), LibraryDependencyTarget.Package) };
var nugetFramework = options.TargetFramework !.ToFrameworks();
await ObservablesForEventGenerator.WriteHeader(writer, packageIdentity).ConfigureAwait(false);
await ObservablesForEventGenerator.ExtractEventsFromNuGetPackages(writer, packageIdentity, nugetFramework, options.PackageFolder).ConfigureAwait(false);
}
return(ExitCode.Success);
}
catch (Exception ex)
{
LogHost.Default.Fatal(ex);
return(ExitCode.Error);
}
},
_ =>
{
System.Console.WriteLine(HelpText.AutoBuild(parserResult));
return(Task.FromResult(ExitCode.Error));
}).ConfigureAwait(false);
return((int)result);
}