private static void AssertStage(bool?ignorecase, IRepository repo, string path) { try { repo.Stage(path); Assert.Equal(FileStatus.Added, repo.RetrieveStatus(path)); repo.Reset(); Assert.Equal(FileStatus.Untracked, repo.RetrieveStatus(path)); } catch (ArgumentException) { Assert.False(ignorecase ?? true); } }
private static void AssertStage(bool?ignorecase, IRepository repo, string path) { try { repo.Stage(path); Assert.Equal(FileStatus.NewInIndex, repo.RetrieveStatus(path)); repo.Index.Replace(repo.Head.Tip); Assert.Equal(FileStatus.NewInWorkdir, repo.RetrieveStatus(path)); } catch (ArgumentException) { Assert.False(ignorecase ?? true); } }
public RepositoryStatus Commit() { UnstageAll(); var status = repo.RetrieveStatus(); var filesToCommit = status.Where(f => f.State != FileStatus.Ignored); foreach (var entry in filesToCommit) { CommitFile(entry.FilePath); } return(status); }
public IndexViewModel(IRepository repo) { this.repo = repo; this.refreshCommand = ReactiveCommand.Create(); this.repositoryStatus = this.refreshCommand.Select(u => { return repo.RetrieveStatus(new StatusOptions() { Show = StatusShowOption.IndexAndWorkDir }); }).ToProperty(this, vm => vm.RepositoryStatus); this.statusEntries = this .WhenAny(vm => vm.RepositoryStatus, change => { var status = change.GetValue(); return status.CreateDerivedCollection(s => s, null, null, null, this.refreshCommand); }).ToProperty(this, vm => vm.StatusEntries); var resetSignal = this.WhenAny(vm => vm.StatusEntries, change => { return 0; }); var allEntries = this.WhenAny(vm => vm.StatusEntries, change => change.GetValue()); this.unstagedEntries = allEntries.Select(s => { return s.CreateDerivedCollection(i => i, i => Unstaged(i.State), null, resetSignal); }).ToProperty(this, vm => vm.UnstagedEntries); this.stagedEntries = allEntries.Select(s => { return s.CreateDerivedCollection(i => i, i => Staged(i.State), null, resetSignal); }).ToProperty(this, vm => vm.StagedEntries); }
private Task Open(string filePath) { var status = repository.RetrieveStatus(new StatusOptions { PathSpec = new[] { filePath } })[filePath]; if (status == null) { return(Task.CompletedTask); } switch (status.State) { case FileStatus.NewInIndex: case FileStatus.NewInWorkdir: case FileStatus.RenamedInIndex: case FileStatus.RenamedInWorkdir: case FileStatus.Unaltered: RunTool(editorTool, repository.GetFullPath(filePath)); break; case FileStatus.ModifiedInIndex: case FileStatus.ModifiedInWorkdir: Diff(filePath); break; default: return(Task.CompletedTask); } return(Task.CompletedTask); }
public Task <bool> IsModified(IRepository repository, string path, byte[] contents) { Guard.ArgumentNotNull(repository, nameof(repository)); Guard.ArgumentNotEmptyString(path, nameof(path)); return(Task.Factory.StartNew(() => { if (repository.RetrieveStatus(path) == FileStatus.Unaltered) { var treeEntry = repository.Head[path]; if (treeEntry?.TargetType != TreeEntryTargetType.Blob) { return false; } var blob1 = (Blob)treeEntry.Target; using (var s = contents != null ? new MemoryStream(contents) : new MemoryStream()) { var blob2 = repository.ObjectDatabase.CreateBlob(s, path); var diff = repository.Diff.Compare(blob1, blob2); return diff.LinesAdded != 0 || diff.LinesDeleted != 0; } } return true; })); }
private static IEnumerable <string> RemoveStagedItems(IRepository repository, IEnumerable <string> paths, bool removeFromWorkingDirectory = true, ExplicitPathsOptions explicitPathsOptions = null) { var removed = new List <string>(); using (var changes = repository.Diff.Compare <TreeChanges>(DiffModifiers.IncludeUnmodified | DiffModifiers.IncludeUntracked, paths, explicitPathsOptions)) { var index = repository.Index; foreach (var treeEntryChanges in changes) { var status = repository.RetrieveStatus(treeEntryChanges.Path); switch (treeEntryChanges.Status) { case ChangeKind.Added: case ChangeKind.Deleted: removed.Add(treeEntryChanges.Path); index.Remove(treeEntryChanges.Path); break; case ChangeKind.Unmodified: if (removeFromWorkingDirectory && ( status.HasFlag(FileStatus.ModifiedInIndex) || status.HasFlag(FileStatus.NewInIndex))) { throw new RemoveFromIndexException("Unable to remove file '{0}', as it has changes staged in the index. You can call the Remove() method with removeFromWorkingDirectory=false if you want to remove it from the index only.", treeEntryChanges.Path); } removed.Add(treeEntryChanges.Path); index.Remove(treeEntryChanges.Path); continue; case ChangeKind.Modified: if (status.HasFlag(FileStatus.ModifiedInWorkdir) && status.HasFlag(FileStatus.ModifiedInIndex)) { throw new RemoveFromIndexException("Unable to remove file '{0}', as it has staged content different from both the working directory and the HEAD.", treeEntryChanges.Path); } if (removeFromWorkingDirectory) { throw new RemoveFromIndexException("Unable to remove file '{0}', as it has local modifications. You can call the Remove() method with removeFromWorkingDirectory=false if you want to remove it from the index only.", treeEntryChanges.Path); } removed.Add(treeEntryChanges.Path); index.Remove(treeEntryChanges.Path); continue; default: throw new RemoveFromIndexException("Unable to remove file '{0}'. Its current status is '{1}'.", treeEntryChanges.Path, treeEntryChanges.Status); } } index.Write(); return(removed); } }
public Model(IRepository repository) { mRepository = repository; mShortHash = new Lazy <string>(() => mRepository.Commits.First().Sha.Substring(0, 7)); mBranch = new Lazy <string>(() => mRepository.Head.CanonicalName); mHasLocalChange = new Lazy <string>(() => mRepository.RetrieveStatus().IsDirty.ToString(CultureInfo.InvariantCulture)); #if DEBUG mBuildConfig = "DEBUG"; #else mBuildConfig = "RELEASE"; #endif var commit = mRepository.Commits.First(); string hash = mRepository.Commits.First().Sha.Substring(0, 7); string tag = String.Empty; try { tag = repository.Describe(commit, new DescribeOptions { Strategy = DescribeStrategy.Tags }); } catch (LibGit2SharpException) { // use default gitDescription value } string dirty = mRepository.RetrieveStatus().IsDirty ? "-dirty" : String.Empty; Match descMatch = Regex.Match(tag, @"(\d+)\.(\d+)\.(\d+)"); if (descMatch.Success) { mMajor = new Lazy <string>(() => descMatch.Groups[1].Value.ToString(CultureInfo.InvariantCulture)); mMinor = new Lazy <string>(() => descMatch.Groups[2].Value.ToString(CultureInfo.InvariantCulture)); mBuild = new Lazy <string>(() => descMatch.Groups[3].Value.ToString(CultureInfo.InvariantCulture)); } else { mMajor = new Lazy <string>(() => "0".ToString(CultureInfo.InvariantCulture)); mMinor = new Lazy <string>(() => "0".ToString(CultureInfo.InvariantCulture)); mBuild = new Lazy <string>(() => "0".ToString(CultureInfo.InvariantCulture)); } mRevision = new Lazy <string>(() => mRepository.Commits.Count().ToString(CultureInfo.InvariantCulture)); mDescription = $"{mMajor.Value}.{mMinor.Value}.{mBuild.Value}.{mRevision.Value}{dirty}"; }
public FileStatus Get(string filePath) { if (string.IsNullOrEmpty(filePath)) { throw new ArgumentException(nameof(filePath)); } return(_repo.RetrieveStatus(filePath)); }
public IEnumerable <RepositoryStatus> GetRepositoryStatus() { var retrivedStatus = _repository.RetrieveStatus(); return(retrivedStatus.Where(x => x.State != FileStatus.Ignored) .Select(d => new RepositoryStatus() { FilePath = d.FilePath, FileStatus = (int)d.State })); }
public IEnumerable <StatusItem> GetAll() { var retrivedStatus = repository.RetrieveStatus(); return(retrivedStatus.Where(x => x.State != FileStatus.Ignored) .Select(d => new StatusItem() { Path = d.FilePath, Status = d.State }).ToList()); }
public IEnumerable <StatusEntry> Status() { try { return(_repo.RetrieveStatus()); } catch (LibGit2SharpException ex) { throw new GitException("Failed to retrieve repository status.", ex); } }
private static void AssertStatus(bool shouldIgnoreCase, FileStatus expectedFileStatus, IRepository repo, string path) { try { Assert.Equal(expectedFileStatus, repo.RetrieveStatus(path)); } catch (ArgumentException) { Assert.False(shouldIgnoreCase); } }
public Model(IRepository repository) { mRepository = repository; mRevision = new Lazy <string>(() => mRepository.Commits.Count().ToString(CultureInfo.InvariantCulture)); mShortHash = new Lazy <string>(() => mRepository.Commits.First().Sha.Substring(0, 7)); mBranch = new Lazy <string>(() => mRepository.Head.CanonicalName); mHasLocalChange = new Lazy <string>(() => mRepository.RetrieveStatus().IsDirty.ToString(CultureInfo.InvariantCulture)); #if DEBUG mBuildConfig = "DEBUG"; #else mBuildConfig = "RELEASE"; #endif }
private static List <string> GetUncommitedFiles(IRepository repository) { var newInIndex = new List <string>(); foreach (var item in repository.RetrieveStatus(new StatusOptions())) { if (FileIsNotCommited(item)) { newInIndex.Add(item.FilePath); } } return(newInIndex); }
public Model(IRepository repository) { mRepository = repository; mRevision = new Lazy<string>(() => mRepository.Commits.Count().ToString(CultureInfo.InvariantCulture)); mShortHash = new Lazy<string>(() => mRepository.Commits.Last().Sha.Substring(0, 7)); mBranch = new Lazy<string>(() => mRepository.Head.CanonicalName); mHasLocalChange = new Lazy<string>(() => mRepository.RetrieveStatus().IsDirty.ToString(CultureInfo.InvariantCulture)); #if DEBUG mBuildConfig = "DEBUG"; #else mBuildConfig = "RELEASE"; #endif }
public ChangesView(IRepository repository, IEventStream eventStream) : base("Changes") { this.repository = repository; this.eventStream = eventStream; var status = repository.RetrieveStatus(new StatusOptions()); view = new ListView <FileStatus>() { AllowsMarking = true }; view.SelectedChanged += OnSelectedChanged; Content = view; }
public static GitRepository FromRepository(IRepository repository) => new GitRepository( repository.Branches.Select( branch => new GitBranch( branch.IsRemote, branch.RemoteName, branch.FriendlyName, branch.IsCurrentRepositoryHead, branch.Commits.Select( commit => new GitCommit(commit.Sha)).ToList())).ToList(), repository.Commits.OrderTopological().Select( commit => new GitCommit(commit.Sha)).ToList(), repository.Tags.Select( tag => new GitTag( tag.FriendlyName, tag.PeeledTarget.Sha)).ToList(), repository.RetrieveStatus().IsDirty);
private static void FeedTheRepository(IRepository repo) { string fullPath = Touch(repo.Info.WorkingDirectory, "a.txt", "Hello\n"); repo.Stage(fullPath); repo.Commit("Initial commit", Constants.Signature, Constants.Signature); repo.ApplyTag("mytag"); File.AppendAllText(fullPath, "World\n"); repo.Stage(fullPath); Signature shiftedSignature = Constants.Signature.TimeShift(TimeSpan.FromMinutes(1)); repo.Commit("Update file", shiftedSignature, shiftedSignature); repo.CreateBranch("mybranch"); repo.Checkout("mybranch"); Assert.False(repo.RetrieveStatus().IsDirty); }
private static Tuple<string, FileStatus> BuildFrom(IRepository repository, string path) { string relativePath = repository.BuildRelativePathFrom(path); return new Tuple<string, FileStatus>(relativePath, repository.RetrieveStatus(relativePath)); }
public FileStatus RetrieveStatus(string filePath) => repository.RetrieveStatus(filePath);
private static Tuple <string, FileStatus> BuildFrom(IRepository repository, string path) { string relativePath = repository.BuildRelativePathFrom(path); return(new Tuple <string, FileStatus>(relativePath, repository.RetrieveStatus(relativePath))); }
private static IEnumerable<string> RemoveStagedItems(IRepository repository, IEnumerable<string> paths, bool removeFromWorkingDirectory = true, ExplicitPathsOptions explicitPathsOptions = null) { var removed = new List<string>(); using (var changes = repository.Diff.Compare<TreeChanges>(DiffModifiers.IncludeUnmodified | DiffModifiers.IncludeUntracked, paths, explicitPathsOptions)) { var index = repository.Index; foreach (var treeEntryChanges in changes) { var status = repository.RetrieveStatus(treeEntryChanges.Path); switch (treeEntryChanges.Status) { case ChangeKind.Added: case ChangeKind.Deleted: removed.Add(treeEntryChanges.Path); index.Remove(treeEntryChanges.Path); break; case ChangeKind.Unmodified: if (removeFromWorkingDirectory && ( status.HasFlag(FileStatus.ModifiedInIndex) || status.HasFlag(FileStatus.NewInIndex))) { throw new RemoveFromIndexException("Unable to remove file '{0}', as it has changes staged in the index. You can call the Remove() method with removeFromWorkingDirectory=false if you want to remove it from the index only.", treeEntryChanges.Path); } removed.Add(treeEntryChanges.Path); index.Remove(treeEntryChanges.Path); continue; case ChangeKind.Modified: if (status.HasFlag(FileStatus.ModifiedInWorkdir) && status.HasFlag(FileStatus.ModifiedInIndex)) { throw new RemoveFromIndexException("Unable to remove file '{0}', as it has staged content different from both the working directory and the HEAD.", treeEntryChanges.Path); } if (removeFromWorkingDirectory) { throw new RemoveFromIndexException("Unable to remove file '{0}', as it has local modifications. You can call the Remove() method with removeFromWorkingDirectory=false if you want to remove it from the index only.", treeEntryChanges.Path); } removed.Add(treeEntryChanges.Path); index.Remove(treeEntryChanges.Path); continue; default: throw new RemoveFromIndexException("Unable to remove file '{0}'. Its current status is '{1}'.", treeEntryChanges.Path, treeEntryChanges.Status); } } index.Write(); return removed; } }
private static void AssertStage(bool? ignorecase, IRepository repo, string path) { try { Commands.Stage(repo, path); Assert.Equal(FileStatus.NewInIndex, repo.RetrieveStatus(path)); repo.Index.Replace(repo.Head.Tip); Assert.Equal(FileStatus.NewInWorkdir, repo.RetrieveStatus(path)); } catch (ArgumentException) { Assert.False(ignorecase ?? true); } }
private static void AssertStage(bool? ignorecase, IRepository repo, string path) { try { repo.Stage(path); Assert.Equal(FileStatus.Added, repo.RetrieveStatus(path)); repo.Reset(); Assert.Equal(FileStatus.Untracked, repo.RetrieveStatus(path)); } catch (ArgumentException) { Assert.False(ignorecase ?? true); } }
public FileStatus RetrieveStatus(string filePath) { return(repositoryInstance.RetrieveStatus(filePath)); }
public async Task ExecuteAsync(object?parameter = null, CancellationToken cancellation = default) { var repositoryStatus = repository.RetrieveStatus(); var localBranch = repository.Head; var targetBranch = repository.Head.TrackedBranch ?? repository.Head; var dialog = new PullDialog( targetBranch.RemoteName ?? repository.GetDefaultRemoteName(), targetBranch.GetName(), showStashWarning: repositoryStatus.IsDirty, trackRemoteBranch: false, remotes: repository.GetRemoteNames(), branches: repository.GetBranchNames()); if (mainThread.Invoke(() => dialog.ShowDialog()) == true && !string.IsNullOrEmpty(dialog.Branch)) { var targetBranchFriendlyName = string.IsNullOrEmpty(dialog.Remote) ? dialog.Branch : $"{dialog.Remote}/{dialog.Branch}"; targetBranch = repository.Branches.FirstOrDefault(x => x.FriendlyName == targetBranchFriendlyName); if (targetBranch == null) { throw new InvalidOperationException(string.Format("Branch {0} not found", targetBranchFriendlyName)); } eventStream.Push(Status.Start("Pull {0} {1}", targetBranchFriendlyName, dialog.IsFastForward ? "With Fast Fordward" : string.Empty)); var stash = default(Stash); var mergeResult = default(MergeResult); var stashResult = default(StashApplyStatus); // 1. Fetch if (targetBranch.IsRemote) { TryFetch(targetBranch); } // 2. Stash (optional, if the repo is dirty) and Merge try { if (repositoryStatus.IsDirty) { stash = repository.Stashes.Add(Signatures.GetStashSignature(), StashModifiers.IncludeUntracked); } mergeResult = Merge(targetBranch, dialog.IsFastForward); } finally { if (stash != null && repository.Stashes.Contains(stash) && !repository.RetrieveStatus().IsDirty) { stashResult = repository.Stashes.Pop(repository.Stashes.ToList().IndexOf(stash)); } } // 3. Resolve conflicts if (mergeResult?.Status == MergeStatus.Conflicts) { await commandService.RunAsync("ResolveConflicts"); } // 4. Track if (dialog.TrackRemoteBranch) { localBranch.Track(repository, targetBranch); } // 5. Update submodules if (dialog.UpdateSubmodules) { eventStream.Push(Status.Create(0.8f, "Updating submodules...")); repository.UpdateSubmodules(eventStream: eventStream); } eventStream.Push(Status.Finish(mergeResult.Status.ToString())); mainThread.Invoke(() => view.Refresh()); } }
/// <summary> /// Get a value indicating if there are modifications in the current working directory. /// </summary> private void GitModifications(IRepository repo) { var status = repo.RetrieveStatus(new StatusOptions()); this.gitInfo.Added = status.Added.Count(); this.gitInfo.Missing = status.Missing.Count(); this.gitInfo.Modified = status.Modified.Count(); this.gitInfo.Removed = status.Removed.Count(); this.gitInfo.Staged = status.Staged.Count(); this.gitInfo.Changes = this.gitInfo.Added + this.gitInfo.Missing + this.gitInfo.Modified + this.gitInfo.Removed + this.gitInfo.Staged; this.gitInfo.HasModifications = Convert.ToBoolean(this.gitInfo.Changes); }