Inheritance: IDisposable
        internal static async Task<GitActionResult<string>> Commit(GitRepository repository, string message, bool signoff = false)
        {
            var result = new GitActionResult<string>();

            SolutionExtensions.WriteMessageToOutputPane("Commiting");

            if (String.IsNullOrWhiteSpace(message))
            {
                result.Succeeded = false;
                result.ErrorMessage = ErrorMessages.CommitMissingComment;
                SolutionExtensions.WriteMessageToOutputPane(ErrorMessages.CommitMissingComment);
                return result;
            }

            var stagedCount = repository?.ChangedFiles.Count(f => f.IsStaged) ?? 0;

            if (stagedCount <= 0)
            {
                result.Succeeded = false;
                result.ErrorMessage = ErrorMessages.CommitNoFilesStaged;
                SolutionExtensions.WriteMessageToOutputPane(ErrorMessages.CommitNoFilesStaged);
                return result;
            }

            result = repository?.Commit(message, false, signoff);
            if (result.Succeeded)
            {
                SolutionExtensions.WriteMessageToOutputPane("Commit successfully. Commit Hash: " + result.Item);
            }
            return result;

        }
        public static IEnumerable<string> GetOptions(GitRepository tracker, string command)
        {
            if (tracker == null) return new string[] { };
            var options = Commands.Where(i => Regex.IsMatch(command, i.Key)).Select(i => i.Value).FirstOrDefault();
            if (options == null) return new string[] { };
            switch (options[0])
            {
                case "*branches*":
                    return tracker.RepositoryGraph.Refs
                        .Where(r => r.Type == RefTypes.Branch)
                        .Select(r => r.Name);

                case "*tags*":
                    return tracker.RepositoryGraph.Refs
                        .Where(r => r.Type == RefTypes.Tag)
                        .Select(r => r.Name);

                case "*remotes*":
                    return tracker.Remotes;

                case "*configs*":
                    return tracker.Configs.Keys;

                case "*commits*":
                    return tracker.RepositoryGraph.Commits
                        .OrderByDescending(c=>c.AuthorDate)
                        .Select(r => r.ShortId);
            }

            if (options[0].Contains("|")) 
                return options[0].Split('|');
            else
                return options;
        }
Example #3
0
 public void WorkingDirectoryTest()
 {
     GitRepository.Init(tempFolder);
     var newFolder = tempFolder + "\\t t\\a a";
     Directory.CreateDirectory(newFolder);
     GitRepository tracker = new GitRepository(newFolder);
     Assert.AreEqual(tempFolder.Replace("\\", "/"), tracker.WorkingDirectory);
 }
Example #4
0
        public void AmendCommitTest()
        {
            GitRepository.Init(tempFolder);
            File.WriteAllLines(tempFilePath, lines);

            GitRepository tracker = new GitRepository(tempFolder);
            tracker.StageFile(tempFile);

            tracker.Commit("中文 1čtestč");
            Assert.IsTrue(tracker.LastCommitMessage.Equals("中文 1čtestč"));

            File.WriteAllText(tempFile, "changed text");
            tracker.StageFile(tempFile);
            tracker.Commit("new message", true);
            Assert.IsTrue(tracker.LastCommitMessage.Equals("new message"));
        }
