public override GitCommit GetLastCommit(IGitRepository repo, string branch) { var rev = new byte[20]; var revStr = this.ExecuteGitCommand(repo, "log -1", "--pretty=format:%H"); return(new GitCommit(revStr)); }
public AmendCommitCommandTests() { eventStream = Mock.Of <IEventStream>(); repository = Mock.Of <IGitRepository>(x => x.Config == Mock.Of <LibGit2Sharp.Configuration>()); mainThread = Mock.Of <MainThread>(); view = Mock.Of <IChangesView>(); }
public GitController(IGitRepository gitRepository, IFileParserService fileParserService, IRssFeedService rssFeedService, IConfiguration configuration) { _gitRepository = gitRepository; _fileParserService = fileParserService; _rssFeedService = rssFeedService; _configuration = configuration; }
public RepositoryTab(string git_repository_path) { git_repository_path_ = git_repository_path; InitializeComponent(); UserControls.PendingTabViewModel pendingTabViewModel = (UserControls.PendingTabViewModel)PendingTab.DataContext; UserControls.StashTabViewModel stashTabViewModel = (UserControls.StashTabViewModel)StashTab.DataContext; UserControls.BranchTabViewModel branchTabViewModel = (UserControls.BranchTabViewModel)BranchTab.DataContext; UserControls.TagTabViewModel tagTabViewModel = (UserControls.TagTabViewModel)TagTab.DataContext; UserControls.RemoteTabViewModel remoteTabViewModel = (UserControls.RemoteTabViewModel)RemoteTab.DataContext; var viewModel = new ViewModels.RepositoryViewModel(git_repository_path, this, pendingTabViewModel, stashTabViewModel, branchTabViewModel, tagTabViewModel, remoteTabViewModel); DataContext = viewModel; pendingTabViewModel.SetGitRepository(viewModel); stashTabViewModel.SetGitRepository(viewModel); branchTabViewModel.SetGitRepository(viewModel); tagTabViewModel.SetGitRepository(viewModel); remoteTabViewModel.SetGitRepository(viewModel); IGitRepository gitRepository = viewModel; Plugin.PluginController.ConstructPluginToolbarButtons(toolBar, gitRepository); }
public override IEnumerable <string> EnumBranches(IGitRepository repo) { string stdout = this.ExecuteGitCommand(repo, "ls-remote --heads origin"); return(BranchParsingRegex.Matches(stdout).Cast <Match>() .Select(match => match.Groups["branch"].Value)); }
public GetResponse <ResetResults> Reset( IGitRepository repo, GitPatcherVersioning patcherVersioning, CancellationToken cancel) { CheckoutRunnerBranch.Checkout(repo); var targets = GetRepoTarget.Get( repo, patcherVersioning); if (targets.Failed) { return(targets.BubbleFailure <ResetResults>()); } var commit = RetrieveCommit.TryGet( repo, targets.Value, patcherVersioning, cancel); if (commit.Failed) { return(commit.BubbleFailure <ResetResults>()); } cancel.ThrowIfCancellationRequested(); _logger.Information("Checking out {TargetSha}", targets.Value.TargetSha); repo.ResetHard(commit.Value); return(new ResetResults(targets.Value, commit.Value.CommitMessage, commit.Value.CommitDate)); }
private static IEnumerable <ICommit> GetIntermediateCommits(IGitRepository repo, ICommit baseCommit, ICommit headCommit) { if (baseCommit == null) { yield break; } IEnumerable <ICommit> commitCache = intermediateCommitCache; if (commitCache == null || !Equals(commitCache.LastOrDefault(), headCommit)) { commitCache = repo.GetCommitsReacheableFromHead(headCommit); intermediateCommitCache = commitCache; } var found = false; foreach (var commit in commitCache) { if (found) { yield return(commit); } if (commit.Sha == baseCommit.Sha) { found = true; } } }
public LoadMessageOverridesFromFileSystemTask(ILogger <LoadMessageOverridesFromFileSystemTask> logger, ChangeLogConfiguration configuration, IGitRepository repository) : base(logger) { m_Logger = logger ?? throw new ArgumentNullException(nameof(logger)); m_Configuration = configuration ?? throw new ArgumentNullException(nameof(configuration)); m_Repository = repository ?? throw new ArgumentNullException(nameof(repository)); m_OverrideMessages = new(LoadOverrideMessages); }
public void RepositoryDesirableOtherwise( IGitRepository repo, CheckIfRepositoryDesirable sut) { sut.IsDesirable(repo) .Should().BeTrue(); }
public static int Do(IGitRepository repository, Action<GitIndexInfo> indexAction) { int nr = 0; repository.CommandInputPipe(stdin => nr = Do(stdin, repository, indexAction), "update-index", "-z", "--index-info"); return nr; }
public AppController(IHostingEnvironment hosting, IGitRepository repository, IMapper mapper, ILogger <AppController> logger) { _hosting = hosting; _repository = repository; _mapper = mapper; _logger = logger; }
void CommitChanges(IGitRepository repository, IEnumerable <StatusEntry> entries, CommitDialog dialog) { if (mainThread.ShowDialog(dialog) == true) { if (!string.IsNullOrEmpty(dialog.NewBranchName)) { repository.Checkout(repository.CreateBranch(dialog.NewBranchName)); } foreach (var entry in entries) { repository.Stage(entry.FilePath); } eventStream.Push <Status>(0.5f); var signature = repository.Config.BuildSignature(DateTimeOffset.Now); repository.Commit( dialog.Message, signature, signature, CreateCommitOptions()); } }
public static Branch SwitchToTargetBranch(this IGitRepository repository, CherryPickConfig config) { GetLocalAndRemoteBranch(repository, config.TargetBranch, config.TargetBranchRemote, out var targetBranch, out var targetBranchRemote); if (targetBranch == null && targetBranchRemote != null) { targetBranch = repository.CreateBranch(config.TargetBranch, targetBranchRemote.Tip); } if (targetBranch is null) { throw new InvalidOperationException(string.Format("Branch {0} not found", config.TargetBranch)); } // Checkout target branch repository.Checkout(targetBranch); if (config.SyncTargetBranch && targetBranchRemote != null) { try { // And try pull with fast forward from remote repository.Merge( targetBranchRemote, repository.Config.BuildSignature(DateTimeOffset.Now), new MergeOptions { FastForwardStrategy = FastForwardStrategy.FastForwardOnly }); } catch (NonFastForwardException) { } } return(targetBranch); }
public static VersionField?DetermineIncrementedField(IGitRepository repository, GitVersionContext context, BaseVersion baseVersion) { var commitMessageIncrement = FindCommitMessageIncrement(repository, context, baseVersion); var defaultIncrement = context.Configuration.Increment.ToVersionField(); // use the default branch config increment strategy if there are no commit message overrides if (commitMessageIncrement == null) { return(baseVersion.ShouldIncrement ? defaultIncrement : (VersionField?)null); } // cap the commit message severity to minor for alpha versions if (baseVersion.SemanticVersion < new SemanticVersion(1) && commitMessageIncrement > VersionField.Minor) { commitMessageIncrement = VersionField.Minor; } // don't increment for less than the branch config increment, if the absence of commit messages would have // still resulted in an increment of configuration.Increment if (baseVersion.ShouldIncrement && commitMessageIncrement < defaultIncrement) { return(defaultIncrement); } return(commitMessageIncrement); }
public CherryPickConfig(IGitRepository repository, string?baseBranch = default, string?targetBranch = default) { Repository = repository; BaseBranch = baseBranch; this.targetBranch = targetBranch; }
public async Task FailedGetRepoTargetReturnsFailure( IGitRepository repo, GitPatcherVersioning patcherVersioning, CancellationToken cancel, ResetToTarget sut) { sut.GetRepoTarget.Get(default !, default !).ReturnsForAnyArgs(GetResponse <RepoTarget> .Failure);
public RenameEdit(IGitRepository repository, string path, string pathTo, string newSha) { _repository = repository; _newSha = newSha; _path = path; _pathTo = pathTo; }
public GetResponse <ICommit> TryGet( IGitRepository repo, RepoTarget targets, GitPatcherVersioning patcherVersioning, CancellationToken cancel) { var commit = repo.TryGetCommit(targets.TargetSha, out var validSha); if (!validSha) { return(GetResponse <ICommit> .Fail("Malformed sha string")); } cancel.ThrowIfCancellationRequested(); if (commit == null) { bool fetchIfMissing = ShouldFetchIfMissing.Should(patcherVersioning); if (!fetchIfMissing) { return(GetResponse <ICommit> .Fail("Could not locate commit with given sha")); } repo.Fetch(); commit = repo.TryGetCommit(targets.TargetSha, out _); if (commit == null) { return(GetResponse <ICommit> .Fail("Could not locate commit with given sha")); } } return(GetResponse <ICommit> .Succeed(commit)); }
public GeneralViewController(IGeneralView view, IGitRepository repository, ILogger logger) { m_view = view; m_repository = repository; m_logger = logger; m_view.SetController(this); }
public async Task BranchUsingLocalGit(long buildId, string branchName) { VcsCommit commit = await GetCommitInformationByBuildId(buildId); if (commit == null) { Log.Info("Could not find commit for build. Skipping creation of branch step."); return; } IGitRepository gitRepository = _gitRepositoryFactory.Clone(commit); if (gitRepository == null) { throw new Exception("Unable to Clone Git Repository and create branch"); } if (gitRepository.AddBranch(branchName, commit.CommitSha)) { gitRepository.CheckoutBranch(branchName); gitRepository.Push(branchName); } gitRepository.DeleteFolder(); }
private IReadOnlyList <GitTag> GetMatchingTags(IExecutionContext context, IGitRepository repository) { IReadOnlyList <GitTag> matchingTags; if (m_TagNames is null) { matchingTags = Array.Empty <GitTag>(); } else if (m_TagNames.Any()) { var tagPatterns = m_TagNames.Select(x => new Wildcard(x)).ToList(); // get tags matching the patterns matchingTags = repository.Tags .Where(tag => tagPatterns.Any(pattern => pattern.IsMatch(tag.Name))) .ToList(); if (!matchingTags.Any()) { context.LogWarning($"The repository contains no tags matching any of the configured tag names {String.Join(", ", m_TagNames.Select(x => $"'{x}'"))}"); } } else { matchingTags = Array.Empty <GitTag>(); } return(matchingTags); }
public CommitCommand(IEventStream eventStream, MainThread mainThread, IGitRepository repository, IChangesView view) { this.eventStream = eventStream; this.mainThread = mainThread; this.repository = repository; this.view = view; }
public IActionResult EditGitToken([FromBody] GitCredentialInputModel model, [FromServices] IGitRepository gitRepository) { //入力値チェック if (!ModelState.IsValid) { return(JsonBadRequest("Invalid inputs.")); } var tenantId = CurrentUserInfo.SelectedTenant.Id; //まずは今の情報を取得 var userGitMap = gitRepository.GetUserTenantGitMap(CurrentUserInfo.Id, tenantId, model.Id); if (userGitMap == null) { //今の値がないのはオカシイ。紐づけられていない情報を変更しようとしているとみなす。 return(JsonBadRequest("Couldn't map the git to the current user & tenant. Please contact a user administrator.")); } //変更 userGitMap.GitToken = model.Token; unitOfWork.Commit(); GitCredentialOutputModel result = new GitCredentialOutputModel(userGitMap); return(JsonOK(result)); }
public void ResetsHard( IGitRepository repo, CheckoutRunnerBranch sut) { sut.Checkout(repo); repo.Received(1).ResetHard(); }
static private List <GitDiffSection> getDiffSections(IGitRepository gitRepository, string sha1, string sha2, string filename1, string filename2) { List <GitDiffSection> sections = new List <GitDiffSection>(); List <string> diff = gitRepository.Diff(sha1, sha2, filename1, filename2, 0); foreach (string line in diff) { Match m = diffSectionRe.Match(line); if (!m.Success || m.Groups.Count < 3) { continue; } if (!m.Groups["left_start"].Success || !m.Groups["right_start"].Success) { continue; } // @@ -1 +1 @@ is essentially the same as @@ -1,1 +1,1 @@ int leftSectionLength = m.Groups["left_len"].Success ? int.Parse(m.Groups["left_len"].Value) : 1; int rightSectionLength = m.Groups["right_len"].Success ? int.Parse(m.Groups["right_len"].Value) : 1; GitDiffSection section; section.LeftSectionStart = int.Parse(m.Groups["left_start"].Value); section.LeftSectionEnd = section.LeftSectionStart + leftSectionLength; section.RightSectionStart = int.Parse(m.Groups["right_start"].Value); section.RightSectionEnd = section.RightSectionStart + rightSectionLength; sections.Add(section); } return(sections); }
public void TryCreatesRunnerBranch( IGitRepository repo, CheckoutRunnerBranch sut) { sut.Checkout(repo); repo.Received(1).TryCreateBranch(CheckoutRunnerBranch.RunnerBranch); }
public GitLabLinkTask(ILogger <GitLabLinkTask> logger, ChangeLogConfiguration configuration, IGitRepository repository, IGitLabClientFactory clientFactory) { m_Logger = logger ?? throw new ArgumentNullException(nameof(logger)); m_Configuration = configuration ?? throw new ArgumentNullException(nameof(configuration)); m_Repository = repository ?? throw new ArgumentNullException(nameof(repository)); m_ClientFactory = clientFactory ?? throw new ArgumentNullException(nameof(clientFactory)); }
public void TagTargetEmptyReturnsFail( [Frozen] IGitRepository repo, GetRepoTarget sut) { sut.Get(repo, new GitPatcherVersioning(PatcherVersioningEnum.Tag, string.Empty)) .Succeeded.Should().BeFalse(); }
public RenameEdit(IGitRepository repository, GitChangeInfo changeInfo) { _repository = repository; NewSha = changeInfo.newSha; Path = changeInfo.path; PathTo = changeInfo.pathTo; Score = changeInfo.score; }
public void TagTargetFetches( [Frozen] IGitRepository repo, string target, GetRepoTarget sut) { sut.Get(repo, new GitPatcherVersioning(PatcherVersioningEnum.Tag, target)); repo.Received(1).Fetch(); }
public RenameEdit(IGitRepository repository, GitChangeInfo changeInfo) { _repository = repository; NewSha = changeInfo.newSha; Path = changeInfo.path; PathTo = changeInfo.pathTo; Score = changeInfo.score; }
private static int Do(TextWriter stdin, IGitRepository repository, Action<GitIndexInfo> action) { using (var indexInfo = new GitIndexInfo(stdin, repository)) { action(indexInfo); return indexInfo.nr; } }
public void TagPassesToRepo( [Frozen] IGitRepository repo, string target, GetRepoTarget sut) { sut.Get(repo, new GitPatcherVersioning(PatcherVersioningEnum.Tag, target)); repo.Received(1).TryGetTagSha(target, out Arg.Any <string?>()); }
public override IEnumerable<string> EnumBranches(IGitRepository repo) { var result = this.ExecuteGitCommand(repo, "branches", "\"" + repo.RemoteRepositoryUrl + "\""); if (result.ExitCode != 0) throw new InvalidOperationException(string.Join(Environment.NewLine, result.Error.ToArray())); return result.Output; }
public PushCommand(IEventStream eventStream, MainThread mainThread, IGitRepository repository, CredentialsHandler credentialsProvider, SyncView view) { this.eventStream = eventStream; this.mainThread = mainThread; this.repository = repository; this.credentialsProvider = credentialsProvider; this.view = view; }
public override byte[] GetLastCommit(IGitRepository repo, string branch) { var rev = new byte[20]; var revStr = this.ExecuteGitCommand(repo, "log -1", "--pretty=format:%H"); if (string.IsNullOrEmpty(revStr)) return rev; for (int i = 0; i < rev.Length; i++) rev[i] = byte.Parse(revStr.Substring(i * 2, 2), NumberStyles.HexNumber); return rev; }
public override void UpdateLocalRepo(IGitRepository repo, string branch, string tag) { /* * git fetch origin <branch> | Get all changesets for the specified branch but does not apply them * git reset --hard FETCH_HEAD | Resets to the HEAD revision and removes commits that haven't been pushed * git clean -dfq | Remove all non-Git versioned files and directories from the repository directory */ this.ExecuteGitCommand(repo, "fetch", repo.RemoteRepositoryUrl, branch, "--quiet"); this.ExecuteGitCommand(repo, "reset --hard FETCH_HEAD --quiet"); this.ExecuteGitCommand(repo, "clean -dfq"); }
private void InitMocks4Tests(out IGitRepository gitRepository, out IGitTfsRemote remote) { // mock git repository gitRepository = _mocks.Get<IGitRepository>(); gitRepository.Stub(r => r.HasRemote(Arg<string>.Is.Anything)).Return(true); _mocks.Get<Globals>().Repository = gitRepository; // mock tfs remote _mocks.Get<Globals>().UserSpecifiedRemoteId = "default"; remote = MockRepository.GenerateStub<IGitTfsRemote>(); gitRepository.Stub(r => r.ReadTfsRemote(Arg<string>.Is.Anything)).Return(remote); }
/// <summary> /// Initializes a repository to always export meta data /// </summary> /// <param name="repository"></param> /// <param name="mappingFile"></param> public void InitializeConfig(IGitRepository repository, string mappingFile = null) { repository.SetConfig(GitTfsConstants.ExportMetadatasConfigKey, "true"); if (!string.IsNullOrEmpty(mappingFile)) { if (File.Exists(mappingFile)) { File.Copy(mappingFile, exportMetadatasFilePath); } else throw new GitTfsException("error: the work items mapping file doesn't exist!"); } }
public override byte[] GetLastCommit(IGitRepository repo, string branch) { var result = this.ExecuteGitCommand(repo, "lastcommit"); if (result.ExitCode != 0) throw new InvalidOperationException(string.Join(Environment.NewLine, result.Error.ToArray())); var revStr = string.Join(string.Empty, result.Output.ToArray()).Trim(); var rev = new byte[revStr.Length / 2]; for (int i = 0; i < rev.Length; i++) rev[i] = byte.Parse(revStr.Substring(i * 2, 2), NumberStyles.HexNumber); return rev; }
public override void UpdateLocalRepo(IGitRepository repo, string branch, string tag) { ProcessResults result; var refspec = string.Format("refs/heads/{0}", string.IsNullOrEmpty(branch) ? "master" : branch); if (string.IsNullOrEmpty(tag)) result = this.ExecuteGitCommand(repo, "get", "\"" + repo.RemoteRepositoryUrl + "\"", "\"" + refspec + "\""); else result = this.ExecuteGitCommand(repo, "gettag", "\"" + repo.RemoteRepositoryUrl + "\"", "\"" + tag + "\"", "\"" + refspec + "\""); if (result.ExitCode != 0) throw new InvalidOperationException(string.Join(Environment.NewLine, result.Error.ToArray())); }
private void InitMocks4Tests(string gitBranchToInit, out IGitRepository gitRepository, out IGitTfsRemote remote, out IGitTfsRemote newBranchRemote) { gitRepository = mocks.Get<IGitRepository>(); mocks.Get<Globals>().Repository = gitRepository; mocks.Get<Globals>().GitDir = ".git"; remote = MockRepository.GenerateStub<IGitTfsRemote>(); remote.TfsUsername = "******"; remote.TfsPassword = "******"; remote.TfsRepositoryPath = "$/MyProject/Trunk"; remote.TfsUrl = "http://myTfsServer:8080/tfs"; remote.Tfs = new VsFake.TfsHelper(mocks.Container, null, null); gitRepository.Stub(r => r.GitDir).Return("."); newBranchRemote = MockRepository.GenerateStub<IGitTfsRemote>(); newBranchRemote.Id = gitBranchToInit; }
public GitTfsRemote(RemoteInfo info, IGitRepository repository, RemoteOptions remoteOptions, Globals globals, ITfsHelper tfsHelper, TextWriter stdout) { this.remoteOptions = remoteOptions; this.globals = globals; this.stdout = stdout; Tfs = tfsHelper; Repository = repository; Id = info.Id; TfsUrl = info.Url; TfsRepositoryPath = info.Repository; TfsUsername = info.Username; TfsPassword = info.Password; Aliases = (info.Aliases ?? Enumerable.Empty<string>()).ToArray(); IgnoreRegexExpression = info.IgnoreRegex; Autotag = info.Autotag; }
public GitTfsRemote(RemoteInfo info, IGitRepository repository, RemoteOptions remoteOptions, Globals globals, ITfsHelper tfsHelper, ConfigProperties properties) { _remoteOptions = remoteOptions; _globals = globals; _properties = properties; Tfs = tfsHelper; Repository = repository; RemoteInfo = info; Id = info.Id; TfsUrl = info.Url; TfsRepositoryPath = info.Repository; TfsUsername = info.Username; TfsPassword = info.Password; Aliases = (info.Aliases ?? Enumerable.Empty<string>()).ToArray(); IgnoreRegexExpression = info.IgnoreRegex; IgnoreExceptRegexExpression = info.IgnoreExceptRegex; Autotag = info.Autotag; IsSubtree = CheckSubtree(); }
public void RebaseOnto(IGitRepository repository, string tfsLatest, string target) { repository.CommandNoisy("rebase", "--preserve-merges", "--onto", tfsLatest, target); }
public RCheckinCommit(IGitRepository repo) : this() { _repo = repo; Commit = null; Sha = null; Message = null; Parents = null; }
public override void ApplyTag(IGitRepository repo, string tag) { var result = this.ExecuteGitCommand(repo, "tag", "\"" + repo.RemoteRepositoryUrl + "\"", "\"" + tag + "\"", "BuildMaster", "\"Tagged by BuildMaster\""); if (result.ExitCode != 0) throw new InvalidOperationException(string.Join(Environment.NewLine, result.Error.ToArray())); }
public override void CloneRepo(IGitRepository repo) { var result = this.ExecuteGitCommand(repo, "clone", "\"" + repo.RemoteRepositoryUrl + "\""); if (result.ExitCode != 0) throw new InvalidOperationException(string.Join(Environment.NewLine, result.Error.ToArray())); }
public Add(IGitRepository repository, GitChangeInfo changeInfo) { Repository = repository; Path = changeInfo.path; NewSha = changeInfo.newSha; }
public Copy(IGitRepository repository, GitChangeInfo changeInfo) : base(repository, changeInfo) { Path = changeInfo.pathTo; }
public override IEnumerable<string> EnumBranches(IGitRepository repo) { string stdout = this.ExecuteGitCommand(repo, "ls-remote --heads origin"); return BranchParsingRegex.Matches(stdout).Cast<Match>() .Select(match => match.Groups["branch"].Value); }
private GitIndexInfo(TextWriter stdin, IGitRepository repository) { this.stdin = stdin; this.repository = repository; }
public Modify(IGitRepository repository, GitChangeInfo changeInfo) { _repository = repository; NewSha = changeInfo.newSha; Path = changeInfo.path; }
public GitInfoController(IGitRepository _gitRepository) { gitRepository = _gitRepository; }
public override void ApplyTag(IGitRepository repo, string tag) { // tag the default branch (where -f replaces existing tag) with the value of label this.ExecuteGitCommand(repo, "tag -f", tag); this.ExecuteGitCommand(repo, "push", repo.RemoteRepositoryUrl, "--tags --quiet"); }
public override void CloneRepo(IGitRepository repo) { throw new NotImplementedException(); }
public RCheckinCommit(IGitRepository repo) : this() { this.repo = repo; this.Commit = null; this.Sha = null; this.Message = null; this.Parents = null; }
public Modify(IGitRepository repository, string path, string newSha) { _repository = repository; _newSha = newSha; _path = path; }
public void RebaseOnto(IGitRepository repository, string newBaseCommit, string oldBaseCommit) { repository.CommandNoisy("rebase", "--preserve-merges", "--onto", newBaseCommit, oldBaseCommit); }
private new string ExecuteGitCommand(IGitRepository repo, string gitCommand, params string[] options) { var results = base.ExecuteGitCommand(repo, gitCommand, options); if (results.ExitCode != 0) throw new InvalidOperationException(string.Join(" ", results.Error.ToArray())); return string.Join(Environment.NewLine, results.Output.ToArray()); }