private async Task<RenameResponse> SendRequest(OmnisharpWorkspace workspace,
string renameTo,
string filename,
string fileContent,
bool wantsTextChanges = false,
bool applyTextChanges = true)
{
var lineColumn = TestHelpers.GetLineAndColumnFromDollar(fileContent);
var controller = new OmnisharpController(workspace, new FakeOmniSharpOptions());
var request = new RenameRequest
{
Line = lineColumn.Line,
Column = lineColumn.Column,
RenameTo = renameTo,
FileName = filename,
Buffer = fileContent.Replace("$", ""),
WantsTextChanges = wantsTextChanges,
ApplyTextChanges = applyTextChanges
};
var bufferFilter = new UpdateBufferFilter(workspace);
bufferFilter.OnActionExecuting(TestHelpers.CreateActionExecutingContext(request, controller));
return await controller.Rename(request);
}
public void UpdateBufferFindsProjectBasedOnNearestPath()
{
var workspace = new OmnisharpWorkspace();
TestHelpers.AddProjectToWorkspace(workspace, Path.Combine("src", "root", "foo.csproj"),
new[] { "" },
new Dictionary<string, string>() { { Path.Combine("src", "root", "foo.cs"), "class C1 {}" } });
TestHelpers.AddProjectToWorkspace(workspace, Path.Combine("src", "root", "foo", "bar", "insane.csproj"),
new[] { "" },
new Dictionary<string, string>() { { Path.Combine("src", "root", "foo", "bar", "nested", "code.cs"), "class C2 {}" } });
workspace.BufferManager.UpdateBuffer(new Request() { FileName = Path.Combine("src", "root", "bar.cs"), Buffer = "enum E {}" });
var documents = workspace.GetDocuments(Path.Combine("src", "root", "bar.cs"));
Assert.Equal(1, documents.Count());
Assert.Equal(Path.Combine("src", "root", "foo.csproj"), documents.ElementAt(0).Project.FilePath);
Assert.Equal(2, documents.ElementAt(0).Project.Documents.Count());
workspace.BufferManager.UpdateBuffer(new Request() { FileName = Path.Combine("src", "root", "foo", "bar", "nested", "paths", "dance.cs"), Buffer = "enum E {}" });
documents = workspace.GetDocuments(Path.Combine("src", "root", "foo", "bar", "nested", "paths", "dance.cs"));
Assert.Equal(1, documents.Count());
Assert.Equal(Path.Combine("src", "root", "foo", "bar", "insane.csproj"), documents.ElementAt(0).Project.FilePath);
Assert.Equal(2, documents.ElementAt(0).Project.Documents.Count());
}
public DnxProjectSystem(OmnisharpWorkspace workspace,
IOmnisharpEnvironment env,
IOptions<OmniSharpOptions> optionsAccessor,
ILoggerFactory loggerFactory,
IMetadataFileReferenceCache metadataFileReferenceCache,
IApplicationLifetime lifetime,
IFileSystemWatcher watcher,
IEventEmitter emitter,
DnxContext context)
{
_workspace = workspace;
_env = env;
_logger = loggerFactory.CreateLogger<DnxProjectSystem>();
_metadataFileReferenceCache = metadataFileReferenceCache;
_options = optionsAccessor.Options;
_dnxPaths = new DnxPaths(env, _options, loggerFactory);
_designTimeHostManager = new DesignTimeHostManager(loggerFactory, _dnxPaths);
_packagesRestoreTool = new PackagesRestoreTool(_options, loggerFactory, emitter, context, _dnxPaths);
_context = context;
_watcher = watcher;
_emitter = emitter;
_directoryEnumerator = new DirectoryEnumerator(loggerFactory);
lifetime.ApplicationStopping.Register(OnShutdown);
}
public ProjectEventForwarder(OmnisharpWorkspace workspace, [ImportMany] IEnumerable<IProjectSystem> projectSystems, IEventEmitter emitter)
{
_projectSystems = projectSystems;
_workspace = workspace;
_emitter = emitter;
_workspace.WorkspaceChanged += OnWorkspaceChanged;
}
public static OmnisharpWorkspace CreateSimpleWorkspace(Dictionary<string, string> sourceFiles)
{
var workspace = new OmnisharpWorkspace();
var versionStamp = VersionStamp.Create();
var mscorlib = MetadataReference.CreateFromAssembly(AssemblyFromType(typeof(object)));
var systemCore = MetadataReference.CreateFromAssembly(AssemblyFromType(typeof(Enumerable)));
var references = new[] { mscorlib, systemCore };
var projects = new[] { "aspnet50", "aspnetcore50" };
foreach (var project in projects)
{
var projectInfo = ProjectInfo.Create(ProjectId.CreateNewId(), versionStamp,
"OmniSharp+" + project, "AssemblyName",
LanguageNames.CSharp, "project.json", metadataReferences: references);
workspace.AddProject(projectInfo);
foreach (var file in sourceFiles)
{
var document = DocumentInfo.Create(DocumentId.CreateNewId(projectInfo.Id), file.Key,
null, SourceCodeKind.Regular,
TextLoader.From(TextAndVersion.Create(SourceText.From(file.Value), versionStamp)), file.Key);
workspace.AddDocument(document);
}
}
return workspace;
}
public ScriptCsProjectSystem(OmnisharpWorkspace workspace, IOmnisharpEnvironment env, ILoggerFactory loggerFactory, ScriptCsContext scriptCsContext)
{
_workspace = workspace;
_env = env;
_scriptCsContext = scriptCsContext;
_logger = loggerFactory.CreateLogger<ScriptCsProjectSystem>();
}
public static OptionSet GetOptions(OmnisharpWorkspace workspace, OmniSharp.Options.FormattingOptions formattingOptions)
{
return workspace.Options
.WithChangedOption(Microsoft.CodeAnalysis.Formatting.FormattingOptions.NewLine, LanguageNames.CSharp, formattingOptions.NewLine)
.WithChangedOption(Microsoft.CodeAnalysis.Formatting.FormattingOptions.UseTabs, LanguageNames.CSharp, formattingOptions.UseTabs)
.WithChangedOption(Microsoft.CodeAnalysis.Formatting.FormattingOptions.TabSize, LanguageNames.CSharp, formattingOptions.TabSize)
.WithChangedOption(Microsoft.CodeAnalysis.Formatting.FormattingOptions.IndentationSize, LanguageNames.CSharp, formattingOptions.IndentationSize);
}
public ProjectEventForwarder(DnxContext dnxContext, MSBuildContext msbuildContext, OmnisharpWorkspace workspace, IEventEmitter emitter)
{
_dnxContext = dnxContext;
_msbuildContext = msbuildContext;
_workspace = workspace;
_emitter = emitter;
_workspace.WorkspaceChanged += OnWorkspaceChanged;
}
public static async Task AddQuickFix(ICollection<QuickFix> quickFixes, OmnisharpWorkspace workspace, Location location)
{
if (location.IsInSource)
{
var quickFix = await GetQuickFix(workspace, location);
quickFixes.Add(quickFix);
}
}
public MSBuildProjectSystem(OmnisharpWorkspace workspace,
IOmnisharpEnvironment env,
ILoggerFactory loggerFactory,
IMetadataFileReferenceCache metadataReferenceCache,
IFileSystemWatcher watcher,
MSBuildContext context)
{
_workspace = workspace;
_metadataReferenceCache = metadataReferenceCache;
_watcher = watcher;
_env = env;
_logger = loggerFactory.Create<MSBuildProjectSystem>();
_context = context;
}
private void CreateSimpleWorkspace(out OmnisharpWorkspace workspace, out OmnisharpController controller, out DocumentInfo document, string filename, string contents)
{
workspace = new OmnisharpWorkspace();
controller = new OmnisharpController(workspace, null);
var projectInfo = ProjectInfo.Create(ProjectId.CreateNewId(), VersionStamp.Create(),
"ProjectNameVal", "AssemblyNameVal", LanguageNames.CSharp);
document = DocumentInfo.Create(DocumentId.CreateNewId(projectInfo.Id), filename,
null, SourceCodeKind.Regular,
TextLoader.From(TextAndVersion.Create(SourceText.From(contents), VersionStamp.Create())),
filename);
workspace.AddProject(projectInfo);
workspace.AddDocument(document);
}
private void CreateSimpleWorkspace(out OmnisharpWorkspace workspace, out ChangeBufferService controller, out DocumentInfo document, string filename, string contents)
{
workspace = new OmnisharpWorkspace(new HostServicesBuilder(Enumerable.Empty<ICodeActionProvider>()));
controller = new ChangeBufferService(workspace);
var projectInfo = ProjectInfo.Create(ProjectId.CreateNewId(), VersionStamp.Create(),
"ProjectNameVal", "AssemblyNameVal", LanguageNames.CSharp);
document = DocumentInfo.Create(DocumentId.CreateNewId(projectInfo.Id), filename,
null, SourceCodeKind.Regular,
TextLoader.From(TextAndVersion.Create(SourceText.From(contents), VersionStamp.Create())),
filename);
workspace.AddProject(projectInfo);
workspace.AddDocument(document);
}
public static async Task<IEnumerable<CodeAction>> GetActions(OmnisharpWorkspace workspace, IEnumerable<ICodeActionProvider> codeActionProviders, ILogger logger, ICodeActionRequest request)
{
var actions = new List<CodeAction>();
var originalDocument = workspace.GetDocument(request.FileName);
if (originalDocument == null)
{
return actions;
}
var refactoringContext = await GetRefactoringContext(originalDocument, request, actions);
var codeFixContext = await GetCodeFixContext(originalDocument, request, actions);
await CollectRefactoringActions(codeActionProviders, logger, refactoringContext);
await CollectCodeFixActions(codeActionProviders, logger, codeFixContext);
actions.Reverse();
return actions;
}
public DotNetProjectSystem(IOmnisharpEnvironment environment,
OmnisharpWorkspace omnisharpWorkspace,
IMetadataFileReferenceCache metadataFileReferenceCache,
ILoggerFactory loggerFactory,
IFileSystemWatcher watcher,
IEventEmitter emitter)
{
_environment = environment;
_omnisharpWorkspace = omnisharpWorkspace;
_logger = loggerFactory.CreateLogger<DotNetProjectSystem>();
_emitter = emitter;
_metadataFileReferenceCache = metadataFileReferenceCache;
_watcher = watcher;
_packageRestore = new PackagesRestoreTool(loggerFactory, _emitter);
_projectStates = new ProjectStatesCache(loggerFactory);
}
public MSBuildProjectSystem(OmnisharpWorkspace workspace,
IOmnisharpEnvironment env,
IOptions<OmniSharpOptions> optionsAccessor,
ILoggerFactory loggerFactory,
IEventEmitter emitter,
IMetadataFileReferenceCache metadataReferenceCache,
IFileSystemWatcher watcher,
MSBuildContext context)
{
_workspace = workspace;
_metadataReferenceCache = metadataReferenceCache;
_watcher = watcher;
_env = env;
_options = optionsAccessor.Options.MsBuild;
_logger = loggerFactory.CreateLogger<MSBuildProjectSystem>();
_emitter = emitter;
_context = context;
}
private static OmnisharpWorkspace GetWorkspaceWithProjects()
{
var workspace = new OmnisharpWorkspace();
TestHelpers.AddProjectToWorkspace(workspace, Path.Combine("src", "project.json"),
new[] { "dnx451", "dnxcore50" },
new Dictionary<string, string>() { { Path.Combine("src", "a.cs"), "class C {}" } });
TestHelpers.AddProjectToWorkspace(workspace, Path.Combine("test", "project.json"),
new[] { "dnx451", "dnxcore50" },
new Dictionary<string, string>() { { Path.Combine("test", "b.cs"), "class C {}" } });
Assert.Equal(4, workspace.CurrentSolution.Projects.Count());
foreach (var project in workspace.CurrentSolution.Projects)
{
Assert.Equal(1, project.Documents.Count());
}
return workspace;
}
public AspNet5ProjectSystem(OmnisharpWorkspace workspace,
IOmnisharpEnvironment env,
IOptions<OmniSharpOptions> optionsAccessor,
ILoggerFactory loggerFactory,
IMetadataFileReferenceCache metadataFileReferenceCache,
IApplicationLifetime lifetime,
IFileSystemWatcher watcher,
AspNet5Context context)
{
_workspace = workspace;
_env = env;
_options = optionsAccessor.Options;
_logger = loggerFactory.Create<AspNet5ProjectSystem>();
_metadataFileReferenceCache = metadataFileReferenceCache;
_designTimeHostManager = new DesignTimeHostManager(loggerFactory);
_context = context;
_watcher = watcher;
lifetime.ApplicationStopping.Register(OnShutdown);
}
public DnxProjectSystem(OmnisharpWorkspace workspace,
IOmnisharpEnvironment env,
ILoggerFactory loggerFactory,
IMetadataFileReferenceCache metadataFileReferenceCache,
IApplicationLifetime lifetime,
IFileSystemWatcher watcher,
IEventEmitter emitter,
DnxContext context)
{
_workspace = workspace;
_env = env;
_loggerFactory = loggerFactory;
_logger = loggerFactory.CreateLogger <DnxProjectSystem>();
_metadataFileReferenceCache = metadataFileReferenceCache;
_context = context;
_watcher = watcher;
_emitter = emitter;
_directoryEnumerator = new DirectoryEnumerator(loggerFactory);
lifetime?.ApplicationStopping.Register(OnShutdown);
}
public ProtobuildProjectSystem(
OmnisharpWorkspace workspace,
IOmnisharpEnvironment env,
ILoggerFactory loggerFactory,
IEventEmitter emitter,
IMetadataFileReferenceCache metadataReferenceCache,
IFileSystemWatcher watcher,
MSBuildContext context) : base(
workspace,
env,
loggerFactory,
emitter,
metadataReferenceCache,
watcher,
context)
{
_env = env;
_logger = loggerFactory.CreateLogger <ProtobuildProjectSystem>();
_context = context;
_watcher = watcher;
}
public DnxProjectSystem(OmnisharpWorkspace workspace,
IOmnisharpEnvironment env,
ILoggerFactory loggerFactory,
IMetadataFileReferenceCache metadataFileReferenceCache,
IApplicationLifetime lifetime,
IFileSystemWatcher watcher,
IEventEmitter emitter,
DnxContext context)
{
_workspace = workspace;
_env = env;
_loggerFactory = loggerFactory;
_logger = loggerFactory.CreateLogger<DnxProjectSystem>();
_metadataFileReferenceCache = metadataFileReferenceCache;
_context = context;
_watcher = watcher;
_emitter = emitter;
_directoryEnumerator = new DirectoryEnumerator(loggerFactory);
lifetime?.ApplicationStopping.Register(OnShutdown);
}
public async Task UpdateBufferFindsProjectBasedOnNearestPath()
{
var workspace = new OmnisharpWorkspace();
TestHelpers.AddProjectToWorkspace(workspace, Path.Combine("src", "root", "foo.csproj"),
new[] { "" },
new Dictionary <string, string>()
{
{ Path.Combine("src", "root", "foo.cs"), "class C1 {}" }
});
TestHelpers.AddProjectToWorkspace(workspace, Path.Combine("src", "root", "foo", "bar", "insane.csproj"),
new[] { "" },
new Dictionary <string, string>()
{
{ Path.Combine("src", "root", "foo", "bar", "nested", "code.cs"), "class C2 {}" }
});
await workspace.BufferManager.UpdateBuffer(new Request()
{
FileName = Path.Combine("src", "root", "bar.cs"), Buffer = "enum E {}"
});
var documents = workspace.GetDocuments(Path.Combine("src", "root", "bar.cs"));
Assert.Equal(1, documents.Count());
Assert.Equal(Path.Combine("src", "root", "foo.csproj"), documents.ElementAt(0).Project.FilePath);
Assert.Equal(2, documents.ElementAt(0).Project.Documents.Count());
await workspace.BufferManager.UpdateBuffer(new Request()
{
FileName = Path.Combine("src", "root", "foo", "bar", "nested", "paths", "dance.cs"), Buffer = "enum E {}"
});
documents = workspace.GetDocuments(Path.Combine("src", "root", "foo", "bar", "nested", "paths", "dance.cs"));
Assert.Equal(1, documents.Count());
Assert.Equal(Path.Combine("src", "root", "foo", "bar", "insane.csproj"), documents.ElementAt(0).Project.FilePath);
Assert.Equal(2, documents.ElementAt(0).Project.Documents.Count());
}
public static async Task<NavigateResponse> Navigate(OmnisharpWorkspace workspace, Request request, Func<FileMemberElement, FileMemberElement, Request, bool> IsCloserNode)
{
var stack = new List<FileMemberElement>(await StructureComputer.Compute(workspace.GetDocuments(request.FileName)));
var response = new NavigateResponse();
//Retain current line in case we dont need to navigate.
response.Line = request.Line;
response.Column = request.Column;
FileMemberElement closestNode = null;
FileMemberElement thisNode = null;
while (stack.Count > 0)
{
var node = stack[0];
stack.Remove(node);
var isCloserNode = IsCloserNode(node, closestNode, request);
if (isCloserNode)
{
closestNode = node;
}
if (node.Location.Line == request.Line)
{
thisNode = node;
}
stack.AddRange(node.ChildNodes);
}
//If there is a closest node, use its line and column.
//or if we are on the last node, adjust column.
//if we are above the first or below the last node, do nothing.
if (closestNode != null)
{
response.Line = closestNode.Location.Line;
response.Column = closestNode.Location.Column;
}
else if (thisNode != null)
{
response.Column = thisNode.Location.Column;
}
return response;
}
private async Task <NavigateResponse> SendRequest(OmnisharpWorkspace workspace, string fileName, string fileContent, NavigateDirection upOrDown)
{
var initialCursorLineColumn = TestHelpers.GetLineAndColumnFromDollar(TestHelpers.RemovePercentMarker(fileContent));
var fileContentNoDollarMarker = TestHelpers.RemoveDollarMarker(fileContent);
var controller = new OmnisharpController(workspace, new FakeOmniSharpOptions());
var request = new Request
{
Line = initialCursorLineColumn.Line,
Column = initialCursorLineColumn.Column,
FileName = fileName,
Buffer = fileContentNoDollarMarker
};
if (upOrDown == NavigateDirection.UP)
{
return(await controller.NavigateUp(request));
}
else
{
return(await controller.NavigateDown(request));
}
}
private async static Task <OmnisharpWorkspace> GetWorkspaceWithProjects()
{
var workspace = new OmnisharpWorkspace(
new HostServicesAggregator(
Enumerable.Empty <IHostServicesProvider>()));
await TestHelpers.AddProjectToWorkspace(workspace, Path.Combine("src", "project.json"),
new[] { "dnx451", "dnxcore50" },
new Dictionary <string, string>() { { Path.Combine("src", "a.cs"), "class C {}" } });
await TestHelpers.AddProjectToWorkspace(workspace, Path.Combine("test", "project.json"),
new[] { "dnx451", "dnxcore50" },
new Dictionary <string, string>() { { Path.Combine("test", "b.cs"), "class C {}" } });
Assert.Equal(4, workspace.CurrentSolution.Projects.Count());
foreach (var project in workspace.CurrentSolution.Projects)
{
Assert.Equal(1, project.Documents.Count());
}
return(workspace);
}
public void AddProjectToWorkspace(OmnisharpWorkspace workspace,
string projectFilePath,
IEnumerable <string> frameworks,
IDictionary <string, string> sourceFiles)
{
_logger.LogInformation($" AddProjectToWorkspace");
var versionStamp = VersionStamp.Create();
var references = new[]
{
CreateFromType(typeof(object)), // mscorlib
CreateFromType(typeof(Enumerable)) // System.Core
};
foreach (var framework in frameworks)
{
var projectInfo = ProjectInfo.Create(ProjectId.CreateNewId(),
versionStamp,
$"OmniSharp+{framework}",
"AssemblyName",
LanguageNames.CSharp,
projectFilePath,
metadataReferences: references);
workspace.AddProject(projectInfo);
foreach (var file in sourceFiles)
{
var document = DocumentInfo.Create(DocumentId.CreateNewId(projectInfo.Id),
file.Key,
folders: null,
sourceCodeKind: SourceCodeKind.Regular,
loader: TextLoader.From(TextAndVersion.Create(SourceText.From(file.Value), versionStamp)),
filePath: file.Key);
workspace.AddDocument(document);
}
}
}
public void AddProjectToWorkspace(OmnisharpWorkspace workspace,
string projectFilePath,
IEnumerable<string> frameworks,
IDictionary<string, string> sourceFiles)
{
_logger.LogInformation($" AddProjectToWorkspace");
var versionStamp = VersionStamp.Create();
var references = new[]
{
CreateFromType(typeof(object)), // mscorlib
CreateFromType(typeof(Enumerable)) // System.Core
};
foreach (var framework in frameworks)
{
var projectInfo = ProjectInfo.Create(ProjectId.CreateNewId(),
versionStamp,
$"OmniSharp+{framework}",
"AssemblyName",
LanguageNames.CSharp,
projectFilePath,
metadataReferences: references);
workspace.AddProject(projectInfo);
foreach (var file in sourceFiles)
{
var document = DocumentInfo.Create(DocumentId.CreateNewId(projectInfo.Id),
file.Key,
folders: null,
sourceCodeKind: SourceCodeKind.Regular,
loader: TextLoader.From(TextAndVersion.Create(SourceText.From(file.Value), versionStamp)),
filePath: file.Key);
workspace.AddDocument(document);
}
}
}
public static async Task<QuickFix> GetQuickFix(OmnisharpWorkspace workspace, Location location)
{
if (!location.IsInSource)
throw new Exception("Location is not in the source tree");
var lineSpan = location.GetLineSpan();
var path = lineSpan.Path;
var documents = workspace.GetDocuments(path);
var line = lineSpan.StartLinePosition.Line;
var syntaxTree = await documents.First().GetSyntaxTreeAsync();
var text = syntaxTree.GetText().Lines[line].ToString();
return new QuickFix
{
Text = text.Trim(),
FileName = path,
Line = line + 1,
Column = lineSpan.StartLinePosition.Character + 1,
EndLine = lineSpan.EndLinePosition.Line + 1,
EndColumn = lineSpan.EndLinePosition.Character + 1,
Projects = documents.Select(document => document.Project.Name).ToArray()
};
}
public static OmnisharpWorkspace CreateCsxWorkspace(string source, string fileName = "dummy.csx")
{
var versionStamp = VersionStamp.Create();
var mscorlib = MetadataReference.CreateFromAssembly(AssemblyFromType(typeof(object)));
var systemCore = MetadataReference.CreateFromAssembly(AssemblyFromType(typeof(Enumerable)));
var references = new[] { mscorlib, systemCore };
var workspace = new OmnisharpWorkspace();
var parseOptions = new CSharpParseOptions(LanguageVersion.CSharp6, DocumentationMode.Parse, SourceCodeKind.Script);
var projectId = ProjectId.CreateNewId(Guid.NewGuid().ToString());
var project = ProjectInfo.Create(projectId, VersionStamp.Create(), fileName, $"{fileName}.dll", LanguageNames.CSharp, fileName,
compilationOptions: new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary), metadataReferences: references, parseOptions: parseOptions,
isSubmission: true);
workspace.AddProject(project);
var document = DocumentInfo.Create(DocumentId.CreateNewId(project.Id), fileName, null, SourceCodeKind.Script, null, fileName)
.WithSourceCodeKind(SourceCodeKind.Script)
.WithTextLoader(TextLoader.From(TextAndVersion.Create(SourceText.From(source), VersionStamp.Create())));
workspace.AddDocument(document);
return(workspace);
}
private async Task <RenameResponse> SendRequest(OmnisharpWorkspace workspace,
string renameTo,
string filename,
string fileContent,
bool wantsTextChanges = false,
bool applyTextChanges = true)
{
var lineColumn = TestHelpers.GetLineAndColumnFromDollar(fileContent);
var controller = new RenameService(workspace);
var request = new RenameRequest
{
Line = lineColumn.Line,
Column = lineColumn.Column,
RenameTo = renameTo,
FileName = filename,
Buffer = fileContent.Replace("$", ""),
WantsTextChanges = wantsTextChanges,
ApplyTextChanges = applyTextChanges
};
await workspace.BufferManager.UpdateBuffer(request);
return(await controller.Handle(request));
}
public AspNet5ProjectSystem(OmnisharpWorkspace workspace,
IOmnisharpEnvironment env,
IOptions <OmniSharpOptions> optionsAccessor,
ILoggerFactory loggerFactory,
IMetadataFileReferenceCache metadataFileReferenceCache,
IApplicationLifetime lifetime,
IFileSystemWatcher watcher,
IEventEmitter emitter,
AspNet5Context context)
{
_workspace = workspace;
_env = env;
_logger = loggerFactory.Create <AspNet5ProjectSystem>();
_metadataFileReferenceCache = metadataFileReferenceCache;
_options = optionsAccessor.Options;
_aspNet5Paths = new AspNet5Paths(env, _options, loggerFactory);
_designTimeHostManager = new DesignTimeHostManager(loggerFactory, _aspNet5Paths);
_packagesRestoreTool = new PackagesRestoreTool(_options, loggerFactory, emitter, context, _aspNet5Paths);
_context = context;
_watcher = watcher;
_emitter = emitter;
lifetime.ApplicationStopping.Register(OnShutdown);
}
public DnxProjectSystem CreateProjectSystem(
Solution solution,
IApplicationLifetime appLifetime,
DnxContext context)
{
var workspace = new OmnisharpWorkspace();
var env = new OmnisharpEnvironment(solution.BaseDirectory);
var options = new OmniSharpOptionsWrapper();
var loggerFactory = new LoggerFactory();
var cache = new MetadataFileReferenceCache();
var emitter = new EventEmitter();
var watcher = new FileSystemWatcherWrapper(env);
return(new DnxProjectSystem(
workspace,
env,
options,
loggerFactory,
cache,
appLifetime,
watcher,
emitter,
context));
}
private async Task<RenameResponse> SendRequest(OmnisharpWorkspace workspace,
string renameTo,
string filename,
string fileContent,
bool wantsTextChanges = false,
bool applyTextChanges = true)
{
var lineColumn = TestHelpers.GetLineAndColumnFromDollar(fileContent);
var controller = new RenameService(workspace);
var request = new RenameRequest
{
Line = lineColumn.Line,
Column = lineColumn.Column,
RenameTo = renameTo,
FileName = filename,
Buffer = fileContent.Replace("$", ""),
WantsTextChanges = wantsTextChanges,
ApplyTextChanges = applyTextChanges
};
await workspace.BufferManager.UpdateBuffer(request);
return await controller.Handle(request);
}
public CodeActionController(OmnisharpWorkspace workspace, IEnumerable <ICodeActionProvider> providers, ILoggerFactory loggerFactory)
{
_workspace = workspace;
_codeActionProviders = providers;
_logger = loggerFactory.CreateLogger <CodeActionController>();
}
public static async Task<IEnumerable<ISymbol>> SymbolsFromQuickFixes(OmnisharpWorkspace workspace, IEnumerable<QuickFix> quickFixes)
{
var symbols = new List<ISymbol>();
foreach (var quickfix in quickFixes)
{
symbols.Add(await TestHelpers.SymbolFromQuickFix(workspace, quickfix));
}
return symbols;
}
public static async Task<ISymbol> SymbolFromQuickFix(OmnisharpWorkspace workspace, QuickFix result)
{
var document = workspace.GetDocument(result.FileName);
var sourceText = await document.GetTextAsync();
var position = sourceText.Lines.GetPosition(new LinePosition(result.Line - 1, result.Column - 1));
var semanticModel = await document.GetSemanticModelAsync();
return SymbolFinder.FindSymbolAtPosition(semanticModel, position, workspace);
}
public static Task<OmnisharpWorkspace> AddProjectToWorkspace(OmnisharpWorkspace workspace, string filePath, string[] frameworks, Dictionary<string, string> sourceFiles)
{
var versionStamp = VersionStamp.Create();
var mscorlib = MetadataReference.CreateFromFile(AssemblyFromType(typeof(object)).Location);
var systemCore = MetadataReference.CreateFromFile(AssemblyFromType(typeof(Enumerable)).Location);
var references = new[] { mscorlib, systemCore };
foreach (var framework in frameworks)
{
var projectInfo = ProjectInfo.Create(ProjectId.CreateNewId(), versionStamp,
"OmniSharp+" + framework, "AssemblyName",
LanguageNames.CSharp, filePath, metadataReferences: references);
workspace.AddProject(projectInfo);
foreach (var file in sourceFiles)
{
var document = DocumentInfo.Create(DocumentId.CreateNewId(projectInfo.Id), file.Key,
null, SourceCodeKind.Regular,
TextLoader.From(TextAndVersion.Create(SourceText.From(file.Value), versionStamp)), file.Key);
workspace.AddDocument(document);
}
}
return Task.FromResult(workspace);
}
public FormatAfterKeystrokeService(OmnisharpWorkspace workspace, FormattingOptions formattingOptions)
{
_workspace = workspace;
_options = OmniSharp.Roslyn.CSharp.Workers.Format.Formatting.GetOptions(_workspace, formattingOptions);
}
public UpdateBufferFilter(OmnisharpWorkspace workspace)
{
_workspace = workspace;
}
public RenameService(OmnisharpWorkspace workspace)
{
_workspace = workspace;
}
public async void ChangeBuffer_InsertRemoveChanges()
{
var workspace = new OmnisharpWorkspace();
var controller = new OmnisharpController(workspace);
var projectInfo = ProjectInfo.Create(ProjectId.CreateNewId(), VersionStamp.Create(),
"ProjectNameVal", "AssemblyNameVal", LanguageNames.CSharp);
var document = DocumentInfo.Create(DocumentId.CreateNewId(projectInfo.Id), "test.cs",
null, SourceCodeKind.Regular,
TextLoader.From(TextAndVersion.Create(SourceText.From("class C {}"), VersionStamp.Create())),
"test.cs");
workspace.AddProject(projectInfo);
workspace.AddDocument(document);
// insert edit
await controller.ChangeBuffer(new Models.ChangeBufferRequest()
{
StartLine = 1,
StartColumn = 1,
EndLine = 1,
EndColumn = 1,
NewText = "farboo",
FileName = "test.cs"
});
var sourceText = await workspace.CurrentSolution.GetDocument(document.Id).GetTextAsync();
Assert.Equal("farbooclass C {}", sourceText.ToString());
// remove edit
await controller.ChangeBuffer(new Models.ChangeBufferRequest()
{
StartLine = 1,
StartColumn = 1,
EndLine = 1,
EndColumn = 7,
NewText = "",
FileName = "test.cs"
});
sourceText = await workspace.CurrentSolution.GetDocument(document.Id).GetTextAsync();
Assert.Equal("class C {}", sourceText.ToString());
// modification edit
await controller.ChangeBuffer(new Models.ChangeBufferRequest()
{
StartLine = 1,
StartColumn = 1,
EndLine = 1,
EndColumn = 6,
NewText = "interface",
FileName = "test.cs"
});
sourceText = await workspace.CurrentSolution.GetDocument(document.Id).GetTextAsync();
Assert.Equal("interface C {}", sourceText.ToString());
}
public CodeCheckService(OmnisharpWorkspace workspace)
{
_workspace = workspace;
}
public CurrentProjectFacts()
{
_context = new DnxContext();
_workspace = new OmnisharpWorkspace();
}
public BufferManager(OmnisharpWorkspace workspace)
{
_workspace = workspace;
_workspace.WorkspaceChanged += OnWorkspaceChanged;
}
public GotoDefinitionService(OmnisharpWorkspace workspace, MetadataHelper metadataHelper)
{
_workspace = workspace;
_metadataHelper = metadataHelper;
}
public StatusMiddleware(RequestDelegate next, OmnisharpWorkspace workspace)
{
_next = next;
_workspace = workspace;
}
private async Task<NavigateResponse> SendRequest(OmnisharpWorkspace workspace, string fileName, string fileContent, NavigateDirection upOrDown)
{
var initialCursorLineColumn = TestHelpers.GetLineAndColumnFromDollar(TestHelpers.RemovePercentMarker(fileContent));
var fileContentNoDollarMarker = TestHelpers.RemoveDollarMarker(fileContent);
var controller = new OmnisharpController(workspace, new FakeOmniSharpOptions());
var request = new Request
{
Line = initialCursorLineColumn.Line,
Column = initialCursorLineColumn.Column,
FileName = fileName,
Buffer = fileContentNoDollarMarker
};
if (upOrDown == NavigateDirection.UP)
{
return await controller.NavigateUp(request);
}
else
{
return await controller.NavigateDown(request);
}
}
public GotoFileService(OmnisharpWorkspace workspace)
{
_workspace = workspace;
}
public UpdateBufferFilter(OmnisharpWorkspace workspace)
{
_workspace = workspace;
}
private async static Task<OmnisharpWorkspace> GetWorkspaceWithProjects()
{
var workspace = new OmnisharpWorkspace(new HostServicesBuilder(Enumerable.Empty<ICodeActionProvider>()));
await TestHelpers.AddProjectToWorkspace(workspace, Path.Combine("src", "project.json"),
new[] { "dnx451", "dnxcore50" },
new Dictionary<string, string>() { { Path.Combine("src", "a.cs"), "class C {}" } });
await TestHelpers.AddProjectToWorkspace(workspace, Path.Combine("test", "project.json"),
new[] { "dnx451", "dnxcore50" },
new Dictionary<string, string>() { { Path.Combine("test", "b.cs"), "class C {}" } });
Assert.Equal(4, workspace.CurrentSolution.Projects.Count());
foreach (var project in workspace.CurrentSolution.Projects)
{
Assert.Equal(1, project.Documents.Count());
}
return workspace;
}
public RunCodeActionsService(OmnisharpWorkspace workspace, [ImportMany] IEnumerable <ICodeActionProvider> providers)
{
_workspace = workspace;
_codeActionProviders = providers;
}
public IntellisenseService(OmnisharpWorkspace workspace, FormattingOptions formattingOptions)
{
_workspace = workspace;
_formattingOptions = formattingOptions;
}
public TypeLookupService(OmnisharpWorkspace workspace, FormattingOptions formattingOptions)
{
_workspace = workspace;
_formattingOptions = formattingOptions;
}
public CurrentProjectFacts()
{
_workspace = new OmnisharpWorkspace(new HostServicesBuilder(Enumerable.Empty <ICodeActionProvider>()));
_context = new DnxContext();
_projectSystem = new DnxProjectSystem(_workspace, null, new FakeLoggerFactory(), null, null, null, null, _context);
}
public TestCommandService(OmnisharpWorkspace workspace, [ImportMany] IEnumerable <ITestCommandProvider> testCommandProviders)
{
_workspace = workspace;
_testCommandProviders = testCommandProviders;
}
public static OmnisharpWorkspace CreateCsxWorkspace(string source, string fileName = "dummy.csx")
{
var versionStamp = VersionStamp.Create();
var mscorlib = MetadataReference.CreateFromFile(AssemblyFromType(typeof(object)).Location);
var systemCore = MetadataReference.CreateFromFile(AssemblyFromType(typeof(Enumerable)).Location);
var references = new[] { mscorlib, systemCore };
var workspace = new OmnisharpWorkspace(new HostServicesBuilder(Enumerable.Empty<ICodeActionProvider>()));
var parseOptions = new CSharpParseOptions(LanguageVersion.CSharp6, DocumentationMode.Parse, SourceCodeKind.Script);
var projectId = ProjectId.CreateNewId(Guid.NewGuid().ToString());
var project = ProjectInfo.Create(projectId, VersionStamp.Create(), fileName, $"{fileName}.dll", LanguageNames.CSharp, fileName,
compilationOptions: new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary), metadataReferences: references, parseOptions: parseOptions,
isSubmission: true);
workspace.AddProject(project);
var document = DocumentInfo.Create(DocumentId.CreateNewId(project.Id), fileName, null, SourceCodeKind.Script, null, fileName)
.WithSourceCodeKind(SourceCodeKind.Script)
.WithTextLoader(TextLoader.From(TextAndVersion.Create(SourceText.From(source), VersionStamp.Create())));
workspace.AddDocument(document);
return workspace;
}
public GotoRegionService(OmnisharpWorkspace workspace)
{
_workspace = workspace;
}
public RunCodeActionService(OmnisharpWorkspace workspace, [ImportMany] IEnumerable <ICodeActionProvider> providers, ILoggerFactory loggerFactory)
{
_workspace = workspace;
_codeActionProviders = providers;
_logger = loggerFactory.CreateLogger <RunCodeActionService>();
}
public MetadataService(OmnisharpWorkspace workspace, MetadataHelper metadataHelper)
{
_workspace = workspace;
_metadataHelper = metadataHelper;
}
public ChangeBufferService(OmnisharpWorkspace workspace)
{
_workspace = workspace;
}
public DiagnosticsService(OmnisharpWorkspace workspace, DiagnosticEventForwarder forwarder, CSharpDiagnosticService diagnostics)
{
_forwarder = forwarder;
_workspace = workspace;
_diagnostics = diagnostics;
}
