//资源树左击事件
private void DomainTreeView_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
{
try
{
//获取点击树节点绑定的TreeDefinition
TreeDefinition treeDefinition = DomainTreeView.SelectedItem as TreeDefinition;
if (treeDefinition == null)
{
return;
}
//获取点击对象的DGObjects实例
DGObjects refObjs = Globals.project.getDomain(treeDefinition.Domain).GetDGObjects(treeDefinition.RefObjID);
if (refObjs == null)
{
return;
}
//根据点击的树，添加对应的Filter（临时）
refObjs.definition.Filter = treeDefinition.Filter;
//传递对象组选择事件到上一级
if (DGObjectsSelectionChangedHandler != null)
{
DGObjectsSelectionChangedHandler(this, new DGObjectsSelectionChangedEvent()
{
newObjs = refObjs,
});
}
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
}
//添加对象事件处理
//例如MonProject、MonGroup之类，
//添加Tree，添加Obj
//返回tree，返回Obj，更新
public async void DGObjectListener(object sender, DGObject model)
{
if (menuItem.Tag.ToString() == "Common")
{
TreeDefinition def = await CommonRepo.AddProjectTree(Globals.project.projectID, _domain, menuBase.TargetObjType, model.ID, 0);
_treeDefinitions.Add(def);
}
else
{
TreeDefinition item = DomainTreeView.SelectedItem as TreeDefinition;
TreeDefinition def = await CommonRepo.AddProjectTree(Globals.project.projectID, _domain, menuBase.TargetObjType, model.ID, item.ID);
if (item.Chillds == null)
{
item.Chillds = new ObservableCollection <TreeDefinition>();
}
item.Chillds.Add(def);
}
Domain domain = Globals.project.getDomain(_domain);
domain.objectsDefinitions = await CommonRepo.GetObjectsDefinition(Globals.project.projectID, domain.name);
domain.DGObjectsList = new List <DGObjects>();
foreach (ObjectsDefinition definition in domain.objectsDefinitions)
{
domain.DGObjectsList.Add(new DGObjects()
{
parent = domain, definition = definition,
});
}
commonPropertyWin.DGObjectHandler -= DGObjectListener;
commonPropertyWin.Close();
}
public void FeedbackTest1()
{
TreeEditDistance treeCorrector = new TreeEditDistance();
TreeDefinition aTree = CreateTreeHelper.MakeTree(new PDLNot(new PDLTrue()));
TreeDefinition bTree = CreateTreeHelper.MakeTree(new PDLTrue());
Transformation transform = treeCorrector.getTransformation(aTree, bTree);
}
public void CanPruneEmptyCommits(string[] treeEntriesToRemove, int expectedCommitCount, string expectedHead)
{
Assert.Equal(7, repo.Head.Commits.Count());
repo.Refs.RewriteHistory(new RewriteHistoryOptions
{
OnError = OnError,
OnSucceeding = OnSucceeding,
PruneEmptyCommits = true,
CommitTreeRewriter =
c => TreeDefinition.From(c)
.Remove(treeEntriesToRemove),
}, repo.Head.Commits);
AssertSucceedingButNotError();
Assert.Equal(expectedCommitCount, repo.Head.Commits.Count());
if (expectedHead == null)
{
Assert.Null(repo.Head.Tip);
}
else
{
Assert.Equal(expectedHead, repo.Head.Tip.Id.Sha.Substring(0, expectedHead.Length));
}
foreach (var treeEntry in treeEntriesToRemove)
{
Assert.True(repo.Head.Commits.All(c => c[treeEntry] == null), "Did not expect a tree entry at " + treeEntry);
}
}
public void CanAddAnExistingTree()
{
const string treeSha = "7f76480d939dc401415927ea7ef25c676b8ddb8f";
const string targetPath = "1/2";
string path = SandboxBareTestRepo();
using (var repo = new Repository(path))
{
TreeDefinition td = TreeDefinition.From(repo.Head.Tip.Tree);
var objectId = new ObjectId(treeSha);
var tree = repo.Lookup <Tree>(objectId);
td.Add(targetPath, tree);
TreeEntryDefinition fetched = td[targetPath];
Assert.NotNull(fetched);
Assert.Equal(objectId, fetched.TargetId);
Assert.Equal(Mode.Directory, fetched.Mode);
Assert.NotNull(td["1/2/branch_file.txt"]);
}
}
public void CanReplaceAnExistingBlobWithATree(string targetPath)
{
const string treeSha = "7f76480d939dc401415927ea7ef25c676b8ddb8f";
string path = SandboxBareTestRepo();
using (var repo = new Repository(path))
{
TreeDefinition td = TreeDefinition.From(repo.Head.Tip.Tree);
Assert.NotNull(td[targetPath]);
Assert.Equal(TreeEntryTargetType.Blob, td[targetPath].TargetType);
var objectId = new ObjectId(treeSha);
var tree = repo.Lookup <Tree>(objectId);
td.Add(targetPath, tree);
TreeEntryDefinition fetched = td[targetPath];
Assert.NotNull(fetched);
Assert.Equal(TreeEntryTargetType.Tree, td[targetPath].TargetType);
Assert.Equal(objectId, fetched.TargetId);
Assert.Equal(Mode.Directory, fetched.Mode);
}
}
/// <summary>
/// Write a config back to the global git repository.
/// </summary>
/// <param name="config"></param>
public void WriteConfig(Config config)
{
using (var repository = new Repository(LocalGitRepositoryLocation))
{
var remote = repository.Network.Remotes[ConfigurationRemote];
repository.Network.Fetch(remote);
// Create a blob from the content stream
Blob blob;
var serializedObject = new JavaScriptSerializer().Serialize(config);
var contentBytes = Encoding.UTF8.GetBytes(serializedObject);
using (var memoryStream = new MemoryStream(contentBytes)) { blob = repository.ObjectDatabase.CreateBlob(memoryStream); }
// Put the blob in a tree
var treeDefinition = new TreeDefinition();
treeDefinition.Add(GitConfigurationFile, blob, Mode.NonExecutableFile);
var tree = repository.ObjectDatabase.CreateTree(treeDefinition);
// Committer and author
var committer = new Signature(string.Format("{0}@{1}", Environment.UserName, Environment.MachineName), TeamEmailAddress, DateTime.Now);
var author = committer;
//Create the commit
var refOriginMaster = repository.Refs[ConfigurationRemoteRef];
var parentCommit = refOriginMaster != null ? new[] { repository.Lookup <Commit>(refOriginMaster.TargetIdentifier) } : new Commit[0];
var commit = repository.ObjectDatabase.CreateCommit(author, committer, "Updating config.json", tree, parentCommit, false);
// Update the HEAD reference to point to the latest commit
repository.Refs.UpdateTarget(repository.Refs.Head, commit.Id);
repository.Network.Push(remote, repository.Refs.Head.CanonicalName, ConfigurationRef);
}
}
private void CanHandleTwoTreeEntryChangesWithTheSamePath(SimilarityOptions similarity, Action <string, TreeChanges> verifier)
{
string repoPath = InitNewRepository();
using (var repo = new Repository(repoPath))
{
Blob mainContent = OdbHelper.CreateBlob(repo, "awesome content\n" + new string('b', 4096));
Blob linkContent = OdbHelper.CreateBlob(repo, "../../objc/Nu.h");
string path = Path.Combine("include", "Nu", "Nu.h");
var tdOld = new TreeDefinition()
.Add(path, linkContent, Mode.SymbolicLink)
.Add("objc/Nu.h", mainContent, Mode.NonExecutableFile);
Tree treeOld = repo.ObjectDatabase.CreateTree(tdOld);
var tdNew = new TreeDefinition()
.Add(path, mainContent, Mode.NonExecutableFile);
Tree treeNew = repo.ObjectDatabase.CreateTree(tdNew);
var changes = repo.Diff.Compare <TreeChanges>(treeOld, treeNew,
compareOptions: new CompareOptions
{
Similarity = similarity,
});
verifier(path, changes);
}
}
private Task <string> GetHeaderAsync(TreeDefinition treeModel, List <TreeEntry> data, TreeSetup setup)
{
HtmlBuilder hb = new HtmlBuilder();
if (treeModel.ShowHeader)
{
PropertyData prop = ObjectSupport.GetPropertyData(treeModel.RecordType, nameof(TreeEntry.Text));
// Caption
string caption = treeModel.Header.ToString();
if (string.IsNullOrWhiteSpace(caption))
{
caption = prop.GetCaption(null);
}
// Description
string description = treeModel.HeaderTooltip.ToString();
if (string.IsNullOrWhiteSpace(description))
{
description = prop.GetDescription(null);
}
string alignCss = "tg_left";
// Render column header
hb.Append($@"
<div class='{alignCss} tg_header{(treeModel.UseSkinFormatting ? " ui-state-default" : "")}' {Basics.CssTooltip}='{HAE(description ?? "")}'>
<span>{HE(caption)}</span>
</div>");
}
return(Task.FromResult(hb.ToString()));
}
public void CanReplaceAnExistingTreeWithAGitLink()
{
var commitId = (ObjectId)"480095882d281ed676fe5b863569520e54a7d5c0";
const string targetPath = "just_a_dir";
var path = SandboxSubmoduleTestRepo();
using (var repo = new Repository(path))
{
TreeDefinition td = TreeDefinition.From(repo.Head.Tip.Tree);
Assert.Equal(TreeEntryTargetType.Tree, td[targetPath].TargetType);
Assert.NotNull(td["just_a_dir/contents"]);
td.AddGitLink(targetPath, commitId);
TreeEntryDefinition fetched = td[targetPath];
Assert.NotNull(fetched);
Assert.Equal(commitId, fetched.TargetId);
Assert.Equal(TreeEntryTargetType.GitLink, fetched.TargetType);
Assert.Equal(Mode.GitLink, fetched.Mode);
Assert.Null(td["just_a_dir/contents"]);
}
}
public void CanCreateATreeContainingABlobFromAFileInTheWorkingDirectory()
{
string path = SandboxStandardTestRepo();
using (var repo = new Repository(path))
{
Assert.Equal(FileStatus.Nonexistent, repo.RetrieveStatus("hello.txt"));
File.AppendAllText(Path.Combine(repo.Info.WorkingDirectory, "hello.txt"), "I'm a new file\n");
TreeDefinition td = TreeDefinition.From(repo.Head.Tip.Tree)
.Add("1/new file", "hello.txt", Mode.NonExecutableFile);
TreeEntryDefinition ted = td["1/new file"];
Assert.NotNull(ted);
Assert.Equal(ObjectId.Zero, ted.TargetId);
td.Add("1/2/another new file", ted);
Tree tree = repo.ObjectDatabase.CreateTree(td);
TreeEntry te = tree["1/new file"];
Assert.NotNull(te.Target);
Assert.Equal("dc53d4c6b8684c21b0b57db29da4a2afea011565", te.Target.Sha);
Assert.Equal("dc53d4c6b8684c21b0b57db29da4a2afea011565", td["1/new file"].TargetId.Sha);
te = tree["1/2/another new file"];
Assert.NotNull(te.Target);
Assert.Equal("dc53d4c6b8684c21b0b57db29da4a2afea011565", te.Target.Sha);
Assert.Equal("dc53d4c6b8684c21b0b57db29da4a2afea011565", td["1/2/another new file"].TargetId.Sha);
}
}
private RebaseStatus CompleteRebase(IRepository r)
{
var computeChanges = _computeTreeChangesFactory(_rebase.Repository.Container, _rebase.Repository.RepositoryDescription);
var previous = _rebase.StartRepository;
var lastCommit = r.Lookup <Commit>(_rebase.RebaseCommitId);
foreach (var info in _rebase.Transformations.Zip(_rebase.ReplayedCommits, (repository, commit) => (repository, r.Lookup <Commit>(commit))))
{
var changes = computeChanges.Compare(previous, info.repository);
if (changes.Any())
{
var definition = TreeDefinition.From(lastCommit);
r.UpdateTreeDefinition(changes, definition, _serializer, lastCommit);
var tree = r.ObjectDatabase.CreateTree(definition);
previous = info.repository;
lastCommit = r.ObjectDatabase.CreateCommit(info.Item2.Author, info.Item2.Committer, info.Item2.Message, tree, new[] { lastCommit }, false);
}
}
var logMessage = lastCommit.BuildCommitLogMessage(false, false, false);
r.UpdateHeadAndTerminalReference(lastCommit, logMessage);
if (_rebase.Repository.Container is ObjectRepositoryContainer container)
{
container.ReloadRepository(_rebase.Repository, lastCommit.Id);
}
return(RebaseStatus.Complete);
}
private static void CopyTree(TreeDefinition definition, string name,
Tree tree, Repository repo, TreeModify?modifyForMe)
{
Tree newObject = CopyTreeToAnotherRepositoryWithModifying(tree, repo, modifyForMe);
definition.Add(name, newObject);
}
public string Save(string fileName, string value)
{
var contentBytes = System.Text.Encoding.UTF8.GetBytes(value);
var ms = new MemoryStream(contentBytes);
var blob = _repo.ObjectDatabase.CreateBlob(ms);
var committer = new Signature("Computer", "*****@*****.**", DateTimeOffset.UtcNow);
var commitLog = _repo.Head.Commits.Take(1).ToArray();
var commitPrefixString =
commitLog.Any() && commitLog.First()[fileName] != null
? "Updated "
: "Created ";
var td = commitLog.Any()
? TreeDefinition.From(commitLog.First())
: new TreeDefinition();
td.Add(fileName, blob, Mode.NonExecutableFile);
var tree = _repo.ObjectDatabase.CreateTree(td);
var commit = _repo.ObjectDatabase.CreateCommit(committer, committer, commitPrefixString + fileName, tree, commitLog, false);
if (_repo.Branches[_branchName] == null)
{
_repo.CreateBranch(_branchName, commit);
//_repo.Branches[_branchName].
}
UpdateRefs(commit);
return(commit.Id.Sha);
}
public void RetrievingDiffChangesMustAlwaysBeCaseSensitive()
{
ObjectId treeOldOid, treeNewOid;
string repoPath = InitNewRepository();
using (var repo = new Repository(repoPath))
{
Blob oldContent = OdbHelper.CreateBlob(repo, "awesome content\n");
Blob newContent = OdbHelper.CreateBlob(repo, "more awesome content\n");
var td = new TreeDefinition()
.Add("A.TXT", oldContent, Mode.NonExecutableFile)
.Add("a.txt", oldContent, Mode.NonExecutableFile);
treeOldOid = repo.ObjectDatabase.CreateTree(td).Id;
td = new TreeDefinition()
.Add("A.TXT", newContent, Mode.NonExecutableFile)
.Add("a.txt", newContent, Mode.NonExecutableFile);
treeNewOid = repo.ObjectDatabase.CreateTree(td).Id;
}
using (var repo = new Repository(repoPath))
{
var changes = repo.Diff.Compare <TreeChanges>(repo.Lookup <Tree>(treeOldOid), repo.Lookup <Tree>(treeNewOid));
Assert.Equal(ChangeKind.Modified, changes["a.txt"].Status);
Assert.Equal(ChangeKind.Modified, changes["A.TXT"].Status);
}
}
string commitTree(string branch, TreeDefinition treeDefinition, Signature signature, string message, bool commitEmpty = false)
{
var branchObj = _repo.Branches.SingleOrDefault(b => b.FriendlyName == branch);
var previousCommit = branchObj?.Tip;
var tree = _repo.ObjectDatabase.CreateTree(treeDefinition);
if (previousCommit != null && previousCommit.Tree.Id == tree.Id && !commitEmpty)
{
return(string.Empty);
}
var ancestors = previousCommit != null ? new List <Commit> {
previousCommit
} : new List <Commit>();
var commit = _repo.ObjectDatabase.CreateCommit(signature, signature, message, tree, ancestors, false);
if (branchObj == null)
{
_repo.Refs.UpdateTarget(_repo.Refs.Head, commit.Id, string.Empty);
}
else
{
_repo.Refs.UpdateTarget(_repo.Refs[branchObj.CanonicalName], commit.Id);
}
return(commit.Sha);
}
public void CanRewriteTreesByInjectingTreeEntry()
{
var commits = repo.Commits.QueryBy(new CommitFilter {
Since = repo.Branches
}).ToArray();
var currentReadme = repo.Head["README"];
repo.Refs.RewriteHistory(new RewriteHistoryOptions
{
OnError = OnError,
OnSucceeding = OnSucceeding,
CommitTreeRewriter =
c => c["README"] == null
? TreeDefinition.From(c)
: TreeDefinition.From(c)
.Add("README", currentReadme),
}, commits);
AssertSucceedingButNotError();
Assert.Equal(new Commit[0],
repo.Commits
.QueryBy(new CommitFilter {
Since = repo.Branches
})
.Where(c => c["README"] != null &&
c["README"].Target.Id != currentReadme.Target.Id)
.ToArray());
}
public void CanAddAndRemoveAnExistingTreeEntry(string sourcePath, string targetPath)
{
string path = SandboxBareTestRepo();
using (var repo = new Repository(path))
{
var tree = repo.Head.Tip.Tree;
var td = TreeDefinition.From(tree);
Assert.Null(td[targetPath]);
var te = tree[sourcePath];
td.Add(targetPath, te);
var fetched = td[targetPath];
Assert.NotNull(fetched);
Assert.Equal(te.Target.Id, fetched.TargetId);
// Ensuring that the object database can handle uncommon paths.
var newTree = repo.ObjectDatabase.CreateTree(td);
Assert.Equal(newTree[targetPath].Target.Id, te.Target.Id);
td.Remove(targetPath);
Assert.Null(td[targetPath]);
}
}
public void CanReplaceAnExistingGitLinkWithABlob()
{
const string blobSha = "42cfb95cd01bf9225b659b5ee3edcc78e8eeb478";
const string targetPath = "sm_unchanged";
using (var repo = new Repository(SubmoduleTestRepoWorkingDirPath))
{
TreeDefinition td = TreeDefinition.From(repo.Head.Tip.Tree);
Assert.NotNull(td[targetPath]);
Assert.Equal(TreeEntryTargetType.GitLink, td[targetPath].TargetType);
Assert.Equal(Mode.GitLink, td[targetPath].Mode);
var objectId = new ObjectId(blobSha);
var blob = repo.Lookup <Blob>(objectId);
td.Add(targetPath, blob, Mode.NonExecutableFile);
TreeEntryDefinition fetched = td[targetPath];
Assert.NotNull(fetched);
Assert.Equal(objectId, fetched.TargetId);
Assert.Equal(TreeEntryTargetType.Blob, fetched.TargetType);
Assert.Equal(Mode.NonExecutableFile, fetched.Mode);
}
}
public void Vote(Post post, Identity voter, VoteType vote)
{
using (var repo = new Repository(_directory.FullName))
{
var postCommit = repo.Branches[post.Id].Tip;
// Retrieve existing tree
var commitRoot = postCommit.Tree;
var votesDir = (Tree)commitRoot[VOTES_DIR].Target;
var repliesDir = (Tree)commitRoot[REPLIES_DIR].Target;
// Copy existing content to new votes treedef
var newVotesDir = new TreeDefinition();
foreach (TreeEntry obj in votesDir)
{
newVotesDir.Add(obj.Name, obj);
}
// Add new vote to new votes treedef
Vote(repo, newVotesDir, vote);
// Assemble new root treedef
var newPostRoot = new TreeDefinition();
newPostRoot.Add(VOTES_DIR, repo.ObjectDatabase.CreateTree(newVotesDir));
newPostRoot.Add(REPLIES_DIR, repliesDir);
// Commit new root treedef to post branch
var message = string.Format("{0} by {1}", vote, voter.Name);
var sig = new Signature(voter.Name, voter.Identifier, DateTimeOffset.UtcNow);
CommitToBranch(repo, post.Id, message, sig, repo.ObjectDatabase.CreateTree(newPostRoot));
}
}
public void CanReplaceAnExistingTreeWithABlob()
{
const string blobSha = "a8233120f6ad708f843d861ce2b7228ec4e3dec6";
const string targetPath = "1";
using (var repo = new Repository(BareTestRepoPath))
{
TreeDefinition td = TreeDefinition.From(repo.Head.Tip.Tree);
Assert.Equal(TreeEntryTargetType.Tree, td[targetPath].TargetType);
var objectId = new ObjectId(blobSha);
var blob = repo.Lookup <Blob>(objectId);
Assert.NotNull(td["1/branch_file.txt"]);
td.Add(targetPath, blob, Mode.NonExecutableFile);
TreeEntryDefinition fetched = td[targetPath];
Assert.NotNull(fetched);
Assert.Equal(TreeEntryTargetType.Blob, td[targetPath].TargetType);
Assert.Equal(objectId, fetched.TargetId);
Assert.Equal(Mode.NonExecutableFile, fetched.Mode);
Assert.Null(td["1/branch_file.txt"]);
}
}
public void CanReplaceAnExistingGitLinkWithATree()
{
const string treeSha = "607d96653d4d0a4f733107f7890c2e67b55b620d";
const string targetPath = "sm_unchanged";
using (var repo = new Repository(SubmoduleTestRepoWorkingDirPath))
{
TreeDefinition td = TreeDefinition.From(repo.Head.Tip.Tree);
Assert.NotNull(td[targetPath]);
Assert.Equal(TreeEntryTargetType.GitLink, td[targetPath].TargetType);
Assert.Equal(Mode.GitLink, td[targetPath].Mode);
var objectId = new ObjectId(treeSha);
var tree = repo.Lookup <Tree>(objectId);
td.Add(targetPath, tree);
TreeEntryDefinition fetched = td[targetPath];
Assert.NotNull(fetched);
Assert.Equal(objectId, fetched.TargetId);
Assert.Equal(TreeEntryTargetType.Tree, fetched.TargetType);
Assert.Equal(Mode.Directory, fetched.Mode);
}
}
public void CanAddAnExistingSubmodule()
{
const string submodulePath = "sm_unchanged";
using (var repo = new Repository(SubmoduleTestRepoWorkingDirPath))
{
var submodule = repo.Submodules[submodulePath];
Assert.NotNull(submodule);
TreeDefinition td = TreeDefinition.From(repo.Head.Tip.Tree);
Assert.NotNull(td[submodulePath]);
td.Remove(submodulePath);
Assert.Null(td[submodulePath]);
td.Add(submodule);
TreeEntryDefinition fetched = td[submodulePath];
Assert.NotNull(fetched);
Assert.Equal(submodule.HeadCommitId, fetched.TargetId);
Assert.Equal(TreeEntryTargetType.GitLink, fetched.TargetType);
Assert.Equal(Mode.GitLink, fetched.Mode);
}
}
public Task <string> Save(string branch, string message, Document document, Author author)
{
if (string.IsNullOrEmpty(document.Key))
{
_logger.Warn("Could not save document with empty key");
throw new ArgumentException("key cannot be empty");
}
if (isTransactionInProgress(branch))
{
var exceptionMessage = $"There is a transaction in progress for branch {branch}. Complete the transaction first.";
_logger.Warn(exceptionMessage);
throw new ArgumentException(exceptionMessage);
}
var blob = addBlob(document.Value);
lock (getLock(branch))
{
var tree = TreeDefinition.From(_repo.Branches[branch].Tip);
addBlobToTree(document.Key, blob, tree);
var sha = commitTree(branch, tree, getSignature(author), message);
_logger.Trace($"Added {document.Key} on branch {branch} with commit {sha}");
push(branch);
return(Task.FromResult(sha));
}
}
private bool PerformTreeFiltering(SimpleCommit commit, out Tree newTree)
{
newTree = null;
if (hasTreeFiltering)
{
// clear the cache of entries to keep and the tasks to run
entriesToKeep.Clear();
// Process white list
if (keepPathPatterns.Count == 0)
{
KeepAllEntries(commit.Tree);
}
else
{
KeepEntries(commit, commit.Tree);
}
ProcessPendingTasks();
// Process black list
if (removePathPatterns.Count > 0)
{
RemoveEntries(commit);
ProcessPendingTasks();
}
// If the commit was discarded by a tree-filtering, we need to skip it also here
if (commit.Discard || entriesToKeep.Count == 0)
{
commit.Discard = true;
// Store that this commit was discarded (used for re-parenting commits)
commitsDiscarded.Add(commit.Sha);
return(true);
}
// Rebuild a new tree based on the list of entries to keep
var treeDef = new TreeDefinition();
foreach (var entryIt in entriesToKeep)
{
var entry = entryIt.Key;
var entryValue = entryIt.Value;
if (entryValue.Blob != null)
{
treeDef.Add(entry.Path, entryValue.Blob, entryValue.Mode);
}
else
{
treeDef.Add(entry.Path, entry);
}
}
newTree = repo.ObjectDatabase.CreateTree(treeDef);
}
else
{
// If we don't have any tree filtering, just use the original tree
newTree = commit.Tree;
}
return(false);
}
public void Delete(string fileName)
{
var committer = CreateSignature();
Branch branch = _repo.Branches[_branchName];
if (branch == null)
{
return;
}
var commitLog = branch.Commits.Take(1).ToArray();
if (!commitLog.Any())
{
return;
}
var td = TreeDefinition.From(commitLog.First());
td.Remove(fileName);
var tree = _repo.ObjectDatabase.CreateTree(td);
var commit = _repo.ObjectDatabase.CreateCommit(committer, committer, "Deleted " + fileName, tree, commitLog, false);
UpdateRefs(commit);
}
public void CanBuildATreeDefinitionFromATree()
{
using (var repo = new Repository(BareTestRepoPath))
{
TreeDefinition td = TreeDefinition.From(repo.Head.Tip.Tree);
Assert.NotNull(td);
}
}
public void TreeScript()
{
TreeEditDistance treeCorrector = new TreeEditDistance();
TreeDefinition aTree = CreateTreeHelper.MakeTree(new PDLModSetEq(new PDLAllPos(), 3, 2));
TreeDefinition bTree = CreateTreeHelper.MakeTree(new PDLModSetEq(new PDLAllPos(), 4, 2));
Transformation transform = treeCorrector.getTransformation(aTree, bTree);
Console.Write(transform.ToHTMLColoredStringAtoB("red", "blue"));
}
public Task <ITransaction> CreateTransaction(string branch)
{
if (isTransactionInProgress(branch))
{
var exceptionMessage = $"There is a transaction in progress for branch {branch}. Complete the transaction first.";
_logger.Warn(exceptionMessage);
throw new ArgumentException(exceptionMessage);
}
_branchesWithTransaction.Add(branch, DateTime.Now.AddSeconds(_transactionTimeout));
var tree = TreeDefinition.From(_repo.Branches[branch].Tip);
void EnsureTransactionInProgress()
{
if (!_branchesWithTransaction.ContainsKey(branch))
{
var exceptionMessage = $"Transaction does not exist for branch {branch} or has timed out";
_logger.Warn(exceptionMessage);
throw new ArgumentException(exceptionMessage);
}
_branchesWithTransaction[branch] = DateTime.Now.AddSeconds(_transactionTimeout);
}
return(Task.FromResult((ITransaction) new Transaction(
add: document =>
{
EnsureTransactionInProgress();
addBlobToTree(document.Key, addBlob(document.Value), tree);
_logger.Trace($"Added blob with key {document.Key} to transaction on {branch}");
return Task.CompletedTask;
},
commit: (message, author) =>
{
EnsureTransactionInProgress();
lock (getLock(branch))
{
var sha = commitTree(branch, tree, getSignature(author), message);
_branchesWithTransaction.Remove(branch);
_logger.Info($"Commited transaction on {branch} with commit {sha}");
push(branch);
return Task.FromResult(sha);
}
},
abort: () =>
{
_branchesWithTransaction.Remove(branch);
_logger.Info($"Aborted transaction on {branch}");
return Task.CompletedTask;
},
delete: key =>
{
EnsureTransactionInProgress();
deleteKeyFromTree(key, tree);
_logger.Trace($"Removed blob with key {key} in transaction on {branch}");
return Task.CompletedTask;
})));
}
private static string[] DumpTreeStats(TreeDefinition def)
{
var list = new List <string>();
list.Add("");
list.AddRange(ConvertSeasons(def.HarvestSeasons));
list.Add(def.HarvestXp.ToString());
list.AddRange(ConvertMoney(def.HarvestMoney));
return(list.ToArray());
}
public void CanReplaceAnExistingTreeWithAnotherPersitedTree()
{
string path = SandboxBareTestRepo();
using (var repo = new Repository(path))
{
TreeDefinition td = TreeDefinition.From(repo.Head.Tip.Tree);
Assert.Equal(TreeEntryTargetType.Tree, td["1"].TargetType);
TreeDefinition newTd = new TreeDefinition()
.Add("new/one", repo.Lookup<Blob>("a823312"), Mode.NonExecutableFile)
.Add("new/two", repo.Lookup<Blob>("a71586c"), Mode.NonExecutableFile)
.Add("new/tree", repo.Lookup<Tree>("7f76480"));
repo.ObjectDatabase.CreateTree(newTd);
td.Add("1", newTd["new"]);
Assert.Equal(TreeEntryTargetType.Tree, td["1/tree"].TargetType);
}
}
private void CanHandleTwoTreeEntryChangesWithTheSamePath(SimilarityOptions similarity, Action<string, TreeChanges> verifier)
{
string repoPath = InitNewRepository();
using (var repo = new Repository(repoPath))
{
Blob mainContent = OdbHelper.CreateBlob(repo, "awesome content\n" + new string('b', 4096));
Blob linkContent = OdbHelper.CreateBlob(repo, "../../objc/Nu.h");
string path = Path.Combine("include", "Nu", "Nu.h");
var tdOld = new TreeDefinition()
.Add(path, linkContent, Mode.SymbolicLink)
.Add("objc/Nu.h", mainContent, Mode.NonExecutableFile);
Tree treeOld = repo.ObjectDatabase.CreateTree(tdOld);
var tdNew = new TreeDefinition()
.Add(path, mainContent, Mode.NonExecutableFile);
Tree treeNew = repo.ObjectDatabase.CreateTree(tdNew);
using (var changes = repo.Diff.Compare<TreeChanges>(treeOld, treeNew,
compareOptions: new CompareOptions
{
Similarity = similarity,
}))
{
verifier(path, changes);
}
}
}
public void RetrievingDiffChangesMustAlwaysBeCaseSensitive()
{
ObjectId treeOldOid, treeNewOid;
string repoPath = InitNewRepository();
using (var repo = new Repository(repoPath))
{
Blob oldContent = OdbHelper.CreateBlob(repo, "awesome content\n");
Blob newContent = OdbHelper.CreateBlob(repo, "more awesome content\n");
var td = new TreeDefinition()
.Add("A.TXT", oldContent, Mode.NonExecutableFile)
.Add("a.txt", oldContent, Mode.NonExecutableFile);
treeOldOid = repo.ObjectDatabase.CreateTree(td).Id;
td = new TreeDefinition()
.Add("A.TXT", newContent, Mode.NonExecutableFile)
.Add("a.txt", newContent, Mode.NonExecutableFile);
treeNewOid = repo.ObjectDatabase.CreateTree(td).Id;
}
using (var repo = new Repository(repoPath))
{
using (var changes = repo.Diff.Compare<TreeChanges>(repo.Lookup<Tree>(treeOldOid), repo.Lookup<Tree>(treeNewOid)))
{
Assert.Equal(ChangeKind.Modified, changes.Single(c => c.Path == "a.txt").Status);
Assert.Equal(ChangeKind.Modified, changes.Single(c => c.Path == "A.TXT").Status);
}
}
}
public void CanCreateAnEmptyTree()
{
string path = CloneBareTestRepo();
using (var repo = new Repository(path))
{
var td = new TreeDefinition();
Tree tree = repo.ObjectDatabase.CreateTree(td);
Assert.NotNull(tree);
Assert.Equal("4b825dc642cb6eb9a060e54bf8d69288fbee4904", tree.Sha);
}
}
/// <summary>
/// Adds a commit to the object database. The tree will have a single text file with the given specific content
/// at the beginning of the file and the given common content at the end of the file.
/// </summary>
/// <param name="repo">The repository.</param>
/// <param name="message">The commit message.</param>
/// <param name="path">The file's path.</param>
/// <param name="specificContent">The content specific to that file.</param>
/// <param name="commonContent">The content shared with other files.</param>
/// <param name="parents">The commit's parents.</param>
/// <returns>The commit added to the object database.</returns>
private Commit AddCommitToOdb(Repository repo, string message, string path, string specificContent,
string commonContent, params Commit[] parents)
{
var content = string.IsNullOrEmpty(commonContent)
? specificContent
: specificContent + Environment.NewLine + commonContent + Environment.NewLine;
var td = new TreeDefinition();
td.Add(path, OdbHelper.CreateBlob(repo, content), Mode.NonExecutableFile);
var t = repo.ObjectDatabase.CreateTree(td);
var commitSignature = GetNextSignature();
return repo.ObjectDatabase.CreateCommit(commitSignature, commitSignature, message, t, parents, true);
}
public void CanReplaceAnExistingTreeWithAnotherPersitedTree()
{
TemporaryCloneOfTestRepo scd = BuildTemporaryCloneOfTestRepo();
using (var repo = new Repository(scd.RepositoryPath))
{
TreeDefinition td = TreeDefinition.From(repo.Head.Tip.Tree);
Assert.Equal(GitObjectType.Tree, td["1"].Type);
TreeDefinition newTd = new TreeDefinition()
.Add("new/one", repo.Lookup<Blob>("a823312"), Mode.NonExecutableFile)
.Add("new/two", repo.Lookup<Blob>("a71586c"), Mode.NonExecutableFile)
.Add("new/tree", repo.Lookup<Tree>("7f76480"));
repo.ObjectDatabase.CreateTree(newTd);
td.Add("1", newTd["new"]);
Assert.Equal(GitObjectType.Tree, td["1/tree"].Type);
}
}
public void CannotCreateATreeContainingABlobFromARelativePathAgainstABareRepository()
{
using (var repo = new Repository(BareTestRepoPath))
{
var td = new TreeDefinition()
.Add("1/new file", "hello.txt", Mode.NonExecutableFile);
Assert.Throws<InvalidOperationException>(() => repo.ObjectDatabase.CreateTree(td));
}
}
public void CanCreateAnEmptyTree()
{
TemporaryCloneOfTestRepo scd = BuildTemporaryCloneOfTestRepo();
using (var repo = new Repository(scd.RepositoryPath))
{
var td = new TreeDefinition();
Tree tree = repo.ObjectDatabase.CreateTree(td);
Assert.NotNull(tree);
Assert.Equal("4b825dc642cb6eb9a060e54bf8d69288fbee4904", tree.Sha);
}
}
public void CanHandleTwoTreeEntryChangesWithTheSamePath()
{
string repoPath = InitNewRepository();
using (var repo = new Repository(repoPath))
{
Blob mainContent = OdbHelper.CreateBlob(repo, "awesome content\n");
Blob linkContent = OdbHelper.CreateBlob(repo, "../../objc/Nu.h");
string path = string.Format("include{0}Nu{0}Nu.h", Path.DirectorySeparatorChar);
var tdOld = new TreeDefinition()
.Add(path, linkContent, Mode.SymbolicLink)
.Add("objc/Nu.h", mainContent, Mode.NonExecutableFile);
Tree treeOld = repo.ObjectDatabase.CreateTree(tdOld);
var tdNew = new TreeDefinition()
.Add(path, mainContent, Mode.NonExecutableFile);
Tree treeNew = repo.ObjectDatabase.CreateTree(tdNew);
var changes = repo.Diff.Compare<TreeChanges>(treeOld, treeNew);
/*
* $ git diff-tree -p 5c87b67 d5278d0
* diff --git a/include/Nu/Nu.h b/include/Nu/Nu.h
* deleted file mode 120000
* index 19bf568..0000000
* --- a/include/Nu/Nu.h
* +++ /dev/null
* @@ -1 +0,0 @@
* -../../objc/Nu.h
* \ No newline at end of file
* diff --git a/include/Nu/Nu.h b/include/Nu/Nu.h
* new file mode 100644
* index 0000000..f9e6561
* --- /dev/null
* +++ b/include/Nu/Nu.h
* @@ -0,0 +1 @@
* +awesome content
* diff --git a/objc/Nu.h b/objc/Nu.h
* deleted file mode 100644
* index f9e6561..0000000
* --- a/objc/Nu.h
* +++ /dev/null
* @@ -1 +0,0 @@
* -awesome content
*/
Assert.Equal(1, changes.Deleted.Count());
Assert.Equal(0, changes.Modified.Count());
Assert.Equal(1, changes.TypeChanged.Count());
TreeEntryChanges change = changes[path];
Assert.Equal(Mode.SymbolicLink, change.OldMode);
Assert.Equal(Mode.NonExecutableFile, change.Mode);
Assert.Equal(ChangeKind.TypeChanged, change.Status);
Assert.Equal(path, change.Path);
}
}
public void RetrievingDiffChangesMustAlwaysBeCaseSensitive()
{
SelfCleaningDirectory scd = BuildSelfCleaningDirectory();
ObjectId treeOldOid, treeNewOid;
using (Repository repo = Repository.Init(scd.DirectoryPath))
{
Blob oldContent = OdbHelper.CreateBlob(repo, "awesome content\n");
Blob newContent = OdbHelper.CreateBlob(repo, "more awesome content\n");
var td = new TreeDefinition()
.Add("A.TXT", oldContent, Mode.NonExecutableFile)
.Add("a.txt", oldContent, Mode.NonExecutableFile);
treeOldOid = repo.ObjectDatabase.CreateTree(td).Id;
td = new TreeDefinition()
.Add("A.TXT", newContent, Mode.NonExecutableFile)
.Add("a.txt", newContent, Mode.NonExecutableFile);
treeNewOid = repo.ObjectDatabase.CreateTree(td).Id;
}
using (var repo = new Repository(scd.DirectoryPath))
{
var changes = repo.Diff.Compare(repo.Lookup<Tree>(treeOldOid), repo.Lookup<Tree>(treeNewOid));
Assert.Equal(ChangeKind.Modified, changes["a.txt"].Status);
Assert.Equal(ChangeKind.Modified, changes["A.TXT"].Status);
}
}
