public void ImplicitConversion_RevisionsToString_ExtractsTheSpecification()
{
RevSpec revSpec = RevSpec.Range(17, 42);
string value = revSpec;
Assert.That(value, Is.EqualTo("17:42"));
}
public Changeset GetCommit(RevisionId id)
{
var command = new LogCommand().WithRevision(RevSpec.ById(id.Value)).WithIncludePathActions();
var changeset = _repository.Log(command).FirstOrDefault(ch => ch.Hash == id.Value);
return(changeset);
}
public void To_WithRevisionByRevisionNumber_ProducesCorrectRevisionSpecification()
{
string output = RevSpec.To(7).ToString();
const string expected = ":7";
Assert.That(output, Is.EqualTo(expected));
}
/// <summary>
/// Gets a <see cref="HgLogQuery"/> that selects commits witch are not only tagging commits.
/// </summary>
public HgLogQuery ExceptTaggingCommits()
{
return(Revision.Except(
RevSpec.Affects(".hgtags") &
RevSpec.Grep("Added tag .+ for changeset .+") &
!RevSpec.Tagged()));
}
private ChangeSet GetChangeSet(RevSpec id)
{
var log = Enumerable.Empty <Changeset>();
try
{
log = Repository.Log(id);
}
catch (MercurialExecutionException e)
{
// Older Mercurial (e.g. 2.4.1) were returning empty without errors when called with an unknown revision,
// but newer versions (e.g. 2.7.1) actually fail here, so account for that possibility so we can run on both
if (!e.Message.Contains("unknown revision"))
{
throw;
}
}
var changeset = log.SingleOrDefault();
if (changeset != null)
{
return(CreateChangeSet(changeset));
}
return(null);
}
public void Pull_FromOtherWithRevisionSpecification_OnlyPullsInRelevantChanges()
{
WriteTextFileAndCommit(Repo1, "test1.txt", "initial contents", "initial commit", true);
WriteTextFileAndCommit(Repo1, "test1.txt", "changed contents", "2nd commit", false);
WriteTextFileAndCommit(Repo1, "test1.txt", "changed contents again", "3rd commit", false);
Repo2.Pull(
Repo1.Path, new PullCommand
{
Revisions =
{
RevSpec.Single(1),
},
});
Changeset[] pulledChangesets = Repo2.Log().OrderBy(c => c.RevisionNumber).ToArray();
Changeset[] originalChangesets = Repo1.Log(
new LogCommand
{
Revisions =
{
RevSpec.Range(0, 1),
},
}).OrderBy(c => c.RevisionNumber).ToArray();
CollectionAssert.AreEqual(pulledChangesets, originalChangesets);
}
static void Main(string[] args)
{
Mercurial.Repository repo = new Repository(@"C:\Users\vddungenpeter\source\repos\Test");
RevSpec working = repo.Identify();
//foreach (var changeSet in repo.Log())
//{
// Console.WriteLine(changeSet);
// if (changeSet.Revision == working)
// {
// Console.WriteLine("*** Working changeset!");
// }
//}
//Mercurial.Gui.GuiClient.ClientType = GuiClientType.PyQT;
var cmd = new WriteGuiConsole();
Mercurial.Client.SetClientPath(@"C:\Program Files\TortoiseHG");
if (Client.CouldLocateClient)
{
repo.Execute(cmd);
//Client.Execute(new RevertCommand());
}
//Mercurial.Gui.GuiClient.InitGui(repo);
Console.ReadLine();
}
/// <inheritdoc />
public ICommit GetBranchHead(string branchName)
{
var heads = _repository.Heads(new HeadsCommand()
.WithBranchRevision(RevSpec.ByBranch(branchName)));
return((HgCommit)heads.First());
}
public void ByBranch_ForVariousTestCases_ProducesCorrectRevisionSpecification(string input, string expected)
{
RevSpec rev = RevSpec.ByBranch(input);
string output = rev.ToString();
Assert.That(output, Is.EqualTo(expected));
}
public void ByTag_WithNameSurroundedBySpaces_ReturnsTrimmedName()
{
string output = RevSpec.ByTag(" stable ").ToString();
const string expected = "stable";
Assert.That(output, Is.EqualTo(expected));
}
public void ImplicitConversion_StringToRevisions_ProducesCorrectRevisionsValue()
{
const string hash = "72beff810";
RevSpec revSpec = hash;
Assert.That(revSpec.ToString(), Is.EqualTo(hash));
}
public void ByHash_CorrectHashSurroundedByWhitespace_ReturnsTrimmedHash()
{
string output = RevSpec.Single(" 123abc ").ToString();
const string expected = "123abc";
Assert.That(output, Is.EqualTo(expected));
}
public void ByHash_UppercaseHash_ReturnsLowercaseHash()
{
string output = RevSpec.Single("123ABC").ToString();
const string expected = "123abc";
Assert.That(output, Is.EqualTo(expected));
}
public void Update(RevSpec rev)
{
using (Logger.IndentLog($"Update working directory to a revision: {rev}"))
{
_repository.Update(rev);
}
}
public void Range_WithTwoRevisionsByRevisionNumber_ProducesCorrectRevisionSpecification()
{
string output = RevSpec.Range(2, 7).ToString();
const string expected = "2:7";
Assert.That(output, Is.EqualTo(expected));
}
public ICommit GetCommit(RevSpec revision)
{
using (Logger.IndentLog($"Get commit by rev: {revision}"))
{
return(_repository.GetCommit(revision));
}
}
public void Not_OnSimpleRange_CreatesCorrectExpression()
{
string output = (!RevSpec.Range(2, 7)).ToString();
const string expected = "not 2:7";
Assert.That(output, Is.EqualTo(expected));
}
/// <inheritdoc />
public ICommit GetCommit(RevSpec revision)
{
var query = new HgLogQuery(revision)
.Last();
return((HgCommit)Log(query).First());
}
public void Log_WithMultipleRevisionFilters_OnlyIncludeMatchingChangesets()
{
Repo.Init();
foreach (string filename in new[]
{
"test1.txt", "test2.txt", "test3.txt"
})
{
File.WriteAllText(Path.Combine(Repo.Path, filename), "dummy content");
Repo.Commit(
filename + " added", new CommitCommand
{
AddRemove = true,
});
}
Changeset[] log = Repo.Log(
new LogCommand
{
Revisions =
{
RevSpec.Range(RevSpec.Single(0), RevSpec.Single(0)),
RevSpec.Range(RevSpec.Single(2), RevSpec.Single(2)),
},
}).ToArray();
Assert.That(log.Length, Is.EqualTo(2));
}
public static MergeResult HgMerge(this ICakeContext context, DirectoryPath repositoryPath, string sourceBranch, string destinationBranch = null)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (repositoryPath == null)
{
throw new ArgumentNullException(nameof(repositoryPath));
}
if (sourceBranch == null)
{
throw new ArgumentNullException(nameof(sourceBranch));
}
using (var repository = context.Hg(repositoryPath))
{
if (!string.IsNullOrEmpty(destinationBranch))
{
repository.Update(destinationBranch);
}
else
{
destinationBranch = repository.Summary().Branch;
}
MergeResult result;
try
{
result = repository.Merge(RevSpec.ByBranch(sourceBranch),
new MergeCommand {
MergeTool = ":merge"
});
}
catch (MercurialExecutionException ex)
{
if (!ex.Message.Contains("merging with a working directory ancestor has no effect"))
{
throw;
}
result = MergeResult.UnresolvedFiles;
}
if (result == MergeResult.Success)
{
repository.Commit($"Merge with {sourceBranch}");
}
else
{
repository.Update(new UpdateCommand {
Clean = true
});
}
return(result);
}
}
public void Except_ProducesCorrectRevisionSpecification()
{
RevSpec include = RevSpec.Range(2, 7);
RevSpec exclude = RevSpec.Single(5);
RevSpec result = include.Except(exclude);
Assert.That(result.ToString(), Is.EqualTo("2:7 - 5"));
}
public void Children_OfRange_ProducesCorrectRevisionSpecification()
{
RevSpec revSpec = RevSpec.Range(2, 17);
string output = revSpec.Children.ToString();
Assert.That(output, Is.EqualTo("children(2:17)"));
}
/// <inheritdoc />
public ICommit GetCommit(RevSpec revision)
{
var log = _repository.Log(new LogCommand()
.WithRevision(revision)
.WithAdditionalArgument("--limit 1"));
return((HgCommit)log.First());
}
public void Author_WithName_ProducesCorrectRevisionSpecification()
{
RevSpec revSpec = RevSpec.Author("Lasse V. Karlsen <*****@*****.**>");
string output = revSpec.ToString();
Assert.That(output, Is.EqualTo("author('Lasse V. Karlsen <*****@*****.**>')"));
}
public void And_WithOtherRevisions_ProducesCorrectRevisionSpecification()
{
RevSpec rev1 = RevSpec.Range(2, 7);
RevSpec rev2 = RevSpec.Range(10, 14);
RevSpec result = rev1.And(rev2);
Assert.That(result.ToString(), Is.EqualTo("2:7 and 10:14"));
}
public void Branches_ForRange_ProducesCorrectRevisionSpecification()
{
RevSpec revSpec = RevSpec.Range(2, 17);
string output = revSpec.Branches.ToString();
Assert.That(output, Is.EqualTo("branch(2:17)"));
}
/// <summary>
/// Initializes a new instance of the <see cref="BisectResult"/> class.
/// </summary>
/// <param name="revision">
/// The revision the <see cref="BisectCommand"/> is currently at in the repository.
/// </param>
/// <param name="done">
/// If <c>true</c>, then <paramref name="revision"/> specifies the first good changeset in the
/// repository; otherwise <paramref name="revision"/> specifies the current changeset that should
/// be tested and marked good or bad by executing another <see cref="BisectCommand"/>.
/// </param>
/// <exception cref="ArgumentNullException">
/// <para><paramref name="revision"/> is <c>null</c>.</para>
/// </exception>
public BisectResult(RevSpec revision, bool done)
{
if (revision == null)
throw new ArgumentNullException("revision");
_Revision = revision;
_Done = done;
}
public void OperatorOr_ReturnsCorrectExpression()
{
var r1 = new RevSpec("10");
var r2 = new RevSpec("20");
RevSpec r = r1 || r2;
Assert.That(r, Is.EqualTo(new RevSpec("10 or 20")));
}
/// <summary>
/// Returns a <see cref="HgLogQuery"/> that selects a commit based on its unique hash number.
/// </summary>
/// <param name="hash">The commit unique hash.</param>
/// <exception cref="ArgumentNullException">
/// <para><paramref name="hash"/> is <c>null</c> or empty.</para>
/// </exception>
public HgLogQuery Single(string hash)
{
if (string.IsNullOrEmpty(hash))
{
throw new ArgumentNullException(nameof(hash));
}
return(RevSpec.Single(hash));
}
/// <summary>
/// Creates a <see cref="HgLogQuery"/> that finds commits that belong to the named branch.
/// </summary>
/// <param name="name">Branch name.</param>
public HgLogQuery ByBranch(string name)
{
if (string.IsNullOrEmpty(name))
{
throw new ArgumentNullException(nameof(name));
}
return(RevSpec.ByBranch(name));
}
/// <summary>
/// Create a <see cref="HgLogQuery"/> that includes the commit
/// specified and all ancestor commits.
/// </summary>
/// <param name="query">The <see cref="HgLogQuery"/> to end with.</param>
public HgLogQuery AncestorsOf(HgLogQuery query)
{
if (query == null)
{
throw new ArgumentNullException(nameof(query));
}
return(RevSpec.AncestorsOf(query.Revision));
}
public IEnumerable<RevisionRange> GetAfterTillHead(RevisionId revisionId, int pageSize)
{
var revSpec = new RevSpec(revisionId.Value);
var command = new LogCommand().WithRevision(RevSpec.From(revSpec) && !new RevSpec(revisionId.Value));
var pages = _repository.Log(command)
.OrderBy(ch => ch.Timestamp)
.ToArray()
.Split(pageSize);
var result = pages.Select(page => new RevisionRange(page.First().ToRevisionId(), page.Last().ToRevisionId()));
return result;
}
public IEnumerable<RevisionRange> GetFromAndBefore(RevisionId fromRevision, RevisionId toRevision, int pageSize)
{
var from = new RevSpec(fromRevision.Value);
var to = new RevSpec(toRevision.Value);
var command = new LogCommand().WithRevision(RevSpec.Range(from, to));
var pages = _repository.Log(command)
.OrderBy(ch => ch.Timestamp)
.ToArray()
.Split(pageSize);
var result = pages.Select(page => new RevisionRange(page.First().ToRevisionId(), page.Last().ToRevisionId()));
return result;
}
public IEnumerable<RevisionRange> GetFromAndBefore(RevisionId fromRevision, RevisionId toRevision, int pageSize)
{
var command = new LogCommand();
if (string.IsNullOrEmpty(fromRevision.Value))
{
if (string.IsNullOrEmpty(toRevision.Value))
{
command = command.WithAdditionalArgument("-d {0:yyyy-MM-dd} to {1:yyyy-MM-dd}".Fmt(fromRevision.Time.Value, toRevision.Time.Value));
}
else
{
var to = new RevSpec(toRevision.Value);
command = command.WithRevision(RevSpec.To(to));
command = command.WithAdditionalArgument("-d >{0:yyyy-MM-dd}".Fmt(fromRevision.Time.Value));
}
}
else
{
var from = new RevSpec(fromRevision.Value);
if (string.IsNullOrEmpty(toRevision.Value))
{
command = command.WithAdditionalArgument("-d <{0:yyyy-MM-dd}".Fmt(toRevision.Time.Value));
command = command.WithRevision(RevSpec.From(from));
}
else
{
var to = new RevSpec(toRevision.Value);
command = command.WithRevision(RevSpec.Range(from, to));
}
}
var pages = _repository.Log(command)
.OrderBy(ch => ch.Timestamp)
.ToArray()
.Split(pageSize);
var result = pages.Select(page => new RevisionRange(page.First().ToRevisionId(), page.Last().ToRevisionId()));
return result;
}
/// <summary>
/// Strip changesets from the repository.
/// </summary>
/// <param name="repository">
/// The <see cref="Repository"/> to strip changesets from.
/// </param>
/// <param name="revision">
/// The <see cref="RevSpec"/> of the revision to strip.
/// </param>
/// <param name="command">
/// Any extra options to the strip method, or <c>null</c> for default options.
/// </param>
/// <exception cref="ArgumentNullException">
/// <para><paramref name="repository"/> is <c>null</c>.</para>
/// <para>- or -</para>
/// <para><paramref name="revision"/> is <c>null</c>.</para>
/// </exception>
public static void StripGui(this Repository repository, RevSpec revision, StripGuiCommand command = null)
{
if (repository == null)
throw new ArgumentNullException("repository");
if (revision == null)
throw new ArgumentNullException("revision");
command = (command ?? new StripGuiCommand())
.WithRevision(revision);
repository.Execute(command);
}
/// <summary>
/// Rebase changesets.
/// </summary>
/// <param name="repository">
/// The <see cref="Repository"/> to rebase changesets in.
/// </param>
/// <param name="sourceRevision">
/// The source revision to rebase. This changeset, and all its descendants, will be rebased.
/// </param>
/// <param name="destinationRevision">
/// The Destination revision to rebase. This changeset will be the parent of the changesets after the rebase.
/// </param>
/// <param name="command">
/// Any extra options to the rebase method, or <c>null</c> for default options.
/// </param>
/// <exception cref="ArgumentNullException">
/// <para><paramref name="repository"/> is <c>null</c>.</para>
/// <para>- or -</para>
/// <para><paramref name="sourceRevision"/> is <c>null</c>.</para>
/// <para>- or -</para>
/// <para><paramref name="destinationRevision"/> is <c>null</c>.</para>
/// </exception>
/// <exception cref="ArgumentException">
/// <para><see cref="RebaseGuiCommand.SourceRevision"/> cannot be set before calling this method.</para>
/// <para>- or -</para>
/// <para><see cref="RebaseGuiCommand.DestinationRevision"/> cannot be set before calling this method.</para>
/// </exception>
/// <remarks>
/// This command is only available for the <see cref="GuiClientType.PyQT"/> client type.
/// </remarks>
public static void RebaseGui(this Repository repository, RevSpec sourceRevision, RevSpec destinationRevision, RebaseGuiCommand command = null)
{
if (repository == null)
throw new ArgumentNullException("repository");
if (sourceRevision == null)
throw new ArgumentNullException("sourceRevision");
if (destinationRevision == null)
throw new ArgumentNullException("destinationRevision");
if (command != null && command.SourceRevision != null)
throw new ArgumentException("RebaseGuiCommand.SourceRevision cannot be set before calling this method", "command");
if (command != null && command.DestinationRevision != null)
throw new ArgumentException("RebaseGuiCommand.DestinationRevision cannot be set before calling this method", "command");
command = (command ?? new RebaseGuiCommand())
.WithSourceRevision(sourceRevision)
.WithDestinationRevision(destinationRevision);
repository.Execute(command);
}
public override DiffInfo GenerateDiff(FilePath baseLocalPath, VersionInfo vi)
{
var rev = new RevSpec (((MercurialRevision) vi.Revision).ShortName);
string diff = RootRepository.Diff (new global::Mercurial.DiffCommand ().WithIncludePattern (vi.LocalPath).WithRevisions (rev));
return new DiffInfo (baseLocalPath, vi.LocalPath, diff);
/*
try {
if ((vi.Status & VersionStatus.ScheduledAdd) != 0) {
var ctxt = GetFileContent (vi.LocalPath);
return new DiffInfo (baseLocalPath, vi.LocalPath, GenerateDiff (null, ctxt));
} else if ((vi.Status & VersionStatus.ScheduledDelete) != 0) {
var ctxt = GetCommitContent (GetHeadCommit (), vi.LocalPath);
return new DiffInfo (baseLocalPath, vi.LocalPath, GenerateDiff (ctxt, null));
} else if ((vi.Status & VersionStatus.Modified) != 0 || (vi.Status & VersionStatus.Conflicted) != 0) {
var ctxt1 = GetCommitContent (GetHeadCommit (), vi.LocalPath);
var ctxt2 = GetFileContent (vi.LocalPath);
return new DiffInfo (baseLocalPath, vi.LocalPath, GenerateDiff (ctxt1, ctxt2));
}
} catch (Exception ex) {
LoggingService.LogError ("Could not get diff for file '" + vi.LocalPath + "'", ex);
}
return null;
*/
}
private ChangeSet GetChangeSet(RevSpec id)
{
var log = Repository.Log(id);
return CreateChangeSet(log.SingleOrDefault());
}
public RevisionInfo[] GetRevisions(RevisionId fromChangeset, RevisionId toChangeset)
{
var from = new RevSpec(fromChangeset.Value);
var to = new RevSpec(toChangeset.Value);
var command = new LogCommand().WithRevision(RevSpec.Range(from, to)).WithIncludePathActions();
var revisionInfos = _repository.Log(command)
.Where(ch => ch.Timestamp >= fromChangeset.Time.Value && ch.Timestamp <= toChangeset.Time.Value)
.Select(ch => ch.ToRevisionInfo())
.ToArray();
return revisionInfos;
}
/// <summary>
/// Open the Tag gui.
/// </summary>
/// <param name="repository">
/// The <see cref="Repository"/> to synchronize.
/// </param>
/// <param name="revision">
/// The <see cref="RevSpec"/> of the revision to tag.
/// </param>
/// <param name="name">
/// The name of the tag.
/// </param>
/// <param name="command">
/// Any extra options to the tag method, or <c>null</c> for default options.
/// </param>
/// <exception cref="ArgumentNullException">
/// <para><paramref name="repository"/> is <c>null</c>.</para>
/// <para>- or -</para>
/// <para><paramref name="revision"/> is <c>null</c>.</para>
/// <para>- or -</para>
/// <para><paramref name="name"/> is <c>null</c> or empty.</para>
/// </exception>
/// <exception cref="ArgumentException">
/// <para><see cref="TagGuiCommand.Revision"/> cannot be set before calling this method.</para>
/// <para>- or -</para>
/// <para><see cref="TagGuiCommand.Name"/> cannot be set before calling this method.</para>
/// </exception>
/// <remarks>
/// This command is only available for the <see cref="GuiClientType.PyQT"/> client type.
/// </remarks>
public static void TagGui(this Repository repository, RevSpec revision, string name, TagGuiCommand command = null)
{
if (repository == null)
throw new ArgumentNullException("repository");
if (revision == null)
throw new ArgumentNullException("revision");
if (StringEx.IsNullOrWhiteSpace(name))
throw new ArgumentNullException("name");
if (command != null && command.Revision != null)
throw new ArgumentException("TagGuiCommand.Revision cannot be set before calling this method", "command");
if (command != null && !StringEx.IsNullOrWhiteSpace(command.Name))
throw new ArgumentException("TagGuiCommand.Name cannot be set before calling this method", "command");
command = (command ?? new TagGuiCommand())
.WithRevision(revision)
.WithName(name);
repository.Execute(command);
}
/// <summary>
/// Initializes a new instance of the <see cref="BisectResult"/> class.
/// </summary>
public BisectResult()
{
_Revision = null;
_Done = true;
}
private ChangeSet GetChangeSet(RevSpec id)
{
var log = Enumerable.Empty<Changeset>();
try
{
log = Repository.Log(id);
}
catch (MercurialExecutionException e)
{
// Older Mercurial (e.g. 2.4.1) were returning empty without errors when called with an unknown revision,
// but newer versions (e.g. 2.7.1) actually fail here, so account for that possibility so we can run on both
if (!e.Message.Contains("unknown revision")) throw;
}
var changeset = log.SingleOrDefault();
if (changeset != null)
{
return CreateChangeSet(changeset);
}
return null;
}
public void OperatorOr_ReturnsCorrectExpression()
{
var r1 = new RevSpec("10");
var r2 = new RevSpec("20");
RevSpec r = r1 || r2;
Assert.That(r, Is.EqualTo(new RevSpec("10 or 20")));
}
/// <summary>
/// Launch the visual diff tool.
/// </summary>
/// <param name="repository">
/// The <see cref="Repository"/> to view diffs from.
/// </param>
/// <param name="revisions">
/// The revision <see cref="RevSpec"/> that identifies the revision or the
/// revision range to view a diff of.
/// </param>
/// <param name="command">
/// Any extra options to the vdiff method, or <c>null</c> for default options.
/// </param>
/// <exception cref="ArgumentNullException">
/// <para><paramref name="repository"/> is <c>null</c>.</para>
/// </exception>
/// <exception cref="ArgumentException">
/// <para><see cref="DiffGuiCommand.Revisions"/> cannot be set before calling this method.</para>
/// </exception>
public static void DiffGui(this Repository repository, RevSpec revisions, DiffGuiCommand command = null)
{
if (repository == null)
throw new ArgumentNullException("repository");
if (revisions == null)
throw new ArgumentNullException("revisions");
if (command != null && !StringEx.IsNullOrWhiteSpace(command.Revisions))
throw new ArgumentException("DiffGuiCommand.Revisions cannot be set before calling this method", "command");
command = (command ?? new DiffGuiCommand())
.WithRevisions(revisions);
repository.Execute(command);
}
private ChangeSet GetChangeSet(RevSpec id)
{
var log = Repository.Log(id);
var changeset = log.SingleOrDefault();
if (changeset != null)
{
return CreateChangeSet(changeset);
}
return null;
}