Example #5
0
        public void CheckOutFileTest()
        {
            GitRepository.Init(tempFolder);
            File.WriteAllLines(tempFilePath, lines);

            GitRepository tracker = new GitRepository(tempFolder);
            tracker.StageFile(tempFile);
            tracker.Commit("test");

            File.WriteAllText(tempFilePath, "changed text");
            tracker.CheckOutFile(tempFile);
            var newlines = File.ReadAllLines(tempFilePath);
            Assert.AreEqual(lines[0], newlines[0]);
            Assert.AreEqual(lines[1], newlines[1]);
            Assert.AreEqual(lines[2], newlines[2]);
        }
        //TODO mode ot RepoManager
        public static DiffFileInfo GenerateDiffFileInfo(GitRepository repository, string filename)
        {
            var info = new DiffFileInfo();

            info.ActualFilename = Path.GetFileName(filename);
            info.ModifiedFilePath = filename;
            info.LastRevision = repository.GetRevision(filename);

            var filetype = Path.GetExtension(filename);

            //write unmodified file to disk
            var unmodifiedFile = repository.GetUnmodifiedFileByAbsolutePath(filename);
            var tempFileName = Path.GetTempFileName() + filetype;
            File.WriteAllText(tempFileName, unmodifiedFile);
            info.UnmodifiedFilePath = tempFileName;

            return info;
        }
        internal static async Task<GitActionResult<string>> AmendCommit(GitRepository repository, string message, bool signoff = false)
        {
            var result = new GitActionResult<string>();

            SolutionExtensions.WriteMessageToOutputPane("Amending Commiti");

            if (String.IsNullOrWhiteSpace(message))
            {
                result.Succeeded = false;
                result.ErrorMessage = ErrorMessages.CommitMissingComment;
                SolutionExtensions.WriteMessageToOutputPane(ErrorMessages.CommitMissingComment);
                return result;
            }

            result = repository?.Commit(message, true, signoff);
            if (result.Succeeded)
            {
                SolutionExtensions.WriteMessageToOutputPane("Amend last commit successfully. Commit Hash: " + result.Item);
            }
            return result;

        }
 public GitRepositoryEvent(GitRepository repository)
 {
     Repository = repository;
 }
Example #9
0
 internal void Refresh(GitRepository tracker)
 {
     this.tracker = tracker;
     RefreshPrompt();
 }
Example #10
0
        public void DiffFileTest()
        {
            GitRepository.Init(tempFolder);
            File.WriteAllLines(tempFilePath, lines);

            GitRepository tracker = new GitRepository(tempFolder);
            tracker.StageFile(tempFile);
            tracker.Commit("test message");
            File.WriteAllText(tempFilePath, "changed text");
            var diffFile = tracker.DiffFile(tempFile);
            var diff = File.ReadAllText(diffFile);
            Assert.IsTrue(diff.Contains("@@ -1,3 +1 @@"));
        }
Example #11
0
        public void SaveFileFromRepositoryTest()
        {
            GitRepository.Init(tempFolder);
            File.WriteAllLines(tempFilePath, lines);

            GitRepository tracker = new GitRepository(tempFolder);
            tracker.StageFile(tempFile);
            tracker.Commit("test");

            var tmp = Path.Combine(Path.GetTempPath(), tempFile) + ".bk";
            tracker.SaveFileFromLastCommit(tempFile, tmp);
            var newlines = File.ReadAllLines(tmp);
            Assert.AreEqual(lines[0], newlines[0]);
            Assert.AreEqual(lines[1], newlines[1]);
            Assert.AreEqual(lines[2], newlines[2]);
        }
Example #12
0
 private void CloseRepository()
 {
     trackers.Clear();
     previousRepository = null;
     UnWatchFileChanges();
 }
 private async Task UpdateSolutionFiles(GitRepository repo, List<GitFile> files, bool force = false)
 {
     if (!_solutionUpdating || force)
     {
         _solutionUpdating = true;
         await UpdateSolutionFileStatus(repo, files);
         if (_updateQueued)
         {
             _updateQueued = false;
             await UpdateSolutionFiles(repo, repo.ChangedFiles.ToList(),true);
         }
         _solutionUpdating = false;
     }
     else
     {
         _updateQueued = true;
     }
 }
Example #14
0
 public void LastCommitMessageTest()
 {
     GitRepository.Init(tempFolder);
     File.WriteAllLines(tempFilePath, lines);
     GitRepository tracker = new GitRepository(tempFolder);
     tracker.StageFile(tempFile);
     tracker.Commit("中文 1čtestč");
     Assert.IsTrue(tracker.LastCommitMessage.Equals("中文 1čtestč"));
 }
