public Lookup ( ObjectId id, GitObjectType type = GitObjectType.Any ) : GitObject | ||
id | ObjectId | The id to lookup. |
type | GitObjectType | The kind of GitObject being looked up |
return | GitObject |
static void Main(string[] args) { Setup(); using (var repo = new Repository(Environment.CurrentDirectory)) { if (repo.Index.Conflicts.Any()) Console.WriteLine("Found UASSET conflicts. Building folder for diff"); foreach (var conflict in repo.Index.Conflicts.Where(x => x.Ours.Path.EndsWith(".uasset"))) { Console.WriteLine("Setting up diff files for " + conflict.Ours.Path); var a = repo.Lookup<Blob>(conflict.Ours.Id); var b = repo.Lookup<Blob>(conflict.Theirs.Id); using (FileStream fileStream = File.Create(Path.Combine(tempDir, Path.GetFileNameWithoutExtension(conflict.Ours.Path) + "_a" + Path.GetExtension(conflict.Ours.Path)))) { a.GetContentStream().CopyTo(fileStream); } using (FileStream fileStream = File.Create(Path.Combine(tempDir, Path.GetFileNameWithoutExtension(conflict.Theirs.Path) + "_b" + Path.GetExtension(conflict.Theirs.Path)))) { b.GetContentStream().CopyTo(fileStream); } } } Console.WriteLine(); Console.WriteLine(File.ReadAllText(Path.Combine(Path.GetDirectoryName(System.Reflection.Assembly.GetEntryAssembly().Location), "helpfiles", "diffsetupcomplete.txt"))); }
/// <summary> /// Calculates the version number of a specific commit in the git repository /// </summary> public SemanticVersion GetVersion(string sha) { Commit commit = repo.Lookup <Commit>(sha); if (commit == null) { throw new ArgumentException($"The commit with reference {sha} does not exist in the repository."); } return(GetVersion(commit)); }
public void GetCommitChangesAddedRemoved() { var commit = "9ed729ee"; var com = repo.Lookup <Commit> (commit); var changes = GitUtil.CompareCommits(repo, com.Parents.First(), com).ToArray(); var add = changes.First(c => c.Path.EndsWith("DocumentLine.cs", StringComparison.Ordinal)); var remove = changes.First(c => c.OldPath.EndsWith("LineSegment.cs", StringComparison.Ordinal)); Assert.AreEqual(ChangeKind.Renamed, add.Status, "#1"); Assert.AreEqual("main/src/core/Mono.Texteditor/Mono.TextEditor/Document/LineSegment.cs".Replace('/', Path.DirectorySeparatorChar), add.OldPath, "#2"); Assert.AreEqual(ChangeKind.Renamed, remove.Status, "#3"); Assert.AreEqual("main/src/core/Mono.Texteditor/Mono.TextEditor/Document/DocumentLine.cs".Replace('/', Path.DirectorySeparatorChar), remove.Path, "#4"); }
public void sha1_of_trees_rocks() { var first = TestHelper.TestGitRepository.Commits.First( sc => sc.Message.StartsWith( "First in parallel world." ) ); var modified = TestHelper.TestGitRepository.Commits.First( sc => sc.Message.StartsWith( "Change in parallel-world.txt content (1)." ) ); var reset = TestHelper.TestGitRepository.Commits.First( sc => sc.Message.StartsWith( "Reset change in parallel-world.txt content (2)." ) ); using( var r = new Repository( TestHelper.TestGitRepositoryFolder ) ) { var cFirst = r.Lookup<Commit>( first.Sha ); var cModified = r.Lookup<Commit>( modified.Sha ); var cReset = r.Lookup<Commit>( reset.Sha ); Assert.That( cFirst.Tree.Sha, Is.Not.EqualTo( cModified.Tree.Sha ) ); Assert.That( cReset.Tree.Sha, Is.Not.EqualTo( cModified.Tree.Sha ) ); Assert.That( cFirst.Tree.Sha, Is.EqualTo( cReset.Tree.Sha ) ); } }
public BranchWrapper(Repository repo, Branch branch) { this.repo = repo; this.branch = branch; IsRemote = branch.IsRemote; if (branch.TrackedBranch != null) { TrackedBranch = new BranchWrapper(repo, branch.TrackedBranch); } IsTracking = branch.IsTracking; TrackingDetails = (Func<object, Task<object>>)(async (j) => { return branch.TrackingDetails; }); IsCurrentRepositoryHead = (Func<object, Task<object>>)(async (j) => { return branch.IsCurrentRepositoryHead; }); Tip = async (j) => { return new CommitWrapper(branch.Tip); }; UpstreamBranchCanonicalName = (Func<object, Task<object>>)(async (j) => { return branch.UpstreamBranchCanonicalName; }); Remote = branch.Remote; CanonicalName = branch.CanonicalName; Commits = (Func<object, Task<object>>)(async (j) => { if (j != null) { Commit after = repo.Lookup<Commit>((string)j); Commit until = branch.Tip; Commit ancestor = repo.Commits.FindMergeBase(after, until) ?? after; return CommitsAfter(after, until, ancestor).Distinct().Select(c => new CommitWrapper(c)); } else { return branch.Commits.Select(c => new CommitWrapper(c)); } }); Name = branch.Name; }
internal Commit(ObjectId id, ObjectId treeId, Repository repo) : base(id) { this.tree = new Lazy<Tree>(() => repo.Lookup<Tree>(treeId)); this.parents = new Lazy<IEnumerable<Commit>>(() => RetrieveParentsOfCommit(id.Oid)); this.repo = repo; }
internal Commit(ObjectId id, ObjectId treeId, Repository repo) : base(id) { tree = new Lazy<Tree>(() => repo.Lookup<Tree>(treeId)); parents = new Lazy<IEnumerable<Commit>>(() => RetrieveParentsOfCommit(id)); shortMessage = new Lazy<string>(ExtractShortMessage); this.repo = repo; }
public override bool Execute() { try { //if (LocalPath == ".") //{ // // User didn't define a Path, find the Git path by expecting this Task to be contained in a Git repo // LocalPath = //} using (var repo = new Repository(LocalPath)) { LastCommitHash = LastCommitShortHash = LastCommitMessage = LastTagName = LastTagMessage = LastTagCommitHash = String.Empty; RevisionCount = 0; Commit commit = null; CommitCollection commits = repo.Commits; if (!String.IsNullOrEmpty(CommitHash)) { // We're looking for a from a particular Commit on back commit = repo.Lookup<Commit>(CommitHash); commits = commits.StartingAt(CommitHash); } else { // We're looking from the most recent Commit commit = repo.Commits.First(); } if (null == commit) { Log.LogError("Can't find a Git Commit with that hash."); return false; } LastCommitShortHash = GetCommitShortHash(commit); LastCommitHash = commit.Sha; LastCommitMessage = commit.Message; Tag tag = GetMostRecentTagByEnumeration(commits, repo.Tags); if (null != tag) { LastTagName = tag.Annotation.Name; LastTagMessage = tag.Annotation.Message; LastTagCommitHash = tag.Annotation.TargetId.Sha; } } } catch (Exception exception) { Log.LogMessage("StackTrace: " + exception.StackTrace); Log.LogErrorFromException(exception); return false; } return true; }
public ChangeSet GetChangeSet(string id) { using (var repo = new LibGit2Sharp.Repository(RepositoryPath)) { LibGit2Sharp.Commit commit = repo.Lookup <LibGit2Sharp.Commit>(id); return(commit == null ? null : new ChangeSet(commit.Sha, commit.Author.Name, commit.Author.Email, commit.Message, commit.Author.When)); } }
public IEnumerable<HunkRangeInfo> GetGitDiffFor(ITextDocument textDocument, ITextSnapshot snapshot) { var content = GetCompleteContent(textDocument, snapshot); if (content == null) yield break; var filename = textDocument.FilePath; var discoveredPath = Repository.Discover(Path.GetFullPath(filename)); if (!Repository.IsValid(discoveredPath)) yield break; using (var repo = new Repository(discoveredPath)) { var retrieveStatus = repo.Index.RetrieveStatus(filename); if (retrieveStatus == FileStatus.Untracked || retrieveStatus == FileStatus.Added) yield break; content = AdaptCrlf(repo, content, textDocument); using (var currentContent = new MemoryStream(content)) { var newBlob = repo.ObjectDatabase.CreateBlob(currentContent); var directoryInfo = new DirectoryInfo(discoveredPath).Parent; if (directoryInfo == null) yield break; var relativeFilepath = filename.Replace(directoryInfo.FullName + "\\", string.Empty); // Determine 'from' and 'to' trees. var currentBranch = repo.Head.Name; var baseCommitEntry = repo.Config.Get<string>(string.Format("branch.{0}.diffmarginbase", currentBranch)); Tree tree = null; if (baseCommitEntry != null) { var baseCommit = repo.Lookup<Commit>(baseCommitEntry.Value); if (baseCommit != null) { // Found a merge base to diff from. tree = baseCommit.Tree; } } tree = tree ?? repo.Head.Tip.Tree; var from = TreeDefinition.From(tree); var treeDefinition = from.Add(relativeFilepath, newBlob, Mode.NonExecutableFile); var to = repo.ObjectDatabase.CreateTree(treeDefinition); var treeChanges = repo.Diff.Compare(tree, to, compareOptions: new CompareOptions { ContextLines = ContextLines, InterhunkLines = 0 }); var gitDiffParser = new GitDiffParser(treeChanges.Patch, ContextLines); var hunkRangeInfos = gitDiffParser.Parse(); foreach (var hunkRangeInfo in hunkRangeInfos) { yield return hunkRangeInfo; } } } }
private string UniqueAbbreviation(Repository repo, string full) { for (int len = 7; len < 40; ++len) { try { repo.Lookup(full.Substring(0, len)); return full.Substring(0, len); } catch (AmbiguousSpecificationException) { continue; } } return full; }
internal static TagAnnotation BuildFromPtr(GitObjectSafeHandle obj, ObjectId id, Repository repo) { ObjectId targetOid = NativeMethods.git_tag_target_oid(obj).MarshalAsObjectId(); return new TagAnnotation(id) { Message = NativeMethods.git_tag_message(obj), Name = NativeMethods.git_tag_name(obj), Tagger = new Signature(NativeMethods.git_tag_tagger(obj)), targetBuilder = new Lazy<GitObject>(() => repo.Lookup<GitObject>(targetOid)) }; }
public void Reset() { // Undo potential impact from earlier tests using (var repository = new LibGit2Sharp.Repository(Module.WorkingDir)) { var options = new LibGit2Sharp.CheckoutOptions(); repository.Reset(LibGit2Sharp.ResetMode.Hard, (LibGit2Sharp.Commit)repository.Lookup(CommitHash, LibGit2Sharp.ObjectType.Commit), options); repository.RemoveUntrackedFiles(); } CommitHelper.SetCommitMessage(Module, commitMessageText: null, amendCommit: false); }
public void Reset() { // Undo potential impact from earlier tests using (var repository = new LibGit2Sharp.Repository(Module.WorkingDir)) { var options = new LibGit2Sharp.CheckoutOptions(); repository.Reset(LibGit2Sharp.ResetMode.Hard, (LibGit2Sharp.Commit)repository.Lookup(CommitHash, LibGit2Sharp.ObjectType.Commit), options); repository.RemoveUntrackedFiles(); } new CommitMessageManager(Module.WorkingDirGitDir, Module.CommitEncoding).ResetCommitMessage(); }
internal static TagAnnotation BuildFromPtr(IntPtr obj, ObjectId id, Repository repo) { IntPtr oidPtr = NativeMethods.git_tag_target_oid(obj); var oid = (GitOid)Marshal.PtrToStructure(oidPtr, typeof(GitOid)); return new TagAnnotation(id) { Message = NativeMethods.git_tag_message(obj).MarshallAsString(), Name = NativeMethods.git_tag_name(obj).MarshallAsString(), Tagger = new Signature(NativeMethods.git_tag_tagger(obj)), targetBuilder = new Lazy<GitObject>(() => repo.Lookup<GitObject>(new ObjectId(oid))) }; }
private string CreateBranchForNewChanges(NewChanges newChanges, string prBranch) { string OriginalSha; var targetRepo = newChanges.TargetRepository; var branchName = $"mirror-merge-{(long)DateTime.Now.Subtract(new DateTime(2000, 1, 1, 0, 0, 0)).TotalMinutes}"; s_logger.Info($"Creating branch {prBranch} in {targetRepo} to merge changes into {prBranch}"); using (var repo = new Repository(targetRepo.Path)) { var branch = repo.CreateBranch(branchName); s_logger.Info("Checking out PR branch"); Commands.Checkout(repo, branch); OriginalSha = branch.Tip.ToString(); } foreach (var source in newChanges.changes.Keys) { var sourceRepository = targetRepo.Configuration.Repos.Where(t => t.Name == source).First(); using (var repo = new Repository(sourceRepository.Path)) { foreach (var change in newChanges.changes[sourceRepository.Name]) { var commit = repo.Lookup <Commit>(change); if (!IsMirrorCommit(commit.Message, targetRepo.Configuration.MirrorSignatureUser) && commit.Parents.Count() == 1 ) { s_logger.Info($"Applying {change}"); var patch = FormatPatch(sourceRepository, change); if (string.IsNullOrWhiteSpace(patch)) { continue; } s_logger.Debug($"Patch:\n{patch}"); ApplyPatch(sourceRepository, newChanges.TargetRepository, patch, commit); } } } } using (var repo = new Repository(targetRepo.Path)) { if (repo.Head.Tip.ToString() == OriginalSha) { s_logger.Info($"No new commits To add into this branch"); return(null); } } return(branchName); }
public bool DoesBranchContainCommit(string branchName, string commitOrBranchName) { using (var repo = new LibGit2Sharp.Repository(RepositoryPath)) { var branch = repo.Branches[branchName]; if (branch == null) { return(false); } return(repo.Refs.ReachableFrom( new[] { repo.Refs[branch.CanonicalName] }, new[] { repo.Lookup <Commit>(commitOrBranchName) }).Any()); } }
public List <Changes> GetChanges(GitCommit commit, string repositoryPath) { List <Changes> changes = new List <Changes>(); using (GitRepository gitRepositoryInfo = new GitRepository(repositoryPath)) { bool isInitial = false; var firstCommit = commit.Parents.FirstOrDefault(); if (firstCommit == null) { isInitial = true; } Tree rootCommitTree = gitRepositoryInfo.Lookup <GitCommit>(commit.Id.ToString()).Tree; Patch patch; if (!isInitial) { Tree commitTreeWithUpdatedFile = gitRepositoryInfo.Lookup <GitCommit>(commit.Parents.FirstOrDefault().Sha).Tree; patch = gitRepositoryInfo.Diff.Compare <Patch>(commitTreeWithUpdatedFile, rootCommitTree); } else { patch = gitRepositoryInfo.Diff.Compare <Patch>(null, rootCommitTree); } foreach (var change in patch) { changes.Add(new Changes() { Type = ConvertChangeKindToChangeType(change.Status), Path = change.Path, ChangeContent = change.Patch }); } } return(changes); }
public IActionResult GetRawBlob(string userName, string repoName, string id, string path) { return(TryGetResult(repoName, () => { if (path == null) { return Redirect(Url.UnencodedRouteLink("GetTreeView", new { repoName = repoName, id = id, path = path })); } repoName = Path.Combine(userName, repoName); LibGit2Sharp.Repository repo = RepositoryService.GetRepository(repoName); Commit commit = repo.Branches[id]?.Tip ?? repo.Lookup <Commit>(id); if (commit == null) { return NotFound(); } TreeEntry entry = commit[path.Replace('/', Path.DirectorySeparatorChar)]; if (entry == null) { return NotFound(); } switch (entry.TargetType) { case TreeEntryTargetType.Blob: { Blob blob = (Blob)entry.Target; if (blob.IsBinary) { return File(blob.GetContentStream(), "application/octet-stream", entry.Name); } else { return File(blob.GetContentStream(), "text/plain"); } } case TreeEntryTargetType.Tree: return Redirect(Url.UnencodedRouteLink("GetTreeView", new { repoName = repoName, id = id, path = path })); default: return BadRequest(); } })); }
public RepositoryWrapper(Repository repo) { this.repo = repo; Head = async (i) => { return new BranchWrapper(repo, repo.Head); }; Config = async (i) => { return repo.Config; }; Index = async (i) => { return repo.Index; }; Ignore = async (i) => { return repo.Ignore; }; Network = async (i) => { return new NetworkWrapper(repo.Network); }; ObjectDatabase = async (i) => { return repo.ObjectDatabase; }; Refs = async (i) => { return repo.Refs; }; Commits = async (i) => { return repo.Commits.Select(c => new CommitWrapper(c)); }; Tags = async (i) => { return repo.Tags; }; Stashes = async (i) => { return repo.Stashes; }; Info = async (i) => { return repo.Info; }; Diff = async (i) => { return repo.Diff; }; Notes = async (i) => { return repo.Notes; }; Submodules = async (i) => { return repo.Submodules; }; Dispose = async (i) => { repo.Dispose(); return null; }; Lookup = async (id) => { var found = repo.Lookup(id.ToString()); if (found.GetType() == typeof(Commit)) { return new CommitWrapper((Commit)found); } else { return found; } }; Branches = async (i) => repo.Branches.Select(b => new BranchWrapper(repo, b)).ToDictionary(b => b.Name); Reset = async (dynamic i) => { var modeName = ((string)i.mode).ToLower(); ResetMode mode; if (modeName == "soft") { mode = ResetMode.Soft; } else if (modeName == "mixed") { mode = ResetMode.Mixed; } else { mode = ResetMode.Hard; } var committish = (string)i.committish; repo.Reset(mode, committish, null, null); return null; }; Checkout = async (i) => { var branch = repo.Branches.First(b => b.Name == i.ToString()); repo.Checkout(branch); return branch; }; }
public VotedPost GetPost(string id) { using (var repo = new Repository(_directory.FullName)) { Commit commit = repo.Lookup<Commit>(id); var post = JsonConvert.DeserializeObject<VotedPost>(commit.Message); post.Id = commit.Sha; // Get the votes for the post Commit postTip = repo.Branches[post.Id].Tip; Tree postTree = postTip.Tree; Tree votesDir = (Tree)postTree[VOTES_DIR].Target; post.Votes = votesDir.Where(f => f.Mode == Mode.NonExecutableFile).Select(DecodeVote).ToList(); return post; } }
private void SanityCheck(RepositoryInfo repository, string branch) { using (var repo = new Repository(repository.Path)) { s_logger.Info($"Running sanity check for {repository.Name}/{branch}"); var lastLookedAtCommit = repo.Lookup <Commit>(repository.LastSynchronizedCommits[branch]); var remoteBranch = repo.Refs[$"refs/heads/{branch}"]; var commitFilter = new CommitFilter { IncludeReachableFrom = remoteBranch, ExcludeReachableFrom = lastLookedAtCommit, SortBy = CommitSortStrategies.Topological | CommitSortStrategies.Time | CommitSortStrategies.Reverse, }; var commitList = repo.Commits.QueryBy(commitFilter).ToList(); if (commitList.Count == 0) { return; } foreach (var commit in commitList) { if (IsMirrorCommit(commit.Message, repository.Configuration.MirrorSignatureUser)) { continue; } var changedFiles = GetChangedFiles(repo, commit); var sharedDirectory = repository.SharedPath; foreach (var changedFile in changedFiles) { if (changedFile.Contains(sharedDirectory)) { foreach (string targetRepo in s_repos[repository.Name]) { RetrieveOrInsert(repository.Name, branch, commit.Sha, targetRepo); } break; } } } UpdateLastSynchronizedCommit(repository, commitList.Last().Sha, branch); s_logger.Info($"sanity check Completed for {repository.Name}/{branch}"); } }
public IEnumerable<HunkRangeInfo> GetGitDiffFor(ITextDocument textDocument, ITextSnapshot snapshot) { var filename = textDocument.FilePath; var discoveredPath = Repository.Discover(Path.GetFullPath(filename)); if (!Repository.IsValid(discoveredPath)) yield break; using (var repo = new Repository(discoveredPath)) { var retrieveStatus = repo.Index.RetrieveStatus(filename); if (retrieveStatus == FileStatus.Untracked || retrieveStatus == FileStatus.Added) yield break; var content = GetCompleteContent(textDocument, snapshot); if (content == null) yield break; content = AdaptCrlf(repo, content, textDocument); using (var currentContent = new MemoryStream(content)) { var newBlob = repo.ObjectDatabase.CreateBlob(currentContent); var directoryInfo = new DirectoryInfo(discoveredPath).Parent; if (directoryInfo == null) yield break; var relativeFilepath = filename.Replace(directoryInfo.FullName + "\\", string.Empty); var from = TreeDefinition.From(repo.Head.Tip.Tree); if (!repo.ObjectDatabase.Contains(@from[relativeFilepath].TargetId)) yield break; var blob = repo.Lookup<Blob>(@from[relativeFilepath].TargetId); var treeChanges = repo.Diff.Compare(blob, newBlob, new CompareOptions { ContextLines = ContextLines, InterhunkLines = 0 }); var gitDiffParser = new GitDiffParser(treeChanges.Patch, ContextLines); var hunkRangeInfos = gitDiffParser.Parse(); foreach (var hunkRangeInfo in hunkRangeInfos) { yield return hunkRangeInfo; } } } }
public static CommitDetails GetCheckinDetails(string checkinId) { Repository repo = new Repository(ConfigurationManager.AppSettings["RepoRoot"]); //Commit commit = repo.Lookup<Commit>(checkinId); //return commit.Message; string patchDirectory = Path.Combine(repo.Info.Path, "patches"); CommitDetails commitDetails = new CommitDetails(); IEnumerable<string> files = Directory.EnumerateFiles(patchDirectory, checkinId + "*", SearchOption.TopDirectoryOnly); if (files != null && files.Any()) { string patchFileName = files.First(); string commitId = Path.GetFileNameWithoutExtension(patchFileName); commitDetails.Commit = repo.Lookup<Commit>(commitId); commitDetails.FileChanges = Serializer.Deserialize<List<FileChanges>>(File.OpenRead(patchFileName)); } return commitDetails; }
private static void ObtenerComits(Repository repo) { /*Obtener dos commits, el comit1 sera el ultimo comit realizado y el comit2 sera el elemento padre (el anterior) del comit actual La cola esta de forma inversa, es decir, cuando accedemos a First() estamos accediendo al ultimo commit guardado */ try { comit1 = repo.Lookup<Commit>(repo.Commits.First().Id.Sha); comit2 = comit1.Parents.First(); Console.WriteLine("\r\nCommit: \r\n\tpadre " + comit1.Id + " \r\n\thijo " + comit2.Id + "; "); } catch (Exception ex) { Console.ForegroundColor = ConsoleColor.Red; Console.WriteLine("Error: " + ex.Message); } }
public void Reset() { // Undo potential impact from earlier tests using (var repository = new LibGit2Sharp.Repository(Module.WorkingDir)) { var options = new LibGit2Sharp.CheckoutOptions(); repository.Reset(LibGit2Sharp.ResetMode.Hard, (LibGit2Sharp.Commit)repository.Lookup(CommitHash, LibGit2Sharp.ObjectType.Commit), options); repository.RemoveUntrackedFiles(); var remoteNames = repository.Network.Remotes.Select(remote => remote.Name).ToArray(); foreach (var remoteName in remoteNames) { repository.Network.Remotes.Remove(remoteName); } repository.Config.Set(SettingKeyString.UserName, "author"); repository.Config.Set(SettingKeyString.UserEmail, "*****@*****.**"); } new CommitMessageManager(Module.WorkingDirGitDir, Module.CommitEncoding).ResetCommitMessage(); }
public void CreateOrResetBranch(string branchName, string startPoint) { using (var repo = new LibGit2Sharp.Repository(RepositoryPath)) { if (string.IsNullOrWhiteSpace(startPoint)) { var branch = repo.GetOrCreateBranch(branchName); repo.Checkout(branch); } else { var commit = repo.Lookup <Commit>(startPoint); if (commit == null) { throw new LibGit2Sharp.NotFoundException(string.Format("Start point \"{0}\" for reset was not found.", startPoint)); } var branch = repo.GetOrCreateBranch(branchName); repo.Checkout(branch); repo.Reset(ResetMode.Hard, commit); } } }
public static string GetConflictContent( string rootFolder, StageLevel stage, string conflict ) { using ( var repository = new Repository( rootFolder ) ) { var conflictEntry = repository.Index.Conflicts.FirstOrDefault( c => c.GetPath() == conflict ); if ( conflictEntry == null ) { throw new InvalidDataException( "Could not find the matching conflict entry for " + conflict ); } IndexEntry entry = conflictEntry.GetEntry( stage ); if ( entry == null ) { return null; } Blob stageBlob = repository.Lookup<Blob>( entry.Id ); using ( var reader = new StreamReader( stageBlob.GetContentStream() ) ) { return reader.ReadToEnd(); } } }
public IActionResult GetTreeView(string userName, string repoName, string id, string path) { return(TryGetResult(repoName, () => { repoName = Path.Combine(userName, repoName); LibGit2Sharp.Repository repo = RepositoryService.GetRepository(repoName); Commit commit = repo.Branches[id]?.Tip ?? repo.Lookup <Commit>(id); if (commit == null) { return View("Init"); } if (path == null) { return View("Tree", new TreeModel(repo, "/", repoName, commit.Tree)); } TreeEntry entry = commit[path]; if (entry == null) { return NotFound(); } string parent = Path.GetDirectoryName(entry.Path).Replace(Path.DirectorySeparatorChar, '/'); switch (entry.TargetType) { case TreeEntryTargetType.Tree: return View("Tree", new TreeModel(repo, entry.Path, entry.Name, (Tree)entry.Target, parent)); case TreeEntryTargetType.Blob: return Redirect(Url.UnencodedRouteLink("GetBlobView", new { repoName = repoName, id = id, path = path })); default: return BadRequest(); } })); }
public ActionResult DownloadVersion(Guid id, string sha) { using (var db = ApplicationDbContext.Create()) { ManagedFile file = db.Files.Where(x => x.Id == id) .Include(x => x.CatalogRecord) .Include(x => x.CatalogRecord.Organization).FirstOrDefault(); if (file == null) { //TODO error page? return(RedirectToAction("Index")); } EnsureUserIsAllowed(file.CatalogRecord, db); EnsureUserCanDownload(file.CatalogRecord.Organization); string processingDirectory = SettingsHelper.GetProcessingDirectory(file.CatalogRecord.Organization, db); string path = Path.Combine(processingDirectory, file.CatalogRecord.Id.ToString()); using (var repo = new LibGit2Sharp.Repository(path)) { var blob = repo.Lookup <Blob>(sha); var cd = new System.Net.Mime.ContentDisposition { FileName = file.Name,//always uses the current file name right now... Inline = false, Size = blob.Size }; var contentStream = blob.GetContentStream(); Response.AppendHeader("Content-Disposition", cd.ToString()); return(new FileStreamResult(contentStream, "application/octet-stream")); } } }
/// <summary> /// Run the current rebase step. This will handle reporting that we are about to run a rebase step, /// identifying and running the operation for the current step, and reporting the current step is completed. /// </summary> /// <param name="rebaseOperationHandle"></param> /// <param name="repository"></param> /// <param name="committer"></param> /// <param name="options"></param> /// <param name="stepToApplyIndex"></param> /// <param name="totalStepCount"/> /// <returns></returns> private static unsafe RebaseResult RunRebaseStep(RebaseHandle rebaseOperationHandle, Repository repository, Identity committer, RebaseOptions options, long stepToApplyIndex, long totalStepCount) { RebaseStepResult rebaseStepResult = null; RebaseResult rebaseSequenceResult = null; git_rebase_operation *rebaseOp = Proxy.git_rebase_operation_byindex(rebaseOperationHandle, stepToApplyIndex); ObjectId idOfCommitBeingRebased = ObjectId.BuildFromPtr(&rebaseOp->id); RebaseStepInfo stepToApplyInfo = new RebaseStepInfo(rebaseOp->type, repository.Lookup <Commit>(idOfCommitBeingRebased), LaxUtf8NoCleanupMarshaler.FromNative(rebaseOp->exec)); // Report the rebase step we are about to perform. if (options.RebaseStepStarting != null) { options.RebaseStepStarting(new BeforeRebaseStepInfo(stepToApplyInfo, stepToApplyIndex, totalStepCount)); } // Perform the rebase step git_rebase_operation *rebaseOpReport = Proxy.git_rebase_next(rebaseOperationHandle); // Verify that the information from the native library is consistent. VerifyRebaseOp(rebaseOpReport, stepToApplyInfo); // Handle the result switch (stepToApplyInfo.Type) { case RebaseStepOperation.Pick: rebaseStepResult = ApplyPickStep(rebaseOperationHandle, repository, committer, options, stepToApplyInfo); break; case RebaseStepOperation.Squash: case RebaseStepOperation.Edit: // case RebaseStepOperation.Exec: case RebaseStepOperation.Fixup: case RebaseStepOperation.Reword: // These operations are not yet supported by lg2. throw new LibGit2SharpException("Rebase Operation Type ({0}) is not currently supported in LibGit2Sharp.", stepToApplyInfo.Type); default: throw new ArgumentException(string.Format( "Unexpected Rebase Operation Type: {0}", stepToApplyInfo.Type)); } // Report that we just completed the step if (options.RebaseStepCompleted != null && (rebaseStepResult.Status == RebaseStepStatus.Committed || rebaseStepResult.Status == RebaseStepStatus.ChangesAlreadyApplied)) { if (rebaseStepResult.ChangesAlreadyApplied) { options.RebaseStepCompleted(new AfterRebaseStepInfo(stepToApplyInfo, stepToApplyIndex, totalStepCount)); } else { options.RebaseStepCompleted(new AfterRebaseStepInfo(stepToApplyInfo, repository.Lookup <Commit>(new ObjectId(rebaseStepResult.CommitId)), stepToApplyIndex, totalStepCount)); } } // If the result of the rebase step is something that requires us to stop // running the rebase sequence operations, then report the result. if (rebaseStepResult.Status == RebaseStepStatus.Conflicts) { rebaseSequenceResult = new RebaseResult(RebaseStatus.Conflicts, stepToApplyIndex, totalStepCount, null); } return(rebaseSequenceResult); }
public void RepoManager() { using (var repo = new Repository(dir)) { // CREATE a new file const string oldName = "polite.txt"; string oldPath = Path.Combine(repo.Info.WorkingDirectory, oldName); File.WriteAllText(oldPath, "hello test file\n", Encoding.ASCII); repo.Index.Stage(oldName); Signature who = new Signature("James Davis", "*****@*****.**", new DateTimeOffset(System.DateTime.Now)); //This is a test helper that returns a dummy signature repo.Commit("Initial Commit", who, who, false); // RENAME a file const string newName = "being.frakking.polite.txt"; string newPath = Path.Combine(repo.Info.WorkingDirectory, newName); repo.Index.Unstage(oldName); File.Move(oldPath, newPath); repo.Index.Stage(newName); //who = who.TimeShift(TimeSpan.FromMinutes(1)); //Also a test helper extension method Commit commit = repo.Commit("Fix file name", who, who); ObjectId blobId = commit.Tree[newName].Target.Id; //For future usage below // UPDATE a file File.AppendAllText(newPath, "Hey! I said 'hello'. Why don't you answer me\n", Encoding.ASCII); repo.Index.Stage(newName); //who = who.TimeShift(TimeSpan.FromMinutes(1)); repo.Commit("Update the content", who, who); // DELETE a file repo.Index.Unstage(newName); //who = who.TimeShift(TimeSpan.FromMinutes(2)); repo.Commit("Remove the file as it's not that polite", who, who); // RETRIEVE a specific version of a file Blob file = repo.Lookup<Blob>(blobId); } }
private static HashSet<Commit> GitMergeBaseAll(Repository repo, Commit source, Commit destination) { var startInfo = new ProcessStartInfo(GitReviewApplication.GitPath, string.Format("merge-base --all {0} {1}", source.Sha, destination.Sha)) { WorkingDirectory = GitReviewApplication.RepositoryPath, RedirectStandardOutput = true, UseShellExecute = false, }; using (var git = Process.Start(startInfo)) { var lines = git.StandardOutput.ReadToEnd().TrimEnd('\n').Split('\n'); return new HashSet<Commit>(lines.Select(s => (Commit)repo.Lookup(s))); } }
public void StartExternalDiff(ITextDocument textDocument) { if (textDocument == null || string.IsNullOrEmpty(textDocument.FilePath)) return; var filename = textDocument.FilePath; var repositoryPath = GetGitRepository(Path.GetFullPath(filename)); if (repositoryPath == null) return; using (var repo = new Repository(repositoryPath)) { string workingDirectory = repo.Info.WorkingDirectory; string relativePath = Path.GetFullPath(filename); if (relativePath.StartsWith(workingDirectory, StringComparison.OrdinalIgnoreCase)) relativePath = relativePath.Substring(workingDirectory.Length); // the name of the object in the database string objectName = Path.GetFileName(filename); Blob oldBlob = null; var indexEntry = repo.Index[relativePath]; if (indexEntry != null) { objectName = Path.GetFileName(indexEntry.Path); oldBlob = repo.Lookup<Blob>(indexEntry.Id); } var tempFileName = Path.GetTempFileName(); if (oldBlob != null) File.WriteAllText(tempFileName, oldBlob.GetContentText(new FilteringOptions(relativePath))); IVsDifferenceService differenceService = _serviceProvider.GetService(typeof(SVsDifferenceService)) as IVsDifferenceService; if (differenceService != null) { string leftFileMoniker = tempFileName; // The difference service will automatically load the text from the file open in the editor, even if // it has changed. string rightFileMoniker = filename; string actualFilename = objectName; string tempPrefix = Path.GetRandomFileName().Substring(0, 5); string caption = string.Format("{0}_{1} vs. {1}", tempPrefix, actualFilename); string tooltip = null; string leftLabel; if (indexEntry != null) { // determine if the file has been staged string revision; FileStatus stagedMask = FileStatus.Added | FileStatus.Staged; if ((repo.Index.RetrieveStatus(relativePath) & stagedMask) != 0) revision = "index"; else revision = repo.Head.Tip.Sha.Substring(0, 7); leftLabel = string.Format("{0}@{1}", objectName, revision); } else if (oldBlob != null) { // file was added leftLabel = null; } else { // we just compared to head leftLabel = string.Format("{0}@{1}", objectName, repo.Head.Tip.Sha.Substring(0, 7)); } string rightLabel = filename; string inlineLabel = null; string roles = null; __VSDIFFSERVICEOPTIONS grfDiffOptions = __VSDIFFSERVICEOPTIONS.VSDIFFOPT_LeftFileIsTemporary; differenceService.OpenComparisonWindow2(leftFileMoniker, rightFileMoniker, caption, tooltip, leftLabel, rightLabel, inlineLabel, roles, (uint)grfDiffOptions); // Since the file is marked as temporary, we can delete it now File.Delete(tempFileName); } else { // Can't use __VSDIFFSERVICEOPTIONS, so mark the temporary file(s) read only on disk File.SetAttributes(tempFileName, File.GetAttributes(tempFileName) | FileAttributes.ReadOnly); string remoteFile; if (textDocument.IsDirty) { remoteFile = Path.GetTempFileName(); File.WriteAllBytes(remoteFile, GetCompleteContent(textDocument, textDocument.TextBuffer.CurrentSnapshot)); File.SetAttributes(remoteFile, File.GetAttributes(remoteFile) | FileAttributes.ReadOnly); } else { remoteFile = filename; } var diffGuiTool = repo.Config.Get<string>("diff.guitool"); if (diffGuiTool == null) { diffGuiTool = repo.Config.Get<string>("diff.tool"); if (diffGuiTool == null) return; } var diffCmd = repo.Config.Get<string>("difftool." + diffGuiTool.Value + ".cmd"); if (diffCmd == null || diffCmd.Value == null) return; var cmd = diffCmd.Value.Replace("$LOCAL", tempFileName).Replace("$REMOTE", remoteFile); string fileName = Regex.Match(cmd, ParameterPattern).Value; string arguments = cmd.Substring(fileName.Length); ProcessStartInfo startInfo = new ProcessStartInfo(fileName, arguments); Process.Start(startInfo); } } }
string TryFindCommit( RepositoryInfoOptions options, Repository r, out Commit commit, out CIBranchVersionMode ciVersionMode, out string branchNameForCIVersion ) { ciVersionMode = CIBranchVersionMode.None; commit = null; branchNameForCIVersion = null; string commitSha = options.StartingCommitSha; // Find current commit (the head) if none is provided. if( string.IsNullOrWhiteSpace( commitSha ) ) { IEnumerable<string> branchNames; if( string.IsNullOrWhiteSpace( options.StartingBranchName ) ) { // locCommit is here because one cannot use an out parameter inside a lambda. var locCommit = commit = r.Head.Tip; if( locCommit == null ) return "Unitialized Git repository."; // Save the branches! // By doing this, when we are in 'Detached Head' state (the head of the repository is on a commit and not on a branch: git checkout <sha>), // we can detect that it is the head of a branch and hence apply possible options (mainly CI) for it. // We take into account only the branches from options.RemoteName remote here. string branchName = r.Head.FriendlyName; if( branchName == "(no branch)" ) { string remotePrefix = options.RemoteName + '/'; branchNames = r.Branches .Where( b => b.Tip == locCommit && (!b.IsRemote || b.FriendlyName.StartsWith( remotePrefix )) ) .Select( b => b.IsRemote ? b.FriendlyName.Substring( remotePrefix.Length ) : b.FriendlyName ); } else branchNames = new[] { branchName }; } else { Branch br = r.Branches[options.StartingBranchName] ?? r.Branches[ options.RemoteName + '/' + options.StartingBranchName]; if( br == null ) return string.Format( "Unknown StartingBranchName: '{0}' (also tested on remote '{1}/{0}').", options.StartingBranchName, options.RemoteName ); commit = br.Tip; branchNames = new[] { options.StartingBranchName }; } RepositoryInfoOptionsBranch bOpt; if( options.Branches != null && (bOpt = options.Branches.FirstOrDefault( b => branchNames.Contains( b.Name ) )) != null && bOpt.CIVersionMode != CIBranchVersionMode.None ) { ciVersionMode = bOpt.CIVersionMode; branchNameForCIVersion = string.IsNullOrWhiteSpace( bOpt.VersionName ) ? bOpt.Name : bOpt.VersionName; } } else { commit = r.Lookup<Commit>( commitSha ); if( commit == null ) return string.Format( "Commit '{0}' not found.", commitSha ); } return null; }
/// <summary> /// Initializes a new instance of the <see cref = "Branch" /> class. /// </summary> /// <param name = "targetId">The id of the commit which is pointed at by this Branch</param> /// <param name = "repo">The repo.</param> /// <param name = "canonicalName">The full name of the reference</param> internal Branch(string canonicalName, ObjectId targetId, Repository repo) : this(canonicalName, new Lazy <Commit>(() => repo.Lookup <Commit>(targetId)), repo) { }
public override bool Execute() { using (var context = CollectorRepository.CreateContext(this.ConnectionString)) { db = new CollectorRepository(); db.Context = context; using (repo = new Repository(System.IO.Path.Combine(this.Directory, ".git"))) { foreach (var tag in repo.Tags) { ObjectId commitID = tag.IsAnnotated ? tag.Annotation.TargetId : tag.Target.Id; ImportTag(tag.Name, (LibGit2Sharp.Commit)repo.Lookup(commitID, GitObjectType.Commit), true); } foreach (var branch in repo.Branches) { if (branch.IsRemote && branch.Name.StartsWith(this.Remote + "/", StringComparison.Ordinal)) { string branchName = branch.Name.Substring(this.Remote.Length + 1); if (branchName != "HEAD") { ImportTag(branchName, branch.Tip, false); } } } } if (EnableGitSvnImport && svnRevisionToCommitIdMapping.Count > 0) { var map = svnRevisionToCommitIdMapping.OrderBy(p => p.Key).ToList(); for (int i = 0; i < map.Count - 1; i++) { int minRev = map[i].Key; int maxRev = map[i + 1].Key - 1; foreach (var session in db.Context.Sessions.Where(s => s.AppVersionRevision >= minRev && s.AppVersionRevision <= maxRev)) { session.CommitId = map[i].Value; } } int lastRev = map.Last().Key; foreach (var session in db.Context.Sessions.Where(s => s.AppVersionRevision == lastRev)) { session.CommitId = map.Last().Value; } db.Context.SaveChanges(); } db = null; } return true; }
/// <summary> /// Change the screen to a new commit /// </summary> /// <param name="sha">sha hash of requested commit</param> private void changeCommit(string sha) { currentRepo = new Repository(mLocalRepositories[0].LocalPath); //Commit currentCommit = (Commit)currentRepo.Commits.Where(Commit => Commit.Id.Sha == sha).First(); Commit currentCommit = (Commit)currentRepo.Lookup(new ObjectId(sha), GitObjectType.Commit); //update file list fillFileList(currentCommit.Tree); //update labels lblUser.Text = currentCommit.Committer.Name; lblChangeset.Text = "(" + currentCommit.Id.ToString().Substring(0,6) + ") " + currentCommit.MessageShort; //lblBranch.Text = currentCommit. }
private static string GetFileContent(Repository repo, Dictionary<string, Commit> commits, string commitId, string fileName) { // look up commit in repo var gitCommit = repo.Lookup<LibGit2Sharp.Commit>(commitId); // save the commit message Commit commit; if (commits.TryGetValue(commitId, out commit)) commit.SetMessage(gitCommit.Message); return GetFileContent(gitCommit, fileName); }
public IActionResult RetrieveQuoteGit(string quoteNumber) { var watch = Stopwatch.StartNew(); using (var repo = new Repository("C:\\temp\\rooted\\path")) { var commit = repo.Lookup<Commit>(quoteNumber); var treeEntry = commit["output.json"]; var blob = (Blob)treeEntry.Target; var contentStream = blob.GetContentStream(); using (var tr = new StreamReader(contentStream, Encoding.UTF8)) { string content = tr.ReadToEnd(); Quote jsondata = new JavaScriptSerializer().Deserialize<Quote>(content); QuoteViewModel viewModel = new QuoteViewModel() { FirstName = jsondata.FirstName, LastName = jsondata.LastName, Email = jsondata.Email }; watch.Stop(); var elapsedMs = watch.ElapsedMilliseconds; ViewBag.Message = "Time taken: " + elapsedMs + " ms"; return View("DisplayQuoteSql", viewModel); } } }
public void CreateOrResetBranch(string branchName, string startPoint) { using (var repo = new LibGit2Sharp.Repository(RepositoryPath)) { if (string.IsNullOrWhiteSpace(startPoint)) { var branch = repo.GetOrCreateBranch(branchName); repo.Checkout(branch); } else { var commit = repo.Lookup<Commit>(startPoint); if (commit == null) { throw new LibGit2Sharp.NotFoundException(string.Format("Start point \"{0}\" for reset was not found.", startPoint)); } var branch = repo.GetOrCreateBranch(branchName); repo.Checkout(branch); repo.Reset(ResetMode.Hard, commit); } } }
//TODO: Cries for refactoring... really! internal static T BuildFromPtr <T>(IntPtr ptr, Repository repo) where T : class { if (ptr == IntPtr.Zero) { return(default(T)); } string name = NativeMethods.git_reference_name(ptr).MarshallAsString(); GitReferenceType type = NativeMethods.git_reference_type(ptr); Reference reference; string targetIdentifier; switch (type) { case GitReferenceType.Symbolic: IntPtr resolveRef; targetIdentifier = NativeMethods.git_reference_target(ptr).MarshallAsString(); int res = NativeMethods.git_reference_resolve(out resolveRef, ptr); if (res == (int)GitErrorCode.GIT_ENOTFOUND) { reference = new SymbolicReference { CanonicalName = name, Target = null, TargetIdentifier = targetIdentifier }; break; } Ensure.Success(res); var targetRef = BuildFromPtr <Reference>(resolveRef, repo); reference = new SymbolicReference { CanonicalName = name, Target = targetRef, TargetIdentifier = targetIdentifier }; break; case GitReferenceType.Oid: IntPtr oidPtr = NativeMethods.git_reference_oid(ptr); var oid = (GitOid)Marshal.PtrToStructure(oidPtr, typeof(GitOid)); var targetId = new ObjectId(oid); targetIdentifier = targetId.Sha; var targetBuilder = new Lazy <GitObject>(() => repo.Lookup(targetId)); reference = new DirectReference(targetBuilder) { CanonicalName = name, TargetIdentifier = targetIdentifier }; break; default: throw new LibGit2Exception(String.Format(CultureInfo.InvariantCulture, "Unable to build a new reference from a type '{0}'.", Enum.GetName(typeof(GitReferenceType), type))); } if (typeof(Reference).IsAssignableFrom(typeof(T))) { return(reference as T); } var targetOid = new ObjectId(targetIdentifier); if (Equals(typeof(T), typeof(Tag))) { return(new Tag(reference.CanonicalName, targetOid, repo) as T); } if (Equals(typeof(T), typeof(Branch))) { return(new Branch(reference.CanonicalName, targetOid, repo) as T); } throw new LibGit2Exception( string.Format(CultureInfo.InvariantCulture, "Unable to build a new instance of '{0}' from a reference of type '{1}'.", typeof(T), Enum.GetName(typeof(GitReferenceType), type))); }
internal Tree Build(Repository repository) { WrapAllTreeDefinitions(repository); using (var builder = new TreeBuilder()) { var builtTreeEntryDefinitions = new List<Tuple<string, TreeEntryDefinition>>(entries.Count); foreach (KeyValuePair<string, TreeEntryDefinition> kvp in entries) { string name = kvp.Key; TreeEntryDefinition ted = kvp.Value; var transient = ted as TransientBlobTreeEntryDefinition; if (transient == null) { builder.Insert(name, ted); continue; } Blob blob = transient.Builder(repository.ObjectDatabase); TreeEntryDefinition ted2 = TreeEntryDefinition.From(blob, ted.Mode); builtTreeEntryDefinitions.Add(new Tuple<string, TreeEntryDefinition>(name, ted2)); builder.Insert(name, ted2); } builtTreeEntryDefinitions.ForEach(t => entries[t.Item1] = t.Item2); ObjectId treeId = builder.Write(repository); return repository.Lookup<Tree>(treeId); } }
private static string GetFileContent(string repositoryPath, string commitId, string fileName) { using (var repo = new Repository(repositoryPath)) { var gitCommit = repo.Lookup<LibGit2Sharp.Commit>(commitId); return GetFileContent(gitCommit, fileName); } }
public static TreeChanges GetChangedFiles(LibGit2Sharp.Repository repo, string refRev) { return(GitUtil.CompareCommits(repo, repo.Lookup <Commit> (refRev), repo.Head.Tip)); }
private int DoPrintLog(CancellationToken cancellationToken) { ConsoleColor defaultColor = Console.ForegroundColor; ConsoleColor graphColor = ConsoleColor.DarkYellow; ConsoleColor versionColor = ConsoleColor.DarkRed; using (GitVersionCalulator versionCalculater = new GitVersionCalulator(RepoPath)) using (LibGit2Sharp.Repository repo = new LibGit2Sharp.Repository(RepoPath)) { Commit tip = repo.Head.Tip; if (!string.IsNullOrEmpty(Sha)) { tip = repo.Lookup <Commit>(Sha); if (tip == null) { log.Error($"The commit with reference {Sha} does not exist in the repository."); return(1); } } IEnumerable <Commit> History = repo.Commits.QueryBy(new CommitFilter() { IncludeReachableFrom = tip, SortBy = CommitSortStrategies.Topological }); // Run through to determine max Position (number of concurrent branches) to be able to indent correctly later int maxLines = int.Parse(PrintLog); int lineCount = 0; Dictionary <Commit, int> commitPosition = new Dictionary <Commit, int>(); commitPosition.Add(History.First(), 0); int maxPosition = 0; foreach (Commit c in History) { cancellationToken.ThrowIfCancellationRequested(); if (maxPosition < commitPosition[c]) { maxPosition = commitPosition[c]; } if (!c.Parents.Any()) { // this is the very first commit in the repo. Stop here. maxLines = ++lineCount; break; } Commit p1 = c.Parents.First(); if (c.Parents.Count() > 1) { Commit p2 = c.Parents.Last(); if (commitPosition.ContainsKey(p1)) { if (commitPosition[p1] != commitPosition[c]) { int startPos = Math.Min(commitPosition[p1], commitPosition[c]); int endPos = Math.Max(commitPosition[p1], commitPosition[c]); commitPosition[c] = startPos; foreach (var kvp in commitPosition.Where((KeyValuePair <Commit, int> kvp) => kvp.Value == endPos).ToList()) { commitPosition.Remove(kvp.Key); } } } if (!commitPosition.ContainsKey(p2)) { // move out to an position out for the new branch int newPosition = commitPosition[c] + 1; while (commitPosition.ContainsValue(newPosition) && (newPosition <= commitPosition.Values.Max())) { newPosition++; } commitPosition[p2] = newPosition; commitPosition[p1] = commitPosition[c]; } else if (!commitPosition.ContainsKey(p1)) { commitPosition[p1] = commitPosition[c]; } } else { if (!commitPosition.ContainsKey(p1)) { commitPosition[p1] = commitPosition[c]; } if (commitPosition[p1] != commitPosition[c]) { int startPos = Math.Min(commitPosition[p1], commitPosition[c]); int endPos = Math.Max(commitPosition[p1], commitPosition[c]); // c is now merged back, no need to keep track of it (or any other commit on this branch) // this way we can reuse the position for another branch foreach (var kvp in commitPosition.Where((KeyValuePair <Commit, int> kvp) => kvp.Value == endPos).ToList()) { commitPosition.Remove(kvp.Key); } commitPosition[p1] = startPos; foreach (var kvp in commitPosition.Where((KeyValuePair <Commit, int> kvp) => kvp.Value == startPos).ToList()) { if (kvp.Key != p1) { commitPosition.Remove(kvp.Key); } } } } if (++lineCount >= maxLines) { break; } } { maxPosition++; } { // Run through again to print lineCount = 0; commitPosition = new Dictionary <Commit, int>(); commitPosition.Add(History.First(), 0); HashSet <Commit> taggedCommits = repo.Tags.Select(t => t.Target.Peel <Commit>()).ToHashSet(); foreach (Commit c in History) { cancellationToken.ThrowIfCancellationRequested(); void DrawPositionSpacer(int fromPos, int toPos) { for (int i = fromPos; i < toPos; i++) { if (commitPosition.ContainsValue(i)) { Console.Write("\u2502 "); } else { Console.Write(" "); } } } void DrawMergePositionSpacer(int fromPos, int toPos) { for (int i = fromPos; i < toPos; i++) { if (commitPosition.ContainsValue(i)) { Console.Write("\u2502\u2500"); } else { Console.Write("\u2500\u2500"); } } } Console.ForegroundColor = graphColor; DrawPositionSpacer(0, commitPosition[c]); Console.ForegroundColor = defaultColor; if (taggedCommits.Contains(c)) { Console.Write("v "); } else { Console.Write("* "); } Console.ForegroundColor = graphColor; DrawPositionSpacer(commitPosition[c] + 1, maxPosition); Console.ForegroundColor = versionColor; Console.Write(versionCalculater.GetVersion(c).ToString(FieldCount)); Console.ForegroundColor = defaultColor; Console.Write(" - "); Console.Write(c.MessageShort.Trim()); if (++lineCount >= maxLines) { Console.WriteLine(); break; } if (c.Parents.Any()) { Commit p1 = c.Parents.First(); //Console.Write("Parent1: " + p1.Sha.Substring(0,8)); Console.WriteLine(); Console.ForegroundColor = graphColor; if (c.Parents.Count() > 1) { Commit p2 = c.Parents.Last(); int startPos; int endPos; if (commitPosition.ContainsKey(p1)) { if (commitPosition[p1] != commitPosition[c]) { startPos = Math.Min(commitPosition[p1], commitPosition[c]); // something we already printed has the current commit as its parent, draw the line to that commit now DrawPositionSpacer(0, startPos); // Draw ├─┘ Console.Write("\u251C\u2500"); endPos = Math.Max(commitPosition[p1], commitPosition[c]); DrawMergePositionSpacer(startPos + 1, endPos); Console.Write("\u2518 "); DrawPositionSpacer(endPos + 1, maxPosition); Console.WriteLine(); commitPosition[c] = startPos; foreach (var kvp in commitPosition.Where((KeyValuePair <Commit, int> kvp) => kvp.Value == endPos).ToList()) { commitPosition.Remove(kvp.Key); } } } if (!commitPosition.ContainsKey(p2)) { DrawPositionSpacer(0, commitPosition[c]); // move out to an position out for the new branch int newPosition = commitPosition[c] + 1; while (commitPosition.ContainsValue(newPosition) && (newPosition <= commitPosition.Values.Max())) { newPosition++; } commitPosition[p2] = newPosition; commitPosition[p1] = commitPosition[c]; // Draw ├─┐ Console.Write("\u251C\u2500"); DrawMergePositionSpacer(commitPosition[c] + 1, commitPosition[p2]); Console.Write("\u2510 "); DrawPositionSpacer(commitPosition[p2] + 1, maxPosition); Console.WriteLine(); } else if (!commitPosition.ContainsKey(p1)) { commitPosition[p1] = commitPosition[c]; // this branch is merged several times startPos = Math.Min(commitPosition[p2], commitPosition[c]); DrawPositionSpacer(0, startPos); // draws something like: ├─┤ Console.Write("\u251C\u2500"); endPos = Math.Max(commitPosition[p2], commitPosition[c]); DrawMergePositionSpacer(startPos + 1, endPos); Console.Write("\u2524 "); DrawPositionSpacer(endPos + 1, maxPosition); Console.WriteLine(); } //else //{ // DrawPositionSpacer(0, commitPosition[p2]); // Console.Write("\u251C\u2500"); // DrawMergePositionSpacer(commitPosition[p2] + 1, commitPosition[c]); // Console.WriteLine("\u2524"); //} } else { if (!commitPosition.ContainsKey(p1)) { commitPosition[p1] = commitPosition[c]; } if (commitPosition[p1] != commitPosition[c]) { int startPos = Math.Min(commitPosition[p1], commitPosition[c]); DrawPositionSpacer(0, startPos); // Draw ├─┘ Console.Write("\u251C\u2500"); int endPos = Math.Max(commitPosition[p1], commitPosition[c]); DrawMergePositionSpacer(startPos + 1, endPos); Console.Write("\u2518 "); DrawPositionSpacer(endPos + 1, maxPosition); Console.WriteLine(); // c is now merged back, no need to keep track of it (or any other commit on this branch) // this way we can reuse the position for another branch foreach (var kvp in commitPosition.Where((KeyValuePair <Commit, int> kvp) => kvp.Value == endPos).ToList()) { commitPosition.Remove(kvp.Key); } commitPosition[p1] = startPos; foreach (var kvp in commitPosition.Where((KeyValuePair <Commit, int> kvp) => kvp.Value == startPos).ToList()) { if (kvp.Key != p1) { commitPosition.Remove(kvp.Key); } } } } } } } } return(0); }
public ChangeSet GetChangeSet(string id) { using (var repo = new LibGit2Sharp.Repository(RepositoryPath)) { LibGit2Sharp.Commit commit = repo.Lookup<LibGit2Sharp.Commit>(id); if (commit == null) { return null; } return new ChangeSet(commit.Sha, commit.Author.Name, commit.Author.Email, commit.Message, commit.Author.When); } }
public void StartExternalDiff(ITextDocument textDocument) { if (textDocument == null || string.IsNullOrEmpty(textDocument.FilePath)) return; var filename = textDocument.FilePath; if (textDocument.IsDirty) { var docu = _dte.Documents.AllDocuments().FirstOrDefault(doc => doc.FullName == filename); if (docu != null) { docu.Save(); } }; var discoveredPath = Repository.Discover(Path.GetFullPath(filename)); using (var repo = new Repository(discoveredPath)) { var diffGuiTool = repo.Config.Get<string>("diff.guitool"); if (diffGuiTool == null) return; var diffCmd = repo.Config.Get<string>("difftool." + diffGuiTool.Value + ".path"); var indexEntry = repo.Index[filename.Replace(repo.Info.WorkingDirectory, "")]; var blob = repo.Lookup<Blob>(indexEntry.Id); var tempFileName = Path.GetTempFileName(); File.WriteAllText(tempFileName, blob.GetContentText()); var process = new Process { StartInfo = { FileName = diffCmd.Value, Arguments = String.Format("{0} {1}", tempFileName, filename) } }; process.Start(); } }
public bool DoesBranchContainCommit(string branchName, string commitOrBranchName) { using (var repo = new LibGit2Sharp.Repository(RepositoryPath)) { var branch = repo.Branches[branchName]; if (branch == null) return false; return repo.Refs.ReachableFrom( new[] { repo.Refs[branch.CanonicalName] }, new[] { repo.Lookup<Commit>(commitOrBranchName) }).Any(); } }
public List <TaskTimeItem> GetRepositoryLog(Settings settings, string currentRepository, DateTime?date = null, CancellationToken cancellationToken = default) { if (string.IsNullOrEmpty(currentRepository) || !Directory.Exists(currentRepository)) { _log.Error("Папка с репо не сушествует."); return(new List <TaskTimeItem>()); } date = date.GetValueOrDefault(DateTime.Now.Date); var workTasks = new List <TaskTimeItem>(); foreach (var repoDirectory in Directory.GetDirectories(currentRepository, ".git", SearchOption.AllDirectories)) { if (cancellationToken.IsCancellationRequested) { return(new List <TaskTimeItem>()); } //var project = new DirectoryInfo(repoDirectory).Name; var repoRootDirectory = repoDirectory.Replace(".git", ""); var directoryInfo = new DirectoryInfo(repoRootDirectory); if (!directoryInfo.Exists) { continue; } var repo = new LibGit2Sharp.Repository(repoRootDirectory); if (settings.PullBeforeProcess) { try { // Credential information to fetch LibGit2Sharp.PullOptions options = new LibGit2Sharp.PullOptions(); options.FetchOptions = new FetchOptions(); // User information to create a merge commit var signature = new LibGit2Sharp.Signature(new Identity("MERGE_USER_NAME", "MERGE_USER_EMAIL"), DateTimeOffset.Now); // Pull Commands.Pull(repo, signature, options); } catch (Exception ex) { _log?.Trace($" - Не получается сделать pull для репозитория: {directoryInfo.Name} - {ex.Message}"); } } var allCommits = new List <Commit>(); var reflog = repo.Refs.Log(repo.Refs.Head); foreach (var reflogItem in reflog) { var dateMatch = date.Value.Date == reflogItem.Committer.When.Date; var committerEmail = reflogItem.Committer.Email; var userMatch = committerEmail.Equals(settings.MercurialAuthorEmail, StringComparison.CurrentCultureIgnoreCase) || committerEmail.Equals(settings.AlternativeEmail, StringComparison.CurrentCultureIgnoreCase); if (!dateMatch || !userMatch) { continue; } var commit = repo.Lookup <LibGit2Sharp.Commit>(reflogItem.To.Sha); if (commit != null && allCommits.All(f => f.Sha != commit.Sha)) { allCommits.Add(commit); } } foreach (Commit commit in allCommits) { if (cancellationToken.IsCancellationRequested) { return(new List <TaskTimeItem>()); } var userMatch = commit.Author.Email.Equals(settings.MercurialAuthorEmail, StringComparison.CurrentCultureIgnoreCase) || commit.Author.Email.Equals(settings.AlternativeEmail, StringComparison.CurrentCultureIgnoreCase); if (commit.Author.When.DateTime.Date != date.Value.Date || !userMatch) { continue; } var regex = new Regex("[a-zA-Z0-9]{1,5}-[0-9]{1,6}"); var branch = ListBranchesContainsCommit(repo, commit.Sha) .Select(f => f.FriendlyName) .FirstOrDefault(f => regex.IsMatch(f)); //.Where(f => f.Contains("-") && !f.Contains("/")).Distinct().FirstOrDefault(); if (branch == null) { continue; } branch = regex.Match(branch).Value; var commitMessage = commit.MessageShort; commitMessage = _technicalInfoSkipper.StripBranchPrefix(branch, commitMessage); if (_commitSkipper.IsNeedToSkip(branch, commitMessage)) { continue; } commitMessage = _technicalInfoSkipper.StripTechnicalInfo(commitMessage); var files = FilesToMerge(commit, repo); var task = new TaskTimeItem(branch, commitMessage, directoryInfo.Name, commit.Committer.When.DateTime, TimeSpan.Zero, 1, files.Length, //changeset.PathActions.Count, "", GetCommitType(branch)); workTasks.Add(task); _log?.Trace($" - Найден commit: {commit.Committer.When.DateTime} - {branch} - {commit.Author.Email} - {commitMessage}"); } } if (!workTasks.Any()) { return(new List <TaskTimeItem>()); } return(workTasks); }