public ExportSolutionDialog (IMSBuildFileObject item, MSBuildFileFormat selectedFormat) { this.Build(); labelNewFormat.Text = GetFormatText (item.FileFormat); formats = MSBuildFileFormat.GetSupportedFormats (item).ToArray (); foreach (var format in formats) { comboFormat.AppendText (GetFormatText (format)); } int sel = Array.IndexOf (formats, selectedFormat); if (sel == -1) sel = 0; comboFormat.Active = sel; if (formats.Length < 2) { table.Remove (newFormatLabel); newFormatLabel.Destroy (); newFormatLabel = null; table.Remove (comboFormat); comboFormat.Destroy (); comboFormat = null; } //auto height folderEntry.WidthRequest = 380; Resize (1, 1); folderEntry.Path = item.ItemDirectory; UpdateControls (); }
public bool CanReadFile (string file, MSBuildFileFormat format) { if (String.Compare (Path.GetExtension (file), ".sln", StringComparison.OrdinalIgnoreCase) == 0) { string version = SlnFile.GetFileVersion (file); return format.SupportsSlnVersion (version); } return false; }
public override Task<SolutionItem> LoadSolutionItem (ProgressMonitor monitor, SolutionLoadContext ctx, string fileName, MSBuildFileFormat expectedFormat, string typeGuid, string itemGuid) { return Task.Run (() => { foreach (var f in MSBuildFileFormat.GetSupportedFormats ()) { if (f.CanReadFile (fileName, typeof(SolutionItem))) return MSBuildProjectService.LoadItem (monitor, fileName, f, typeGuid, itemGuid, ctx); } throw new NotSupportedException (); }); }
internal protected override bool OnGetSupportsFormat (MSBuildFileFormat format) { int version; if (!format.Id.StartsWith ("MSBuild", StringComparison.Ordinal)) return false; if (!int.TryParse (format.Id.Substring ("MSBuild".Length), out version)) return false; return version >= 10; }
public SourcesZipEditorWidget (PackageBuilder target, MSBuildFileFormat selectedFormat) { this.Build(); this.target = (SourcesZipPackageBuilder) target; loading = true; if (target.RootSolutionItem is SolutionFolder) formats = MSBuildFileFormat.GetSupportedFormats (target.Solution).ToArray (); else formats = MSBuildFileFormat.GetSupportedFormats ((SolutionItem)target.RootSolutionItem).ToArray (); if (selectedFormat == null) selectedFormat = this.target.FileFormat; if (selectedFormat == null) selectedFormat = formats [0]; int sel = 0; for (int n=0; n<formats.Length; n++) { comboFormat.AppendText (formats[n].Name); if (formats[n].Name == selectedFormat.Name) sel = n; } comboFormat.Active = sel; this.target.FileFormat = formats [sel]; string[] archiveFormats = DeployService.SupportedArchiveFormats; int zel = 1; for (int n=0; n<archiveFormats.Length; n++) { comboZip.AppendText (archiveFormats [n]); if (this.target.TargetFile.EndsWith (archiveFormats [n])) zel = n; } if (!string.IsNullOrEmpty (this.target.TargetFile)) { string ext = archiveFormats [zel]; folderEntry.Path = System.IO.Path.GetDirectoryName (this.target.TargetFile); entryZip.Text = System.IO.Path.GetFileName (this.target.TargetFile.Substring (0, this.target.TargetFile.Length - ext.Length)); comboZip.Active = zel; } loading = false; }
public SlnFileFormat(MSBuildFileFormat format) { this.format = format; }
public async Task<string> Export (ProgressMonitor monitor, string rootSourceFile, string[] includedChildIds, string targetPath, MSBuildFileFormat format) { IMSBuildFileObject obj = null; if (IsWorkspaceItemFile (rootSourceFile)) { obj = (await ReadWorkspaceItem (monitor, rootSourceFile)) as IMSBuildFileObject; } else if (IsSolutionItemFile (rootSourceFile)) { obj = await ReadSolutionItem (monitor, rootSourceFile); } if (obj == null) throw new InvalidOperationException ("File is not a solution or project."); using (obj) { return await Export (monitor, obj, includedChildIds, targetPath, format); } }
async Task<string> Export (ProgressMonitor monitor, IMSBuildFileObject obj, string[] includedChildIds, string targetPath, MSBuildFileFormat format) { string rootSourceFile = obj.FileName; string sourcePath = Path.GetFullPath (Path.GetDirectoryName (rootSourceFile)); targetPath = Path.GetFullPath (targetPath); if (sourcePath != targetPath) { if (!CopyFiles (monitor, obj, obj.GetItemFiles (true), targetPath, true)) return null; string newFile = Path.Combine (targetPath, Path.GetFileName (rootSourceFile)); if (IsWorkspaceItemFile (rootSourceFile)) obj = (Solution) await ReadWorkspaceItem (monitor, newFile); else obj = await ReadSolutionItem (monitor, newFile); using (obj) { var oldFiles = obj.GetItemFiles (true).ToList (); ExcludeEntries (obj, includedChildIds); if (format != null) obj.ConvertToFormat (format); await obj.SaveAsync (monitor); var newFiles = obj.GetItemFiles (true); var resolvedTargetPath = new FilePath (targetPath).ResolveLinks ().FullPath; foreach (FilePath f in newFiles) { if (!f.IsChildPathOf (resolvedTargetPath)) { if (obj is Solution) monitor.ReportError (GettextCatalog.GetString ("The solution '{0}' is referencing the file '{1}' which is located outside the root solution directory.", obj.Name, f.FileName), null); else monitor.ReportError (GettextCatalog.GetString ("The project '{0}' is referencing the file '{1}' which is located outside the project directory.", obj.Name, f.FileName), null); } oldFiles.Remove (f); } // Remove old files foreach (FilePath file in oldFiles) { if (File.Exists (file)) { File.Delete (file); // Exclude empty directories FilePath dir = file.ParentDirectory; if (Directory.GetFiles (dir).Length == 0 && Directory.GetDirectories (dir).Length == 0) { try { Directory.Delete (dir); } catch (Exception ex) { monitor.ReportError (null, ex); } } } } return obj.FileName; } } else { using (obj) { ExcludeEntries (obj, includedChildIds); if (format != null) obj.ConvertToFormat (format); await obj.SaveAsync (monitor); return obj.FileName; } } }
public Task<SolutionItem> ReadSolutionItem (ProgressMonitor monitor, string file, MSBuildFileFormat format, string typeGuid = null, string itemGuid = null, SolutionLoadContext ctx = null) { return Runtime.RunInMainThread (async delegate { if (!File.Exists (file)) throw new IOException (GettextCatalog.GetString ("File not found: {0}", file)); file = Path.GetFullPath (file); using (Counters.ReadSolutionItem.BeginTiming ("Read project " + file)) { file = GetTargetFile (file); var r = GetObjectReaderForFile (file, typeof(SolutionItem)); if (r == null) throw new UnknownSolutionItemTypeException (); SolutionItem loadedItem = await r.LoadSolutionItem (monitor, ctx, file, format, typeGuid, itemGuid); if (loadedItem != null) loadedItem.NeedsReload = false; return loadedItem; } }); }
public Task<string> Export (ProgressMonitor monitor, string rootSourceFile, string targetPath, MSBuildFileFormat format) { rootSourceFile = GetTargetFile (rootSourceFile); return Export (monitor, rootSourceFile, null, targetPath, format); }
static string GetFormatText (MSBuildFileFormat format) { if (!string.IsNullOrEmpty (format.ProductDescription)) return string.Format ("{0} ({1})", format.Name, format.ProductDescription); return format.Name; }
public override void CopyFrom (PackageBuilder other) { base.CopyFrom (other); SourcesZipPackageBuilder builder = (SourcesZipPackageBuilder) other; targetFile = builder.targetFile; format = builder.format; fileFormat = builder.fileFormat; }
public SlnFileFormat (MSBuildFileFormat format) { this.format = format; }
public static async Task TestCreateLoadSaveConsoleProject (MSBuildFileFormat fileFormat) { Solution sol = CreateConsoleSolution ("TestCreateLoadSaveConsoleProject"); sol.ConvertToFormat (fileFormat); await sol.SaveAsync (Util.GetMonitor ()); string solFile = sol.FileName; sol = (Solution) await Services.ProjectService.ReadWorkspaceItem (Util.GetMonitor (), solFile); CheckConsoleProject (sol); // Save over existing file await sol.SaveAsync (Util.GetMonitor ()); sol = (Solution) await Services.ProjectService.ReadWorkspaceItem (Util.GetMonitor (), solFile); CheckConsoleProject (sol); }
public override Task<SolutionItem> LoadSolutionItem (ProgressMonitor monitor, SolutionLoadContext ctx, string fileName, MSBuildFileFormat expectedFormat, string typeGuid, string itemGuid) { return Task.Run (() => (SolutionItem) ReadFile (fileName, false, monitor)); }
public string GetValidFormatName(object obj, string fileName, MSBuildFileFormat format) { return(Path.ChangeExtension(fileName, ".sln")); }
internal protected virtual void OnSetFormat (MSBuildFileFormat value) { next.OnSetFormat (value); }
public static async Task TestLoadSaveResources (MSBuildFileFormat fileFormat) { string solFile = Util.GetSampleProject ("resources-tester", "ResourcesTester.sln"); Solution sol = (Solution) await Services.ProjectService.ReadWorkspaceItem (Util.GetMonitor (), solFile); sol.ConvertToFormat (fileFormat); ProjectTests.CheckResourcesSolution (sol); await sol.SaveAsync (Util.GetMonitor ()); solFile = sol.FileName; sol = (Solution) await Services.ProjectService.ReadWorkspaceItem (Util.GetMonitor (), solFile); ProjectTests.CheckResourcesSolution (sol); DotNetProject p = (DotNetProject) sol.Items [0]; string f = Path.Combine (p.BaseDirectory, "Bitmap1.bmp"); ProjectFile pf = p.Files.GetFile (f); pf.ResourceId = "SomeBitmap.bmp"; await sol.SaveAsync (Util.GetMonitor ()); sol = (Solution) await Services.ProjectService.ReadWorkspaceItem (Util.GetMonitor (), solFile); p = (DotNetProject) sol.Items [0]; f = Path.Combine (p.BaseDirectory, "Bitmap1.bmp"); pf = p.Files.GetFile (f); Assert.AreEqual ("SomeBitmap.bmp", pf.ResourceId); }
public override Task<SolutionItem> LoadSolutionItem (ProgressMonitor monitor, SolutionLoadContext ctx, string fileName, MSBuildFileFormat expectedFormat, string typeGuid, string itemGuid) { return Task<SolutionItem>.Factory.StartNew (delegate { CompiledAssemblyProject p = new CompiledAssemblyProject (); p.LoadFrom (fileName); return p; }); }
public virtual Task<SolutionItem> LoadSolutionItem (ProgressMonitor monitor, SolutionLoadContext ctx, string fileName, MSBuildFileFormat expectedFormat, string typeGuid, string itemGuid) { throw new NotSupportedException (); }
public async void Export (IMSBuildFileObject item, MSBuildFileFormat format) { ExportSolutionDialog dlg = new ExportSolutionDialog (item, format); try { if (MessageService.RunCustomDialog (dlg) == (int) Gtk.ResponseType.Ok) { using (ProgressMonitor monitor = IdeApp.Workbench.ProgressMonitors.GetToolOutputProgressMonitor (true)) { await Services.ProjectService.Export (monitor, item.FileName, dlg.TargetFolder, dlg.Format); } } } finally { dlg.Destroy (); dlg.Dispose (); } }
public static async Task TestLoadSaveSolutionFolders (MSBuildFileFormat fileFormat) { List<string> ids = new List<string> (); Solution sol = new Solution (); sol.ConvertToFormat (fileFormat); string dir = Util.CreateTmpDir ("solution-folders-" + fileFormat.Name); sol.FileName = Path.Combine (dir, "TestSolutionFolders"); sol.Name = "TheSolution"; var p1 = Services.ProjectService.CreateDotNetProject ("C#"); p1.FileName = Path.Combine (dir, "p1"); sol.RootFolder.Items.Add (p1); string idp1 = p1.ItemId; Assert.IsFalse (string.IsNullOrEmpty (idp1)); Assert.IsFalse (ids.Contains (idp1)); ids.Add (idp1); SolutionFolder f1 = new SolutionFolder (); f1.Name = "f1"; sol.RootFolder.Items.Add (f1); string idf1 = f1.ItemId; Assert.IsFalse (string.IsNullOrEmpty (idf1)); Assert.IsFalse (ids.Contains (idf1)); ids.Add (idf1); var p2 = Services.ProjectService.CreateDotNetProject ("C#"); p2.FileName = Path.Combine (dir, "p2"); f1.Items.Add (p2); string idp2 = p2.ItemId; Assert.IsFalse (string.IsNullOrEmpty (idp2)); Assert.IsFalse (ids.Contains (idp2)); ids.Add (idp2); SolutionFolder f2 = new SolutionFolder (); f2.Name = "f2"; f1.Items.Add (f2); string idf2 = f2.ItemId; Assert.IsFalse (string.IsNullOrEmpty (idf2)); Assert.IsFalse (ids.Contains (idf2)); ids.Add (idf2); var p3 = Services.ProjectService.CreateDotNetProject ("C#"); p3.FileName = Path.Combine (dir, "p3"); f2.Items.Add (p3); string idp3 = p3.ItemId; Assert.IsFalse (string.IsNullOrEmpty (idp3)); Assert.IsFalse (ids.Contains (idp3)); ids.Add (idp3); var p4 = Services.ProjectService.CreateDotNetProject ("C#"); p4.FileName = Path.Combine (dir, "p4"); f2.Items.Add (p4); string idp4 = p4.ItemId; Assert.IsFalse (string.IsNullOrEmpty (idp4)); Assert.IsFalse (ids.Contains (idp4)); ids.Add (idp4); await sol.SaveAsync (Util.GetMonitor ()); Solution sol2 = (Solution) await Services.ProjectService.ReadWorkspaceItem (Util.GetMonitor (), sol.FileName); Assert.AreEqual (4, sol2.Items.Count); Assert.AreEqual (2, sol2.RootFolder.Items.Count); Assert.AreEqual (typeof(CSharpProject), sol2.RootFolder.Items [0].GetType ()); Assert.AreEqual (typeof(SolutionFolder), sol2.RootFolder.Items [1].GetType ()); Assert.AreEqual ("p1", sol2.RootFolder.Items [0].Name); Assert.AreEqual ("f1", sol2.RootFolder.Items [1].Name); Assert.AreEqual (idp1, sol2.RootFolder.Items [0].ItemId, "idp1"); Assert.AreEqual (idf1, sol2.RootFolder.Items [1].ItemId, "idf1"); f1 = (SolutionFolder) sol2.RootFolder.Items [1]; Assert.AreEqual (2, f1.Items.Count); Assert.AreEqual (typeof(CSharpProject), f1.Items [0].GetType ()); Assert.AreEqual (typeof(SolutionFolder), f1.Items [1].GetType ()); Assert.AreEqual ("p2", f1.Items [0].Name); Assert.AreEqual ("f2", f1.Items [1].Name); Assert.AreEqual (idp2, f1.Items [0].ItemId, "idp2"); Assert.AreEqual (idf2, f1.Items [1].ItemId, "idf2"); f2 = (SolutionFolder) f1.Items [1]; Assert.AreEqual (2, f2.Items.Count); Assert.AreEqual (typeof(CSharpProject), f2.Items [0].GetType ()); Assert.AreEqual (typeof(CSharpProject), f2.Items [1].GetType ()); Assert.AreEqual ("p3", f2.Items [0].Name); Assert.AreEqual ("p4", f2.Items [1].Name); Assert.AreEqual (idp3, f2.Items [0].ItemId, "idp4"); Assert.AreEqual (idp4, f2.Items [1].ItemId, "idp4"); }
public static async Task CheckGenericItemProject (MSBuildFileFormat format) { Solution sol = new Solution (); sol.ConvertToFormat (format); string dir = Util.CreateTmpDir ("generic-item-" + format.Name); sol.FileName = Path.Combine (dir, "TestGenericItem"); sol.Name = "TheItem"; MonoDevelop.Projects.MSBuild.MSBuildProjectService.RegisterGenericProjectType ("GenericItem", typeof(GenericItem)); GenericItem it = new GenericItem (); it.SomeValue = "hi"; sol.RootFolder.Items.Add (it); it.FileName = Path.Combine (dir, "TheItem"); it.Name = "TheItem"; await sol.SaveAsync (Util.GetMonitor ()); Solution sol2 = (Solution) await Services.ProjectService.ReadWorkspaceItem (Util.GetMonitor (), sol.FileName); Assert.AreEqual (1, sol2.Items.Count); Assert.IsInstanceOf<GenericItem> (sol2.Items [0]); it = (GenericItem) sol2.Items [0]; Assert.AreEqual ("hi", it.SomeValue); }
public bool CanWriteFile(object obj, MSBuildFileFormat format) { return(obj is Solution); }
public override void InitializeSettings (SolutionFolderItem entry) { targetFile = Path.Combine (entry.BaseDirectory, entry.Name) + ".tar.gz"; if (entry.ParentSolution != null) fileFormat = entry.ParentSolution.FileFormat; }
public string GetValidFormatName (object obj, string fileName, MSBuildFileFormat format) { return Path.ChangeExtension (fileName, ".sln"); }
static void SetClosestSupportedTargetFramework (MSBuildFileFormat format, DotNetProject project) { // If the solution format can't write this project due to an unsupported framework, try finding the // closest valid framework. DOn't worry about whether it's installed, that's up to the user to correct. TargetFramework curFx = project.TargetFramework; var candidates = Runtime.SystemAssemblyService.GetTargetFrameworks () .Where (fx => //only frameworks with the same ID, else version comparisons are meaningless fx.Id.Identifier == curFx.Id.Identifier && //don't consider profiles, only full frameworks fx.Id.Profile == null && //and the project and format must support the framework project.SupportsFramework (fx) && format.SupportsFramework (fx)) //FIXME: string comparisons aren't a valid way to compare profiles, but it works w/released .NET versions .OrderBy (fx => fx.Id.Version) .ToList (); TargetFramework newFx = candidates.FirstOrDefault (fx => string.CompareOrdinal (fx.Id.Version, curFx.Id.Version) > 0) ?? candidates.LastOrDefault (); if (newFx != null) project.TargetFramework = newFx; }
public bool CanWriteFile (object obj, MSBuildFileFormat format) { return obj is Solution; }
internal protected virtual void OnSetFormat (MSBuildFileFormat format) { next.OnSetFormat (format); }
/// <summary> /// Loads a solution item /// </summary> /// <returns>The item.</returns> /// <param name="monitor">Progress monitor</param> /// <param name="fileName">File path to the item file</param> /// <param name="expectedFormat">File format that the project should have</param> /// <param name="typeGuid">Optional item type GUID. If not provided, the type is guessed from the file extension.</param> /// <param name="itemGuid">Optional item Id</param> /// <param name="ctx">Optional solution context</param> public async static Task<SolutionItem> LoadItem (ProgressMonitor monitor, string fileName, MSBuildFileFormat expectedFormat, string typeGuid, string itemGuid, SolutionLoadContext ctx) { SolutionItem item = null; // Find an extension node that can handle this item type var node = GetItemTypeNodes ().FirstOrDefault (n => n.CanHandleFile (fileName, typeGuid)); if (node != null) { item = await node.CreateSolutionItem (monitor, ctx, fileName); if (item == null) return null; } if (item == null) { // If it is a known unsupported project, load it as UnknownProject item = CreateUnknownSolutionItem (monitor, fileName, typeGuid, typeGuid, ctx); if (item == null) return null; } item.EnsureInitialized (); item.BeginLoad (); ctx.LoadCompleted += delegate { item.EndLoad (); item.NotifyItemReady (); }; await item.LoadAsync (monitor, fileName, expectedFormat); return item; }
internal protected virtual bool OnGetSupportsFormat (MSBuildFileFormat format) { return next.OnGetSupportsFormat (format); }