Lookup() public method

Try to lookup an object by its ObjectId and GitObjectType. If no matching object is found, null will be returned.
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
Ejemplo n.º 1
0
        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")));
        }
Ejemplo n.º 2
0
        /// <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));
        }
Ejemplo n.º 3
0
        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");
        }
Ejemplo n.º 4
0
 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 ) );
     }
 }
Ejemplo n.º 5
0
 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;
 }
Ejemplo n.º 6
0
 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;
 }
Ejemplo n.º 7
0
 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;
 }
Ejemplo n.º 8
0
        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));
            }
        }
Ejemplo n.º 10
0
        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;
                    }
                }
            }
        }
Ejemplo n.º 11
0
 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;
 }
Ejemplo n.º 12
0
        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);
        }
Ejemplo n.º 14
0
        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();
        }
Ejemplo n.º 15
0
        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)))
                       };
        }
Ejemplo n.º 16
0
        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);
        }
Ejemplo n.º 17
0
 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());
     }
 }
Ejemplo n.º 18
0
        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);
        }
Ejemplo n.º 19
0
        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();
                }
            }));
        }
Ejemplo n.º 20
0
 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;
     };
 }
Ejemplo n.º 21
0
        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;
            }
        }
Ejemplo n.º 22
0
        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}");
            }
        }
Ejemplo n.º 23
0
        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;
                    }
                }
            }
        }
Ejemplo n.º 24
0
        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;
        }
Ejemplo n.º 25
0
        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);
            }
        }
Ejemplo n.º 26
0
        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();
        }
Ejemplo n.º 27
0
 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);
         }
     }
 }
Ejemplo n.º 28
0
        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();
            }
              }
        }
Ejemplo n.º 29
0
        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();
                }
            }));
        }
Ejemplo n.º 30
0
        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"));
                }
            }
        }
Ejemplo n.º 31
0
        /// <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);
        }
Ejemplo n.º 32
0
        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);
            }
        }
Ejemplo n.º 33
0
        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)));
            }
        }
Ejemplo n.º 34
0
        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);
                }
            }
        }
Ejemplo n.º 35
0
        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;
        }
Ejemplo n.º 36
0
 /// <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;
        }
Ejemplo n.º 38
0
        /// <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.
        }
Ejemplo n.º 39
0
        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);
        }
Ejemplo n.º 40
0
        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);
                }
            }
        }
Ejemplo n.º 41
0
 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);
         }
     }
 }
Ejemplo n.º 42
0
        //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)));
        }
Ejemplo n.º 43
0
        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);
            }
        }
Ejemplo n.º 44
0
 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);
     }
 }
Ejemplo n.º 45
0
 public static TreeChanges GetChangedFiles(LibGit2Sharp.Repository repo, string refRev)
 {
     return(GitUtil.CompareCommits(repo, repo.Lookup <Commit> (refRev), repo.Head.Tip));
 }
Ejemplo n.º 46
0
        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);
        }
Ejemplo n.º 47
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);
            }
        }
Ejemplo n.º 48
0
        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();
            }
        }
Ejemplo n.º 49
0
 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();
     }
 }
Ejemplo n.º 50
0
        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);
        }