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);
