private PackageReference SafeParsePackageFormula(string v, string msg, string optionName) { PackageReference result; if (PackageReference.TryParse(v, out result)) { return(result); } throw ParseFailure(v, msg, optionName); }
public override object ConvertFrom(ref ObjectContext context, Scalar fromScalar) { PackageReference packageReference; if (!PackageReference.TryParse(fromScalar.Value, out packageReference)) { throw new YamlException(fromScalar.Start, fromScalar.End, "Unable to decode package reference [{0}]. Expecting format GUID:LOCATION".ToFormat(fromScalar.Value)); } return(packageReference); }
public static CSharpKernel UseNugetDirective(this CSharpKernel kernel) { var packageRefArg = new Argument <PackageReference>( result => { var token = result.Tokens.Select(t => t.Value).SingleOrDefault(); if (PackageReference.TryParse(token, out var reference)) { return(reference); } else { result.ErrorMessage = $"Could not parse \"{token}\" as a package reference."; return(null); } }) { Name = "package" }; var poundR = new Command("#r") { packageRefArg }; var restoreContext = new PackageRestoreContext(); kernel.RegisterForDisposal(restoreContext); poundR.Handler = CommandHandler.Create <PackageReference, KernelInvocationContext>(HandleAddPackageReference); kernel.AddDirective(poundR); var restore = new Command("#!nuget-restore") { Handler = CommandHandler.Create(DoNugetRestore(kernel, restoreContext)) }; kernel.AddDirective(restore); return(kernel); async Task HandleAddPackageReference(PackageReference package, KernelInvocationContext pipelineContext) { var addPackage = new AddPackage(package) { Handler = (command, context) => { if (restoreContext.ResolvedPackageReferences.SingleOrDefault(r => r.PackageName.Equals(package.PackageName, StringComparison.OrdinalIgnoreCase)) is { } resolvedRef&& !string.IsNullOrWhiteSpace(package.PackageVersion) && package.PackageVersion != resolvedRef.PackageVersion) { var errorMessage = $"{GenerateErrorMessage(package, resolvedRef)}"; context.Publish(new ErrorProduced(errorMessage)); }
private static Command r(PackageRestoreContext restoreContext) { var rDirective = new Command("#r") { new Argument <Union <PackageReference, FileInfo> >( result => { var token = result.Tokens .Select(t => t.Value) .SingleOrDefault(); if (PackageReference.TryParse(token, out var reference)) { return(reference); } if (token != null && !token.StartsWith("nuget:") && !Path.EndsInDirectorySeparator(token)) { return(new FileInfo(token)); } result.ErrorMessage = $"Unable to parse package reference: \"{token}\""; return(null); }) { Name = "package" } }; rDirective.Handler = CommandHandler.Create <Union <PackageReference, FileInfo>, KernelInvocationContext>(HandleAddPackageReference); return(rDirective); Task HandleAddPackageReference( Union <PackageReference, FileInfo> package, KernelInvocationContext context) { if (package?.Value is PackageReference pkg) { var alreadyGotten = restoreContext.ResolvedPackageReferences .Concat(restoreContext.RequestedPackageReferences) .FirstOrDefault(r => r.PackageName.Equals(pkg.PackageName, StringComparison.OrdinalIgnoreCase)); if (alreadyGotten is { } && !string.IsNullOrWhiteSpace(pkg.PackageVersion) && pkg.PackageVersion != alreadyGotten.PackageVersion) { var errorMessage = $"{GenerateErrorMessage(pkg, alreadyGotten)}"; context.Publish(new ErrorProduced(errorMessage)); }
public static CSharpKernel UseNugetDirective(this CSharpKernel kernel) { var packageRefArg = new Argument <PackageReference>((SymbolResult result, out PackageReference reference) => PackageReference.TryParse(result.Token.Value, out reference)) { Name = "package" }; var poundR = new Command("#r") { packageRefArg }; var restoreContext = new PackageRestoreContext(); kernel.RegisterForDisposal(restoreContext); poundR.Handler = CommandHandler.Create <PackageReference, KernelInvocationContext>(async(package, pipelineContext) => { var addPackage = new AddPackage(package) { Handler = async(command, context) => { var added = await Task.FromResult( restoreContext.AddPackagReference( package.PackageName, package.PackageVersion, package.RestoreSources)); if (!added) { var errorMessage = $"{GenerateErrorMessage(package)}{Environment.NewLine}"; context.Publish(new ErrorProduced(errorMessage)); } } }; await pipelineContext.HandlingKernel.SendAsync(addPackage); }); kernel.AddDirective(poundR); var restore = new Command("#!nuget-restore") { Handler = CommandHandler.Create(DoNugetRestore(kernel, restoreContext)) }; kernel.AddDirective(restore); return(kernel);
private static Command r(PackageRestoreContext restoreContext) { var rDirective = new Command("#r") { new Argument <PackageReference>( result => { var token = result.Tokens.Select(t => t.Value).SingleOrDefault(); if (PackageReference.TryParse(token, out var reference)) { return(reference); } else { result.ErrorMessage = $"Unable to parse package reference: \"{token}\""; return(null); } }) { Name = "package" } }; rDirective.Handler = CommandHandler.Create <PackageReference, KernelInvocationContext>(HandleAddPackageReference); return(rDirective); async Task HandleAddPackageReference( PackageReference package, KernelInvocationContext pipelineContext) { var addPackage = new AddPackage(package) { Handler = (command, context) => { var alreadyGotten = restoreContext.ResolvedPackageReferences .Concat(restoreContext.RequestedPackageReferences) .FirstOrDefault(r => r.PackageName.Equals(package.PackageName, StringComparison.OrdinalIgnoreCase)); if (alreadyGotten is { } && !string.IsNullOrWhiteSpace(package.PackageVersion) && package.PackageVersion != alreadyGotten.PackageVersion) { var errorMessage = $"{GenerateErrorMessage(package, alreadyGotten)}"; context.Publish(new ErrorProduced(errorMessage)); }
public void Nuget_package_reference_correctly_parses_package_version(string value, string expectedVersion) { PackageReference.TryParse(value, out var reference); reference.PackageVersion.Should().Be(expectedVersion); }
public void Nuget_package_reference_correctly_parses_package_name(string value) { PackageReference.TryParse(value, out var reference); reference.PackageName.Should().Be("PocketLogger"); }
public static CSharpKernel UseNugetDirective( this CSharpKernel kernel, Func <NativeAssemblyLoadHelper> getHelper = null) { var packageRefArg = new Argument <PackageReference>((SymbolResult result, out PackageReference reference) => PackageReference.TryParse(result.Token.Value, out reference)) { Name = "package" }; var command = new Command("#r") { packageRefArg }; var restoreContext = new PackageRestoreContext(); command.Handler = CommandHandler.Create <PackageReference, KernelInvocationContext>(async(package, pipelineContext) => { var addPackage = new AddPackage(package) { Handler = async context => { var added = await Task.FromResult( restoreContext.AddPackagReference( package.PackageName, package.PackageVersion, package.RestoreSources)); if (!added) { var errorMessage = $"{GenerateErrorMessage(package)}{Environment.NewLine}"; context.Publish(new ErrorProduced(errorMessage)); } context.Complete(); } }; await pipelineContext.HandlingKernel.SendAsync(addPackage); }); kernel.AddDirective(command); var restore = new Command("#!nuget-restore") { Handler = CommandHandler.Create(async(KernelInvocationContext pipelineContext) => { var nugetRestoreDirective = new RestoreNugetDirective(); nugetRestoreDirective.Handler = async context => { var messages = new Dictionary <string, string>(); foreach (var package in restoreContext.PackageReferences) { var key = InstallingPackageMessage(package); if (key == null) { context.Publish(new ErrorProduced($"Invalid Package Id: '{package.PackageName}'{Environment.NewLine}")); } else { var message = key + "..."; var displayed = new DisplayedValueProduced(message, context.Command, null, valueId: key); context.Publish(displayed); messages.Add(key, message); } } // Restore packages var restorePackagesTask = restoreContext.Restore(); while (await Task.WhenAny(Task.Delay(500), restorePackagesTask) != restorePackagesTask) { foreach (var key in messages.Keys.ToArray()) { var message = messages[key] + "."; context.Publish(new DisplayedValueUpdated(message, key, null, null)); messages[key] = message; } } var helper = kernel.NativeAssemblyLoadHelper; var result = await restorePackagesTask; if (result.Succeeded) { switch (result) { case PackageRestoreResult packageRestore: var nativeLibraryProbingPaths = packageRestore.NativeLibraryProbingPaths; helper?.SetNativeLibraryProbingPaths(nativeLibraryProbingPaths); var addedAssemblyPaths = packageRestore .ResolvedReferences .SelectMany(added => added.AssemblyPaths) .Distinct() .ToArray(); if (helper != null) { foreach (var addedReference in packageRestore.ResolvedReferences) { helper.Handle(addedReference); } } kernel.AddScriptReferences(packageRestore.ResolvedReferences); foreach (var resolvedReference in packageRestore.ResolvedReferences) { string message; string key = InstallingPackageMessage(resolvedReference); if (messages.TryGetValue(key, out message)) { context.Publish(new DisplayedValueUpdated(message + " done!", key, null, null)); messages[key] = message; } context.Publish(new PackageAdded(new AddPackage(resolvedReference))); // Load extensions await context.HandlingKernel.SendAsync( new LoadExtensionsInDirectory( resolvedReference.PackageRoot, addedAssemblyPaths)); } break; default: break; } } else { var errors = $"{string.Join(Environment.NewLine, result.Errors)}"; switch (result) { case PackageRestoreResult packageRestore: foreach (var resolvedReference in packageRestore.ResolvedReferences) { if (string.IsNullOrEmpty(resolvedReference.PackageName)) { context.Publish(new ErrorProduced($"Failed to apply RestoreSources {resolvedReference.RestoreSources}{Environment.NewLine}{errors}")); } else { context.Publish(new ErrorProduced($"Failed to add reference to package {resolvedReference.PackageName}{Environment.NewLine}{errors}")); } } break; default: break; } } // Events for finished context.Complete(); }; await pipelineContext.HandlingKernel.SendAsync(nugetRestoreDirective); }) }; kernel.AddDirective(restore); return(kernel);