public async Task SaveProjectFileExternally_TwoSolutionsOpened_NoCommonDirectories()
{
string solFile = Util.GetSampleProject("console-project", "ConsoleProject.sln");
sol = (Solution)await Services.ProjectService.ReadWorkspaceItem(Util.GetMonitor(), solFile);
var p = (DotNetProject)sol.Items [0];
var file1 = p.Files.First(f => f.FilePath.FileName == "Program.cs");
solFile = Util.GetSampleProject("console-with-libs", "console-with-libs.sln");
using (var sol2 = (Solution)await Services.ProjectService.ReadWorkspaceItem(Util.GetMonitor(), solFile)) {
var p2 = sol2.GetAllProjects().First(project => project.FileName.FileName == "console-with-libs.csproj");
var file2 = p2.Files.First(f => f.FilePath.FileName == "Program.cs");
ClearFileEventsCaptured();
await FileWatcherService.Add(sol);
await FileWatcherService.Add(sol2);
TextFileUtility.WriteText(file1.FilePath, string.Empty, Encoding.UTF8);
TextFileUtility.WriteText(file2.FilePath, string.Empty, Encoding.UTF8);
await WaitForFilesChanged(new [] { file1.FilePath, file2.FilePath });
AssertFileChanged(file1.FilePath);
AssertFileChanged(file2.FilePath);
}
}
async Task FormatFile(Project p, FilePath file)
{
string mime = DesktopService.GetMimeTypeForUri(file);
if (mime == null)
{
return;
}
var formatter = CodeFormatterService.GetFormatter(mime);
if (formatter != null)
{
try {
var content = await TextFileUtility.ReadAllTextAsync(file);
var formatted = formatter.FormatText(p.Policies, content.Text);
if (formatted != null)
{
TextFileUtility.WriteText(file, formatted, content.Encoding);
}
} catch (Exception ex) {
LoggingService.LogError("File formatting failed", ex);
}
}
}
protected virtual Task OnSaveUserProperties()
{
FilePath file = GetPreferencesFileName();
var userProps = userProperties;
return(Task.Run(() => {
if (userProps == null || userProps.IsEmpty)
{
if (File.Exists(file))
{
File.Delete(file);
}
return;
}
using (var sw = new StringWriter()) {
XmlTextWriter writer = null;
try {
writer = new XmlTextWriter(sw);
writer.Formatting = Formatting.Indented;
XmlDataSerializer ser = new XmlDataSerializer(new DataContext());
ser.SerializationContext.BaseFile = file;
ser.Serialize(writer, userProps, typeof(PropertyBag));
TextFileUtility.WriteText(file, sw.ToString(), Encoding.UTF8);
} catch (Exception e) {
LoggingService.LogWarning("Could not save solution preferences: " + file, e);
} finally {
if (writer != null)
{
writer.Close();
}
}
}
}));
}
public async Task SaveProjectFileExternally_TwoSolutionsOpen_SolutionsHaveCommonDirectories()
{
FilePath rootProject = Util.GetSampleProject("FileWatcherTest", "Root.csproj");
string solFile = rootProject.ParentDirectory.Combine("FileWatcherTest", "FileWatcherTest.sln");
sol = (Solution)await Services.ProjectService.ReadWorkspaceItem(Util.GetMonitor(), solFile);
var p1 = (DotNetProject)sol.Items [0];
var file1 = p1.Files.First(f => f.FilePath.FileName == "MyClass.cs");
solFile = rootProject.ParentDirectory.Combine("FileWatcherTest", "FileWatcherTest2.sln");
using (var sol2 = (Solution)await Services.ProjectService.ReadWorkspaceItem(Util.GetMonitor(), solFile)) {
var p2 = (DotNetProject)sol.Items [0];
var file2 = p2.Files.First(f => f.FilePath.FileName == "MyClass.cs");
ClearFileEventsCaptured();
await FileWatcherService.Add(sol);
await FileWatcherService.Add(sol2);
TextFileUtility.WriteText(file1.FilePath, string.Empty, Encoding.UTF8);
TextFileUtility.WriteText(file2.FilePath, string.Empty, Encoding.UTF8);
await WaitForFilesChanged(new [] { file1.FilePath, file2.FilePath });
AssertFileChanged(file1.FilePath);
AssertFileChanged(file2.FilePath);
}
}
internal void ApplyChanges()
{
if (loadingError)
{
return;
}
try {
TextFileUtility.WriteText(TypeSystemService.RuleSetManager.GlobalRulesetFileName, TextEditor.Text, encoding);
} catch (Exception e) {
LoggingService.LogError("Error while saving global rule set file " + TypeSystemService.RuleSetManager.GlobalRulesetFileName, e);
MessageService.ShowError(GettextCatalog.GetString("Error while saving global rule set file '{0}'.", TypeSystemService.RuleSetManager.GlobalRulesetFileName));
}
}
/// <summary>
/// Tries the fix the issues passed in <paramref name="issues"/>.
/// </summary>
/// <param name="issues">The issues to fix.</param>
/// <returns>The fix issues.</returns>
public IEnumerable <ActionSummary> TryFixIssues(IEnumerable <ActionSummary> actions)
{
if (actions == null)
{
throw new ArgumentNullException("actions");
}
// enumerate once
var actionSummaries = actions as IList <ActionSummary> ?? actions.ToArray();
var issueSummaries = actionSummaries.Select(action => action.IssueSummary).ToArray();
var files = issueSummaries.Select(issue => issue.File).ToList();
monitor.BeginTask("Applying fixes", files.Count);
var appliedActions = new List <ActionSummary> (issueSummaries.Length);
Parallel.ForEach(files, file => {
monitor.Step(1);
var fileSummaries = issueSummaries.Where(summary => summary.File == file);
var inspectorIds = new HashSet <string> (fileSummaries.Select(summary => summary.InspectorIdString));
bool hadBom;
Encoding encoding;
bool isOpen;
var data = TextFileProvider.Instance.GetTextEditorData(file.FilePath, out hadBom, out encoding, out isOpen);
object refactoringContext;
var realActions = GetIssues(data, file, inspectorIds, out refactoringContext).SelectMany(issue => issue.Actions).ToList();
if (realActions.Count == 0 || refactoringContext == null)
{
return;
}
var fileActionSummaries = actionSummaries.Where(summary => summary.IssueSummary.File == file).ToList();
var matches = matcher.Match(fileActionSummaries, realActions).ToList();
var appliedFixes = RefactoringService.ApplyFixes(matches.Select(match => match.Action), refactoringContext);
appliedActions.AddRange(matches.Where(match => appliedFixes.Contains(match.Action)).Select(match => match.Summary));
if (!isOpen)
{
// If the file is open we leave it to the user to explicitly save the file
TextFileUtility.WriteText(file.Name, data.Text, encoding, hadBom);
}
});
return(appliedActions);
}
public async Task SaveFileInProjectExternally()
{
string solFile = Util.GetSampleProject("console-project", "ConsoleProject.sln");
sol = (Solution)await Services.ProjectService.ReadWorkspaceItem(Util.GetMonitor(), solFile);
var p = (DotNetProject)sol.Items [0];
var file = p.Files.First(f => f.FilePath.FileName == "Program.cs");
ClearFileEventsCaptured();
await FileWatcherService.Add(sol);
TextFileUtility.WriteText(file.FilePath, string.Empty, Encoding.UTF8);
await WaitForFileChanged(file.FilePath);
AssertFileChanged(file.FilePath);
}
public virtual void EndReplace()
{
if (textBuffer != null)
{
Gtk.Application.Invoke((o, args) => {
textEdit.Apply();
textEdit = null;
});
return;
}
if (buffer != null && somethingReplaced)
{
object attributes = IdeServices.DesktopService.GetFileAttributes(FileName);
TextFileUtility.WriteText(FileName, buffer.ToString(), encoding ?? Encoding.UTF8);
IdeServices.DesktopService.SetFileAttributes(FileName, attributes);
}
buffer = null;
}
public async Task CreateDirectory_AddFolderItemToProject_DirectoryDeletedEventIsNotFired()
{
FilePath rootProject = Util.GetSampleProject("FileWatcherTest", "Root.csproj");
string solFile = rootProject.ParentDirectory.Combine("FileWatcherTest", "FileWatcherTest2.sln");
sol = (Solution)await Services.ProjectService.ReadWorkspaceItem(Util.GetMonitor(), solFile);
var p = (DotNetProject)sol.Items [0];
p.UseAdvancedGlobSupport = true;
p.UseFileWatcher = true;
var file = p.Files.First(f => f.FilePath.FileName == "MyClass.cs");
ClearFileEventsCaptured();
await FileWatcherService.Add(sol);
var newDirectory = p.BaseDirectory.Combine("NewFolder");
Directory.CreateDirectory(newDirectory);
var newFolderItem = new ProjectFile(newDirectory);
newFolderItem.Subtype = Subtype.Directory;
p.Files.Add(newFolderItem);
var newDirectory2 = p.BaseDirectory.Combine("NewFolder2");
var newFolderItem2 = new ProjectFile(newDirectory2);
newFolderItem2.Subtype = Subtype.Directory;
p.Files.Add(newFolderItem2);
Directory.CreateDirectory(newDirectory2);
await p.SaveAsync(Util.GetMonitor());
TextFileUtility.WriteText(file.FilePath, string.Empty, Encoding.UTF8);
await WaitForFileChanged(file.FilePath);
AssertFileChanged(file.FilePath);
Assert.IsTrue(p.Files.Contains(newFolderItem));
Assert.IsTrue(p.Files.Contains(newFolderItem2));
Assert.IsFalse(filesRemoved.Any(f => f.FileName == newDirectory));
Assert.IsFalse(filesRemoved.Any(f => f.FileName == newDirectory2));
}
public async Task AddNewProjectToSolution_ChangeFileInNewProject()
{
FilePath rootProject = Util.GetSampleProject("FileWatcherTest", "Root.csproj");
string solFile = rootProject.ParentDirectory.Combine("FileWatcherTest", "FileWatcherTest3.sln");
using var sol = (Solution) await Services.ProjectService.ReadWorkspaceItem(Util.GetMonitor(), solFile);
var p = (DotNetProject)sol.Items [0];
var otherFile = p.Files.First(f => f.FilePath.FileName == "MyClass.cs");
await FileWatcherService.Add(sol);
var libraryProjectFile = rootProject.ParentDirectory.Combine("Library", "Library.csproj");
ProjectFile file;
using (var p2 = (DotNetProject)await sol.RootFolder.AddItem(Util.GetMonitor(), libraryProjectFile)) {
await sol.SaveAsync(Util.GetMonitor());
file = p2.Files.First(f => f.FilePath.FileName == "MyClass.cs");
await FileWatcherService.Update();
ClearFileEventsCaptured();
TextFileUtility.WriteText(file.FilePath, string.Empty, Encoding.UTF8);
await WaitForFileChanged(file.FilePath);
AssertFileChanged(file.FilePath);
Assert.IsFalse(file.FilePath.IsChildPathOf(sol.BaseDirectory));
sol.RootFolder.Items.Remove(p2);
}
await sol.SaveAsync(Util.GetMonitor());
await FileWatcherService.Update();
ClearFileEventsCaptured();
TextFileUtility.WriteText(file.FilePath, string.Empty, Encoding.UTF8);
TextFileUtility.WriteText(otherFile.FilePath, string.Empty, Encoding.UTF8);
await WaitForFilesChanged(new [] { file.FilePath, otherFile.FilePath });
Assert.IsFalse(fileChanges.Any(f => f.FileName == file.FilePath));
}
public async Task AddSolutionToWorkspace_ChangeFileInAddedSolution()
{
FilePath rootProject = Util.GetSampleProject("FileWatcherTest", "Root.csproj");
string workspaceFile = rootProject.ParentDirectory.Combine("Workspace", "FileWatcherTest.mdw");
using (var workspace = (Workspace)await Services.ProjectService.ReadWorkspaceItem(Util.GetMonitor(), workspaceFile)) {
await FileWatcherService.Add(workspace);
string solFile = rootProject.ParentDirectory.Combine("FileWatcherTest", "FileWatcherTest3.sln");
sol = (Solution)await Services.ProjectService.ReadWorkspaceItem(Util.GetMonitor(), solFile);
var p = (DotNetProject)sol.Items [0];
var file = p.Files.First(f => f.FilePath.FileName == "MyClass.cs");
workspace.Items.Add(sol);
await workspace.SaveAsync(Util.GetMonitor());
var otherFile = workspace.FileName.ParentDirectory.Combine("test.txt");
ClearFileEventsCaptured();
// Make sure file watcher is updated since adding the new solution
// will start a task and may not have finished. So force an update here.
await FileWatcherService.Update();
TextFileUtility.WriteText(file.FilePath, string.Empty, Encoding.UTF8);
await WaitForFileChanged(file.FilePath);
AssertFileChanged(file.FilePath);
Assert.IsFalse(file.FilePath.IsChildPathOf(workspace.BaseDirectory));
workspace.Items.Remove(sol);
await workspace.SaveAsync(Util.GetMonitor());
await FileWatcherService.Update();
ClearFileEventsCaptured();
TextFileUtility.WriteText(file.FilePath, string.Empty, Encoding.UTF8);
TextFileUtility.WriteText(otherFile, string.Empty, Encoding.UTF8);
await WaitForFilesChanged(new [] { file.FilePath, otherFile });
Assert.IsFalse(fileChanges.Any(f => f.FileName == file.FilePath));
}
}
public async Task AddFile_FileOutsideSolutionDirectory()
{
FilePath rootProject = Util.GetSampleProject("FileWatcherTest", "Root.csproj");
string solFile = rootProject.ParentDirectory.Combine("FileWatcherTest", "FileWatcherTest3.sln");
sol = (Solution)await Services.ProjectService.ReadWorkspaceItem(Util.GetMonitor(), solFile);
var p = (DotNetProject)sol.Items [0];
var file2 = p.Files.First(f => f.FilePath.FileName == "MyClass.cs");
ClearFileEventsCaptured();
await FileWatcherService.Add(sol);
var newFile = rootProject.ParentDirectory.Combine("Library", "MyClass.cs");
var file = new ProjectFile(newFile);
file.Link = "LinkedMyClass.cs";
p.AddFile(file);
await FileWatcherService.Update();
ClearFileEventsCaptured();
TextFileUtility.WriteText(file.FilePath, string.Empty, Encoding.UTF8);
await WaitForFileChanged(file.FilePath);
AssertFileChanged(file.FilePath);
Assert.IsFalse(file.FilePath.IsChildPathOf(p.BaseDirectory));
Assert.IsFalse(file.FilePath.IsChildPathOf(sol.BaseDirectory));
// After removing the file no events should be generated for the file.
p.Files.Remove(file);
await FileWatcherService.Update();
ClearFileEventsCaptured();
TextFileUtility.WriteText(file.FilePath, string.Empty, Encoding.UTF8);
TextFileUtility.WriteText(file2.FilePath, string.Empty, Encoding.UTF8);
await WaitForFilesChanged(new [] { file.FilePath, file2.FilePath });
AssertFileChanged(file2.FilePath);
Assert.IsFalse(fileChanges.Any(f => f.FileName == file.FilePath));
}
public async Task SaveProjectFileExternally_FileOutsideSolutionDirectory()
{
FilePath rootProject = Util.GetSampleProject("FileWatcherTest", "Root.csproj");
string solFile = rootProject.ParentDirectory.Combine("FileWatcherTest", "FileWatcherTest2.sln");
sol = (Solution)await Services.ProjectService.ReadWorkspaceItem(Util.GetMonitor(), solFile);
var p = (DotNetProject)sol.Items [0];
var file = p.Files.First(f => f.FilePath.FileName == "MyClass.cs");
ClearFileEventsCaptured();
await FileWatcherService.Add(sol);
TextFileUtility.WriteText(file.FilePath, string.Empty, Encoding.UTF8);
await WaitForFileChanged(file.FilePath);
AssertFileChanged(file.FilePath);
Assert.IsFalse(file.FilePath.IsChildPathOf(p.BaseDirectory));
Assert.IsFalse(file.FilePath.IsChildPathOf(sol.BaseDirectory));
}
public static void FormatFile(PolicyContainer policies, FilePath fileName)
{
CodeFormatter formatter = GetFormatter(fileName);
if (formatter == null)
{
return;
}
try {
string content = File.ReadAllText(fileName);
string formatted = formatter.FormatText(policies, content);
if (formatted != null)
{
TextFileUtility.WriteText(fileName, formatted, Encoding.UTF8);
}
} catch (Exception ex) {
TemplatingServices.LogError("File formatting failed", ex);
}
}
public async Task TextFileUtility_WriteText_FileNotRemovedAndAddedBackToProject()
{
var project = await OpenProject();
var fileAdded = WaitForSingleFileAdded(project);
var csharpFilePath = WriteFile(project.BaseDirectory, "CSharpFile.cs");
await AssertFileAddedToProject(fileAdded, csharpFilePath, "Compile");
fileAdded = WaitForSingleFileAdded(project);
var fileRemoved = WaitForSingleFileRemoved(project);
TextFileUtility.WriteText(csharpFilePath, "//", Encoding.UTF8);
// Finished task should be the delay timeout. No file should be added or
// removed when the C# file is saved.
var finishedTask = await Task.WhenAny(fileAdded, fileRemoved, Task.Delay(500));
Assert.AreNotEqual(fileAdded, finishedTask);
Assert.AreNotEqual(fileRemoved, finishedTask);
}
public async Task WatchDirectories_TwoFilesChanged_OneClosed()
{
FilePath rootSolFile = Util.GetSampleProject("FileWatcherTest", "Root.sln");
var file1 = rootSolFile.ParentDirectory.Combine("FileWatcherTest", "MyClass.cs");
var file2 = rootSolFile.ParentDirectory.Combine("Library", "Properties", "AssemblyInfo.cs");
var id = new object();
try {
var directories = new [] {
file1.ParentDirectory,
file2.ParentDirectory
};
await FileWatcherService.WatchDirectories(id, directories);
TextFileUtility.WriteText(file1, string.Empty, Encoding.UTF8);
TextFileUtility.WriteText(file2, string.Empty, Encoding.UTF8);
await WaitForFilesChanged(new [] { file1, file2 });
AssertFileChanged(file1);
AssertFileChanged(file2);
// Unwatch one directory.
directories = new [] {
file1.ParentDirectory
};
await FileWatcherService.WatchDirectories(id, directories);
ClearFileEventsCaptured();
fileChangesTask = new TaskCompletionSource <bool> ();
TextFileUtility.WriteText(file2, string.Empty, Encoding.UTF8);
TextFileUtility.WriteText(file1, string.Empty, Encoding.UTF8);
await WaitForFilesChanged(new [] { file1, file2 });
AssertFileChanged(file1);
Assert.IsFalse(fileChanges.Any(f => f.FileName == file2));
} finally {
await FileWatcherService.WatchDirectories(id, null);
}
}
public virtual void EndReplace()
{
if (document != null)
{
Gtk.Application.Invoke((o, args) => {
if (undoGroup != null)
{
undoGroup.Dispose();
undoGroup = null;
}
/*document.Editor.Document.CommitUpdateAll (); */
});
return;
}
if (buffer != null && somethingReplaced)
{
object attributes = DesktopService.GetFileAttributes(FileName);
TextFileUtility.WriteText(FileName, buffer.ToString(), encoding ?? Encoding.UTF8);
DesktopService.SetFileAttributes(FileName, attributes);
}
buffer = null;
}
public void EndReplace()
{
if (document != null)
{
Gtk.Application.Invoke(delegate {
if (undoGroup != null)
{
undoGroup.Dispose();
undoGroup = null;
}
/*document.Editor.Document.CommitUpdateAll (); */
});
return;
}
if (buffer != null && somethingReplaced)
{
object attributes = DesktopService.GetFileAttributes(FileName);
TextFileUtility.WriteText(FileName, buffer.ToString(), encoding, hadBom);
DesktopService.SetFileAttributes(FileName, attributes);
}
FileService.NotifyFileChanged(FileName);
buffer = null;
}
async Task <bool> SaveAsTask(string filename)
{
if (Window.ViewContent.IsViewOnly || !Window.ViewContent.IsFile)
{
return(false);
}
Encoding encoding = null;
var tbuffer = GetContent <ITextSource> ();
if (tbuffer != null)
{
encoding = tbuffer.Encoding;
if (encoding == null)
{
encoding = Encoding.UTF8;
}
}
if (filename == null)
{
var dlg = new OpenFileDialog(GettextCatalog.GetString("Save as..."), MonoDevelop.Components.FileChooserAction.Save)
{
TransientFor = IdeApp.Workbench.RootWindow,
Encoding = encoding,
ShowEncodingSelector = (tbuffer != null),
};
if (Window.ViewContent.IsUntitled)
{
dlg.InitialFileName = Window.ViewContent.UntitledName;
}
else
{
dlg.CurrentFolder = Path.GetDirectoryName((string)Window.ViewContent.ContentName);
dlg.InitialFileName = Path.GetFileName((string)Window.ViewContent.ContentName);
}
if (!dlg.Run())
{
return(false);
}
filename = dlg.SelectedFile;
encoding = dlg.Encoding;
}
if (!FileService.IsValidPath(filename))
{
MessageService.ShowMessage(GettextCatalog.GetString("File name {0} is invalid", filename));
return(false);
}
// detect preexisting file
if (File.Exists(filename))
{
if (!MessageService.Confirm(GettextCatalog.GetString("File {0} already exists. Overwrite?", filename), AlertButton.OverwriteFile))
{
return(false);
}
}
// save backup first
if (IdeApp.Preferences.CreateFileBackupCopies)
{
if (tbuffer != null && encoding != null)
{
TextFileUtility.WriteText(filename + "~", tbuffer.Text, encoding);
}
else
{
await Window.ViewContent.Save(new FileSaveInformation (filename + "~", encoding));
}
}
TypeSystemService.RemoveSkippedfile(FileName);
// do actual save
Window.ViewContent.ContentName = filename;
Window.ViewContent.Project = Workbench.GetProjectContainingFile(filename);
await Window.ViewContent.Save(new FileSaveInformation (filename, encoding));
DesktopService.RecentFiles.AddFile(filename, (Project)null);
OnSaved(EventArgs.Empty);
await UpdateParseDocument();
return(true);
}
