public Task <LineEvaluationResult> HandleAsync(Guid lineId, string text, IReplLogger logger)
{
// this line exits the application. The subsequent lines don't run.
Application.Current.Shutdown();
return(Task.FromResult(LineEvaluationResult.NoOutput));
}
public Task <LineEvaluationResult> HandleAsync(Guid lineId, string text, IReplLogger logger)
{
var help = new[]
{
new[]
{
"Welcome to Replay! ❤",
"",
"Keyboard Shortcuts",
"==================",
},
KeyboardShortcuts.KeyboardShortcutHelp,
new[]
{
"",
"Commands",
"========",
},
CommandHelp
};
string helpText = string.Join(Environment.NewLine, help.SelectMany(linegroups => linegroups));
return(Task.FromResult(
new LineEvaluationResult(null, helpText, null, null)
));
}
public async Task <LineEvaluationResult> HandleAsync(Guid lineId, string input, IReplLogger logger)
{
string assemblyFile = input.Substring(CommandPrefix.Length).Trim('"');
var assemblies = DotNetAssemblyLocator
.GroupDirectoryContentsIntoAssemblies(ReadAssembly(assemblyFile))
.Select(assembly => io.CreateMetadataReferenceWithDocumentation(assembly));
foreach (var assembly in assemblies)
{
logger.LogOutput("Referencing " + assembly.Display);
await scriptEvaluator.AddReferences(assembly);
workspaceManager.CreateOrUpdateSubmission(lineId, assemblyReferences: assembly);
logger.LogOutput("Assembly successfully referenced");
}
return(LineEvaluationResult.NoOutput);
}
public async Task <LineEvaluationResult> HandleAsync(Guid lineId, string text, IReplLogger logger)
{
string package = text.Substring(CommandPrefix.Length).Trim('"');
var assemblies = (await nugetInstaller.Install(package, logger)).ToArray();
if (assemblies.Any())
{
await scriptEvaluator.AddReferences(assemblies);
workspaceManager.CreateOrUpdateSubmission(lineId, assemblyReferences: assemblies);
}
return(LineEvaluationResult.NoOutput);
}
public NugetErrorLoggerTest()
{
this.replLogger = Substitute.For <IReplLogger>();
this.logger = new NugetErrorLogger(replLogger);
}
public async Task <IReadOnlyCollection <MetadataReference> > Install(string packageSearchTerm, IReplLogger logger)
{
var nugetLogger = new NugetErrorLogger(logger);
logger.LogOutput($"Searching for {packageSearchTerm}");
var package = await FindPackageAsync(packageSearchTerm, repositories, nugetLogger);
if (package == null)
{
logger.LogError($"Could not find package '{packageSearchTerm}'");
return(Array.Empty <MetadataReference>());
}
logger.LogOutput("Found " + Display(package));
logger.LogOutput("Determining dependences...");
var dependencies = await GetPackageDependencies(package, nugetFramework, nugetCache, nugetLogger, repositories);
var packagesToInstall = ResolvePackages(package, dependencies, nugetLogger);
var packageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv3,
XmlDocFileSaveMode.None,
clientPolicy,
nugetLogger);
var assemblyPaths = await Task.WhenAll(packagesToInstall
.Select(async packageToInstall =>
{
var installedPath = packagePathResolver.GetInstalledPath(packageToInstall);
PackageReaderBase packageReader = installedPath == null
? await DownloadPackage(packageToInstall, packageExtractionContext, nugetLogger)
: LocalPackageReader(packageToInstall, installedPath, nugetLogger);
var allResources = await Task.WhenAll(
packageReader.GetLibItemsAsync(CancellationToken.None),
packageReader.GetFrameworkItemsAsync(CancellationToken.None)
);
installedPath ??= packagePathResolver.GetInstalledPath(packageToInstall);
var references = DotNetAssemblyLocator.GroupDirectoryContentsIntoAssemblies(
FilterByFramework(frameworkReducer, allResources.SelectMany(x => x).ToList())
.Select(item => Path.Combine(installedPath, item))
)
.Select(assembly => io.CreateMetadataReferenceWithDocumentation(assembly))
.ToList();
logger.LogOutput("Installation complete for " + Display(packageToInstall));
return(references);
})
);
return(assemblyPaths
.SelectMany(assemblyGroup => assemblyGroup)
.ToList());
}
public async Task <LineEvaluationResult> AppendEvaluationAsync(Guid lineId, string code, IReplLogger logger)
{
await commandInitialization.ConfigureAwait(false);
try
{
var result = await commandHandlers
.First(handler => handler.CanHandle(code))
.HandleAsync(lineId, code, logger)
.ConfigureAwait(false);
// Depending on which command was run (e.g. 'help'), we might not have a
// corresponding entry in our workspace. The following line will create an
// empty record if that's the case. Everything's easier to reason about if
// the viewmodel and the workspace have the same number of lines.
workspaceManager.EnsureRecordForLine(lineId);
return(result);
}
catch (Exception ex)
{
return(new LineEvaluationResult(code, null, "Error: " + ex.Message, null));
}
}
public async Task <LineEvaluationResult> HandleAsync(Guid lineId, string text, IReplLogger logger)
{
// bail out if it's not a complete statement, but first try automatic completions
var(success, newTree) = await scriptEvaluator.TryCompleteStatementAsync(text);
if (!success)
{
return(LineEvaluationResult.IncompleteInput);
}
text = (await newTree.GetRootAsync())
.ToFullString();
// track the submission in our workspace. We won't need the
// result for script evaluation, but other roslyn APIs like
// code completion and syntax highlighting will need it.
var submission = workspaceManager.CreateOrUpdateSubmission(lineId, text);
var scriptResult = await scriptEvaluator.EvaluateAsync(text);
var output = await prettyPrinter.FormatAsync(submission.Document, scriptResult);
return(output);
}
public NugetErrorLogger(IReplLogger logger)
{
this.logger = logger;
}
