public RevertDialog(IRevisionPointer revisionPointer)
{
Verify.Argument.IsValidRevisionPointer(revisionPointer, "revisionPointer");
_revisionPointer = revisionPointer;
InitializeComponent();
Text = Resources.StrRevertCommit;
_lblRevision.Text = Resources.StrRevision.AddColon();
_txtRevision.Text = revisionPointer.Pointer;
_grpMainlineParentCommit.Text = Resources.StrMainlineParentCommit;
_grpOptions.Text = Resources.StrOptions;
_chkNoCommit.Text = Resources.StrsNoCommit;
ToolTipService.Register(_chkNoCommit, Resources.TipRevertNoCommit);
_txtRevision.Text = _revisionPointer.Pointer;
GitterApplication.FontManager.InputFont.Apply(_txtRevision);
var revision = revisionPointer.Dereference();
if(!revision.IsLoaded)
{
revision.Load();
}
if(revision.Parents.Count > 1)
{
_lstCommits.Style = GitterApplication.DefaultStyle;
bool first = true;
foreach(var parent in revision.Parents)
{
if(!parent.IsLoaded)
{
parent.Load();
}
if(first)
{
first = false;
}
else
{
_lstCommits.Panels.Add(new FlowPanelSeparator() { Height = 10 });
}
_lstCommits.Panels.Add(
new RevisionHeaderPanel()
{
Revision = parent,
IsSelectable = true,
IsSelected = _lstCommits.Panels.Count == 0,
});
}
}
else
{
_pnlMainlineParentCommit.Visible = false;
Height -= _pnlMainlineParentCommit.Height + _pnlOptions.Margin.Top;
Width = 385;
}
}
public RevisionTreeSource(IRevisionPointer revision)
{
Verify.Argument.IsNotNull(revision, "revision");
Verify.Argument.IsFalse(revision.IsDeleted, "revision");
_revision = revision;
}
public RevisionChangesDiffSource(IRevisionPointer revision, IList<string> paths)
{
Verify.Argument.IsNotNull(revision, "revision");
_revision = revision;
_paths = paths;
}
public static string TryFormatDefaultLocalBranchName(IRevisionPointer revision)
{
if(revision == null)
{
return string.Empty;
}
var branch = revision as RemoteBranch;
if(branch != null)
{
var branchName = branch.Name;
var remote = branch.Remote;
if(remote == null)
{
var remoteName = remote.Name;
if((branchName.Length > remoteName.Length + 1) && branchName.StartsWith(remoteName))
{
return branchName.Substring(remoteName.Length + 1);
}
}
var slashPos = branchName.IndexOf('/');
if(slashPos >= 0)
{
return branchName.Substring(slashPos + 1);
}
}
return string.Empty;
}
public RevisionFileBlameSource(IRevisionPointer revision, string fileName)
{
Verify.Argument.IsNotNull(revision, "revision");
Verify.Argument.IsNeitherNullNorWhitespace(fileName, "fileName");
_revision = revision;
_fileName = fileName;
}
/// <summary>Initializes a new instance of the <see cref="PathLogSource"/> class.</summary>
/// <param name="revision">Revision to start history log from.</param>
/// <param name="path">Inspected path.</param>
/// <param name="followRenames">if set to <c>true</c> follow file renames.</param>
public PathLogSource(IRevisionPointer revision, string path, bool followRenames = true)
{
Verify.Argument.IsNotNull(revision, "revision");
Verify.Argument.IsNotNull(path, "path");
_revision = revision;
_path = path;
_followRenames = followRenames;
}
public RevisionCompareDiffSource(IRevisionPointer revision1, IRevisionPointer revision2)
{
Verify.Argument.IsNotNull(revision1, "revision1");
Verify.Argument.IsNotNull(revision2, "revision2");
Verify.Argument.IsTrue(revision1.Repository == revision2.Repository,
"revision2", "Cannot compare objects from different repositories.");
_revision1 = revision1;
_revision2 = revision2;
}
/// <summary>Create <see cref="Reference"/>.</summary>
/// <param name="repository">Host <see cref="Repository"/>.</param>
/// <param name="name">Reference name.</param>
/// <param name="pointer">Referenced object.</param>
internal Reference(Repository repository, string name, IRevisionPointer pointer)
: base(repository, name)
{
Verify.Argument.IsNotNull(pointer, "pointer");
_pointer = PrepareInputPointer(pointer);
_reflogSync = new object();
EnterPointer(_pointer);
var rev = _pointer.Dereference();
if(rev != null)
{
EnterRevision(_pointer.Dereference());
}
}
/// <summary>Filter <see cref="IRevisionPointer"/> to types supported by this <see cref="BranchBase"/>.</summary>
/// <param name="pointer">Raw pointer.</param>
/// <returns>Valid pointer.</returns>
protected override IRevisionPointer PrepareInputPointer(IRevisionPointer pointer)
{
Verify.Argument.IsNotNull(pointer, "pointer");
return(pointer.Dereference());
}
public static IBlameSource GetBlameSource(this IRevisionPointer revision, string fileName)
{
Verify.Argument.IsValidRevisionPointer(revision, "revision");
return(new RevisionFileBlameSource(revision, fileName));
}
public PointerBounds(IRevisionPointer revisionPointer, Rectangle bounds)
{
_revisionPointer = revisionPointer;
_bounds = bounds;
}
/// <summary>Initializes a new instance of the <see cref="Head"/> class.</summary>
/// <param name="repository">Host repository.</param>
/// <param name="pointer">Target of this reference.</param>
/// <exception cref="T:System.ArgumentNullException"><paramref name="repository"/> == <c>null</c>.</exception>
internal Head(Repository repository, IRevisionPointer pointer)
: base(repository, GitConstants.HEAD, pointer)
{
}
/// <summary>Reset HEAD to <paramref name="pointer"/>.</summary>
/// <param name="pointer">HEAD's new position.</param>
/// <exception cref="T:System.ArgumentNullException"><paramref name="pointer"/> == <c>null</c>.</exception>
/// <exception cref="T:System.ArgumentException">
/// <paramref name="pointer"/> is not handled by this <see cref="Repository"/> or it is deleted.
/// </exception>
/// <exception cref="T:gitter.Git.GitException">Failed to dereference <paramref name="pointer"/> or git reset failed.</exception>
public void Reset(IRevisionPointer pointer)
{
Reset(pointer, ResetMode.Mixed);
}
public Revision Merge(IRevisionPointer branch, bool noCommit, bool noFastForward, bool squash, string message)
{
Verify.Argument.IsValidRevisionPointer(branch, Repository, "branch");
Verify.State.IsFalse(IsEmpty,
Resources.ExcCantDoOnEmptyRepository.UseAsFormat("merge"));
var oldRev = branch.Dereference();
var currentBranch = CurrentBranch;
using(Repository.Monitor.BlockNotifications(
RepositoryNotifications.Checkout,
RepositoryNotifications.IndexUpdated,
RepositoryNotifications.WorktreeUpdated,
RepositoryNotifications.BranchChanged))
{
try
{
Repository.Accessor.Merge.Invoke(
new MergeParameters(branch.FullName)
{
NoCommit = noCommit,
NoFastForward = noFastForward,
Squash = squash,
Message = message,
});
}
catch(AutomaticMergeFailedException)
{
Repository.OnStateChanged();
Repository.Status.Refresh();
throw;
}
}
if(currentBranch != null)
{
currentBranch.Refresh();
}
else
{
Refresh();
}
var headRev = Revision;
if(noCommit)
{
Repository.OnStateChanged();
Repository.Status.Refresh();
}
else
{
if(noFastForward || headRev != oldRev) //not fast-forwarded
{
Repository.OnCommitCreated(headRev);
}
}
NotifyRelogRecordAdded();
return headRev;
}
private void InvokeReferenceItemActivated(IRevisionPointer revision)
{
var handler = ReferenceItemActivated;
if(handler != null) handler(this, new RevisionPointerEventArgs(revision));
}
public static GuiCommandStatus FormatPatch(IWin32Window parent, IRevisionPointer revision)
{
Verify.Argument.IsNotNull(revision, "revision");
const string patchExt = ".patch";
string outputPath = null;
using (var dlg = new SaveFileDialog()
{
FileName = revision.Pointer + patchExt,
Filter = Resources.StrPatches + "|" + patchExt,
DefaultExt = patchExt,
OverwritePrompt = true,
Title = Resources.StrSavePatch,
})
{
if (dlg.ShowDialog(parent) == DialogResult.OK)
{
outputPath = dlg.FileName;
}
else
{
return(GuiCommandStatus.Canceled);
}
}
if (string.IsNullOrWhiteSpace(outputPath))
{
return(GuiCommandStatus.Canceled);
}
byte[] patch;
try
{
patch = ProgressForm.MonitorTaskAsModalWindow(parent,
Resources.StrSavePatch, revision.FormatPatchAsync);
}
catch (OperationCanceledException)
{
return(GuiCommandStatus.Canceled);
}
catch (GitException exc)
{
GitterApplication.MessageBoxService.Show(
parent,
exc.Message,
Resources.ErrFailedToFormatPatch,
MessageBoxButton.Close,
MessageBoxIcon.Error);
return(GuiCommandStatus.Faulted);
}
if (patch != null)
{
try
{
File.WriteAllBytes(outputPath, patch);
return(GuiCommandStatus.Completed);
}
catch (Exception exc)
{
if (exc.IsCritical())
{
throw;
}
GitterApplication.MessageBoxService.Show(
parent,
exc.Message,
Resources.ErrFailedToSavePatch,
MessageBoxButton.Close,
MessageBoxIcon.Error);
return(GuiCommandStatus.Faulted);
}
}
return(GuiCommandStatus.Faulted);
}
private static RebaseParameters GetRebaseParameters(IRevisionPointer revision)
{
Assert.IsNotNull(revision);
return new RebaseParameters(revision.Pointer);
}
/// <summary>Create local branch.</summary>
/// <param name="name">Branch name.</param>
/// <param name="startingRevision">Starting revision.</param>
/// <returns>Created branch.</returns>
/// <exception cref="T:System.ArgumentNullException"><paramref name="name"/> == null or <paramref name="startingRevision"/> == <c>null</c>.</exception>
/// <exception cref="T:System.ArgumentException">
/// <paramref name="startingRevision"/> is not handled by this repository or deleted.
/// <paramref name="name"/> is not a valid reference name.
/// Branch '<paramref name="name"/>' already exists.
/// </exception>
/// <exception cref="T:gitter.Git.GitException">Failed to dereference <paramref name="startingRevision"/> or create a branch.</exception>
public Branch Create(string name, IRevisionPointer startingRevision)
{
return(Create(name, startingRevision, BranchTrackingMode.Default, false, false));
}
/// <summary>Create local branch.</summary>
/// <param name="name">Branch name.</param>
/// <param name="startingRevision">Starting revision.</param>
/// <param name="tracking">Tracking mode.</param>
/// <param name="checkout">Set to true to checkout branch after creation.</param>
/// <returns>Created branch.</returns>
/// <exception cref="T:System.ArgumentNullException"><paramref name="name"/> == null or <paramref name="startingRevision"/> == <c>null</c>.</exception>
/// <exception cref="T:System.ArgumentException">
/// <paramref name="startingRevision"/> is not handled by this repository or deleted.
/// <paramref name="name"/> is not a valid reference name.
/// Branch '<paramref name="name"/>' already exists.
/// </exception>
/// <exception cref="T:gitter.Git.GitException">Failed to dereference <paramref name="startingRevision"/> or create a branch.</exception>
public Branch Create(string name, IRevisionPointer startingRevision, BranchTrackingMode tracking, bool checkout)
{
return(Create(name, startingRevision, tracking, checkout, false));
}
public RevisionCompareDiffSource(IRevisionPointer revision1, IRevisionPointer revision2, IList <string> paths)
: this(revision1, revision2)
{
_paths = paths;
}
/// <summary>Called when this <see cref="Reference"/> is moved away from <paramref name="pointer"/>.</summary>
/// <param name="pointer">Object, which this <see cref="Reference"/> was pointing to.</param>
protected virtual void LeavePointer(IRevisionPointer pointer)
{
}
/// <summary>Invoke <see cref="PointerChanged"/>.</summary>
private void InvokePointerChanged(IRevisionPointer oldPos, IRevisionPointer newPos)
{
var handler = PointerChanged;
if(handler != null) handler(this, new RevisionPointerChangedEventArgs(oldPos, newPos));
}
/// <summary>Reset HEAD to <paramref name="pointer"/>.</summary>
/// <param name="pointer">HEAD's new position.</param>
/// <exception cref="T:System.ArgumentNullException"><paramref name="pointer"/> == <c>null</c>.</exception>
/// <exception cref="T:System.ArgumentException">
/// <paramref name="pointer"/> is not handled by this <see cref="Repository"/> or it is deleted.
/// </exception>
/// <exception cref="T:gitter.Git.GitException">Failed to dereference <paramref name="pointer"/> or git reset failed.</exception>
public void Reset(IRevisionPointer pointer)
{
Reset(pointer, ResetMode.Mixed);
}
/// <summary>Initializes a new instance of the <see cref="BranchBase"/> class.</summary>
/// <param name="repository">Host <see cref="Repository"/>.</param>
/// <param name="name">Reference name.</param>
/// <param name="pointer">Referenced object.</param>
internal BranchBase(Repository repository, string name, IRevisionPointer pointer)
: base(repository, name, pointer)
{
}
public Revision Merge(IRevisionPointer branch, bool noCommit, bool noFastForward, bool squash)
{
return(Merge(branch, noCommit, noFastForward, squash, null));
}
public Revision Merge(IRevisionPointer branch)
{
return Merge(branch, false, false, false, null);
}
public Revision Merge(IRevisionPointer branch)
{
return(Merge(branch, false, false, false, null));
}
/// <summary>Called when this <see cref="Reference"/> is moved away from <paramref name="pointer"/>.</summary>
/// <param name="pointer">Object, which this <see cref="Reference"/> was pointing to.</param>
protected override void LeavePointer(IRevisionPointer pointer)
{
var branch = pointer as Branch;
_wasDetached = branch == null;
if(branch != null)
{
branch.PositionChanged -= OnBranchPositionChanged;
}
}
/// <summary>Initializes a new instance of the <see cref="Head"/> class.</summary>
/// <param name="repository">Host repository.</param>
/// <param name="pointer">Target of this reference.</param>
/// <exception cref="T:System.ArgumentNullException"><paramref name="repository"/> == <c>null</c>.</exception>
internal Head(Repository repository, IRevisionPointer pointer)
: base(repository, GitConstants.HEAD, pointer)
{
}
/// <summary>Filter <see cref="IRevisionPointer"/> to types supported by this <see cref="Reference"/>.</summary> /// <param name="pointer">Raw pointer.</param> /// <returns>Valid pointer.</returns> protected virtual IRevisionPointer PrepareInputPointer(IRevisionPointer pointer) => pointer;
private static string GetHeadString(IRevisionPointer revision)
{
string headString;
if(revision != null)
{
if(GitUtils.IsValidSHA1(revision.Pointer))
{
headString = revision.Pointer.Substring(0, 7);
}
else
{
headString = revision.Pointer;
}
}
else
{
headString = string.Empty;
}
return headString;
}
/// <summary>Invoke <see cref="PointerChanged"/>.</summary> private void InvokePointerChanged(IRevisionPointer oldPos, IRevisionPointer newPos) => PointerChanged?.Invoke(this, new RevisionPointerChangedEventArgs(oldPos, newPos));
public void SelectRevision(IRevisionPointer revision)
{
Verify.Argument.IsNotNull(revision, "revision");
var rev = revision.Dereference();
RevisionListItem item;
if(_itemLookupTable.TryGetValue(rev, out item))
{
item.FocusAndSelect();
}
}
/// <summary>Initializes a new instance of the <see cref="BranchBase"/> class.</summary>
/// <param name="repository">Host <see cref="Repository"/>.</param>
/// <param name="name">Reference name.</param>
/// <param name="pointer">Referenced object.</param>
internal BranchBase(Repository repository, string name, IRevisionPointer pointer)
: base(repository, name, pointer)
{
}
/// <summary>Initializes a new instance of the <see cref="Tag"/> class.</summary>
/// <param name="repository">Host repository.</param>
/// <param name="name">Tag name.</param>
/// <param name="pointer">Commit which is pointed by tag.</param>
/// <param name="type">The type.</param>
internal Tag(Repository repository, string name, IRevisionPointer pointer, TagType type)
: base(repository, name, pointer)
{
TagType = type;
}
/// <summary>Called when this <see cref="Reference"/> is moved to <paramref name="pointer"/>.</summary>
/// <param name="pointer">Object, which this <see cref="Reference"/> will be pointing to.</param>
protected virtual void EnterPointer(IRevisionPointer pointer)
{
}
/// <summary>
/// Reset this branch to position specified by <paramref name="revision"/>.
/// </summary>
/// <param name="revision">New branch position.</param>
/// <exception cref="T:System.ArgumentNullException">
/// <paramref name="branch"/> == null or <paramref name="revision"/> == null.
/// </exception>
/// <exception cref="T:System.ArgumentException">
/// <paramref name="branch"/> is not handled by this <see cref="Repository"/> or it is deleted;
/// <paramref name="revision"/> is not handled by this <see cref="Repository"/> or it is deleted.
/// </exception>
/// <exception cref="T:gitter.Git.GitException">
/// Failed to dereference <paramref name="revision"/> or git reset failed.
/// </exception>
public void Reset(IRevisionPointer revision)
{
Verify.Argument.IsValidRevisionPointer(revision, Repository, "revision");
Verify.State.IsNotDeleted(this);
var rev = revision.Dereference();
if(Revision != rev)
{
using(Repository.Monitor.BlockNotifications(
RepositoryNotifications.BranchChanged))
{
Repository.Accessor.ResetBranch.Invoke(
new ResetBranchParameters(Name, revision.Pointer));
}
Pointer = rev;
NotifyRelogRecordAdded();
}
}
/// <summary>Filter <see cref="IRevisionPointer"/> to types supported by this <see cref="Reference"/>.</summary>
/// <param name="pointer">Raw pointer.</param>
/// <returns>Valid pointer.</returns>
protected virtual IRevisionPointer PrepareInputPointer(IRevisionPointer pointer)
{
return pointer;
}
public RevertDialog(IRevisionPointer revisionPointer)
{
Verify.Argument.IsValidRevisionPointer(revisionPointer, "revisionPointer");
_revisionPointer = revisionPointer;
InitializeComponent();
Text = Resources.StrRevertCommit;
_lblRevision.Text = Resources.StrRevision.AddColon();
_txtRevision.Text = revisionPointer.Pointer;
_grpMainlineParentCommit.Text = Resources.StrMainlineParentCommit;
_grpOptions.Text = Resources.StrOptions;
_chkNoCommit.Text = Resources.StrsNoCommit;
ToolTipService.Register(_chkNoCommit, Resources.TipRevertNoCommit);
_txtRevision.Text = _revisionPointer.Pointer;
GitterApplication.FontManager.InputFont.Apply(_txtRevision);
var revision = revisionPointer.Dereference();
if (!revision.IsLoaded)
{
revision.Load();
}
if (revision.Parents.Count > 1)
{
_lstCommits.Style = GitterApplication.DefaultStyle;
bool first = true;
foreach (var parent in revision.Parents)
{
if (!parent.IsLoaded)
{
parent.Load();
}
if (first)
{
first = false;
}
else
{
_lstCommits.Panels.Add(new FlowPanelSeparator()
{
Height = 10
});
}
_lstCommits.Panels.Add(
new RevisionHeaderPanel()
{
Revision = parent,
IsSelectable = true,
IsSelected = _lstCommits.Panels.Count == 0,
});
}
}
else
{
_pnlMainlineParentCommit.Visible = false;
Height -= _pnlMainlineParentCommit.Height + _pnlOptions.Margin.Top;
Width = 385;
}
}
/// <summary>Performs a cherry-pick operation on <paramref name="revision"/>.</summary>
/// <param name="revision">Commit to cherry-pick.</param>
public static void CherryPick(this IRevisionPointer revision)
{
CherryPick(revision, 0, false);
}
/// <summary>Performs a cherry-pick operation on <paramref name="revision"/>.</summary>
/// <param name="revision">Commit to cherry-pick.</param>
/// <param name="noCommit">Do not commit.</param>
public static void CherryPick(this IRevisionPointer revision, bool noCommit)
{
CherryPick(revision, 0, noCommit);
}
/// <summary>Filter <see cref="IRevisionPointer"/> to types supported by this <see cref="BranchBase"/>.</summary>
/// <param name="pointer">Raw pointer.</param>
/// <returns>Valid pointer.</returns>
protected override IRevisionPointer PrepareInputPointer(IRevisionPointer pointer)
{
Verify.Argument.IsNotNull(pointer, "pointer");
return pointer.Dereference();
}
public static void Revert(this IRevisionPointer revision)
{
Revert(revision, 0, false);
}
/// <summary>Called when this <see cref="Reference"/> is moved away from <paramref name="pointer"/>.</summary>
/// <param name="pointer">Object, which this <see cref="Reference"/> was pointing to.</param>
protected virtual void LeavePointer(IRevisionPointer pointer)
{
}
public static void Revert(this IRevisionPointer revision, bool noCommit)
{
Revert(revision, 0, noCommit);
}
public Revision Merge(IRevisionPointer branch, bool noCommit, bool noFastForward, bool squash)
{
return Merge(branch, noCommit, noFastForward, squash, null);
}
public static void Revert(this IRevisionPointer revision, int mainline, bool noCommit)
{
Verify.Argument.IsValidRevisionPointer(revision, "revision");
Verify.Argument.IsNotNegative(mainline, "mainline");
var repository = revision.Repository;
var rev = repository.Head.Revision;
var currentBranch = repository.Head.CurrentBranch;
var notifications = noCommit ?
new[]
{
RepositoryNotifications.IndexUpdated,
RepositoryNotifications.WorktreeUpdated,
} :
new[]
{
RepositoryNotifications.BranchChanged,
RepositoryNotifications.Checkout,
RepositoryNotifications.IndexUpdated,
RepositoryNotifications.WorktreeUpdated,
};
using (repository.Monitor.BlockNotifications(notifications))
{
var parameters = new RevertParameters(revision.Pointer, noCommit);
if (mainline > 0)
{
parameters.Mainline = mainline;
}
try
{
repository.Accessor.Revert.Invoke(parameters);
if (!noCommit)
{
if (currentBranch != null)
{
currentBranch.Refresh();
}
else
{
repository.Head.Refresh();
}
var headRev = repository.Head.Revision;
if (headRev != rev)
{
repository.OnCommitCreated(headRev);
repository.Head.NotifyRelogRecordAdded();
}
}
}
catch (GitException)
{
repository.OnStateChanged();
throw;
}
finally
{
repository.Status.Refresh();
}
}
}
/// <summary>Reset HEAD to <paramref name="pointer"/>.</summary>
/// <param name="mode">Reset mode</param>
/// <param name="pointer">HEAD's new position.</param>
/// <exception cref="T:System.ArgumentNullException"><paramref name="pointer"/> == <c>null</c>.</exception>
/// <exception cref="T:System.ArgumentException">
/// <paramref name="pointer"/> is not handled by this <see cref="Repository"/> or it is deleted.
/// </exception>
/// <exception cref="T:gitter.Git.GitException">
/// Failed to dereference <paramref name="pointer"/> or git reset failed.
/// </exception>
public void Reset(IRevisionPointer pointer, ResetMode mode)
{
Verify.Argument.IsValidRevisionPointer(pointer, Repository, "pointer");
var pos = Pointer.Dereference();
var rev = pointer.Dereference();
var currentBranch = Pointer as Branch;
using(Repository.Monitor.BlockNotifications(
RepositoryNotifications.BranchChanged,
RepositoryNotifications.Checkout,
RepositoryNotifications.IndexUpdated,
RepositoryNotifications.WorktreeUpdated,
RepositoryNotifications.SubmodulesChanged))
{
Repository.Accessor.Reset.Invoke(
new ResetParameters(rev.Hash.ToString(), mode));
}
if(currentBranch != null)
{
currentBranch.Pointer = rev;
}
else
{
Pointer = rev;
}
if(pos != rev)
{
NotifyRelogRecordAdded();
}
Repository.Status.Refresh();
Repository.Submodules.Refresh();
Repository.OnStateChanged();
}
private static RebaseParameters GetRebaseParameters(IRevisionPointer revision)
{
Assert.IsNotNull(revision);
return(new RebaseParameters(revision.Pointer));
}
/// <summary>Called when this <see cref="Reference"/> is moved to <paramref name="pointer"/>.</summary>
/// <param name="pointer">Object, which this <see cref="Reference"/> will be pointing to.</param>
protected override void EnterPointer(IRevisionPointer pointer)
{
var branch = pointer as Branch;
bool detached = branch == null;
if(_wasDetached != detached)
{
if(detached)
{
OnDetached();
}
else
{
OnAttached();
}
}
if(branch != null)
{
branch.PositionChanged += OnBranchPositionChanged;
}
}
public static async Task RebaseHeadHereAsync(this IRevisionPointer revision, IProgress <OperationProgress> progress)
{
Verify.Argument.IsValidRevisionPointer(revision, nameof(revision));
var repository = revision.Repository;
var oldHead = repository.Head.CurrentBranch;
var parameters = GetRebaseParameters(revision);
var block = repository.Monitor.BlockNotifications(
RepositoryNotifications.BranchChanged,
RepositoryNotifications.Checkout,
RepositoryNotifications.IndexUpdated,
RepositoryNotifications.WorktreeUpdated);
progress?.Report(new OperationProgress(Resources.StrsRebaseIsInProcess.AddEllipsis()));
var task = repository.Accessor
.Rebase
.InvokeAsync(parameters, progress, CancellationToken.None);
//FIXME: may be to rework the logic
try
{
await task;
}
finally
{
block.Dispose();
if (oldHead != null)
{
oldHead.Refresh();
}
else
{
repository.Head.Refresh();
}
if (task.Status != TaskStatus.RanToCompletion)
{
repository.OnStateChanged();
}
repository.OnUpdated();
TaskUtility.PropagateFaultedStates(task);
}
//return repository.Accessor
// .Rebase.InvokeAsync(parameters, progress, CancellationToken.None)
// .ContinueWith(
// t =>
// {
// block.Dispose();
// if(oldHead != null)
// {
// oldHead.Refresh();
// }
// else
// {
// repository.Head.Refresh();
// }
// if(t.Status != TaskStatus.RanToCompletion)
// {
// repository.OnStateChanged();
// }
// repository.OnUpdated();
// TaskUtility.PropagateFaultedStates(t);
// },
// CancellationToken.None,
// TaskContinuationOptions.ExecuteSynchronously,
// TaskScheduler.Default);
}
/// <summary>Filter <see cref="IRevisionPointer"/> to types supported by this <see cref="Reference"/>.</summary>
/// <param name="pointer">Raw pointer.</param>
/// <returns>Valid pointer.</returns>
protected override IRevisionPointer PrepareInputPointer(IRevisionPointer pointer)
{
Verify.Argument.IsNotNull(pointer, "pointer");
switch(pointer.Type)
{
case ReferenceType.None:
case ReferenceType.LocalBranch:
return pointer;
default:
return pointer.Dereference();
}
}
/// <summary>Gets <see cref="Tree"/> pointed by the specified <paramref name="revision"/>.</summary>
/// <param name="revision">The revision.</param>
/// <returns>Function which retrieves <see cref="Tree"/> pointed by the specified <paramref name="revision"/>.</returns>
public static Task <Tree> GetTreeAsync(this IRevisionPointer revision, IProgress <OperationProgress> progress, CancellationToken cancellationToken)
{
Verify.Argument.IsValidRevisionPointer(revision, "revision");
return(Tree.GetAsync(revision.Repository, revision.FullName, progress, cancellationToken));
}
public string FormatMergeMessage(IRevisionPointer revision)
{
Verify.Argument.IsValidRevisionPointer(revision, Repository, "revision");
Verify.State.IsFalse(IsEmpty,
Resources.ExcCantDoOnEmptyRepository.UseAsFormat("format merge message"));
return Repository.Accessor.FormatMergeMessage.Invoke(
new FormatMergeMessageParameters(revision.Pointer, Pointer.Pointer));
}
public static IDiffSource GetCompareDiffSource(this IRevisionPointer revision1, IRevisionPointer revision2, IEnumerable <string> paths = null)
{
Verify.Argument.AreValidRevisionPointers(revision1, revision2);
if (paths == null)
{
return(new RevisionCompareDiffSource(revision1, revision2));
}
else
{
return(new RevisionCompareDiffSource(revision1, revision2, paths.ToList()));
}
}
public RevisionChangesDiffSource(IRevisionPointer revision)
{
Verify.Argument.IsNotNull(revision, "revision");
_revision = revision;
}
private static IGitFunction <QueryRevisionDiffParameters, byte[]> GetFormatPatchFunction(IRevisionPointer revision)
{
Assert.IsNotNull(revision);
if (revision.Type == ReferenceType.Stash)
{
return(revision.Repository.Accessor.QueryStashPatch);
}
else
{
return(revision.Repository.Accessor.QueryRevisionPatch);
}
}
/// <summary>Gets <see cref="Tree"/> pointed by the specified <paramref name="revision"/>.</summary>
/// <param name="revision">The revision.</param>
/// <returns><see cref="Tree"/> pointed by the specified <paramref name="revision"/>.</returns>
public static Tree GetTree(this IRevisionPointer revision)
{
Verify.Argument.IsValidRevisionPointer(revision, "revision");
return(new Tree(revision.Repository, revision.FullName));
}
/// <summary>Called when this <see cref="Reference"/> is moved to <paramref name="pointer"/>.</summary>
/// <param name="pointer">Object, which this <see cref="Reference"/> will be pointing to.</param>
protected virtual void EnterPointer(IRevisionPointer pointer)
{
}