Example #15
0
        public void GetChangedFilesTest()
        {
            GitRepository.Init(tempFolder);
            File.WriteAllLines(tempFilePath, lines);

            GitRepository tracker = new GitRepository(tempFolder);
            tracker.StageFile(tempFile);
            tracker.Refresh();
            Assert.AreEqual(GitFileStatus.Added, tracker.GetFileStatus(tempFile));
            tracker.Commit("中文 1čtestč");
            tracker.Refresh();
            Assert.AreEqual(0, tracker.ChangedFiles.Count());
            File.WriteAllText(tempFilePath, "a");
            tracker.Refresh();
            Assert.AreEqual(GitFileStatus.Modified, tracker.GetFileStatus(tempFile));
        }
Example #16
0
        public void GetFileStatusTest()
        {
            GitRepository.Init(tempFolder);
            GitRepository tracker = new GitRepository(tempFolder);

            File.WriteAllLines(tempFilePath, lines);
            Assert.AreEqual(GitFileStatus.New, tracker.GetFileStatus(tempFile));

            tracker.StageFile(tempFile);
            tracker.Refresh();
            Assert.AreEqual(GitFileStatus.Added, tracker.GetFileStatus(tempFile));

            tracker.UnStageFile(tempFile);
            tracker.Refresh();
            Assert.AreEqual(GitFileStatus.New, tracker.GetFileStatus(tempFile));

            tracker.StageFile(tempFile);
            tracker.Refresh();
            Assert.AreEqual(GitFileStatus.Added, tracker.GetFileStatus(tempFile));

            tracker.Commit("中文 1čtestč");
            tracker.Refresh();
            Assert.AreEqual(GitFileStatus.Tracked, tracker.GetFileStatus(tempFile));

            File.WriteAllText(tempFilePath, "changed text");
            tracker.Refresh();
            Assert.AreEqual(GitFileStatus.Modified, tracker.GetFileStatus(tempFile));

            tracker.StageFile(tempFile);
            tracker.Refresh();
            Assert.AreEqual(GitFileStatus.Staged, tracker.GetFileStatus(tempFile));

            tracker.UnStageFile(tempFile);
            tracker.Refresh();
            Assert.AreEqual(GitFileStatus.Modified, tracker.GetFileStatus(tempFile));

            File.Delete(tempFilePath);
            tracker.Refresh();
            Assert.AreEqual(GitFileStatus.Deleted, tracker.GetFileStatus(tempFile));

            tracker.StageFile(tempFile);
            tracker.Refresh();
            Assert.AreEqual(GitFileStatus.Removed, tracker.GetFileStatus(tempFile));

            tracker.UnStageFile(tempFile);
            tracker.Refresh();
            Assert.AreEqual(GitFileStatus.Deleted, tracker.GetFileStatus(tempFile));
        }
Example #17
0
        private void CloseRepository()
        {
            //Repository = null;
            trackers.Clear();

            previousRepository = null;
            UnWatchFileChanges();

            //if (VSConstants.VSCOOKIE_NIL != _vsIVsFileChangeEventsCookie)
            //{
            //    IVsFileChangeEx fileChangeService = package.GetServiceEx<SVsFileChangeEx>() as IVsFileChangeEx;
            //    fileChangeService.UnadviseDirChange(_vsIVsFileChangeEventsCookie);
            //    // Debug.WriteLine("==== Stop Monitoring: " + _vsIVsFileChangeEventsCookie.ToString());
            //    _vsIVsFileChangeEventsCookie = VSConstants.VSCOOKIE_NIL;
            //    lastMinotorFolder = "";
            //}
        }
