/// <summary>
/// Returns the next rebase step, or null if there are none,
/// and the rebase operation needs to be finished.
/// </summary>
/// <param name="repository"></param>
/// <param name="rebaseOperationHandle"></param>
/// <returns></returns>
private static RebaseProgress NextRebaseStep(
Repository repository,
RebaseSafeHandle rebaseOperationHandle)
{
// stepBeingApplied indicates the step that will be applied by by git_rebase_next.
// The current step does not get incremented until git_rebase_next (except on
// the initial step), but we want to report the step that will be applied.
long stepToApplyIndex = Proxy.git_rebase_operation_current(rebaseOperationHandle);
stepToApplyIndex++;
long totalStepCount = Proxy.git_rebase_operation_entrycount(rebaseOperationHandle);
if (stepToApplyIndex == totalStepCount)
{
stepToApplyIndex = -1;
}
RebaseProgress progress = new RebaseProgress()
{
current = stepToApplyIndex,
total = totalStepCount,
};
return(progress);
}
/// <summary>
/// Run a rebase to completion, a conflict, or a requested stop point.
/// </summary>
/// <param name="rebaseOperationHandle">Handle to the rebase operation.</param>
/// <param name="repository">Repository in which rebase operation is being run.</param>
/// <param name="committer">Committer Identity to use for the rebased commits.</param>
/// <param name="options">Options controlling rebase behavior.</param>
/// <returns>RebaseResult that describes the result of the rebase operation.</returns>
public static RebaseResult Run(RebaseSafeHandle rebaseOperationHandle,
Repository repository,
Identity committer,
RebaseOptions options)
{
Ensure.ArgumentNotNull(rebaseOperationHandle, "rebaseOperationHandle");
Ensure.ArgumentNotNull(repository, "repository");
Ensure.ArgumentNotNull(committer, "committer");
Ensure.ArgumentNotNull(options, "options");
RebaseResult rebaseResult = null;
// This loop will run until a rebase result has been set.
while (rebaseResult == null)
{
RebaseProgress rebaseStepContext = NextRebaseStep(repository, rebaseOperationHandle);
if (rebaseStepContext.current != -1)
{
rebaseResult = RunRebaseStep(rebaseOperationHandle,
repository,
committer,
options,
rebaseStepContext.current,
rebaseStepContext.total);
}
else
{
// No step to apply - need to complete the rebase.
rebaseResult = CompleteRebase(rebaseOperationHandle, committer);
}
}
return(rebaseResult);
}
private static RebaseStepResult ApplyPickStep(RebaseSafeHandle rebaseOperationHandle, Repository repository, Identity committer, RebaseOptions options, RebaseStepInfo stepToApplyInfo)
{
RebaseStepResult rebaseStepResult;
// commit and continue.
if (repository.Index.IsFullyMerged)
{
Proxy.GitRebaseCommitResult rebase_commit_result = Proxy.git_rebase_commit(rebaseOperationHandle, null, committer);
if (rebase_commit_result.WasPatchAlreadyApplied)
{
rebaseStepResult = new RebaseStepResult(RebaseStepStatus.ChangesAlreadyApplied);
}
else
{
rebaseStepResult = new RebaseStepResult(RebaseStepStatus.Committed, rebase_commit_result.CommitId);
}
}
else
{
rebaseStepResult = new RebaseStepResult(RebaseStepStatus.Conflicts);
}
return(rebaseStepResult);
}
/// <summary>
/// Start a rebase operation.
/// </summary>
/// <param name="branch">The branch to rebase.</param>
/// <param name="upstream">The starting commit to rebase.</param>
/// <param name="onto">The branch to rebase onto.</param>
/// <param name="committer">The <see cref="Identity"/> of who added the change to the repository.</param>
/// <param name="options">The <see cref="RebaseOptions"/> that specify the rebase behavior.</param>
/// <returns>true if completed successfully, false if conflicts encountered.</returns>
public virtual RebaseResult Start(Branch branch, Branch upstream, Branch onto, Identity committer, RebaseOptions options)
{
Ensure.ArgumentNotNull(upstream, "upstream");
options = options ?? new RebaseOptions();
EnsureNonBareRepo();
if (this.repository.Info.CurrentOperation != CurrentOperation.None)
{
throw new LibGit2SharpException(string.Format(
"A {0} operation is already in progress.", this.repository.Info.CurrentOperation));
}
Func <Branch, ReferenceSafeHandle> RefHandleFromBranch = (Branch b) =>
{
return((b == null) ?
null :
this.repository.Refs.RetrieveReferencePtr(b.CanonicalName));
};
Func <ReferenceSafeHandle, GitAnnotatedCommitHandle> AnnotatedCommitHandleFromRefHandle =
(ReferenceSafeHandle refHandle) =>
{
return((refHandle == null) ?
new GitAnnotatedCommitHandle() :
Proxy.git_annotated_commit_from_ref(this.repository.Handle, refHandle));
};
using (GitCheckoutOptsWrapper checkoutOptionsWrapper = new GitCheckoutOptsWrapper(options))
{
GitRebaseOptions gitRebaseOptions = new GitRebaseOptions()
{
version = 1,
checkout_options = checkoutOptionsWrapper.Options,
};
using (ReferenceSafeHandle branchRefPtr = RefHandleFromBranch(branch))
using (ReferenceSafeHandle upstreamRefPtr = RefHandleFromBranch(upstream))
using (ReferenceSafeHandle ontoRefPtr = RefHandleFromBranch(onto))
using (GitAnnotatedCommitHandle annotatedBranchCommitHandle = AnnotatedCommitHandleFromRefHandle(branchRefPtr))
using (GitAnnotatedCommitHandle upstreamRefAnnotatedCommitHandle = AnnotatedCommitHandleFromRefHandle(upstreamRefPtr))
using (GitAnnotatedCommitHandle ontoRefAnnotatedCommitHandle = AnnotatedCommitHandleFromRefHandle(ontoRefPtr))
using (RebaseSafeHandle rebaseOperationHandle = Proxy.git_rebase_init(this.repository.Handle,
annotatedBranchCommitHandle,
upstreamRefAnnotatedCommitHandle,
ontoRefAnnotatedCommitHandle,
gitRebaseOptions))
{
RebaseResult rebaseResult = RebaseOperationImpl.Run(rebaseOperationHandle,
this.repository,
committer,
options);
return(rebaseResult);
}
}
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public virtual long GetTotalStepCount()
{
GitRebaseOptions gitRebaseOptions = new GitRebaseOptions()
{
version = 1,
};
using (RebaseSafeHandle rebaseHandle = Proxy.git_rebase_open(repository.Handle, gitRebaseOptions))
{
return(Proxy.git_rebase_operation_entrycount(rebaseHandle));
}
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public virtual long GetCurrentStepIndex()
{
GitRebaseOptions gitRebaseOptions = new GitRebaseOptions()
{
version = 1,
};
using (RebaseSafeHandle rebaseHandle = Proxy.git_rebase_open(repository.Handle, gitRebaseOptions))
{
return(Proxy.git_rebase_operation_current(rebaseHandle));
}
}
/// <summary>
/// Continue the current rebase.
/// </summary>
/// <param name="committer">The <see cref="Identity"/> of who added the change to the repository.</param>
/// <param name="options">The <see cref="RebaseOptions"/> that specify the rebase behavior.</param>
public virtual RebaseResult Continue(Identity committer, RebaseOptions options)
{
Ensure.ArgumentNotNull(committer, "committer");
options = options ?? new RebaseOptions();
EnsureNonBareRepo();
using (GitCheckoutOptsWrapper checkoutOptionsWrapper = new GitCheckoutOptsWrapper(options))
{
GitRebaseOptions gitRebaseOptions = new GitRebaseOptions()
{
version = 1,
checkout_options = checkoutOptionsWrapper.Options,
};
using (RebaseSafeHandle rebase = Proxy.git_rebase_open(repository.Handle, gitRebaseOptions))
{
// TODO: Should we check the pre-conditions for committing here
// for instance - what if we had failed on the git_rebase_finish call,
// do we want continue to be able to restart afterwords...
var rebaseCommitResult = Proxy.git_rebase_commit(rebase, null, committer);
// Report that we just completed the step
if (options.RebaseStepCompleted != null)
{
// Get information on the current step
long currentStepIndex = Proxy.git_rebase_operation_current(rebase);
long totalStepCount = Proxy.git_rebase_operation_entrycount(rebase);
GitRebaseOperation gitRebasestepInfo = Proxy.git_rebase_operation_byindex(rebase, currentStepIndex);
var stepInfo = new RebaseStepInfo(gitRebasestepInfo.type,
repository.Lookup <Commit>(new ObjectId(gitRebasestepInfo.id)),
LaxUtf8NoCleanupMarshaler.FromNative(gitRebasestepInfo.exec));
if (rebaseCommitResult.WasPatchAlreadyApplied)
{
options.RebaseStepCompleted(new AfterRebaseStepInfo(stepInfo, currentStepIndex, totalStepCount));
}
else
{
options.RebaseStepCompleted(new AfterRebaseStepInfo(stepInfo,
repository.Lookup <Commit>(new ObjectId(rebaseCommitResult.CommitId)),
currentStepIndex,
totalStepCount));
}
}
RebaseResult rebaseResult = RebaseOperationImpl.Run(rebase, repository, committer, options);
return(rebaseResult);
}
}
}
private static RebaseResult CompleteRebase(RebaseSafeHandle rebaseOperationHandle, Identity committer)
{
long totalStepCount = Proxy.git_rebase_operation_entrycount(rebaseOperationHandle);
// Rebase is completed!
Proxy.git_rebase_finish(rebaseOperationHandle, committer);
var rebaseResult = new RebaseResult(RebaseStatus.Complete,
totalStepCount,
totalStepCount,
null);
return(rebaseResult);
}
/// <summary>
/// Abort the rebase operation.
/// </summary>
/// <param name="options">The <see cref="RebaseOptions"/> that specify the rebase behavior.</param>
public virtual void Abort(RebaseOptions options)
{
options = options ?? new RebaseOptions();
EnsureNonBareRepo();
using (GitCheckoutOptsWrapper checkoutOptionsWrapper = new GitCheckoutOptsWrapper(options))
{
GitRebaseOptions gitRebaseOptions = new GitRebaseOptions()
{
checkout_options = checkoutOptionsWrapper.Options,
};
using (RebaseSafeHandle rebase = Proxy.git_rebase_open(repository.Handle, gitRebaseOptions))
{
Proxy.git_rebase_abort(rebase);
}
}
}
/// <summary>
/// Get info on the specified step
/// </summary>
/// <param name="stepIndex"></param>
/// <returns></returns>
public virtual RebaseStepInfo GetStepInfo(long stepIndex)
{
if (repository.Info.CurrentOperation != LibGit2Sharp.CurrentOperation.RebaseMerge)
{
return(null);
}
GitRebaseOptions gitRebaseOptions = new GitRebaseOptions()
{
version = 1,
};
using (RebaseSafeHandle rebaseHandle = Proxy.git_rebase_open(repository.Handle, gitRebaseOptions))
{
GitRebaseOperation gitRebasestepInfo = Proxy.git_rebase_operation_byindex(rebaseHandle, stepIndex);
var stepInfo = new RebaseStepInfo(gitRebasestepInfo.type,
repository.Lookup <Commit>(new ObjectId(gitRebasestepInfo.id)),
LaxUtf8Marshaler.FromNative(gitRebasestepInfo.exec));
return(stepInfo);
}
}
/// <summary>
/// Run the current rebase step. This will handle reporting that we are about to run a rebase step,
/// identifying and running the operation for the current step, and reporting the current step is completed.
/// </summary>
/// <param name="rebaseOperationHandle"></param>
/// <param name="repository"></param>
/// <param name="committer"></param>
/// <param name="options"></param>
/// <param name="stepToApplyIndex"></param>
/// <param name="totalStepCount"/>
/// <returns></returns>
private static RebaseResult RunRebaseStep(RebaseSafeHandle rebaseOperationHandle,
Repository repository,
Identity committer,
RebaseOptions options,
long stepToApplyIndex,
long totalStepCount)
{
RebaseStepResult rebaseStepResult = null;
RebaseResult rebaseSequenceResult = null;
GitRebaseOperation rebaseOp = Proxy.git_rebase_operation_byindex(rebaseOperationHandle, stepToApplyIndex);
ObjectId idOfCommitBeingRebased = new ObjectId(rebaseOp.id);
RebaseStepInfo stepToApplyInfo = new RebaseStepInfo(rebaseOp.type,
repository.Lookup <Commit>(idOfCommitBeingRebased),
LaxUtf8NoCleanupMarshaler.FromNative(rebaseOp.exec));
// Report the rebase step we are about to perform.
if (options.RebaseStepStarting != null)
{
options.RebaseStepStarting(new BeforeRebaseStepInfo(stepToApplyInfo, stepToApplyIndex, totalStepCount));
}
// Perform the rebase step
GitRebaseOperation rebaseOpReport = Proxy.git_rebase_next(rebaseOperationHandle);
// Verify that the information from the native library is consistent.
VerifyRebaseOp(rebaseOpReport, stepToApplyInfo);
// Handle the result
switch (stepToApplyInfo.Type)
{
case RebaseStepOperation.Pick:
rebaseStepResult = ApplyPickStep(rebaseOperationHandle, repository, committer, options, stepToApplyInfo);
break;
case RebaseStepOperation.Squash:
case RebaseStepOperation.Edit:
// case RebaseStepOperation.Exec:
case RebaseStepOperation.Fixup:
case RebaseStepOperation.Reword:
// These operations are not yet supported by lg2.
throw new LibGit2SharpException("Rebase Operation Type ({0}) is not currently supported in LibGit2Sharp.",
stepToApplyInfo.Type);
default:
throw new ArgumentException(string.Format(
"Unexpected Rebase Operation Type: {0}", stepToApplyInfo.Type));
}
// Report that we just completed the step
if (options.RebaseStepCompleted != null &&
(rebaseStepResult.Status == RebaseStepStatus.Committed ||
rebaseStepResult.Status == RebaseStepStatus.ChangesAlreadyApplied))
{
if (rebaseStepResult.ChangesAlreadyApplied)
{
options.RebaseStepCompleted(new AfterRebaseStepInfo(stepToApplyInfo, stepToApplyIndex, totalStepCount));
}
else
{
options.RebaseStepCompleted(new AfterRebaseStepInfo(stepToApplyInfo,
repository.Lookup <Commit>(new ObjectId(rebaseStepResult.CommitId)),
stepToApplyIndex,
totalStepCount));
}
}
// If the result of the rebase step is something that requires us to stop
// running the rebase sequence operations, then report the result.
if (rebaseStepResult.Status == RebaseStepStatus.Conflicts)
{
rebaseSequenceResult = new RebaseResult(RebaseStatus.Conflicts,
stepToApplyIndex,
totalStepCount,
null);
}
return(rebaseSequenceResult);
}