public virtual Task <SolutionItem> LoadSolutionItem(ProgressMonitor monitor, SolutionLoadContext ctx, string fileName, MSBuildFileFormat expectedFormat, string typeGuid, string itemGuid)
{
return(Task.FromException <SolutionItem> (new NotSupportedException()));
}
public void ConvertToFormat(MSBuildFileFormat format)
{
SolutionExtension.OnSetFormat(format);
}
public override SolutionEntityItem LoadSolutionItem(IProgressMonitor monitor, string fileName, MSBuildFileFormat expectedFormat, string itemGuid)
{
MSBuildProjectHandler handler = CreateHandler <MSBuildProjectHandler> (fileName, itemGuid);
handler.SetCustomResourceHandler(GetResourceHandler());
return(handler.Load(monitor, fileName, expectedFormat, language, null));
}
public async Task <int> Run(string[] arguments)
{
if (arguments.Length == 0 || arguments [0] == "--help")
{
Console.WriteLine("");
Console.WriteLine("Project Export Tool");
Console.WriteLine("Usage: mdtool project-export <source-project-file> [-d:dest-path] [-f:format-name]");
Console.WriteLine("");
Console.WriteLine("Options");
Console.WriteLine(" -d:<dest-path> Directory where the project will be exported.");
Console.WriteLine(" -f:\"<format-name>\" Format to which export the project or solution.");
Console.WriteLine(" -l Show a list of all allowed target formats.");
Console.WriteLine(" -p:<project-name> When exporting a solution, name of a project to be");
Console.WriteLine(" included in the export. It can be specified multiple");
Console.WriteLine(" times.");
Console.WriteLine("");
Console.WriteLine(" The format name is optional. A list of allowed file formats will be");
Console.WriteLine(" shown if none is provided.");
Console.WriteLine("");
return(0);
}
string projectFile = null;
string destPath = null;
string formatName = null;
bool formatList = false;
List <string> projects = new List <string> ();
string[] itemsToExport = null;
foreach (string s in arguments)
{
if (s.StartsWith("-d:"))
{
destPath = s.Substring(3);
}
else if (s.StartsWith("-f:"))
{
formatName = s.Substring(3);
}
else if (s.StartsWith("-p:"))
{
projects.Add(s.Substring(3));
}
else if (s == "-l")
{
formatList = true;
}
else if (projectFile != null)
{
Console.WriteLine("Only one project can be converted at a time.");
return(1);
}
else
{
projectFile = s;
}
}
if (projectFile == null)
{
Console.WriteLine("Project or solution file name not provided.");
return(1);
}
projectFile = FileService.GetFullPath(projectFile);
if (!File.Exists(projectFile))
{
Console.WriteLine("File {0} not found.", projectFile);
return(1);
}
ConsoleProgressMonitor monitor = new ConsoleProgressMonitor();
monitor.IgnoreLogMessages = true;
object item;
if (Services.ProjectService.IsWorkspaceItemFile(projectFile))
{
item = await Services.ProjectService.ReadWorkspaceItem(monitor, projectFile);
if (projects.Count > 0)
{
Solution sol = item as Solution;
if (sol == null)
{
Console.WriteLine("The -p option can only be used when exporting a solution.");
return(1);
}
for (int n = 0; n < projects.Count; n++)
{
string pname = projects [n];
if (pname.Length == 0)
{
Console.WriteLine("Project name not specified in -p option.");
return(1);
}
Project p = sol.FindProjectByName(pname);
if (p == null)
{
Console.WriteLine("Project '" + pname + "' not found in solution.");
return(1);
}
projects[n] = p.ItemId;
}
itemsToExport = projects.ToArray();
}
}
else
{
if (projects.Count > 0)
{
Console.WriteLine("The -p option can't be used when exporting a single project");
return(1);
}
item = await Services.ProjectService.ReadSolutionItem(monitor, projectFile);
}
var formats = MSBuildFileFormat.GetSupportedFormats().ToArray();
if (formats.Length == 0)
{
Console.WriteLine("Can't convert file to any format: " + projectFile);
return(1);
}
MSBuildFileFormat format = null;
if (formatName == null || formatList)
{
Console.WriteLine();
Console.WriteLine("Target formats:");
for (int n = 0; n < formats.Length; n++)
{
Console.WriteLine(" {0}. {1}", n + 1, formats [n].Name);
}
Console.WriteLine();
if (formatList)
{
return(0);
}
int op = 0;
do
{
Console.Write("Convert to format: ");
string s = Console.ReadLine();
if (s.Length == 0)
{
return(1);
}
if (int.TryParse(s, out op))
{
if (op > 0 && op <= formats.Length)
{
break;
}
}
} while (true);
format = formats [op - 1];
}
else
{
foreach (var f in formats)
{
if (f.Name == formatName)
{
format = f;
}
}
if (format == null)
{
Console.WriteLine("Unknown file format: " + formatName);
return(1);
}
}
if (destPath == null)
{
destPath = Path.GetDirectoryName(projectFile);
}
destPath = FileService.GetFullPath(destPath);
string ofile = await Services.ProjectService.Export(monitor, projectFile, itemsToExport, destPath, format);
if (ofile != null)
{
Console.WriteLine("Saved file: " + ofile);
return(0);
}
else
{
Console.WriteLine("Project export failed.");
return(1);
}
}
internal protected virtual void OnSetFormat(MSBuildFileFormat format)
{
next.OnSetFormat(format);
}
internal protected virtual bool OnGetSupportsFormat(MSBuildFileFormat format)
{
return(OnGetSupportsFormat(format));
}
public WorkspaceItemCreatedInformation CreateEntry(ProjectCreateInformation projectCreateInformation, string defaultLanguage)
{
WorkspaceItem workspaceItem = null;
if (string.IsNullOrEmpty(type))
{
workspaceItem = new Solution();
}
else
{
Type workspaceItemType = addin.GetType(type, false);
if (workspaceItemType != null)
{
workspaceItem = Activator.CreateInstance(workspaceItemType) as WorkspaceItem;
}
if (workspaceItem == null)
{
MessageService.ShowError(GettextCatalog.GetString("Can't create solution with type: {0}", type));
return(null);
}
}
var substitution = new string[, ] {
{ "ProjectName", projectCreateInformation.SolutionName }
};
workspaceItem.Name = StringParserService.Parse(name, substitution);
string newStartupProjectName = startupProject;
if (newStartupProjectName != null)
{
newStartupProjectName = StringParserService.Parse(startupProject, substitution);
}
workspaceItem.SetLocation(projectCreateInformation.SolutionPath, workspaceItem.Name);
ProjectCreateInformation localProjectCI;
if (!string.IsNullOrEmpty(directory) && directory != ".")
{
localProjectCI = new ProjectCreateInformation(projectCreateInformation);
localProjectCI.SolutionPath = Path.Combine(localProjectCI.SolutionPath, directory);
localProjectCI.ProjectBasePath = Path.Combine(localProjectCI.ProjectBasePath, directory);
if (!Directory.Exists(localProjectCI.SolutionPath))
{
Directory.CreateDirectory(localProjectCI.SolutionPath);
}
if (!Directory.Exists(localProjectCI.ProjectBasePath))
{
Directory.CreateDirectory(localProjectCI.ProjectBasePath);
}
}
else
{
localProjectCI = projectCreateInformation;
}
var workspaceItemCreatedInfo = new WorkspaceItemCreatedInformation(workspaceItem);
Solution solution = workspaceItem as Solution;
if (solution != null)
{
for (int i = 0; i < entryDescriptors.Count; i++)
{
ProjectCreateInformation entryProjectCI;
var entry = entryDescriptors[i] as ICustomProjectCIEntry;
if (entry != null)
{
entryProjectCI = entry.CreateProjectCI(localProjectCI);
entryProjectCI = new ProjectTemplateCreateInformation(entryProjectCI, localProjectCI.ProjectName);
}
else
{
entryProjectCI = localProjectCI;
}
var solutionItemDesc = entryDescriptors[i];
SolutionItem info = solutionItemDesc.CreateItem(entryProjectCI, defaultLanguage);
if (info == null)
{
continue;
}
solutionItemDesc.InitializeItem(solution.RootFolder, entryProjectCI, defaultLanguage, info);
IConfigurationTarget configurationTarget = info as IConfigurationTarget;
if (configurationTarget != null)
{
foreach (ItemConfiguration configuration in configurationTarget.Configurations)
{
bool flag = false;
foreach (SolutionConfiguration solutionCollection in solution.Configurations)
{
if (solutionCollection.Id == configuration.Id)
{
flag = true;
}
}
if (!flag)
{
solution.AddConfiguration(configuration.Id, true);
}
}
}
if ((info is Project) && (solutionItemDesc is ProjectDescriptor))
{
workspaceItemCreatedInfo.AddPackageReferenceForCreatedProject((Project)info, (ProjectDescriptor)solutionItemDesc, projectCreateInformation);
}
solution.RootFolder.Items.Add(info);
if (newStartupProjectName == info.Name)
{
solution.StartupItem = info;
}
}
}
var sol = workspaceItem as Solution;
if (sol != null && !sol.SupportsFormat(sol.FileFormat))
{
// The default format can't write solutions of this type. Find a compatible format.
var f = MSBuildFileFormat.GetSupportedFormats().First(ff => ff.CanWriteFile(sol));
sol.ConvertToFormat(f);
}
return(workspaceItemCreatedInfo);
}
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 override SolutionEntityItem LoadSolutionItem(IProgressMonitor monitor, string fileName, MSBuildFileFormat expectedFormat, string itemGuid)
{
return(DubFileManager.Instance.LoadProject(fileName, Ide.IdeApp.Workspace.GetAllSolutions() [0], monitor));
}
public override Task <SolutionItem> LoadSolutionItem(ProgressMonitor monitor, SolutionLoadContext ctx, string fileName, MSBuildFileFormat expectedFormat, string typeGuid, string itemGuid)
{
CompiledAssemblyProject p = new CompiledAssemblyProject();
p.LoadFrom(fileName);
return(Task.FromResult <SolutionItem> (p));
}
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();
}));
}
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");
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("MonoDevelop.CSharp.Project.CSharpProject", sol2.RootFolder.Items[0].GetType().FullName);
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("MonoDevelop.CSharp.Project.CSharpProject", f1.Items [0].GetType().FullName);
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("MonoDevelop.CSharp.Project.CSharpProject", f2.Items [0].GetType().FullName);
Assert.AreEqual("MonoDevelop.CSharp.Project.CSharpProject", f2.Items [1].GetType().FullName);
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");
sol.Dispose();
}
public override Task <SolutionItem> LoadSolutionItem(ProgressMonitor monitor, SolutionLoadContext ctx, string fileName, MSBuildFileFormat expectedFormat, string typeGuid, string itemGuid)
{
return(Task.FromResult((SolutionItem)ReadFile(fileName, false, monitor)));
}
public bool SupportsFormat(MSBuildFileFormat format)
{
return(true);
}
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);
var metadata = GetReadSolutionItemMetadata(file, typeGuid, itemGuid);
using (Counters.ReadSolutionItem.BeginTiming("Read project " + file, metadata)) {
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;
UpdateReadSolutionItemMetadata(metadata, loadedItem);
}
return loadedItem;
}
}));
}
bool OnGetSupportsFormat(MSBuildFileFormat format)
{
return(GetAllItems <SolutionItem> ().All(p => p.SupportsFormat(format)));
}
public Task <string> Export(ProgressMonitor monitor, string rootSourceFile, string targetPath, MSBuildFileFormat format)
{
rootSourceFile = GetTargetFile(rootSourceFile);
return(Export(monitor, rootSourceFile, null, targetPath, format));
}
public override Task <SolutionItem> LoadSolutionItem(ProgressMonitor monitor, SolutionLoadContext ctx, string fileName, MSBuildFileFormat expectedFormat, string typeGuid, string itemGuid)
{
return(Task.Run(() => {
if (CanRead(fileName, typeof(SolutionItem)))
{
DotNetCoreSdk.EnsureInitialized();
return MSBuildProjectService.LoadItem(monitor, fileName, MSBuildFileFormat.VS2012, typeGuid, itemGuid, ctx);
}
throw new NotSupportedException();
}));
}
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));
}
}
internal protected virtual void OnSetFormat(MSBuildFileFormat value)
{
next.OnSetFormat(value);
}
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.EnumerateFileSystemEntries(dir).Any())
{
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 override SolutionEntityItem LoadSolutionItem(IProgressMonitor monitor, string fileName, MSBuildFileFormat expectedFormat, string itemGuid)
{
throw new NotImplementedException();
}
internal protected override bool OnGetSupportsFormat(MSBuildFileFormat format)
{
return(Solution.OnGetSupportsFormat(format));
}
public override SolutionEntityItem LoadSolutionItem(IProgressMonitor monitor, string fileName, MSBuildFileFormat expectedFormat, string itemGuid)
{
MSBuildProjectHandler handler = CreateHandler <MSBuildProjectHandler> (fileName, itemGuid);
return(handler.Load(monitor, fileName, expectedFormat, null, ItemType));
}
internal protected override void OnSetFormat(MSBuildFileFormat value)
{
Solution.OnSetFormat(value);
}
public abstract SolutionEntityItem LoadSolutionItem(IProgressMonitor monitor, string fileName, MSBuildFileFormat expectedFormat, string itemGuid);
public override async Task <SolutionItem> LoadSolutionItem(ProgressMonitor monitor, SolutionLoadContext ctx, string fileName, MSBuildFileFormat expectedFormat, string typeGuid, string itemGuid)
{
if (CanRead(fileName, typeof(SolutionItem)))
{
return(await MSBuildProjectService.LoadItem(monitor, fileName, MSBuildFileFormat.VS2012, typeGuid, itemGuid, ctx));
}
throw new NotSupportedException();
}