Example #18
0
        public void GetBranchTest()
        {
            GitRepository.Init(tempFolder);
            File.WriteAllLines(tempFilePath, lines);

            GitRepository tracker = new GitRepository(tempFolder);
            Assert.AreEqual("master", tracker.CurrentBranch);

            tracker.StageFile(tempFile);
            Assert.AreEqual("master", tracker.CurrentBranch);

            tracker.Commit("test message");
            Assert.AreEqual("master", tracker.CurrentBranch);

            tempFile = tempFile.Replace("test", "TEST");
            File.WriteAllText(tempFilePath, "changed text");

            tracker.CheckOutBranch("dev", true);
            Assert.AreEqual("dev", tracker.CurrentBranch);
        }
        private GitChangesetManager GetChangesetManager(GitRepository repo)
        {
            if(!_fileChangesetManager.ContainsKey(repo))
            {
                //Get the inital state of the repo.. I guess :)
                _fileChangesetManager.Add(repo, new GitChangesetManager());
            }

            return _fileChangesetManager[repo];
        }
        private async Task ProcessMultiFileChange(GitRepository repo, GitFilesUpdateEventArgs e)
        {
            //lock (_glyphsLock)
            //{
                HashSet<IVsSccProject2> nodes = new HashSet<IVsSccProject2>();
                foreach (var file in e.Files)
                {
                    var items = _fileCache.GetProjectsSelectionForFile(file);
                    if (items != null)
                    {
                        foreach (var vsitemselection in items)
                        {
                           
                            nodes.Add(vsitemselection);
                        }
                    }
                }
                if (nodes.Count > 0)
                {
                Debug.WriteLine("Updating Multiple Files");
                await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
                foreach (var project in nodes)
                {
                   
                    project.SccGlyphChanged(0, null, null, null);
                }
            }

                //todo maybe move this
                var caption = "Solution Explorer";
                string branch = await GetCurrentBranchNameAsync();
                if (!string.IsNullOrEmpty(branch))
                {
                    caption += " (" + branch + ")";
                    SetSolutionExplorerTitle(caption);
                }
           // }
        }
        private async Task UpdateSolutionFileStatus(GitRepository repo, List<GitFile> files)
        {
            HashSet<IVsSccProject2> nodes = new HashSet<IVsSccProject2>();
            var changeSet = GetChangesetManager(repo).LoadChangeSet(files);
            foreach (var file in changeSet)
            {
                ////if (_fileCache.StatusChanged(file.Key.t, file.Status))
                ////{

                var items = _fileCache.GetProjectsSelectionForFile(file.Key.ToLower());
                if (items != null)
                {
                    foreach (var vsitemselection in items)
                    {

                        nodes.Add(vsitemselection);
                    }
                }
                await Task.Run(async delegate
                {
                    await RefreshProjectGlyphs(nodes.ToList());
                });
            }
        }
 private GitChangesetManager GetChangesetManager(GitRepository repo)
 {
     GitChangesetManager manager;
     if (!_fileChangesetManager.TryGetValue(repo, out manager))
     {
         manager = new GitChangesetManager();
         _fileChangesetManager.TryAdd(repo, manager);
     }
     return manager;
 }
Example #23
0
        public void HasGitRepositoryTest()
        {
            GitRepository.Init(tempFolder);
            GitRepository tracker = new GitRepository(tempFolder);

            Assert.IsTrue(tracker.IsGit);
            Assert.IsTrue(Directory.Exists(tempFolder + "\\.git"));
        }
Example #24
0
        public void FileNameCaseTest()
        {
            GitRepository.Init(tempFolder);
            File.WriteAllLines(tempFilePath, lines);

            GitRepository tracker = new GitRepository(tempFolder);
            tracker.StageFile(tempFile);

            tracker.Commit("test message");
            Assert.IsTrue(tracker.LastCommitMessage.StartsWith("test message"));
            tempFile = tempFile.Replace("test", "TEST");
            File.WriteAllText(tempFilePath, "changed text");
            tracker.Refresh();
            //This test fails all cases because status check uses ngit, never git.exe
            //Assert.AreEqual(GitFileStatus.Modified, tracker.GetFileStatus(tempFile));

            var file = tracker.ChangedFiles.First();
            Assert.AreEqual(GitFileStatus.Modified, file.Status);
        }
 private async Task ProcessFileStatusUpdate(GitRepository repo, GitFilesStatusUpdateEventArgs e)
 {
     //await UpdateSolutionFiles(repo, e.Files);
     await UpdateSolutionFileStatus(repo, e.Files);
 }