public static ReleaseDate Execute(IRepository repo, string commitSha, int calculatedPatch) { var c = repo.Lookup<Commit>(commitSha); Debug.Assert(c != null); var rd = new ReleaseDate { OriginalDate = c.When(), OriginalCommitSha = c.Sha, Date = c.When(), CommitSha = c.Sha, }; if (GitVersionFinder.ShouldGitHubFlowVersioningSchemeApply(repo)) { return rd; } if (calculatedPatch == 0) { return rd; } var vp = new VersionOnMasterFinder().FindLatestStableTaggedCommitReachableFrom(repo, c); var latestStable = repo.Lookup<Commit>(vp.CommitSha); Debug.Assert(latestStable != null); rd.OriginalDate = latestStable.When(); rd.OriginalCommitSha = vp.CommitSha; return rd; }
private static Patch DiffCommit(IRepository repo, ObjectId oldId, ObjectId newId) { var commitLeft = repo.Lookup <Commit>(oldId); var commitRight = repo.Lookup <Commit>(newId); Console.WriteLine($"正在比对差异 [old]{commitLeft.Message} - [new]{commitRight.Message}"); var patch = repo.Diff.Compare <Patch>(commitLeft.Tree, commitRight.Tree); return(patch); }
/// <summary> /// Try to lookup an object by its <see cref="ObjectId"/>. /// </summary> /// <typeparam name="T">The kind of <see cref="GitObject"/> to lookup.</typeparam> /// <param name="repository">The <see cref="Repository"/> being looked up.</param> /// <param name="id">The id.</param> /// <returns>The retrieved <see cref="GitObject"/>, or <c>null</c> if none was found.</returns> public static T Lookup <T>(this IRepository repository, ObjectId id) where T : GitObject { EnsureNoGitLink <T>(); if (typeof(T) == typeof(GitObject)) { return((T)repository.Lookup(id)); } return((T)repository.Lookup(id, GitObject.TypeToKindMap[typeof(T)])); }
private Task Diff(string filePath) { // TODO: throw? warn? if (string.IsNullOrEmpty(diffTool.Cmd)) { return(Task.CompletedTask); } var changes = repository.Diff.Compare <TreeChanges>().Modified.First(x => x.Path == filePath); var old = repository.Lookup <Blob>(changes.OldOid); // We can't show diff in this case if (changes.Mode != Mode.NonExecutableFile || !changes.Exists || old == null || old.IsBinary) { return(Task.CompletedTask); } // Write the old content to a temp file for comparison. var baseFile = Path.Combine(Path.GetTempPath(), Path.ChangeExtension(Path.GetFileName(filePath), ".BASE" + Path.GetExtension(filePath))); File.WriteAllText(baseFile, old.GetContentText()); #pragma warning disable CS8602 // Dereference of a possibly null reference. var indexOfDolar = diffTool.Cmd.IndexOf("$"); if (indexOfDolar == -1) { // TODO: There were no replacements, so we can't diff anything. Report warning/error? return(Task.CompletedTask); } var indexOfArgs = diffTool.Cmd.Substring(0, indexOfDolar).LastIndexOf(' '); var toolFilePath = diffTool.Cmd.Substring(0, indexOfArgs).Trim(); var fullFilePath = repository.GetFullPath(filePath); // Replace arguments as documented in https://git-scm.com/docs/git-difftool#_options var arguments = diffTool.Cmd.Substring(indexOfArgs) // "$LOCAL is set to the name of the temporary file containing the contents of the diff pre-image" .Replace("$LOCAL", baseFile) // "$REMOTE is set to the name of the temporary file containing the contents of the diff post-image" // We want the current file to be the one including the "changes post-image". .Replace("$REMOTE", fullFilePath) // Yes, it's confusing even in the docs that $BASE == $MERGED. // "$MERGED is the name of the file which is being compared. .Replace("$MERGED", fullFilePath) // "$BASE is provided for compatibility with custom merge tool commands and has the same value as $MERGED." .Replace("$BASE", fullFilePath); #pragma warning restore CS8602 // Dereference of a possibly null reference. RunTool(toolFilePath, arguments); return(Task.CompletedTask); }
static string GetMergeBase(IRepository repo, string a, string b) { var aCommit = repo.Lookup <Commit>(a); var bCommit = repo.Lookup <Commit>(b); if (aCommit == null || bCommit == null) { return(null); } var baseCommit = repo.ObjectDatabase.FindMergeBase(aCommit, bCommit); return(baseCommit?.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); }
public Task <byte[]> ExtractFileBinary(IRepository repository, string commitSha, string fileName) { Guard.ArgumentNotNull(repository, nameof(repository)); Guard.ArgumentNotEmptyString(commitSha, nameof(commitSha)); Guard.ArgumentNotEmptyString(fileName, nameof(fileName)); return(Task.Factory.StartNew(() => { var commit = repository.Lookup <Commit>(commitSha); if (commit == null) { throw new FileNotFoundException("Couldn't find '" + fileName + "' at commit " + commitSha + "."); } var blob = commit[fileName]?.Target as Blob; if (blob != null) { using (var m = new MemoryStream()) { var content = blob.GetContentStream(); content.CopyTo(m); return m.ToArray(); } } return null; })); }
public async Task <IEnumerable <ObjectInventoryItem> > Lookup(ObjectInventoryLookup lookup) { var defaultDate = new DateTime(2008, 5, 1, 8, 30, 52); var result = new List <ObjectInventoryItem>(); var game = (await gameRepository.Lookup(lookup.gameLookup)).FirstOrDefault(); if (game != null && game.Id == 1324) //stella/bf2142 { if (lookup.DomainId.CompareTo("eagames") == 0 && lookup.SubdomainId.CompareTo("bf2142") == 0 && lookup.PartitionKey.CompareTo("online_content") == 0 && lookup.ObjectIds.Contains("bf2142_bp1")) { var entry = new ObjectInventoryItem { ObjectId = "bf2142_bp1", EditionNo = 0, DateEntitled = defaultDate, EntitleId = 114793868, UseCount = 0 }; result.Add(entry); entry = new ObjectInventoryItem { ObjectId = "bf2142_bp1", EditionNo = 0, DateEntitled = defaultDate, EntitleId = 245445381, UseCount = 0 }; result.Add(entry); } } return((IEnumerable <ObjectInventoryItem>)result); }
public async Task <string> ExtractFile(IRepository repository, string commitSha, string fileName) { var commit = repository.Lookup <Commit>(commitSha); var blob = commit[fileName]?.Target as Blob; var tempDir = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString()); var tempFileName = $"{Path.GetFileNameWithoutExtension(fileName)}@{commitSha}{Path.GetExtension(fileName)}"; var tempFile = Path.Combine(tempDir, tempFileName); Directory.CreateDirectory(tempDir); if (blob != null) { using (var source = blob.GetContentStream(new FilteringOptions(fileName))) using (var destination = File.OpenWrite(tempFile)) { await source.CopyToAsync(destination); } } else { File.Create(tempFile).Dispose(); } return(tempFile); }
internal static ObjectRepositoryAdd ComputeChanges_Added(IObjectRepository objectRepository, IObjectRepositorySerializer serializer, IRepository repository, PatchEntryChanges change, Func <string, string> relativeFileDataResolver) { // Only data file changes have to be taken into account // Changes made to the blobs will product a 'modified' change as well if (System.IO.Path.GetFileName(change.Path) != FileSystemStorage.DataFile) { return(null); } if (objectRepository.TryGetFromGitPath(change.Path) != null) { throw new NotImplementedException("Node already present in current state."); } var parentDataPath = change.Path.GetDataParentDataPath(); if (objectRepository.TryGetFromGitPath(parentDataPath) == null) { throw new NotImplementedException("Node addition while parent has been deleted in head is not supported."); } var @new = serializer.Deserialize(repository.Lookup <Blob>(change.Oid).GetContentStream(), relativeFileDataResolver); var parentId = change.Path.GetDataParentId(objectRepository); return(new ObjectRepositoryAdd(change.Path, @new, parentId)); }
private static void AssertNormalization(IRepository repo, string filename, bool shouldHaveBeenNormalized, string expectedSha) { var sb = new StringBuilder(); sb.Append("I'm going to be dynamically processed\r\n"); sb.Append("And my line endings...\r\n"); sb.Append("...are going to be\n"); sb.Append("normalized!\r\n"); Touch(repo.Info.WorkingDirectory, filename, sb.ToString()); repo.Stage(filename); IndexEntry entry = repo.Index[filename]; Assert.NotNull(entry); Assert.Equal(expectedSha, entry.Id.Sha); var blob = repo.Lookup <Blob>(entry.Id); Assert.NotNull(blob); Assert.Equal(!shouldHaveBeenNormalized, blob.GetContentText().Contains("\r")); }
public CommitDetail GetCommitDetails(string sha) { if (string.IsNullOrEmpty(sha)) { throw new ArgumentNullException(); } var commit = _repository.Lookup <LibGit2Sharp.Commit>(sha); if (commit == null) { throw new CommitNotFoundException(sha); } var commitParent = commit.Parents.Last(); TreeChanges treeChanges = _repository.Diff.Compare <TreeChanges>(commitParent.Tree, commit.Tree); CommitDetail commitDetail = new CommitDetail(sha, commit.Message, commit.Author.Name, commit.Author.When.Date); commitDetail.Files.AddRange(treeChanges.Select(s => new CommitFile((int)s.Status, s.Path, Path.GetFileName(s.Path)))); //commitDetail.Files.AddRange(treeChanges.Modified.Select(s => new CommitFile((int)s.Status, s.Path, Path.GetFileName(s.Path)))); //commitDetail.Files.AddRange(treeChanges.Deleted.Select(s => new CommitFile((int)s.Status, s.Path, Path.GetFileName(s.Path)))); return(commitDetail); }
public async Task <IEnumerable <Session> > Lookup(SessionLookup lookup) { var db = sessionCache.GetDatabase(); var result = db.HashGet(lookup.sessionKey.ToString(), "guid"); var ret = new List <Session>(); if (!result.HasValue) { return(ret); } var session = new Session(); session.sessionKey = result.ToString(); var profileId = db.HashGet(lookup.sessionKey.ToString(), "profileid"); var userId = db.HashGet(lookup.sessionKey.ToString(), "userid"); var profileLookup = new ProfileLookup(); profileLookup.id = int.Parse(profileId.ToString()); session.profile = (await profileRepository.Lookup(profileLookup)).FirstOrDefault(); var userLookup = new UserLookup(); userLookup.id = int.Parse(userId.ToString()); session.user = (await userRepository.Lookup(userLookup)).FirstOrDefault(); session.appName = db.HashGet(lookup.sessionKey.ToString(), "appName"); ret.Add(session); return(ret); }
private static Commit LookUpCommit(IRepository repository, string committish) { GitObject obj = repository.Lookup(committish); Ensure.GitObjectIsNotNull(obj, committish); return(obj.DereferenceToCommit(true)); }
public Task <byte[]> ExtractFileBinary(IRepository repository, string commitSha, string relativePath) { Guard.ArgumentNotNull(repository, nameof(repository)); Guard.ArgumentNotEmptyString(commitSha, nameof(commitSha)); Guard.ArgumentIsRelativePath(relativePath, nameof(relativePath)); var gitPath = Paths.ToGitPath(relativePath); return(Task.Run(() => { var commit = repository.Lookup <Commit>(commitSha); if (commit == null) { throw new FileNotFoundException("Couldn't find '" + gitPath + "' at commit " + commitSha + "."); } var blob = commit[gitPath]?.Target as Blob; if (blob != null) { using (var m = new MemoryStream()) { var content = blob.GetContentStream(); content.CopyTo(m); return m.ToArray(); } } return null; })); }
/// <summary> /// Inserts a <see cref="LibGit2Sharp.Commit" /> into the object database by applying a <see cref="TreeDefinition"/>. /// </summary> /// <param name="repository">The repository.</param> /// <param name="changes">The changes.</param> /// <param name="message">The message.</param> /// <param name="author">The author.</param> /// <param name="committer">The committer.</param> /// <param name="hooks">The hooks.</param> /// <param name="options">The options.</param> /// <param name="mergeParent">The parent commit for a merge.</param> /// <returns>The created <see cref="LibGit2Sharp.Commit" />.</returns> internal static Commit CommitChanges(this IRepository repository, MetadataTreeChanges changes, string message, Signature author, Signature committer, GitHooks hooks, CommitOptions options = null, Commit mergeParent = null) { TreeDefinition definition; if (changes.OldRepository?.CommitId != null) { if (repository.Head.Tip.Id != changes.OldRepository.CommitId) { throw new NotSupportedException("Changes are not based on the HEAD commit."); } var startCommit = repository.Lookup <Commit>(changes.OldRepository.CommitId); definition = TreeDefinition.From(startCommit); } else if (repository.Info.IsHeadUnborn) { definition = new TreeDefinition(); } else { throw new NotSupportedException("Changes are not based on the HEAD commit."); } if (!hooks.OnCommitStarted(changes, message)) { return(null); } changes.UpdateTreeDefinition(repository, definition); var result = Commit(repository, definition, message, author, committer, options, mergeParent); hooks.OnCommitCompleted(changes, message, result.Id); return(result); }
public async Task <string> GetPullRequestMergeBase(IRepository repo, UriString targetCloneUrl, string baseSha, string headSha, string baseRef, int pullNumber) { Guard.ArgumentNotNull(repo, nameof(repo)); Guard.ArgumentNotNull(targetCloneUrl, nameof(targetCloneUrl)); Guard.ArgumentNotEmptyString(baseRef, nameof(baseRef)); var headCommit = repo.Lookup <Commit>(headSha); if (headCommit == null) { // The PR base branch might no longer exist, so we fetch using `refs/pull/<PR>/head` first. // This will often fetch the base commits, even when the base branch no longer exists. var headRef = $"refs/pull/{pullNumber}/head"; await Fetch(repo, targetCloneUrl, headRef); headCommit = repo.Lookup <Commit>(headSha); if (headCommit == null) { throw new NotFoundException($"Couldn't find {headSha} after fetching from {targetCloneUrl}:{headRef}."); } } var baseCommit = repo.Lookup <Commit>(baseSha); if (baseCommit == null) { await Fetch(repo, targetCloneUrl, baseRef); baseCommit = repo.Lookup <Commit>(baseSha); if (baseCommit == null) { throw new NotFoundException($"Couldn't find {baseSha} after fetching from {targetCloneUrl}:{baseRef}."); } } var mergeBaseCommit = repo.ObjectDatabase.FindMergeBase(baseCommit, headCommit); if (mergeBaseCommit == null) { throw new NotFoundException($"Couldn't find merge base between {baseCommit} and {headCommit}."); } return(mergeBaseCommit.Sha); }
public async Task <Session> GetSession([FromBody] AuthRequest request) { var lookup = new SessionLookup(); lookup.sessionKey = request.password; var session = (await sessionRepository.Lookup(lookup)).FirstOrDefault(); return(session); }
public async Task <AuthResponse> ProfileIDAuth([FromBody] AuthRequest request) { var sesskey = gs_sesskey(request.session_key); var profile = (await profileRepository.Lookup(request.profileLookup)).FirstOrDefault(); if (profile == null) { throw new NoSuchUserException(); } var userLookup = new UserLookup(); userLookup.id = profile.Userid; var user = (await userRepository.Lookup(userLookup)).FirstOrDefault(); if (user == null) { throw new NoSuchUserException(); } StringBuilder sb = new StringBuilder(); sb.Append(user.Password); sb.Append(sesskey); String md5String; using (MD5 md5Hash = MD5.Create()) { StringBuilder sBuilder = new StringBuilder(); byte[] data = md5Hash.ComputeHash(Encoding.UTF8.GetBytes(sb.ToString())); for (int i = 0; i < data.Length; i++) { sBuilder.Append(data[i].ToString("x2")); } md5String = sBuilder.ToString().ToLower(); } if (md5String.Equals(request.client_response.ToLower())) { var resp = new AuthResponse(); resp.profile = profile; resp.user = user; return(resp); } throw new AuthInvalidCredentialsException(); }
public async Task <string> GetPullRequestMergeBase(IRepository repo, UriString baseCloneUrl, UriString headCloneUrl, string baseSha, string headSha, string baseRef, string headRef) { Guard.ArgumentNotNull(repo, nameof(repo)); Guard.ArgumentNotNull(baseCloneUrl, nameof(baseCloneUrl)); Guard.ArgumentNotNull(headCloneUrl, nameof(headCloneUrl)); Guard.ArgumentNotEmptyString(baseRef, nameof(baseRef)); var baseCommit = repo.Lookup <Commit>(baseSha); if (baseCommit == null) { await Fetch(repo, baseCloneUrl, baseRef); baseCommit = repo.Lookup <Commit>(baseSha); if (baseCommit == null) { return(null); } } var headCommit = repo.Lookup <Commit>(headSha); if (headCommit == null) { await Fetch(repo, headCloneUrl, headRef); headCommit = repo.Lookup <Commit>(headSha); if (headCommit == null) { return(null); } } var mergeBaseCommit = repo.ObjectDatabase.FindMergeBase(baseCommit, headCommit); if (mergeBaseCommit == null) { return(null); } return(mergeBaseCommit.Sha); }
private async Task <IEnumerable <Commit> > Map(string sha) { if (!commitMap.ContainsKey(sha)) { // Not in the set to rewrite (that were preloaded) return(new[] { repo.Lookup <Commit>(sha) }); } // Wait for it to be rewritten var rewritten = await rewrittenMap[sha]; if (rewritten != null) { return(new[] { rewritten }); } // It was dropped, so it "becomes" its (rewritten) parents return((await commitMap[sha].ConfigureAwait(false)).Parents); }
public async Task PutBlock([FromBody] BuddyLookup lookupData) { var from_profile = (await profileRepository.Lookup(lookupData.SourceProfile)).First(); var to_profile = (await profileRepository.Lookup(lookupData.TargetProfile)).First(); Block block = new Block(); block.FromProfileid = from_profile.Id; block.ToProfileid = to_profile.Id; await blockRepository.Create(block); blockRepository.SendAddEvent(from_profile, to_profile); }
public async Task <string> GetPullRequestMergeBase(IRepository repo, UriString baseCloneUrl, UriString headCloneUrl, string baseSha, string headSha, string baseRef, string headRef) { Guard.ArgumentNotNull(repo, nameof(repo)); Guard.ArgumentNotNull(baseCloneUrl, nameof(baseCloneUrl)); Guard.ArgumentNotNull(headCloneUrl, nameof(headCloneUrl)); Guard.ArgumentNotEmptyString(baseRef, nameof(baseRef)); var baseCommit = repo.Lookup <Commit>(baseSha); if (baseCommit == null) { await Fetch(repo, baseCloneUrl, baseRef); baseCommit = repo.Lookup <Commit>(baseSha); if (baseCommit == null) { throw new NotFoundException($"Couldn't find {baseSha} after fetching from {baseCloneUrl}:{baseRef}."); } } var headCommit = repo.Lookup <Commit>(headSha); if (headCommit == null) { await Fetch(repo, headCloneUrl, headRef); headCommit = repo.Lookup <Commit>(headSha); if (headCommit == null) { throw new NotFoundException($"Couldn't find {headSha} after fetching from {headCloneUrl}:{headRef}."); } } var mergeBaseCommit = repo.ObjectDatabase.FindMergeBase(baseCommit, headCommit); if (mergeBaseCommit == null) { throw new NotFoundException($"Couldn't find merge base between {baseCommit} and {headCommit}."); } return(mergeBaseCommit.Sha); }
/// <remarks> /// While we could easily grab the date while grabbing the interpolated commits, /// it would combine two concerns -- e.g. InterpolatedOutDates needs to interpolate also /// but does NOT need to know when the commits went in. /// /// As such, we instead encourage someone with that performance optimization need to /// make an IRepository that keeps a list of recently accessed Commits by hash in order /// to optimize Lookup{Commit} calls. /// </remarks> public static IEnumerable <(GitCommitHash changeHash, DateTimeOffset inDate)> GetInDates( IEnumerable <GitCommitHash> changes, IRepository repository) { foreach (var commit in changes) { var c = repository.Lookup <Commit>((string)commit); yield return(changeHash : (GitCommitHash)c.Sha, inDate : c.Committer.When); } }
Blob GetBlob(string path, string id) { string sha; if (!commitAliases.TryGetValue(id, out sha)) { sha = id; } var commit = repository.Lookup <Commit>(sha); return(commit?[path]?.Target as Blob); }
public async Task <CDKeySuccessResponse> AssociateCDKeyToProfile([FromBody] CDKeyAssociateRequest request) { var profile = (await profileRepository.Lookup(request.profileLookup)).FirstOrDefault(); if (profile == null) { throw new NoSuchUserException(); } var game = (await gameRepository.Lookup(request.gameLookup)).FirstOrDefault(); if (game == null) { throw new ArgumentException(); } var profileCdKeyLookup = new CdKeyLookup(); profileCdKeyLookup.Gameid = game.Id; profileCdKeyLookup.profileLookup = request.profileLookup; var cdKeyData = await cdkeyRepository.LookupCDKeyFromProfile(profileCdKeyLookup); if (cdKeyData != null) { throw new CdKeyAlreadySetException(); } var cdkeyLookup = new CdKeyLookup(); cdkeyLookup.Cdkey = request.cdkey; cdkeyLookup.Gameid = game.Id; var resp = new CDKeySuccessResponse(); resp.success = await cdkeyRepository.AssociateCDKeyToProfile(cdkeyLookup, profile); return(resp); }
private Commit ResolveRequiredMigrator(IRepository repository, Commit branchTip, IImmutableList <Migrator> migrators) { RequiredMigrator = migrators.Count > 0 ? migrators[0] : null; if (RequiredMigrator != null && RequiredMigrator.CommitId != MergeCommitId) { IsPartialMerge = true; branchTip = repository.Lookup <Commit>(RequiredMigrator.CommitId); MergeCommitId = RequiredMigrator.CommitId; } return(branchTip); }
Commit ResolveRequiredMigrator(IRepository repository, Commit branchTip, System.Collections.Immutable.IImmutableList <Migrator> migrators) { RequiredMigrator = migrators.Count > 0 ? migrators[0] : null; if (RequiredMigrator != null && RequiredMigrator.CommitId != BranchTarget) { IsPartialMerge = true; branchTip = repository.Lookup <Commit>(RequiredMigrator.CommitId); BranchTarget = RequiredMigrator.CommitId; } return(branchTip); }
private async Task <BsonDocument> getMatchFromLookupRequest(LeaderboardLookup lookup) { var matchItems = new BsonDocument { }; if (lookup.objectId != null) { matchItems["_id"] = new BsonObjectId(new ObjectId(lookup.objectId)); } else { var game = (await gameRepository.Lookup(lookup.gameLookup)).FirstOrDefault(); matchItems["gameid"] = game.Id; if (lookup.baseKey != null) { matchItems["baseKey"] = lookup.baseKey; } } return(new BsonDocument("$match", matchItems)); }
public async Task <IEnumerable <PersistData> > Lookup(PersistDataLookup lookup) { var game = (await gameRepository.Lookup(lookup.gameLookup)).FirstOrDefault(); var profile = (await profileRepository.Lookup(lookup.profileLookup)).FirstOrDefault(); var query = gameTrackerDb.PersistData as IQueryable <PersistData>; query = query.Where(s => s.Profileid == profile.Id && s.Gameid == game.Id && s.DataIndex == lookup.DataIndex && s.PersistType == lookup.PersistType); if (lookup.modifiedSince.HasValue) { query = query.Where(s => s.Modified >= lookup.modifiedSince.Value); } return(await query.ToListAsync()); }
internal DirectReference(string canonicalName, IRepository repo, ObjectId targetId) : base(repo, canonicalName, targetId.Sha) { targetBuilder = new Lazy <GitObject>(() => { if (repo == null) { throw new InvalidOperationException("Target requires a local repository"); } return(repo.Lookup(targetId)); }); }
internal DirectReference(string canonicalName, IRepository repo, ObjectId targetId) : base(repo, canonicalName, targetId.Sha) { targetBuilder = new Lazy<GitObject>(() => { if (repo == null) { throw new InvalidOperationException("Target requires a local repository"); } return repo.Lookup(targetId); }); }
private static void AssertNormalization(IRepository repo, string filename, bool shouldHaveBeenNormalized, string expectedSha) { var sb = new StringBuilder(); sb.Append("I'm going to be dynamically processed\r\n"); sb.Append("And my line endings...\r\n"); sb.Append("...are going to be\n"); sb.Append("normalized!\r\n"); Touch(repo.Info.WorkingDirectory, filename, sb.ToString()); repo.Index.Stage(filename); IndexEntry entry = repo.Index[filename]; Assert.NotNull(entry); Assert.Equal(expectedSha, entry.Id.Sha); var blob = repo.Lookup<Blob>(entry.Id); Assert.NotNull(blob); Assert.Equal(!shouldHaveBeenNormalized, blob.GetContentText().Contains("\r")); }
internal DirectReference(string canonicalName, IRepository repo, ObjectId targetId) : base(canonicalName, targetId.Sha) { targetBuilder = new Lazy<GitObject>(() => repo.Lookup(targetId)); }