public override void Execute(MonoDevelop.Core.IProgressMonitor monitor, IBuildTarget item, ExecutionContext context, ConfigurationSelector configuration) { if (base.CanExecute(item, context, configuration)) { // It is executable by default base.Execute(monitor, item, context, configuration); return; } else if (item is IWorkspaceObject) { UnitTest test = NUnitService.Instance.FindRootTest((IWorkspaceObject)item); if (test != null) { IAsyncOperation oper = null; DispatchService.GuiSyncDispatch(delegate { oper = NUnitService.Instance.RunTest(test, context.ExecutionHandler, false); }); if (oper != null) { monitor.CancelRequested += delegate { oper.Cancel(); }; oper.WaitForCompleted(); } } } }
public override void Commit(ChangeSet changeSet, MonoDevelop.Core.IProgressMonitor monitor) { List <string> files = new List <string> (); string basePath = MercurialRepository.GetLocalBasePath(changeSet.BaseLocalPath), pyfiles = string.Empty, messageFile = Path.GetTempFileName(); if (!basePath.EndsWith(Path.DirectorySeparatorChar.ToString(), StringComparison.Ordinal)) { basePath += Path.DirectorySeparatorChar; } foreach (ChangeSetItem item in changeSet.Items) { files.Add(string.Format("os.path.realpath('{0}')", item.LocalPath.FullPath)); } if (!(0 == files.Count || (1 == files.Count && string.Empty.Equals(files[0], StringComparison.Ordinal)))) { pyfiles = string.Format("{0},", string.Join(",", files.ToArray())); } try { File.WriteAllText(messageFile, changeSet.GlobalComment); RunMercurialRepoCommand(basePath, "commands.commit(repo.ui,repo,{1}logfile='{0}')", messageFile, pyfiles); } finally { try { File.Delete(messageFile); } catch { } } }
public override void Update(string localPath, bool recurse, MonoDevelop.Core.IProgressMonitor monitor) { try { client.Update(null); } catch (CommandException ce) { monitor.ReportError(ce.Message, ce); } monitor.ReportSuccess(string.Empty); }
public override void Export(string localPath, string exportPath, MonoDevelop.Core.IProgressMonitor monitor) { try { client.Archive(NormalizePath(exportPath)); monitor.ReportSuccess(string.Empty); } catch (CommandException ce) { monitor.ReportError(ce.Message, ce); } }
public override void Resolve(string path, bool recurse, MonoDevelop.Core.IProgressMonitor monitor) { try { client.Resolve(new[] { path }, mark: true); } catch (CommandException ce) { monitor.ReportError(ce.Message, ce); } monitor.ReportSuccess(string.Empty); }
public override void Commit(ChangeSet changeSet, MonoDevelop.Core.IProgressMonitor monitor) { try { client.Commit(changeSet.GlobalComment, changeSet.Items.Select(i => Path.Combine(changeSet.BaseLocalPath, i.LocalPath)).ToArray()); } catch (CommandException ce) { monitor.ReportError(ce.Message, ce); } monitor.ReportSuccess(string.Empty); }
internal static void Clone(string branchLocation, string localPath, MonoDevelop.Core.IProgressMonitor monitor) { try { CommandClient.Clone(source: branchLocation, destination: localPath, mercurialPath: DefaultMercurialPath); } catch (CommandException ce) { monitor.ReportError(ce.Message, ce); } monitor.ReportSuccess(string.Empty); }
public override void Revert(string localPath, bool recurse, MonoDevelop.Core.IProgressMonitor monitor, MercurialRevision toRevision) { try { client.Revert(null, NormalizePath(localPath)); } catch (CommandException ce) { monitor.ReportError(ce.Message, ce); } monitor.ReportSuccess(string.Empty); }
public override void Update(string localPath, bool recurse, MonoDevelop.Core.IProgressMonitor monitor) { localPath = NormalizePath(Path.GetFullPath(localPath)); if (null == monitor) { monitor = new MonoDevelop.Core.ProgressMonitoring.NullProgressMonitor(); } string output = RunMercurialRepoCommand(localPath, "commands.update(repo.ui,repo)"); monitor.Log.WriteLine(output); }
public object ReadFile(FilePath file, Type expectedType, MonoDevelop.Core.IProgressMonitor monitor) { if (slnFileFormat.CanReadFile(file, this)) { return(slnFileFormat.ReadFile(file, this, monitor)); } else { return(MSBuildProjectService.LoadItem(monitor, file, null, null, null)); } }
} // CanRebase public override void Rebase(string mergeLocation, string localPath, MonoDevelop.Core.IProgressMonitor monitor) { localPath = NormalizePath(Path.GetFullPath(localPath)); if (null == monitor) { monitor = new MonoDevelop.Core.ProgressMonitoring.NullProgressMonitor(); } string output = RunMercurialRepoCommand(localPath, "commands.pull(repo.ui,repo,'{0}',update=True,rebase=True)", mergeLocation); monitor.Log.WriteLine(output); monitor.Log.WriteLine("Rebased {0} onto {1}", localPath, mergeLocation); } // Rebase
} // Bind public override void Unbind(string localPath, MonoDevelop.Core.IProgressMonitor monitor) { // Mercurial doesn't support bound branches yet (by default) /* * run (null, "b = branch.Branch.open_containing(url=ur'{0}')[0]\n", NormalizePath (localPath)); * monitor.Log.WriteLine ("Opened {0}", localPath); * * run (null, "b.unbind()\n"); * monitor.Log.WriteLine ("Unbound {0}", localPath); */ } // Unbind
public override void Uncommit(string localPath, MonoDevelop.Core.IProgressMonitor monitor) { try { if (!client.Rollback()) { monitor.ReportWarning("Rollback failed"); } } catch (CommandException ce) { monitor.ReportError(ce.Message, ce); } monitor.ReportSuccess(string.Empty); }
public override void Branch(string branchLocation, string localPath, MonoDevelop.Core.IProgressMonitor monitor) { localPath = NormalizePath(localPath); if (null == monitor) { monitor = new MonoDevelop.Core.ProgressMonitoring.NullProgressMonitor(); } string output = RunMercurialCommand("commands.clone(myui,'{0}','{1}')", branchLocation, localPath); monitor.Log.WriteLine(output); monitor.Log.WriteLine("Cloned to {0}", localPath); }
} // GetBoundBranch public override void Bind(string branchUrl, string localPath, MonoDevelop.Core.IProgressMonitor monitor) { // Mercurial doesn't support bound branches yet (by default) /* * run (null, "b = branch.Branch.open_containing(url=ur'{0}')[0]\n", localPath); * monitor.Log.WriteLine ("Opened {0}", NormalizePath (localPath)); * * run (null, "remoteb = branch.Branch.open_containing(url=ur'{0}')[0]\n", branchUrl); * monitor.Log.WriteLine ("Opened {0}", branchUrl); * * run (null, "b.bind(other=remoteb)\n"); * monitor.Log.WriteLine ("Bound {0} to {1}", localPath, branchUrl); */ } // Bind
public override void Revert(string localPath, bool recurse, MonoDevelop.Core.IProgressMonitor monitor, MercurialRevision toRevision) { string rev = string.Empty; localPath = NormalizePath(localPath); if (null != toRevision && MercurialRevision.HEAD != toRevision.Rev && MercurialRevision.NONE != toRevision.Rev) { rev = string.Format(",rev='{0}',date=None", toRevision.Rev); } else { rev = ",rev='tip',date=None"; } RunMercurialRepoCommand(localPath, "commands.revert(repo.ui,repo,os.path.realpath('{0}'){1})", localPath, rev); }
} // GetAnnotations public override void Export(string localPath, string exportPath, MonoDevelop.Core.IProgressMonitor monitor) { localPath = NormalizePath(Path.GetFullPath(localPath)); exportPath = NormalizePath(exportPath); if (!IsValidExportPath(exportPath)) { throw new MercurialClientException(string.Format("Invalid export path: {0}", exportPath)); } if (null == monitor) { monitor = new MonoDevelop.Core.ProgressMonitoring.NullProgressMonitor(); } string output = RunMercurialRepoCommand(localPath, "commands.archive(repo.ui,repo,'{0}',prefix='')", exportPath); monitor.Log.WriteLine(output); monitor.Log.WriteLine("Exported to {0}", exportPath); } // Export
public void Save(MonoDevelop.Core.IProgressMonitor monitor) { if (HasSlnData && !SavingSolution && Item.ParentSolution != null) { // The project has data that has to be saved in the solution, but the solution is not being saved. Do it now. monitor.BeginTask(null, 2); SaveItem(monitor); monitor.Step(1); Solution sol = Item.ParentSolution; targetFormat.SlnFileFormat.WriteFile(sol.FileName, sol, targetFormat, false, monitor); sol.NeedsReload = false; monitor.EndTask(); } else { SaveItem(monitor); } }
public void WriteFile(FilePath file, object obj, MonoDevelop.Core.IProgressMonitor monitor) { if (slnFileFormat.CanWriteFile(obj, this)) { slnFileFormat.WriteFile(file, obj, this, true, monitor); } else { SolutionEntityItem item = (SolutionEntityItem)obj; if (!(item.ItemHandler is MSBuildProjectHandler)) { MSBuildProjectService.InitializeItemHandler(item); } MSBuildProjectHandler handler = (MSBuildProjectHandler)item.ItemHandler; handler.SetTargetFormat(this); handler.Save(monitor); } }
public BuildResult RunTarget(MonoDevelop.Core.IProgressMonitor monitor, string target, ConfigurationSelector configuration) { if (target == ProjectService.BuildTarget) { target = "all"; } else if (target == ProjectService.CleanTarget) { target = "clean"; } DotNetProjectConfiguration conf = (DotNetProjectConfiguration)project.GetConfiguration(configuration); using (var output = new StringWriter()) { using (var tw = new LogTextWriter()) { tw.ChainWriter(output); tw.ChainWriter(monitor.Log); using (ProcessWrapper proc = Runtime.ProcessService.StartProcess("make", "PROFILE=" + conf.Id + " " + target, conf.OutputDirectory, monitor.Log, tw, null)) proc.WaitForOutput(); tw.UnchainWriter(output); tw.UnchainWriter(monitor.Log); var result = new BuildResult(output.ToString(), 1, 0); string[] lines = result.CompilerOutput.Split('\n'); foreach (string line in lines) { var err = CreateErrorFromString(line); if (err != null) { result.Append(err); } } return(result); } } }
public BuildResult RunTarget(MonoDevelop.Core.IProgressMonitor monitor, string target, ConfigurationSelector configuration) { if (target == ProjectService.BuildTarget) { target = "all"; } else if (target == ProjectService.CleanTarget) { target = "clean"; } DotNetProjectConfiguration conf = (DotNetProjectConfiguration)project.GetConfiguration(configuration); StringWriter output = new StringWriter(); LogTextWriter tw = new LogTextWriter(); tw.ChainWriter(output); tw.ChainWriter(monitor.Log); ProcessWrapper proc = Runtime.ProcessService.StartProcess("make", "PROFILE=" + conf.Id + " " + target, conf.OutputDirectory, monitor.Log, tw, null); proc.WaitForOutput(); CompilerResults cr = new CompilerResults(null); string[] lines = output.ToString().Split('\n'); foreach (string line in lines) { CompilerError err = CreateErrorFromString(line); if (err != null) { cr.Errors.Add(err); } } return(new BuildResult(cr, output.ToString())); }
public BuildResult Compile(ProjectItemCollection items, DotNetProjectConfiguration configuration, ConfigurationSelector configSelector, MonoDevelop.Core.IProgressMonitor monitor) { return(new BuildResult("ok", 1, 0)); }
public abstract void DPush(string pushLocation, string localPath, bool remember, MonoDevelop.Core.IProgressMonitor monitor);
protected override void OnCommit(ChangeSet changeSet, MonoDevelop.Core.IProgressMonitor monitor) { throw new NotImplementedException(); }
public abstract void Uncommit(string localPath, MonoDevelop.Core.IProgressMonitor monitor);
protected override void OnCheckout(MonoDevelop.Core.FilePath targetLocalPath, Revision rev, bool recurse, MonoDevelop.Core.IProgressMonitor monitor) { throw new NotImplementedException(); }
protected override BuildResult OnBuild(MonoDevelop.Core.IProgressMonitor monitor, ConfigurationSelector configuration) { return(new BuildResult()); }
protected override void OnDeleteDirectories(MonoDevelop.Core.FilePath[] localPaths, bool force, MonoDevelop.Core.IProgressMonitor monitor, bool keepLocal) { throw new NotImplementedException(); }
protected override void OnAdd(MonoDevelop.Core.FilePath[] localPaths, bool recurse, MonoDevelop.Core.IProgressMonitor monitor) { throw new NotImplementedException(); }
protected override void OnRevertToRevision(MonoDevelop.Core.FilePath localPath, Revision revision, MonoDevelop.Core.IProgressMonitor monitor) { throw new NotImplementedException(); }