/// <summary>
/// Internal implementation of Checkout that expects the ID of the checkout target
/// to already be in the form of a canonical branch name or a commit ID.
/// </summary>
/// <param name="tree">The <see cref="Tree"/> to checkout.</param>
/// <param name="checkoutModifiers"><see cref="CheckoutModifiers"/> controlling checkout behavior.</param>
/// <param name="onCheckoutProgress"><see cref="CheckoutProgressHandler"/> that checkout progress is reported through.</param>
/// <param name="checkoutNotificationOptions"><see cref="CheckoutNotificationOptions"/> to manage checkout notifications.</param>
/// <param name="headTarget">Target for the new HEAD.</param>
/// <param name="refLogHeadSpec">The spec which will be written as target in the reflog.</param>
/// <param name="writeReflogEntry">Will a reflog entry be created.</param>
private void Checkout(
Tree tree,
CheckoutModifiers checkoutModifiers,
CheckoutProgressHandler onCheckoutProgress,
CheckoutNotificationOptions checkoutNotificationOptions,
string headTarget, string refLogHeadSpec, bool writeReflogEntry)
{
var previousHeadName = Info.IsHeadDetached ? Head.Tip.Sha : Head.Name;
var opts = new CheckoutOptions
{
CheckoutModifiers = checkoutModifiers,
OnCheckoutProgress = onCheckoutProgress,
CheckoutNotificationOptions = checkoutNotificationOptions
};
CheckoutTree(tree, null, opts);
Refs.UpdateTarget("HEAD", headTarget);
if (writeReflogEntry)
{
LogCheckout(previousHeadName, Head.Tip.Id, refLogHeadSpec);
}
}
/// <summary>
/// Checkout the specified <see cref = "Branch" />, reference or SHA.
/// </summary>
/// <param name = "committishOrBranchSpec">A revparse spec for the commit or branch to checkout.</param>
/// <param name="checkoutOptions"><see cref = "CheckoutOptions" /> controlling checkout behavior.</param>
/// <param name="onCheckoutProgress"><see cref = "CheckoutProgressHandler" /> that checkout progress is reported through.</param>
/// <returns>The <see cref = "Branch" /> that was checked out.</returns>
public Branch Checkout(string committishOrBranchSpec, CheckoutOptions checkoutOptions, CheckoutProgressHandler onCheckoutProgress)
{
Ensure.ArgumentNotNullOrEmptyString(committishOrBranchSpec, "committishOrBranchSpec");
Branch branch = TryResolveBranch(committishOrBranchSpec);
if (branch != null)
{
return(Checkout(branch, checkoutOptions, onCheckoutProgress));
}
var previousHeadName = Info.IsHeadDetached ? Head.Tip.Sha : Head.Name;
Commit commit = LookupCommit(committishOrBranchSpec);
CheckoutTree(commit.Tree, checkoutOptions, onCheckoutProgress);
// Update HEAD.
Refs.UpdateTarget("HEAD", commit.Id.Sha);
if (committishOrBranchSpec != "HEAD")
{
LogCheckout(previousHeadName, commit.Id, committishOrBranchSpec);
}
return(Head);
}
/// <summary>
/// Checkout the tip commit of the specified <see cref="Branch"/> object. If this commit is the
/// current tip of the branch, will checkout the named branch. Otherwise, will checkout the tip commit
/// as a detached HEAD.
/// </summary>
/// <param name="repository">The repository to act on</param>
/// <param name="branch">The <see cref="Branch"/> to check out.</param>
/// <param name="options"><see cref="CheckoutOptions"/> controlling checkout behavior.</param>
/// <returns>The <see cref="Branch"/> that was checked out.</returns>
public static Branch Checkout(IRepository repository, Branch branch, CheckoutOptions options)
{
Ensure.ArgumentNotNull(repository, "repository");
Ensure.ArgumentNotNull(branch, "branch");
Ensure.ArgumentNotNull(options, "options");
// Make sure this is not an unborn branch.
if (branch.Tip == null)
{
throw new UnbornBranchException("The tip of branch '{0}' is null. There's nothing to checkout.",
branch.FriendlyName);
}
Console.WriteLine("branch: {0}", branch);
if (!branch.IsRemote && !(branch is DetachedHead) &&
string.Equals(repository.Refs[branch.CanonicalName].TargetIdentifier, branch.Tip.Id.Sha,
StringComparison.OrdinalIgnoreCase))
{
Checkout(repository, branch.Tip.Tree, options, branch.CanonicalName);
}
else
{
Checkout(repository, branch.Tip.Tree, options, branch.Tip.Id.Sha);
}
return(repository.Head);
}
/// <summary>
/// Checkout the tip commit of the specified <see cref = "Branch" /> object. If this commit is the
/// current tip of the branch, will checkout the named branch. Otherwise, will checkout the tip commit
/// as a detached HEAD.
/// </summary>
/// <param name="branch">The <see cref = "Branch" /> to check out. </param>
/// <param name="checkoutOptions"><see cref = "CheckoutOptions" /> controlling checkout behavior.</param>
/// <param name="onCheckoutProgress"><see cref = "CheckoutProgressHandler" /> that checkout progress is reported through.</param>
/// <returns>The <see cref = "Branch" /> that was checked out.</returns>
public Branch Checkout(Branch branch, CheckoutOptions checkoutOptions, CheckoutProgressHandler onCheckoutProgress)
{
Ensure.ArgumentNotNull(branch, "branch");
// Make sure this is not an unborn branch.
if (branch.Tip == null)
{
throw new OrphanedHeadException(
string.Format(CultureInfo.InvariantCulture,
"The tip of branch '{0}' is null. There's nothing to checkout.", branch.Name));
}
CheckoutTree(branch.Tip.Tree, checkoutOptions, onCheckoutProgress);
// Update HEAD.
if (!branch.IsRemote &&
string.Equals(Refs[branch.CanonicalName].TargetIdentifier, branch.Tip.Id.Sha,
StringComparison.OrdinalIgnoreCase))
{
Refs.UpdateTarget("HEAD", branch.CanonicalName);
}
else
{
Refs.UpdateTarget("HEAD", branch.Tip.Id.Sha);
}
return(Head);
}
/// <summary>
/// Checkout the tip commit of the specified <see cref="Branch"/> object. If this commit is the
/// current tip of the branch, will checkout the named branch. Otherwise, will checkout the tip commit
/// as a detached HEAD.
/// </summary>
/// <param name="repository">The repository to act on</param>
/// <param name="branch">The <see cref="Branch"/> to check out.</param>
/// <param name="options"><see cref="CheckoutOptions"/> controlling checkout behavior.</param>
/// <returns>The <see cref="Branch"/> that was checked out.</returns>
public static Branch Checkout(IRepository repository, Branch branch, CheckoutOptions options)
{
Ensure.ArgumentNotNull(repository, "repository");
Ensure.ArgumentNotNull(branch, "branch");
Ensure.ArgumentNotNull(options, "options");
// Make sure this is not an unborn branch.
if (branch.Tip == null)
{
throw new UnbornBranchException("The tip of branch '{0}' is null. There's nothing to checkout.",
branch.FriendlyName);
}
if (!branch.IsRemote && !(branch is DetachedHead) &&
string.Equals(repository.Refs[branch.CanonicalName].TargetIdentifier, branch.Tip.Id.Sha,
StringComparison.OrdinalIgnoreCase))
{
Checkout(repository, branch.Tip.Tree, options, branch.CanonicalName);
}
else
{
Checkout(repository, branch.Tip.Tree, options, branch.Tip.Id.Sha);
}
return repository.Head;
}
/// <summary>
/// Checkout the specified tree.
/// </summary>
/// <param name="tree">The <see cref="Tree"/> to checkout.</param>
/// <param name="paths">The paths to checkout.</param>
/// <param name="opts">Collection of parameters controlling checkout behavior.</param>
private void CheckoutTree(
Tree tree,
IList <string> paths,
CheckoutOptions opts)
{
CheckoutNotifyHandler onCheckoutNotify = opts.CheckoutNotificationOptions != null ? opts.CheckoutNotificationOptions.CheckoutNotifyHandler : null;
CheckoutNotifyFlags checkoutNotifyFlags = opts.CheckoutNotificationOptions != null ? opts.CheckoutNotificationOptions.NotifyFlags : default(CheckoutNotifyFlags);
CheckoutCallbacks checkoutCallbacks = CheckoutCallbacks.GenerateCheckoutCallbacks(opts.OnCheckoutProgress, onCheckoutNotify);
GitStrArrayIn strArray = (paths != null && paths.Count > 0) ? GitStrArrayIn.BuildFrom(ToFilePaths(paths)) : null;
var options = new GitCheckoutOpts
{
version = 1,
checkout_strategy = CheckoutStrategy.GIT_CHECKOUT_SAFE,
progress_cb = checkoutCallbacks.CheckoutProgressCallback,
notify_cb = checkoutCallbacks.CheckoutNotifyCallback,
notify_flags = checkoutNotifyFlags,
paths = strArray
};
try
{
if (opts.CheckoutModifiers.HasFlag(CheckoutModifiers.Force))
{
options.checkout_strategy = CheckoutStrategy.GIT_CHECKOUT_FORCE;
}
Proxy.git_checkout_tree(Handle, tree.Id, ref options);
}
finally
{
options.Dispose();
}
}
/// <summary>
/// Checkout the specified <see cref="LibGit2Sharp.Commit"/>.
/// <para>
/// Will detach the HEAD and make it point to this commit sha.
/// </para>
/// </summary>
/// <param name="repository">The repository to act on</param>
/// <param name="commit">The <see cref="LibGit2Sharp.Commit"/> to check out.</param>
/// <param name="options"><see cref="CheckoutOptions"/> controlling checkout behavior.</param>
/// <returns>The <see cref="Branch"/> that was checked out.</returns>
public static Branch Checkout(IRepository repository, Commit commit, CheckoutOptions options)
{
Ensure.ArgumentNotNull(repository, "repository");
Ensure.ArgumentNotNull(commit, "commit");
Ensure.ArgumentNotNull(options, "options");
Checkout(repository, commit.Tree, options, commit.Id.Sha);
return(repository.Head);
}
public void CheckoutPaths(string committishOrBranchSpec, IList <string> paths, CheckoutModifiers checkoutOptions, CheckoutProgressHandler onCheckoutProgress, CheckoutNotificationOptions checkoutNotificationOptions)
{
var opts = new CheckoutOptions
{
CheckoutModifiers = checkoutOptions,
OnCheckoutProgress = onCheckoutProgress,
CheckoutNotificationOptions = checkoutNotificationOptions
};
CheckoutPaths(committishOrBranchSpec, paths, opts);
}
public void Reset()
{
// Undo potential impact from earlier tests
using (var repository = new LibGit2Sharp.Repository(Module.WorkingDir))
{
var options = new LibGit2Sharp.CheckoutOptions();
repository.Reset(LibGit2Sharp.ResetMode.Hard, (LibGit2Sharp.Commit)repository.Lookup(CommitHash, LibGit2Sharp.ObjectType.Commit), options);
repository.RemoveUntrackedFiles();
}
new CommitMessageManager(Module.WorkingDirGitDir, Module.CommitEncoding).ResetCommitMessage();
}
public void Reset()
{
// Undo potential impact from earlier tests
using (var repository = new LibGit2Sharp.Repository(Module.WorkingDir))
{
var options = new LibGit2Sharp.CheckoutOptions();
repository.Reset(LibGit2Sharp.ResetMode.Hard, (LibGit2Sharp.Commit)repository.Lookup(CommitHash, LibGit2Sharp.ObjectType.Commit), options);
repository.RemoveUntrackedFiles();
}
CommitHelper.SetCommitMessage(Module, commitMessageText: null, amendCommit: false);
}
private void FastForward(Commit fastForwardCommit)
{
var checkoutOpts = new CheckoutOptions
{
CheckoutModifiers = CheckoutModifiers.None,
};
CheckoutTree(fastForwardCommit.Tree, null, checkoutOpts);
var reference = Refs.Head.ResolveToDirectReference();
Refs.UpdateTarget(reference, fastForwardCommit.Id.Sha);
// TODO: Update Reflog...
}
/// <summary>
/// Internal implementation of Checkout that expects the ID of the checkout target
/// to already be in the form of a canonical branch name or a commit ID.
/// </summary>
/// <param name="tree">The <see cref="Tree"/> to checkout.</param>
/// <param name="checkoutOptions"><see cref = "CheckoutOptions" /> controlling checkout behavior.</param>
/// <param name="onCheckoutProgress"><see cref = "CheckoutProgressHandler" /> that checkout progress is reported through.</param>
private void CheckoutTree(Tree tree, CheckoutOptions checkoutOptions, CheckoutProgressHandler onCheckoutProgress)
{
GitCheckoutOpts options = new GitCheckoutOpts
{
version = 1,
checkout_strategy = CheckoutStrategy.GIT_CHECKOUT_SAFE,
progress_cb = CheckoutCallbacks.GenerateCheckoutCallbacks(onCheckoutProgress)
};
if (checkoutOptions.HasFlag(CheckoutOptions.Force))
{
options.checkout_strategy = CheckoutStrategy.GIT_CHECKOUT_FORCE;
}
Proxy.git_checkout_tree(this.Handle, tree.Id, ref options);
}
public virtual void Checkout(CheckoutModifiers checkoutModifiers, CheckoutProgressHandler onCheckoutProgress, CheckoutNotificationOptions checkoutNotificationOptions)
{
var options = new CheckoutOptions
{
CheckoutModifiers = checkoutModifiers,
OnCheckoutProgress = onCheckoutProgress,
};
if (checkoutNotificationOptions != null)
{
options.OnCheckoutNotify = checkoutNotificationOptions.CheckoutNotifyHandler;
options.CheckoutNotifyFlags = checkoutNotificationOptions.NotifyFlags;
}
Checkout(options, null);
}
/// <inheritdoc />
public IObservable<Unit> Checkout(
string commitOrBranchSpec,
IObserver<Tuple<string, int>> observer)
{
var signature = _repository.Config.BuildSignature(DateTimeOffset.Now);
var options = new CheckoutOptions
{
OnCheckoutProgress = ProgressFactory.CreateHandler(observer)
};
return Observable.Start(() =>
{
_repository.Checkout(commitOrBranchSpec, options, signature);
SignalCompleted(observer);
}, Scheduler.Default);
}
public static bool TryCheckout(this Repository repository, Branch branch, bool force = false)
{
CheckoutOptions options = new CheckoutOptions();
if (force)
{
options.CheckoutModifiers = CheckoutModifiers.Force;
}
try
{
var checkoutBranch = repository.Checkout(branch, options);
GitFlowExtensions.Log("Checked out Branch : " + checkoutBranch.FriendlyName);
}
catch (CheckoutConflictException conflict)
{
GitFlowExtensions.LogError("Checkout Failed", conflict.Message);
return false;
}
return true;
}
/// <summary>
/// Checkout the specified <see cref = "Branch" />, reference or SHA.
/// </summary>
/// <param name = "committishOrBranchSpec">A revparse spec for the commit or branch to checkout.</param>
/// <param name="checkoutOptions"><see cref = "CheckoutOptions" /> controlling checkout behavior.</param>
/// <param name="onCheckoutProgress"><see cref = "CheckoutProgressHandler" /> that checkout progress is reported through.</param>
/// <returns>The <see cref = "Branch" /> that was checked out.</returns>
public Branch Checkout(string committishOrBranchSpec, CheckoutOptions checkoutOptions, CheckoutProgressHandler onCheckoutProgress)
{
Ensure.ArgumentNotNullOrEmptyString(committishOrBranchSpec, "committishOrBranchSpec");
var branch = Branches[committishOrBranchSpec];
if (branch != null)
{
return(Checkout(branch, checkoutOptions, onCheckoutProgress));
}
Commit commit = LookupCommit(committishOrBranchSpec);
CheckoutTree(commit.Tree, checkoutOptions, onCheckoutProgress);
// Update HEAD.
Refs.UpdateTarget("HEAD", commit.Id.Sha);
return(Head);
}
public void Reset()
{
// Undo potential impact from earlier tests
using (var repository = new LibGit2Sharp.Repository(Module.WorkingDir))
{
var options = new LibGit2Sharp.CheckoutOptions();
repository.Reset(LibGit2Sharp.ResetMode.Hard, (LibGit2Sharp.Commit)repository.Lookup(CommitHash, LibGit2Sharp.ObjectType.Commit), options);
repository.RemoveUntrackedFiles();
var remoteNames = repository.Network.Remotes.Select(remote => remote.Name).ToArray();
foreach (var remoteName in remoteNames)
{
repository.Network.Remotes.Remove(remoteName);
}
repository.Config.Set(SettingKeyString.UserName, "author");
repository.Config.Set(SettingKeyString.UserEmail, "*****@*****.**");
}
new CommitMessageManager(Module.WorkingDirGitDir, Module.CommitEncoding).ResetCommitMessage();
}
/// <summary>
/// Checkout the specified <see cref="Branch"/>, reference or SHA.
/// <para>
/// If the committishOrBranchSpec parameter resolves to a branch name, then the checked out HEAD will
/// will point to the branch. Otherwise, the HEAD will be detached, pointing at the commit sha.
/// </para>
/// </summary>
/// <param name="repository">The repository to act on</param>
/// <param name="committishOrBranchSpec">A revparse spec for the commit or branch to checkout.</param>
/// <param name="options"><see cref="CheckoutOptions"/> controlling checkout behavior.</param>
/// <returns>The <see cref="Branch"/> that was checked out.</returns>
public static Branch Checkout(IRepository repository, string committishOrBranchSpec, CheckoutOptions options)
{
Ensure.ArgumentNotNull(repository, "repository");
Ensure.ArgumentNotNullOrEmptyString(committishOrBranchSpec, "committishOrBranchSpec");
Ensure.ArgumentNotNull(options, "options");
Reference reference;
GitObject obj;
repository.RevParse(committishOrBranchSpec, out reference, out obj);
if (reference != null && reference.IsLocalBranch)
{
Branch branch = repository.Branches[reference.CanonicalName];
return Checkout(repository, branch, options);
}
Commit commit = obj.DereferenceToCommit(true);
Checkout(repository, commit.Tree, options, committishOrBranchSpec);
return repository.Head;
}
/// <summary>
/// Internal implementation of Checkout that expects the ID of the checkout target
/// to already be in the form of a canonical branch name or a commit ID.
/// </summary>
/// <param name="repository">The repository to act on</param>
/// <param name="tree">The <see cref="Tree"/> to checkout.</param>
/// <param name="checkoutOptions"><see cref="CheckoutOptions"/> controlling checkout behavior.</param>
/// <param name="refLogHeadSpec">The spec which will be written as target in the reflog.</param>
public static void Checkout(IRepository repository, Tree tree, CheckoutOptions checkoutOptions, string refLogHeadSpec)
{
repository.Checkout(tree, null, checkoutOptions);
repository.Refs.MoveHeadTarget(refLogHeadSpec);
}
/// <summary>
/// Checkout the specified <see cref="LibGit2Sharp.Commit"/>.
/// <para>
/// Will detach the HEAD and make it point to this commit sha.
/// </para>
/// </summary>
/// <param name="repository">The repository to act on</param>
/// <param name="commit">The <see cref="LibGit2Sharp.Commit"/> to check out.</param>
/// <param name="options"><see cref="CheckoutOptions"/> controlling checkout behavior.</param>
/// <returns>The <see cref="Branch"/> that was checked out.</returns>
public static Branch Checkout(IRepository repository, Commit commit, CheckoutOptions options)
{
Ensure.ArgumentNotNull(repository, "repository");
Ensure.ArgumentNotNull(commit, "commit");
Ensure.ArgumentNotNull(options, "options");
Checkout(repository, commit.Tree, options, commit.Id.Sha);
return repository.Head;
}
public void CheckoutPaths(string commitishOrBranchSpec, IEnumerable<string> paths, CheckoutOptions options = null)
{
Repository.CheckoutPaths(commitishOrBranchSpec, paths, options ?? new CheckoutOptions());
}
/// <summary>
/// Checkout the specified <see cref="Branch"/>, reference or SHA.
/// <para>
/// If the committishOrBranchSpec parameter resolves to a branch name, then the checked out HEAD will
/// will point to the branch. Otherwise, the HEAD will be detached, pointing at the commit sha.
/// </para>
/// </summary>
/// <param name="repository">The <see cref="IRepository"/> being worked with.</param>
/// <param name="committishOrBranchSpec">A revparse spec for the commit or branch to checkout.</param>
/// <param name="options"><see cref="CheckoutOptions"/> controlling checkout behavior.</param>
/// <returns>The <see cref="Branch"/> that was checked out.</returns>
public static Branch Checkout(this IRepository repository, string committishOrBranchSpec, CheckoutOptions options)
{
return(repository.Checkout(committishOrBranchSpec, options, null));
}
/// <summary>
/// Checkout the tip commit of the specified <see cref="Branch"/> object. If this commit is the
/// current tip of the branch, will checkout the named branch. Otherwise, will checkout the tip commit
/// as a detached HEAD.
/// </summary>
/// <param name="repository">The <see cref="IRepository"/> being worked with.</param>
/// <param name="branch">The <see cref="Branch"/> to check out.</param>
/// <param name="options"><see cref="CheckoutOptions"/> controlling checkout behavior.</param>
/// <returns>The <see cref="Branch"/> that was checked out.</returns>
public static Branch Checkout(this IRepository repository, Branch branch, CheckoutOptions options)
{
return(repository.Checkout(branch, options, null));
}
public NodeBranch Checkout(Commit commit, CheckoutOptions options = null, Signature signature = null)
{
return new NodeBranch(Repository.Checkout(commit, options ?? new CheckoutOptions(), signature));
}
/// <summary>
/// Checkout the specified <see cref="Branch"/>, reference or SHA.
/// </summary>
/// <param name="repository">The <see cref="Repository"/> being worked with.</param>
/// <param name="commitOrBranchSpec">A revparse spec for the commit or branch to checkout.</param>
/// <returns>The <see cref="Branch"/> that was checked out.</returns>
public static Branch Checkout(this IRepository repository, string commitOrBranchSpec)
{
CheckoutOptions options = new CheckoutOptions();
return(repository.Checkout(commitOrBranchSpec, options));
}
/// <summary>
/// Checkout the specified <see cref="LibGit2Sharp.Commit"/>.
/// <para>
/// Will detach the HEAD and make it point to this commit sha.
/// </para>
/// </summary>
/// <param name="repository">The <see cref="Repository"/> being worked with.</param>
/// <param name="commit">The <see cref="LibGit2Sharp.Commit"/> to check out.</param>
/// <returns>The <see cref="Branch"/> that was checked out.</returns>
public static Branch Checkout(this IRepository repository, Commit commit)
{
CheckoutOptions options = new CheckoutOptions();
return(repository.Checkout(commit, options));
}
public Branch Checkout(Branch branch, CheckoutOptions checkoutOptions, CheckoutProgressHandler onCheckoutProgress)
{
return(Checkout(branch, (CheckoutModifiers)checkoutOptions, onCheckoutProgress, null));
}
public Branch Checkout(string committishOrBranchSpec, CheckoutOptions checkoutOptions, CheckoutProgressHandler onCheckoutProgress)
{
return(Checkout(committishOrBranchSpec, (CheckoutModifiers)checkoutOptions, onCheckoutProgress, null));
}
public void DiscardChanges(IEnumerable<string> paths)
{
var enumerable = paths as string[] ?? paths.ToArray();
_jobQueue.AddJob(
$"DiscardChanges: {string.Join(",", enumerable)}",
() =>
{
var opts = new CheckoutOptions {CheckoutModifiers = CheckoutModifiers.Force};
Internal.CheckoutPaths("HEAD", enumerable, opts);
});
}
/// <summary>
/// Checkout the specified <see cref="Branch"/>, reference or SHA.
/// <para>
/// If the committishOrBranchSpec parameter resolves to a branch name, then the checked out HEAD will
/// will point to the branch. Otherwise, the HEAD will be detached, pointing at the commit sha.
/// </para>
/// </summary>
/// <param name="repository">The repository to act on</param>
/// <param name="committishOrBranchSpec">A revparse spec for the commit or branch to checkout.</param>
/// <param name="options"><see cref="CheckoutOptions"/> controlling checkout behavior.</param>
/// <returns>The <see cref="Branch"/> that was checked out.</returns>
public static Branch Checkout(IRepository repository, string committishOrBranchSpec, CheckoutOptions options)
{
Ensure.ArgumentNotNull(repository, "repository");
Ensure.ArgumentNotNullOrEmptyString(committishOrBranchSpec, "committishOrBranchSpec");
Ensure.ArgumentNotNull(options, "options");
Reference reference;
GitObject obj;
Console.WriteLine("revparsing {0}", committishOrBranchSpec);
repository.RevParse(committishOrBranchSpec, out reference, out obj);
Console.WriteLine("grabbed ref {0}, obj {1}", reference, obj);
if (reference != null && reference.IsLocalBranch)
{
Branch branch = repository.Branches[reference.CanonicalName];
Console.WriteLine("grabbed branch {0}", branch);
return(Checkout(repository, branch, options));
}
Commit commit = obj.DereferenceToCommit(true);
Console.WriteLine("dereferenced to commit {0}", commit);
Checkout(repository, commit.Tree, options, committishOrBranchSpec);
return(repository.Head);
}
/// <summary>
/// Internal implementation of Checkout that expects the ID of the checkout target
/// to already be in the form of a canonical branch name or a commit ID.
/// </summary>
/// <param name="repository">The repository to act on</param>
/// <param name="tree">The <see cref="Tree"/> to checkout.</param>
/// <param name="checkoutOptions"><see cref="CheckoutOptions"/> controlling checkout behavior.</param>
/// <param name="refLogHeadSpec">The spec which will be written as target in the reflog.</param>
public static void Checkout(IRepository repository, Tree tree, CheckoutOptions checkoutOptions, string refLogHeadSpec)
{
repository.Checkout(tree, null, checkoutOptions);
repository.Refs.MoveHeadTarget(refLogHeadSpec);
}
public GitActionResult<GitBranchInfo> Checkout(GitBranchInfo info, bool force = false)
{
using (var repository = GetRepository())
{
var result = new GitActionResult<GitBranchInfo>();
CheckoutOptions options = new CheckoutOptions();
var branch = repository.Branches.FirstOrDefault(
x => string.Equals(x.CanonicalName, info.CanonicalName, StringComparison.OrdinalIgnoreCase));
if (force)
{
options.CheckoutModifiers = CheckoutModifiers.Force;
}
try
{
var checkoutBranch = repository.Checkout(branch, options);
if (checkoutBranch != null)
{
result.Item = new GitBranchInfo
{
CanonicalName = checkoutBranch.CanonicalName,
RemoteName = checkoutBranch.Remote?.Name,
Name = checkoutBranch.FriendlyName,
IsRemote = checkoutBranch.IsRemote
};
result.Succeeded = true;
return result;
}
result.Succeeded = false;
}
catch (CheckoutConflictException conflict)
{
result.Succeeded = false;
result.ErrorMessage = conflict.Message;
}
return result;
}
}
public NodeBranch Checkout(string commitishOrBranchSpec, CheckoutOptions options = null, Signature signature = null)
{
return new NodeBranch(Repository.Checkout(commitishOrBranchSpec, options ?? new CheckoutOptions(), signature));
}
public Branch Checkout(string committishOrBranchSpec, CheckoutOptions options, Signature signature = null)
{
throw new NotImplementedException();
}
/// <summary>
/// Checkout the commit pointed at by the tip of the specified <see cref="Branch"/>.
/// <para>
/// If this commit is the current tip of the branch as it exists in the repository, the HEAD
/// will point to this branch. Otherwise, the HEAD will be detached, pointing at the commit sha.
/// </para>
/// </summary>
/// <param name="repository">The <see cref="Repository"/> being worked with.</param>
/// <param name="branch">The <see cref="Branch"/> to check out.</param>
/// <returns>The <see cref="Branch"/> that was checked out.</returns>
public static Branch Checkout(this IRepository repository, Branch branch)
{
CheckoutOptions options = new CheckoutOptions();
return(repository.Checkout(branch, options));
}
public Branch Checkout(Commit commit, CheckoutOptions options, Signature signature = null)
{
throw new NotImplementedException();
}
public void Reset(ResetMode resetMode, Commit commit, CheckoutOptions options)
{
throw new NotImplementedException();
}
public Branch Checkout(Commit commit, CheckoutOptions options)
{
throw new NotImplementedException();
}
public void UndoFileChanges(string filename)
{
using (var repository = GetRepository())
{
CheckoutOptions options = new CheckoutOptions { CheckoutModifiers = CheckoutModifiers.Force };
repository.CheckoutPaths("HEAD", new string[] { filename }, options);
}
}
public void CheckoutPaths(string committishOrBranchSpec, IEnumerable<string> paths, CheckoutOptions checkoutOptions = null)
{
throw new NotImplementedException();
}
/// <summary>
/// Checkout the specified <see cref="LibGit2Sharp.Commit"/>.
/// <para>
/// Will detach the HEAD and make it point to this commit sha.
/// </para>
/// </summary>
/// <param name="repository">The <see cref="Repository"/> being worked with.</param>
/// <param name="commit">The <see cref="LibGit2Sharp.Commit"/> to check out.</param>
/// <param name="signature">The identity used for updating the reflog</param>
/// <returns>The <see cref="Branch"/> that was checked out.</returns>
public static Branch Checkout(this IRepository repository, Commit commit, Signature signature = null)
{
CheckoutOptions options = new CheckoutOptions();
return(repository.Checkout(commit, options, signature));
}
public void Checkout(Tree tree, IEnumerable<string> paths, CheckoutOptions opts)
{
throw new NotImplementedException();
}
/// <summary>
/// Checkout the specified <see cref="LibGit2Sharp.Commit"/>.
/// <para>
/// Will detach the HEAD and make it point to this commit sha.
/// </para>
/// </summary>
/// <param name="repository">The <see cref="IRepository"/> being worked with.</param>
/// <param name="commit">The <see cref="LibGit2Sharp.Commit"/> to check out.</param>
/// <param name="options"><see cref="CheckoutOptions"/> controlling checkout behavior.</param>
/// <returns>The <see cref="Branch"/> that was checked out.</returns>
public static Branch Checkout(this IRepository repository, Commit commit, CheckoutOptions options)
{
return(repository.Checkout(commit, options, null));
}
public MergeResult UpstreamSync()
{
// Need to check status before doing this
MergeResult mergeResult;
var mergeOptions = new MergeOptions ();
mergeOptions.FastForwardStrategy = FastForwardStrategy.FastForwardOnly;
var signature = new Signature ("x", "x", DateTime.Now);
var checkoutOptions = new CheckoutOptions ();
checkoutOptions.CheckoutModifiers = CheckoutModifiers.Force;
try {
Console.WriteLine ("Checkout master");
repo.Checkout (master);
Console.Write ("Any Key");
Console.ReadKey ();
Console.WriteLine ("Fetch Upstream");
Remote remote = repo.Network.Remotes ["upstream"];
repo.Network.Fetch (remote);
Console.Write ("Any Key");
Console.ReadKey ();
Console.WriteLine ("Merge the fetched Upstream");
mergeResult = repo.MergeFetchedRefs (signature, mergeOptions);
Console.WriteLine (mergeResult.Status);
Console.Write ("Any Key");
Console.ReadKey ();
} finally {
Console.WriteLine ("Checkout prior head");
repo.Checkout (head);
Console.Write ("Any Key");
Console.ReadKey ();
}
return mergeResult;
}
private static void SetupDevBranch(Repository repository, string branchName, string masterName, Signature author)
{
Log("Setting Up Dev Branch");
var branch = repository.AddGetBranch(branchName,masterName,track:true);
CheckoutOptions options = new CheckoutOptions();
options.CheckoutModifiers = CheckoutModifiers.Force;
repository.TryCheckout(branch, true);
Log("Checked out Dev Branch");
}
/// <summary>
/// Checkout the tip commit of this <see cref = "Branch" /> object
/// with a callback for progress reporting. If this commit is the
/// current tip of the branch, will checkout the named branch. Otherwise,
/// will checkout the tip commit as a detached HEAD.
/// </summary>
/// <param name="checkoutOptions">Options controlling checkout behavior.</param>
/// <param name="onCheckoutProgress">Callback method to report checkout progress updates through.</param>
public virtual void Checkout(CheckoutOptions checkoutOptions, CheckoutProgressHandler onCheckoutProgress)
{
repo.Checkout(this, checkoutOptions, onCheckoutProgress);
}
public Branch Checkout(Commit commit, CheckoutOptions checkoutOptions, CheckoutProgressHandler onCheckoutProgress)
{
Checkout(commit.Tree, (CheckoutModifiers)checkoutOptions, onCheckoutProgress, null, commit.Id.Sha, commit.Id.Sha, true);
return(Head);
}
public Branch Checkout(Branch branch, CheckoutOptions options)
{
throw new NotImplementedException();
}
/// <summary>
/// Updates specifed paths in the index and working directory with the versions from the specified branch, reference, or SHA.
/// <para>
/// This method does not switch branches or update the current repository HEAD.
/// </para>
/// </summary>
/// <param name = "committishOrBranchSpec">A revparse spec for the commit or branch to checkout paths from.</param>
/// <param name="paths">The paths to checkout. Will throw if null is passed in. Passing an empty enumeration results in nothing being checked out.</param>
/// <param name="checkoutOptions">Collection of parameters controlling checkout behavior.</param>
public void CheckoutPaths(string committishOrBranchSpec, IEnumerable <string> paths, CheckoutOptions checkoutOptions = null)
{
Ensure.ArgumentNotNullOrEmptyString(committishOrBranchSpec, "committishOrBranchSpec");
Ensure.ArgumentNotNull(paths, "paths");
// If there are no paths, then there is nothing to do.
if (!paths.Any())
{
return;
}
Commit commit = LookupCommit(committishOrBranchSpec);
CheckoutTree(commit.Tree, paths.ToList(), checkoutOptions ?? new CheckoutOptions());
}
/// <summary>
/// Get a single file version from the git repository
/// </summary>
/// <param name="repoPath">Repository main path</param>
/// <param name="tmpItem">The temporary item table holding the sha commit</param>
/// <returns>a temporary file path</returns>
public static string FileGetVersion(string repoPath, string fileName, SysVersionControlTmpItem tmpItem)
{
string indexPath = tmpItem.InternalFilename.Replace(repoPath, string.Empty);
CheckoutOptions options = new CheckoutOptions();
options.CheckoutModifiers = CheckoutModifiers.Force;
using (Repository repo = new Repository(repoPath))
{
var commit = repo.Lookup<Commit>(tmpItem.GTXSha);
if (commit != null)
{
try
{
repo.CheckoutPaths(commit.Id.Sha, new[] { fileName }, options);
}
catch (MergeConflictException ex)
{
//should not reach here as we're forcing checkout
throw ex;
}
}
}
return fileName;
}
public virtual void Checkout(CheckoutOptions checkoutOptions, CheckoutProgressHandler onCheckoutProgress)
{
Checkout((CheckoutModifiers)checkoutOptions, onCheckoutProgress, null);
}
/// <summary>
/// Resets the changes of a file to it's HEAD last commit
/// </summary>
/// <param name="repoPath">Repository main path</param>
/// <param name="fileName">The file path</param>
/// <returns>True if reset was successful false if not</returns>
public static bool FileUndoCheckout(string repoPath, string fileName, bool forceCheckout)
{
FileInfo fileInfo = new FileInfo(fileName);
using (Repository repo = new Repository(repoPath))
{
string indexPath = fileInfo.FullName.Replace(repo.Info.WorkingDirectory, string.Empty);
CheckoutOptions checkoutOptions = new CheckoutOptions
{
CheckoutModifiers =
forceCheckout
? CheckoutModifiers.Force
: CheckoutModifiers.None
};
var fileCommits = repo.Head.Commits.Where(c => c.Parents.Count() == 1 &&
c.Tree[indexPath] != null &&
(c.Parents.FirstOrDefault().Tree[indexPath] == null ||
c.Tree[indexPath].Target.Id != c.Parents.FirstOrDefault().Tree[indexPath].Target.Id)
);
if (fileCommits.Any())
{
var lastCommit = fileCommits.First();
repo.CheckoutPaths(lastCommit.Id.Sha, new[] { fileName }, checkoutOptions);
}
return true;
}
}
public virtual void Checkout(CheckoutOptions options, Signature signature = null)
{
Ensure.ArgumentNotNull(options, "options");
repo.Checkout(this, options, signature);
}
/// <summary>
/// Synchronizes a folder
/// </summary>
/// <param name="repoPath">Main repository path</param>
/// <param name="folderPath">The folder to synchronize (checkout). Could be the model path or the layer path</param>
/// <param name="forceCheckout">Forces the update from the latest commit (head tip)</param>
/// <returns>A SysVersionControlItem with all the files that have been affected</returns>
public static SysVersionControlTmpItem FolderSync(string repoPath, string folderPath, bool forceCheckout)
{
SysVersionControlTmpItem tmpItem = new SysVersionControlTmpItem();
CheckoutOptions checkoutOptions = new CheckoutOptions
{
CheckoutModifiers =
forceCheckout
? CheckoutModifiers.Force
: CheckoutModifiers.None
};
string tipSha;
string folderName = folderPath.Split('\\').Last();
using (Repository repo = new Repository(repoPath))
{
repo.CheckoutPaths(repo.Head.Tip.Id.Sha, new[] { folderPath }, checkoutOptions);
tipSha = repo.Head.Tip.Id.Sha;
InitTmpItemFromTree(repoPath, repo.Head.Tip.Tree[folderName].Target as Tree, ref tmpItem);
}
return tmpItem;
}
public override void Undo(string filePath)
{
try
{
var tip = _repo.Branches.First(b => !b.IsRemote && b.IsCurrentRepositoryHead).Tip;
var options = new CheckoutOptions { CheckoutModifiers = CheckoutModifiers.Force };
_repo.CheckoutPaths(tip.Sha, new List<string> { filePath }, options);
base.Undo(filePath);
}
catch (LibGit2SharpException ex)
{
throw new SourceControlException(SourceControlText.GitUndoFailed, ex);
}
}
public bool checkoutHead()
{
var rval = true;
if (repo.Head == head) {
return rval;
}
var checkoutOptions = new CheckoutOptions ();
// foreach (var sub in repo.Submodules)
// {
// Console.WriteLine("{0} {1} {2}", sub.Name, sub.RetrieveStatus().IsWorkingDirectoryDirty(), sub.RetrieveStatus().IsUnmodified());
// }
// Note: There are issues in gitlib2/sharp in the use of .IsWorkingDirectoryDirty() and .IsUnmodified())
// Really should open the submodule ourself via a new repo object...
var dirtySubmodules = repo.Submodules.Where (s => s.RetrieveStatus ().IsWorkingDirectoryDirty ());
if (!dirtySubmodules.Any ()) {
// Console.WriteLine("No submodules dirty, forcing checkout");
checkoutOptions.CheckoutModifiers = CheckoutModifiers.Force;
}
// foreach (var item in repo.RetrieveStatus().Where(m => m.State == FileStatus.ModifiedInWorkdir))
// {
// Console.WriteLine("{0} : {1}", item.State, item.FilePath);
// }
// Console.Write("Any Key");
// Console.ReadKey();
// Console.WriteLine("Checkout prior head");
try {
repo.Checkout (head, checkoutOptions);
// Console.Write("Any Key"); Console.ReadKey();
} catch (Exception e) {
Console.WriteLine ("HEAD checkout failed");
Console.WriteLine (e.Message);
//Console.WriteLine(e.StackTrace);
rval = false;
}
return rval;
}
