//资源树左击事件 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); } }