protected AbstractGitTransactionTest() { RemoteRepositoryPath = Path.Combine(m_TempDirectory.Directory.Location, "Remote"); RepositoryInitHelper.InitializeRepository(RemoteRepositoryPath); m_RemoteRepository = new Repository(RemoteRepositoryPath); m_RemoteRepository.CreateBranch(s_Branch2, m_RemoteRepository.Commits.Single()); m_RemoteRepository.CreateBranch(s_Branch3, m_RemoteRepository.Commits.Single()); }
public override void CreateBranch(string branch) { try { _repo.CreateBranch(branch); _repo.Checkout(branch); RequeryUnsyncedCommits(); } catch (LibGit2SharpException ex) { throw new SourceControlException(SourceControlText.GitNewBranchFailed, ex); } }
private async Task PullSrcRepo(string branch) { Logger.Info($"Pulling branch {branch} from source repo..."); var options = new PullOptions { FetchOptions = new FetchOptions { CredentialsProvider = GitCredentials } }; await Task.Run(() => { using var repo = new GitRepository("srcRepo"); if (repo.Branches[branch] == null) { var remoteBranch = repo.Branches[$"origin/{branch}"]; var newBranch = repo.CreateBranch(branch, remoteBranch.Tip); repo.Branches.Update(newBranch, b => b.TrackedBranch = remoteBranch.CanonicalName); } Commands.Checkout(repo, repo.Branches[branch]); Commands.Pull(repo, _defaultSignature, options); }); }
public string SetupBranch(string p_BranchNamePrefix, string p_RemoteName) { string guid = DateTime.Now.ToString("yyyyMMdd_HHmmss"); m_BranchName = $"{p_BranchNamePrefix}_{guid}"; s_Logger.Info($"Branch: {m_BranchName}"); Branch localBranch; if (m_Repository.Branches[m_BranchName] == null) { localBranch = m_Repository.CreateBranch(m_BranchName); } else { //todo will not checkout due to a conflict if there are files there already localBranch = m_Repository.Branches[m_BranchName]; } Commands.Checkout(m_Repository, localBranch); Remote remote = m_Repository.Network.Remotes[p_RemoteName]; m_Repository.Branches.Update(localBranch, b => b.Remote = remote.Name, b => b.UpstreamBranch = localBranch.CanonicalName); return(m_BranchName); }
public void PullAndRebaseAndPush(PullRequest pr) { string reppath = Path.Combine(_account.TempRepPath, pr.Base.Repository.Name); using (var repo = new Repository(reppath)) { var branchMaster = repo.Branches["master"]; var masterCommits = branchMaster.Commits.First(); var orgin = repo.Network.Remotes["orgin"]; var branchname = pr.Head.Ref; repo.Branches.Remove(branchname); Branch orginBranch = repo.Branches[$"refs/remotes/origin/{branchname}"]; Branch localBranch = repo.CreateBranch(branchname, orginBranch.Tip); localBranch = Commands.Checkout(repo, localBranch); if (!localBranch.Commits.Contains(masterCommits)) { Console.WriteLine(branchname); var rebaseOptions = new RebaseOptions(); var rb = repo.Rebase.Start(localBranch, branchMaster, null, _identity, rebaseOptions); if (rb.Status != RebaseStatus.Complete) { repo.Rebase.Abort(); return; } Commands.Checkout(repo, branchname); repo.Network.Push(orgin, $"+refs/heads/{branchname}:refs/heads/{branchname}", _pushOptions); } } }
public bool Checkout(Api.Git.Repository repository, string branchName) { using (var repo = new LibGit2Sharp.Repository(repository.Path)) { string realBranchName = branchName; Branch branch; // Check if local branch exists if (repo.Branches.Any(b => b.FriendlyName == branchName)) { branch = Commands.Checkout(repo, branchName); } else { // Create local branch to remote branch tip and set its upstream branch to remote var upstreamBranch = repo.Branches.FirstOrDefault(b => b.FriendlyName.EndsWith(branchName)); branch = repo.CreateBranch(branchName, upstreamBranch.Tip); this.SetUpstream(repository, branchName, upstreamBranch.FriendlyName); branch = Commands.Checkout(repo, branchName); } return(branch.FriendlyName == branchName); } }
public bool Checkout(Api.Git.Repository repository, string branchName) { using (var repo = new LibGit2Sharp.Repository(repository.Path)) { Branch branch; // Check if local branch exists if (repo.Branches.Any(b => b.FriendlyName == branchName)) { branch = Commands.Checkout(repo, branchName); } else { // Create local branch to remote branch tip and set its upstream branch to remote var upstreamBranch = repo.Branches.FirstOrDefault(b => string.Equals(b.UpstreamBranchCanonicalName, "refs/heads/" + branchName, StringComparison.OrdinalIgnoreCase)); if (upstreamBranch is null) { return(false); } _ = repo.CreateBranch(branchName, upstreamBranch.Tip); this.SetUpstream(repository, branchName, upstreamBranch.FriendlyName); branch = Commands.Checkout(repo, branchName); } return(branch.FriendlyName == branchName); } }
public string SetupBranch(string p_BranchNamePrefix, string p_RemoteName) { //todo Create logic for branch name string ticketName = "INNO-001"; string guid = "alpha1234"; m_BranchName = $"{p_BranchNamePrefix}{ticketName}_{guid}"; s_Logger.Info($"Branch: {m_BranchName}"); Branch localBranch; if (m_Repository.Branches[m_BranchName] == null) { localBranch = m_Repository.CreateBranch(m_BranchName); } else { //todo will not checkout due to a conflict if there are files there already localBranch = m_Repository.Branches[m_BranchName]; } Commands.Checkout(m_Repository, localBranch); var remote = m_Repository.Network.Remotes[p_RemoteName]; m_Repository.Branches.Update(localBranch, b => b.Remote = remote.Name, b => b.UpstreamBranch = localBranch.CanonicalName); return(m_BranchName); }
public void FetchWithoutConflict(string remoteUrl, string branchName) { var tracer = _tracerFactory.GetTracer(); try { using (var repo = new LibGit2Sharp.Repository(RepositoryPath)) { var trackedBranchName = string.Format("{0}/{1}", _remoteAlias, branchName); var refSpec = string.Format("+refs/heads/{0}:refs/remotes/{1}", branchName, trackedBranchName); // Configure the remote var remote = repo.Network.Remotes.Add(_remoteAlias, remoteUrl, refSpec); // This will only retrieve the "master" repo.Network.Fetch(remote); // Optionally set up the branch tracking configuration var trackedBranch = repo.Branches[trackedBranchName]; if (trackedBranch == null) { throw new BranchNotFoundException(branchName, null); } var branch = repo.Branches[branchName] ?? repo.CreateBranch(branchName, trackedBranch.Tip); repo.Branches.Update(branch, b => b.TrackedBranch = trackedBranch.CanonicalName); //Update the raw ref to point the head of branchName to the latest fetched branch UpdateRawRef(string.Format("refs/heads/{0}", branchName), trackedBranchName); // Now checkout out our branch, which points to the right place Update(branchName); } } catch (LibGit2SharpException exception) { tracer.TraceWarning("LibGit2SharpRepository fetch failed with {0}", exception); // LibGit2Sharp doesn't support SSH yet. Use GitExeRepository // LibGit2Sharp only supports smart Http protocol if (exception.Message.Equals("Unsupported URL protocol") || exception.Message.Equals("Received unexpected content-type")) { tracer.TraceWarning("LibGit2SharpRepository fallback to git.exe"); _legacyGitExeRepository.FetchWithoutConflict(remoteUrl, branchName); } else { throw; } } finally { using (var repo = new LibGit2Sharp.Repository(RepositoryPath)) { repo.Network.Remotes.Remove(_remoteAlias); } } }
public GitBasedFileSystemSnapshotTest() { RepositoryInitHelper.InitializeRepository(m_TempDirectory.Location); using (var repo = new Repository(m_TempDirectory.Location)) { repo.CreateBranch(new BranchName("branch", "name"), repo.Commits.Single()); } }
public GitBasedFileSystemHistoryTest() { RepositoryInitHelper.InitializeRepository(m_TempDirectory.Location); m_Repository = new Repository(m_TempDirectory.Location); var branchName = new BranchName("", "branch1"); m_Repository.CreateBranch(branchName, m_Repository.GetAllCommits().Single()); m_Instance = new GitBasedFileSystemHistory(m_Repository, branchName); }
public override void CreateBranch(string branch) { try { _repo.CreateBranch(branch); _repo.Checkout(branch); } catch (LibGit2SharpException ex) { throw new SourceControlException("Branch creation failed.", ex); } }
public void CheckoutBaseBranch(string branchName) { var localBranch = _repository.Branches[branchName]; if (localBranch == null) { // Probably a remote branch Branch trackedBranch = _repository.Branches[$"origin/{branchName}"]; if (trackedBranch == null) { throw new Exception($"Branch {branchName} not found locally or on origin."); } localBranch = _repository.CreateBranch(branchName, trackedBranch.Tip); _repository.Branches.Update(localBranch, b => b.UpstreamBranch = $"refs/heads/{branchName}"); } Commands.Checkout(_repository, _repository.Branches[branchName]); _baseBranch = localBranch; _changesBranch = localBranch; }
private string CreateBranchForNewChanges(NewChanges newChanges, string prBranch) { string OriginalSha; var targetRepo = newChanges.TargetRepository; var branchName = $"mirror-merge-{(long)DateTime.Now.Subtract(new DateTime(2000, 1, 1, 0, 0, 0)).TotalMinutes}"; s_logger.Info($"Creating branch {prBranch} in {targetRepo} to merge changes into {prBranch}"); using (var repo = new Repository(targetRepo.Path)) { var branch = repo.CreateBranch(branchName); s_logger.Info("Checking out PR branch"); Commands.Checkout(repo, branch); OriginalSha = branch.Tip.ToString(); } foreach (var source in newChanges.changes.Keys) { var sourceRepository = targetRepo.Configuration.Repos.Where(t => t.Name == source).First(); using (var repo = new Repository(sourceRepository.Path)) { foreach (var change in newChanges.changes[sourceRepository.Name]) { var commit = repo.Lookup <Commit>(change); if (!IsMirrorCommit(commit.Message, targetRepo.Configuration.MirrorSignatureUser) && commit.Parents.Count() == 1 ) { s_logger.Info($"Applying {change}"); var patch = FormatPatch(sourceRepository, change); if (string.IsNullOrWhiteSpace(patch)) { continue; } s_logger.Debug($"Patch:\n{patch}"); ApplyPatch(sourceRepository, newChanges.TargetRepository, patch, commit); } } } } using (var repo = new Repository(targetRepo.Path)) { if (repo.Head.Tip.ToString() == OriginalSha) { s_logger.Info($"No new commits To add into this branch"); return(null); } } return(branchName); }
public void Init(DeclarationOfExistence doe) { if (!_directory.Exists) { _directory.Create(); } if (!_directory.GetFiles().Any() && !_directory.GetDirectories().Any()) { // Directory is empty Repository.Init(_directory.FullName, isBare: true); using (var repo = new Repository(_directory.FullName)) { InitCoreTags(repo); Commit doeCommit = CreateDeclarationOfExistence(repo, doe); repo.CreateBranch(CONTROL_BRANCH, doeCommit); repo.CreateBranch(CONTENT_BRANCH, doeCommit); } } else { throw new BastionException(string.Format("{0} has already been initialized", _directory.FullName)); } }
/// <summary> /// Ensure that the repository exists on disk and its origin remote points to the correct url /// </summary> /// <param name="repo"></param> private void EnsureRepository(List <RepositoryInfo> repos) { foreach (var repo in repos) { var repoPath = repo.Path; s_logger.Info($"Verifying repository {repo} at {repo.Path}"); if (!Directory.Exists(repoPath) || !Repository.IsValid(repoPath)) { if (Directory.Exists(repoPath)) { Directory.Delete(repoPath, true); } s_logger.Info($"Cloning the repo from {repo.CloneUrl}"); Repository.Clone(repo.CloneUrl, repoPath); } using (var repository = new Repository(repoPath)) { var remote = repository.Network.Remotes["origin"]; if (remote == null) { repository.Network.Remotes.Add("origin", repo.CloneUrl); } else if (remote.Url != repo.CloneUrl) { repository.Network.Remotes.Update("origin", u => u.Url = repo.CloneUrl); } var master = repository.Branches["master"] ?? repository.CreateBranch("master"); repository.Branches.Update(master, b => b.Remote = "origin", b => b.UpstreamBranch = "refs/heads/master"); remote = repository.Network.Remotes["upstream"]; if (remote == null) { repository.Network.Remotes.Add("upstream", @"https://github.com/" + repo.UpstreamOwner + @"/" + repo.Name + ".git"); } } } }
/// <summary> /// Initializes a new bare repository at the specified location, adds a repository info file to the root directory /// and tags the initial commit with he value of <see cref="InitialCommitTagName"/> /// </summary> public static void InitializeRepository(string location) { // initialize a bare repository Repository.Init(location, true); var directoryCreator = new LocalItemCreator(); // clone the repository, add initial commit and push the changes back to the actual repository using (var tempDirectory = directoryCreator.CreateTemporaryDirectory()) { var clonedRepoPath = Repository.Clone(location, tempDirectory.Directory.Location); var repositoryInfoFile = new RepositoryInfoFile(tempDirectory.Directory); // add a empty file to the repository directoryCreator.CreateFile(repositoryInfoFile, tempDirectory.Directory.Location); // commit and push the file to the bare repository we created using (var clonedRepo = new Repository(clonedRepoPath)) { var signature = SignatureHelper.NewSignature(); clonedRepo.Stage(repositoryInfoFile.Name); clonedRepo.Commit("Initial Commit", signature, signature, new CommitOptions()); clonedRepo.Network.Push(clonedRepo.Network.Remotes["origin"], @"refs/heads/master"); } } //create the configuration branch pointing to the initial commit using (var repository = new Repository(location)) { repository.CreateBranch(ConfigurationBranchName.ToString(), repository.GetAllCommits().Single()); repository.Tags.Add(InitialCommitTagName, repository.GetAllCommits().Single()); } }
/// <summary> /// Adds the standard .NET targets to the build. /// </summary> /// <param name="build">The build to which to add targets.</param> /// <param name="settings">The build settings.</param> public static void AddDotNetTargets(this BuildApp build, DotNetBuildSettings?settings = null) { settings ??= new DotNetBuildSettings(); var buildOptions = settings.BuildOptions ?? (settings.BuildOptions = new DotNetBuildOptions()); var configurationOption = buildOptions.ConfigurationOption ?? (buildOptions.ConfigurationOption = build.AddOption("-c|--configuration <name>", "The configuration to build (default Release)", "Release")); var platformOption = buildOptions.PlatformOption ?? (buildOptions.PlatformOption = build.AddOption("-p|--platform <name>", "The solution platform to build")); var versionSuffixOption = buildOptions.VersionSuffixOption ?? (buildOptions.VersionSuffixOption = build.AddOption("--version-suffix <suffix>", "Generates a prerelease package")); var nugetOutputOption = buildOptions.NuGetOutputOption ?? (buildOptions.NuGetOutputOption = build.AddOption("--nuget-output <path>", "Directory for generated package (default release)", "release")); var triggerOption = buildOptions.TriggerOption ?? (buildOptions.TriggerOption = build.AddOption("--trigger <name>", "The git branch or tag that triggered the build")); var buildNumberOption = buildOptions.BuildNumberOption ?? (buildOptions.BuildNumberOption = build.AddOption("--build-number <number>", "The automated build number")); var noTestFlag = buildOptions.NoTestFlag ?? (buildOptions.NoTestFlag = build.AddFlag("--no-test", "Skip the unit tests")); var solutionName = settings.SolutionName; var nugetSource = settings.NuGetSource ?? "https://api.nuget.org/v3/index.json"; var msbuildSettings = settings.MSBuildSettings; var dotNetTools = settings.DotNetTools ?? new DotNetTools(Path.Combine("tools", "bin")); var xmlDocMarkdownVersion = settings.DocsSettings?.ToolVersion ?? "2.0.1"; var packagePaths = new List <string>(); string?trigger = null; var ignoreIfAlreadyPushed = false; build.Target("clean") .Describe("Deletes all build output") .Does(() => { var findDirectoriesToDelete = settings.CleanSettings?.FindDirectoriesToDelete ?? (() => FindDirectories("{src,tests}/**/{bin,obj}", "tools/XmlDocTarget/{bin,obj}")); foreach (var directoryToDelete in findDirectoriesToDelete()) { deleteDirectory(directoryToDelete); } var extraProperties = getExtraProperties("clean"); if (msbuildSettings == null) { RunDotNet(new[] { "clean", solutionName, "-c", configurationOption.Value, getPlatformArg(), "--verbosity", "normal", getMaxCpuCountArg() }.Concat(extraProperties)); } else { runMSBuild(new[] { solutionName, "-t:Clean", $"-p:Configuration={configurationOption.Value}", getPlatformArg(), "-v:normal", getMaxCpuCountArg() }.Concat(extraProperties)); } }); build.Target("restore") .Describe("Restores NuGet packages") .Does(() => { var extraProperties = getExtraProperties("restore"); if (msbuildSettings == null) { RunDotNet(new[] { "restore", solutionName, getPlatformArg(), "--verbosity", "normal", getMaxCpuCountArg() }.Concat(extraProperties)); } else { runMSBuild(new[] { solutionName, "-t:Restore", $"-p:Configuration={configurationOption.Value}", getPlatformArg(), "-v:normal", getMaxCpuCountArg() }.Concat(extraProperties)); } }); build.Target("build") .DependsOn("restore") .Describe("Builds the solution") .Does(() => { var buildNumberArg = buildNumberOption.Value == null ? null : $"-p:BuildNumber={buildNumberOption.Value}"; var extraProperties = getExtraProperties("build"); if (msbuildSettings == null) { RunDotNet(new[] { "build", solutionName, "-c", configurationOption.Value, getPlatformArg(), buildNumberArg, "--no-restore", "--verbosity", "normal", getMaxCpuCountArg() }.Concat(extraProperties)); } else { runMSBuild(new[] { solutionName, $"-p:Configuration={configurationOption.Value}", getPlatformArg(), buildNumberArg, "-v:normal", getMaxCpuCountArg() }.Concat(extraProperties)); } }); build.Target("test") .DependsOn("build") .Describe("Runs the unit tests") .Does(() => { if (noTestFlag.Value) { Console.WriteLine("Skipping unit tests due to --no-test."); } else { var extraProperties = getExtraProperties("test").ToList(); var findTestAssemblies = settings.TestSettings?.FindTestAssemblies; if (findTestAssemblies != null) { foreach (var testAssembly in findTestAssemblies()) { if (settings.TestSettings?.RunTests != null) { settings.TestSettings.RunTests(testAssembly); } else { RunDotNet(new AppRunnerSettings { Arguments = new[] { "vstest", Path.GetFileName(testAssembly) }.Concat(extraProperties), WorkingDirectory = Path.GetDirectoryName(testAssembly) }); } } } else { var testProjects = new List <string?>(); var findTestProjects = settings.TestSettings?.FindProjects; if (findTestProjects != null) { testProjects.AddRange(findTestProjects()); } else { testProjects.Add(solutionName); } foreach (var testProject in testProjects) { if (settings.TestSettings?.RunTests != null) { settings.TestSettings.RunTests(testProject); } else { RunDotNet(new[] { "test", testProject, "-c", configurationOption.Value, getPlatformArg(), "--no-build", getMaxCpuCountArg() }.Concat(extraProperties)); } } } } }); build.Target("package") .DependsOn("clean", "test") .Describe("Builds NuGet packages") .Does(() => { trigger = triggerOption.Value; if (trigger == "detect") { using var repository = new Repository("."); var headSha = repository.Head.Tip.Sha; var autoTrigger = GetBestTriggerFromTags(repository.Tags.Where(x => x.Target.Sha == headSha).Select(x => x.FriendlyName).ToList()); if (autoTrigger != null) { trigger = autoTrigger; ignoreIfAlreadyPushed = true; Console.WriteLine($"Detected trigger: {trigger}"); } } var versionSuffix = versionSuffixOption.Value; if (versionSuffix == null && trigger != null) { versionSuffix = GetVersionFromTrigger(trigger) is string triggerVersion ? SplitVersion(triggerVersion).Suffix : null; } var nugetOutputPath = Path.GetFullPath(nugetOutputOption.Value); var tempOutputPath = Path.Combine(nugetOutputPath, $"temp_{Guid.NewGuid():N}"); var packageProjects = new List <string?>(); var findPackageProjects = settings.PackageSettings?.FindProjects; if (findPackageProjects != null) { packageProjects.AddRange(findPackageProjects()); } else { packageProjects.Add(solutionName); } var extraProperties = getExtraProperties("package").ToList(); foreach (var packageProject in packageProjects) { if (msbuildSettings == null) { RunDotNet(new[] { "pack", packageProject, "-c", configurationOption.Value, getPlatformArg(), "--no-build", "--output", tempOutputPath, versionSuffix != null ? "--version-suffix" : null, versionSuffix, getMaxCpuCountArg() }.Concat(extraProperties)); } else { runMSBuild(new[] { packageProject, "-t:Pack", $"-p:Configuration={configurationOption.Value}", getPlatformArg(), "-p:NoBuild=true", $"-p:PackageOutputPath={tempOutputPath}", versionSuffix != null ? $"-p:VersionSuffix={versionSuffix}" : null, "-v:normal", getMaxCpuCountArg() }.Concat(extraProperties)); } } var tempPackagePaths = FindFilesFrom(tempOutputPath, "*.nupkg"); foreach (var tempPackagePath in tempPackagePaths) { var packagePath = Path.Combine(nugetOutputPath, Path.GetFileName(tempPackagePath) ?? throw new InvalidOperationException()); if (File.Exists(packagePath)) { File.Delete(packagePath); } File.Move(tempPackagePath, packagePath); packagePaths.Add(packagePath); } deleteDirectory(tempOutputPath); if (packagePaths.Count == 0) { throw new ApplicationException("No NuGet packages created."); } }); build.Target("publish") .Describe("Publishes NuGet packages and documentation") .DependsOn("package") .Does(() => { if (packagePaths.Count == 0) { throw new ApplicationException("No NuGet packages found."); } if (trigger == null) { throw new ApplicationException("--trigger option required."); } var triggerParts = trigger.Split('-'); var publishTrigger = triggerParts.Length >= 2 && triggerParts[0] == "publish" ? triggerParts[1] : null; var shouldPublishPackages = publishTrigger == "package" || publishTrigger == "packages" || publishTrigger == "all"; var shouldPublishDocs = publishTrigger == "docs" || publishTrigger == "all"; var triggerVersion = GetVersionFromTrigger(trigger); if (triggerVersion != null) { var mismatches = packagePaths.Where(x => GetPackageInfo(x).Version != triggerVersion).ToList(); if (mismatches.Count != 0) { throw new ApplicationException($"Trigger '{trigger}' doesn't match package version: {string.Join(", ", mismatches.Select(Path.GetFileName))}"); } shouldPublishPackages = true; shouldPublishDocs = triggerVersion.IndexOf('-') == -1; } if (shouldPublishPackages || shouldPublishDocs) { var docsSettings = settings.DocsSettings; var shouldPushDocs = false; string?cloneDirectory = null; string?repoDirectory = null; string?gitBranchName = null; Credentials provideCredentials(string url, string usernameFromUrl, SupportedCredentialTypes types) => new UsernamePasswordCredentials { Username = docsSettings?.GitLogin?.Username ?? throw new ApplicationException("GitLogin has a null Username."), Password = docsSettings?.GitLogin?.Password ?? throw new ApplicationException("GitLogin has a null Password."), }; if (shouldPublishDocs && docsSettings != null) { if (docsSettings.GitLogin == null || docsSettings.GitAuthor == null) { throw new ApplicationException("GitLogin and GitAuthor must be set on DocsSettings."); } var gitRepositoryUrl = docsSettings.GitRepositoryUrl; gitBranchName = docsSettings.GitBranchName; if (gitRepositoryUrl != null) { cloneDirectory = "docs_repo_" + Path.GetRandomFileName(); Repository.Clone(sourceUrl: gitRepositoryUrl, workdirPath: cloneDirectory, options: new CloneOptions { BranchName = gitBranchName, CredentialsProvider = provideCredentials }); repoDirectory = cloneDirectory; } else { repoDirectory = "."; } using var repository = new Repository(repoDirectory); if (gitRepositoryUrl != null) { if (gitBranchName == null) { gitBranchName = repository.Head.FriendlyName; } } else if (gitBranchName != null) { if (gitBranchName != repository.Head.FriendlyName) { var branch = repository.Branches[gitBranchName] ?? repository.CreateBranch(gitBranchName); Commands.Checkout(repository, branch); } } else { var branch = repository.Branches.FirstOrDefault(x => x.IsCurrentRepositoryHead); if (branch == null) { var autoBranchName = Environment.GetEnvironmentVariable("APPVEYOR_REPO_BRANCH"); if (autoBranchName != null) { branch = repository.Branches[autoBranchName] ?? repository.CreateBranch(autoBranchName); } else { branch = repository.Branches.FirstOrDefault(x => x.Tip.Sha == repository.Head.Tip.Sha); } if (branch != null) { Commands.Checkout(repository, branch); } } if (branch == null) { throw new ArgumentException("Could not determine repository branch for publishing docs."); } gitBranchName = branch.FriendlyName; } var projectHasDocs = docsSettings.ProjectHasDocs ?? (_ => true); foreach (var projectName in packagePaths.Select(x => GetPackageInfo(x).Name).Where(projectHasDocs)) { string findAssembly(string name) => FindFiles($"tools/XmlDocTarget/bin/**/{name}.dll").OrderByDescending(File.GetLastWriteTime).FirstOrDefault() ?? FindFiles($"src/{name}/bin/**/{name}.dll").OrderByDescending(File.GetLastWriteTime).FirstOrDefault(); var assemblyPaths = new List <string>(); if (docsSettings.FindAssemblies != null) { assemblyPaths.AddRange(docsSettings.FindAssemblies(projectName)); } else { var assemblyPath = (docsSettings.FindAssembly ?? findAssembly)(projectName); if (assemblyPath != null) { assemblyPaths.Add(assemblyPath); } } if (assemblyPaths.Count != 0) { foreach (var assemblyPath in assemblyPaths) { RunApp(dotNetTools.GetToolPath($"xmldocmd/{xmlDocMarkdownVersion}"), assemblyPath, Path.Combine(repoDirectory, docsSettings.TargetDirectory ?? "docs"), "--source", $"{docsSettings.SourceCodeUrl}/{projectName}", "--newline", "lf", "--clean"); } } else { Console.WriteLine($"Documentation not generated for {projectName}; assembly not found."); } } shouldPushDocs = repository.RetrieveStatus().IsDirty; } if (shouldPublishPackages) { var nugetApiKey = settings.NuGetApiKey; if (string.IsNullOrEmpty(nugetApiKey)) { throw new ApplicationException("NuGetApiKey required to publish."); } if (ignoreIfAlreadyPushed) { var nugetSettings = NuGet.Configuration.Settings.LoadDefaultSettings(root: null); var packageSourceProvider = new PackageSourceProvider(nugetSettings); var sourceRepositoryProvider = new SourceRepositoryProvider(packageSourceProvider, NuGet.Protocol.Core.Types.Repository.Provider.GetCoreV3()); using var sourceCacheContext = new SourceCacheContext(); var nugetRepositories = sourceRepositoryProvider.GetRepositories() .Select(x => x.GetResourceAsync <DependencyInfoResource>().GetAwaiter().GetResult()) .ToList(); foreach (var packagePath in packagePaths.ToList()) { var packageInfo = GetPackageInfo(packagePath); var package = new PackageIdentity(packageInfo.Name, NuGetVersion.Parse(packageInfo.Version)); foreach (var nugetRepository in nugetRepositories) { var dependencyInfo = nugetRepository.ResolvePackage(package, NuGetFramework.AnyFramework, sourceCacheContext, NullLogger.Instance, CancellationToken.None).GetAwaiter().GetResult(); if (dependencyInfo != null) { Console.WriteLine($"Package already pushed: {packageInfo.Name} {packageInfo.Version}"); packagePaths.Remove(packagePath); break; } } } } foreach (var packagePath in packagePaths) { RunDotNet("nuget", "push", packagePath, "--source", nugetSource, "--api-key", nugetApiKey); } } if (shouldPushDocs) { using var repository = new Repository(repoDirectory); Console.WriteLine("Publishing documentation changes."); Commands.Stage(repository, "*"); var author = new Signature(docsSettings !.GitAuthor !.Name, docsSettings !.GitAuthor !.Email, DateTimeOffset.Now); repository.Commit("Documentation updated.", author, author, new CommitOptions()); repository.Network.Push(repository.Network.Remotes["origin"], $"refs/heads/{gitBranchName}", new PushOptions { CredentialsProvider = provideCredentials }); } if (cloneDirectory != null) { // delete the cloned directory foreach (var fileInfo in FindFiles(cloneDirectory, "**").Select(x => new FileInfo(x)).Where(x => x.IsReadOnly)) { fileInfo.IsReadOnly = false; } deleteDirectory(cloneDirectory); } } else { Console.WriteLine("To publish to NuGet, push this tag: v" + GetPackageInfo(packagePaths[0]).Version); } }); string?getPlatformArg() { var platformValue = platformOption?.Value ?? settings?.SolutionPlatform; return(platformValue == null ? null : $"-p:Platform={platformValue}"); } string?getMaxCpuCountArg() { if (settings !.MaxCpuCount != null) { return($"-maxcpucount:{settings.MaxCpuCount}"); }
public void GetGitVersion() { commitChangesToReadme(repo, "Hej", "Added Readme"); verifyVersion(repo, 0, 0, 1, "beta.1"); commitChangesToGitVersionFile(repo, "1.0.0", "Added .gitversion file with version = 1.0.0"); verifyVersion(repo, 1, 0, 0, "beta.1"); var featureBranch = repo.CreateBranch("feature"); Commands.Checkout(repo, featureBranch); commitChangesToReadme(repo, "Hej2", "Changed Readme on feature branch"); verifyVersion(repo, 1, 0, 0, "alpha.1.1", featureBranch.FriendlyName); Commands.Checkout(repo, "master"); repo.Merge(featureBranch, me, noFastForward); verifyVersion(repo, 1, 0, 0, "beta.2"); commitChangesToReadme(repo, "Version 2", "Bumped version to 2.0"); commitChangesToGitVersionFile(repo, "2.0.0", "Updated version to 2.0.0 in .gitversion file"); verifyVersion(repo, 2, 0, 0, "beta.1"); repo.CreateBranch("release2x"); Commands.Checkout(repo, "release2x"); verifyVersion(repo, 2, 0, 0, "rc"); Commands.Checkout(repo, "master"); verifyVersion(repo, 2, 0, 0, "beta.1"); Commands.Checkout(repo, "release2x"); repo.ApplyTag("v2.0.0", me, "Official 2.0.0 release"); verifyVersion(repo, 2, 0, 0, null); Commands.Checkout(repo, "master"); commitChangesToGitVersionFile(repo, "2.1.0", "Bumped version to 2.1"); verifyVersion(repo, 2, 1, 0, "beta.1"); featureBranch = repo.CreateBranch("feature2"); Commands.Checkout(repo, featureBranch); commitChangesToReadme(repo, "Version 2.1 something", "Changed readme"); verifyVersion(repo, 2, 1, 0, "alpha.1.1", featureBranch.FriendlyName); Commands.Checkout(repo, "master"); repo.Merge(featureBranch, me, noFastForward); verifyVersion(repo, 2, 1, 0, "beta.2"); Commands.Checkout(repo, "release2x"); repo.Merge("master", me, noFastForward); // At this point we have created the following git history: // * Merge branch 'master' into 'rc2x' // |\ // | * (master) Merge branch 'feature2' // | |\ // | | * (feature2) Changed readme // | |/ // | * (tag: v2.1) Bumped version to 2.1 // |/ // * (tag: v2.0, release2x) Bumped version to 2.0 var commit210rc = repo.Head.Tip; verifyVersion(repo, 2, 1, 0, "rc.1"); var hotfixBranch = repo.CreateBranch("hotfix"); Commands.Checkout(repo, hotfixBranch); commitChangesToReadme(repo, "Version 2.1 hotfix", "Changed readme on hotfix branch."); Commands.Checkout(repo, "release2x"); repo.Merge(hotfixBranch, me, noFastForward); // At this point we have created the following git history: // * (rc2x) Merge branch 'hotfix' into 'rc2x' // |\ // | * (hotfix) Changed readme on hotfix branch. // |/ // * Merge branch 'master' into 'rc2x' // |\ // | * (master) Merge branch 'feature2' // | |\ // | | * (feature2) Changed readme // | |/ // | * (tag: v2.1) Bumped version to 2.1 // |/ // * (tag: v2.0, release2x) Bumped version to 2.0 new GitVersionAction() { PrintLog = "10", RepoPath = repo.Info.WorkingDirectory }.Execute(new System.Threading.CancellationToken()); verifyVersion(repo, 2, 1, 0, "rc.2"); // Now we will try to go back to a previous commit (not the HEAD): // This is what GitLab CI does, so important for us to support //Commands.Checkout(repo, shortHash211alpha); //verifyVersion(2, 1, 0, "alpha.1.1", shortHash211alpha + ".hotfix"); // TODO: This fails and we should try to improve. See TODO in GitVersionCalulator Commands.Checkout(repo, commit210rc); verifyVersion(repo, commit210rc, 2, 1, 0, "rc.1"); }
private static void SetupMasterBranch(Repository repository, string masterName, Signature author) { //We know we have a master branch , so check to see if the gitflow master is different and if it is Branch branch; if (masterName != "master" && !repository.TryGetBranch(masterName, out branch)) { repository.CreateBranch(masterName); } }
public void Commit_pushes_newly_created_branches() { var branchName = "newBranch"; var transaction = CreateTransaction(); transaction.Begin(); using (var repository = new Repository(transaction.LocalPath)) { repository.CreateBranch(branchName, repository.Commits.Single()); } AddFile(transaction, branchName, "file1"); transaction.Commit(); Assert.True(m_RemoteRepository.Branches.Any(x => x.FriendlyName == branchName)); Assert.Equal(2, m_RemoteRepository.GetAllCommits().Count()); }
private static async Task WriteContributorsToRepo(string username, string password) { var nameOfThankyouBranch = "thankyou"; var contributorsHeader = _parsedOptions.acknowledgementSection; var fileHoldingContributorsInfo = _parsedOptions.fileInRepoForAcknowledgement; var githubRepoOwner = _parsedOptions.githubRepoOwner; var githubRepoName = _parsedOptions.githubRepoName; string tempPathGitFolder = CreateTempFolderForTheRepo(); // Login to GitHub with Octokit var githubClient = new GitHubClient(new ProductHeaderValue(username)); githubClient.Credentials = new Octokit.Credentials(password); var githubRepo = await githubClient.Repository.Get(githubRepoOwner, githubRepoName); var gitCredentialsHandler = new CredentialsHandler( (url, usernameFromUrl, types) => new UsernamePasswordCredentials() { Username = username, Password = password }); var cloneOptions = new CloneOptions(); cloneOptions.CredentialsProvider = gitCredentialsHandler; LibGit2Sharp.Repository.Clone(githubRepo.CloneUrl, tempPathGitFolder, cloneOptions); using (var repo = new LibGit2Sharp.Repository(tempPathGitFolder)) { var remote = repo.Network.Remotes["origin"]; var defaultBranch = repo.Branches.FirstOrDefault(b => b.IsCurrentRepositoryHead == true); var refSpecs = remote.FetchRefSpecs.Select(x => x.Specification); var remoteThankYouBranch = repo.Branches.FirstOrDefault(b => b.FriendlyName == repo.Network.Remotes.FirstOrDefault()?.Name + "/" + nameOfThankyouBranch); if (remoteThankYouBranch != null) { Commands.Checkout(repo, remoteThankYouBranch); } if (repo.Head.FriendlyName != nameOfThankyouBranch) { var newThankyouBranch = repo.CreateBranch(nameOfThankyouBranch); repo.Branches.Update(newThankyouBranch, b => b.UpstreamBranch = newThankyouBranch.CanonicalName, b => b.Remote = repo.Network.Remotes.First().Name); Commands.Checkout(repo, newThankyouBranch); } var pathToReadme = Path.Combine(tempPathGitFolder, fileHoldingContributorsInfo); // Change the file and save it var inputLines = await File.ReadAllLinesAsync(pathToReadme); var outputLines = MarkdownProcessor.AddContributorsToMarkdownFile(inputLines, _contributorsToday); await File.WriteAllLinesAsync(pathToReadme, outputLines); var status = repo.RetrieveStatus(fileHoldingContributorsInfo); if (status == FileStatus.ModifiedInWorkdir) { try { // Commit the file to the repo, on a non-master branch repo.Index.Add(fileHoldingContributorsInfo); repo.Index.Write(); var gitAuthorName = _parsedOptions.gitAuthorName; var gitAuthorEmail = _parsedOptions.gitAuthorEmail; // Create the committer's signature and commit var author = new LibGit2Sharp.Signature(gitAuthorName, gitAuthorEmail, DateTime.Now); var committer = author; // Commit to the repository var commit = repo.Commit("A new list of awesome contributors", author, committer); //Push the commit to origin LibGit2Sharp.PushOptions options = new LibGit2Sharp.PushOptions(); options.CredentialsProvider = gitCredentialsHandler; repo.Network.Push(repo.Head, options); // Check if there is already a PR exist for the same branch var prsOfRepo = await githubClient.PullRequest.GetAllForRepository(githubRepoOwner, githubRepoName, new PullRequestRequest { State = ItemStateFilter.Open }); var currentPR = prsOfRepo.FirstOrDefault(x => x.Head.Label == $"{githubRepoOwner}:{nameOfThankyouBranch}"); if (currentPR == null) { // Create a PR on the repo for the branch "thank you" await githubClient.PullRequest.Create(username, githubRepoName, new NewPullRequest("Give credit for people on Twitch chat", nameOfThankyouBranch, defaultBranch.FriendlyName)); } else { _logger.LogWarning($"Pull Rrequest is already created. Check PR {currentPR.Id}"); } } catch (Exception ex) { // This exception might be caused by an already existing PR for this branch. In this case it's ok, otherwise we will just log it. _logger.LogError(ex, $"Ops, We couldn't create the PR. But here is the list of contributors you were trying to add {string.Join(", ", _contributorsToday.Select(c => c.Name))}"); } } else { _logger.LogInformation("There was no changes on the README file, this means that either there was no contributors, or all today's contributors are duplicates."); } } }
private static async Task WriteContributorsToRepo(string username, string password) { var nameOfThankyouBranch = "thankyou"; var repoUrl = _parsedOptions.gitRepositoryUrl; var contributorsHeader = _parsedOptions.acknowledgementSection; var fileHoldingContributorsInfo = _parsedOptions.fileInRepoForAcknowledgement; string tempPathGitFolder = CreateTempFolderForTheRepo(); var gitCredentialsHandler = new CredentialsHandler( (url, usernameFromUrl, types) => new UsernamePasswordCredentials() { Username = username, Password = password }); var cloneOptions = new CloneOptions(); cloneOptions.CredentialsProvider = gitCredentialsHandler; LibGit2Sharp.Repository.Clone(repoUrl, tempPathGitFolder, cloneOptions); using (var repo = new LibGit2Sharp.Repository(tempPathGitFolder)) { var remote = repo.Network.Remotes["origin"]; var defaultBranch = repo.Branches.FirstOrDefault(b => b.IsCurrentRepositoryHead == true); var refSpecs = remote.FetchRefSpecs.Select(x => x.Specification); var remoteThankYouBranch = repo.Branches.FirstOrDefault(b => b.FriendlyName == repo.Network.Remotes.FirstOrDefault()?.Name + "/" + nameOfThankyouBranch); if (remoteThankYouBranch != null) { Commands.Checkout(repo, remoteThankYouBranch); } if (repo.Head.FriendlyName != nameOfThankyouBranch) { var newThankyouBranch = repo.CreateBranch(nameOfThankyouBranch); repo.Branches.Update(newThankyouBranch, b => b.UpstreamBranch = newThankyouBranch.CanonicalName, b => b.Remote = repo.Network.Remotes.First().Name); Commands.Checkout(repo, newThankyouBranch); } var pathToReadme = Path.Combine(tempPathGitFolder, fileHoldingContributorsInfo); // Change the file and save it var inputLines = await File.ReadAllLinesAsync(pathToReadme); var outputLines = MarkdownProcessor.AddContributorsToMarkdownFile(inputLines, _contributorsToday); await File.WriteAllLinesAsync(pathToReadme, outputLines); var status = repo.RetrieveStatus(fileHoldingContributorsInfo); if (status == FileStatus.ModifiedInWorkdir) { // Commit the file to the repo, on a non-master branch repo.Index.Add(fileHoldingContributorsInfo); repo.Index.Write(); var gitAuthorName = _parsedOptions.gitAuthorName; var gitAuthorEmail = _parsedOptions.gitAuthorEmail; // Create the committer's signature and commit var author = new LibGit2Sharp.Signature(gitAuthorName, gitAuthorEmail, DateTime.Now); var committer = author; // Commit to the repository var commit = repo.Commit("A new list of awesome contributors", author, committer); //Push the commit to origin LibGit2Sharp.PushOptions options = new LibGit2Sharp.PushOptions(); options.CredentialsProvider = gitCredentialsHandler; repo.Network.Push(repo.Head, options); // Login to GitHub with Octokit var githubClient = new GitHubClient(new ProductHeaderValue(username)); githubClient.Credentials = new Octokit.Credentials(password); try { // Create a PR on the repo for the branch "thank you" await githubClient.PullRequest.Create(username, "thankyou", new NewPullRequest("Give credit for people on Twitch chat", nameOfThankyouBranch, defaultBranch.FriendlyName)); } catch (Exception ex) { // It's alright, the PR is already there. No harm is done. } } } }
private static void ResetBuildBranchToTag(Repository repository, ILogger logger, VersionLabel versionLabel, Tag versionLabelTag) { var buildBranch = (from branch in repository.Branches where branch.FriendlyName == BuildBranchName select branch).SingleOrDefault(); if (buildBranch == null) { logger.Log($"The branch '{BuildBranchName}' doesn't exist: creating it and resetting it to '{versionLabel.Raw}'"); // If the build branch doesn't exist, create it and check it out buildBranch = repository.CreateBranch(BuildBranchName, versionLabelTag.Target as Commit); repository.Checkout(buildBranch, new CheckoutOptions() { CheckoutModifiers = CheckoutModifiers.Force }); } else { logger.Log($"The branch '{BuildBranchName}' already exists: checking it out and resetting it to '{versionLabel.Raw}'"); // If the build branch exists, check it out and do an hard reset repository.Checkout(buildBranch, new CheckoutOptions() { CheckoutModifiers = CheckoutModifiers.Force }); repository.Reset(ResetMode.Hard, versionLabelTag.Target as Commit); } }
public void CanReuseLocalRepository_returns_false_if_the_repository_contains_unpublished_branches() { var transaction1 = CreateTransaction(); transaction1.Begin(); using (var repository = new Repository(transaction1.LocalPath)) { repository.CreateBranch("newBranch", repository.GetAllCommits().Single()); } //do not commit the changes from the transaction (leaves the local directory intact (with a new commit)) var cachingTransaction = CreateCachingTransaction(transaction1.LocalPath); Assert.False(cachingTransaction.CanReuseLocalRepository()); }
public void Commit_fails_to_create_a_new_branch_if_the_same_branch_was_created_by_another_transaction() { const string branchName = "newBranch"; var transaction1 = CreateTransaction(); var transaction2 = CreateTransaction(); transaction1.Begin(); transaction2.Begin(); using (var localRepository1 = new Repository(transaction1.LocalPath)) { localRepository1.CreateBranch(branchName, localRepository1.Commits.Single()); } AddFile(transaction1, branchName, "file1"); using (var localRepository2 = new Repository(transaction2.LocalPath)) { localRepository2.CreateBranch(branchName, localRepository2.Commits.Single()); } transaction1.Commit(); Assert.Throws<TransactionFailedException>(() => transaction2.Commit()); }
private static async Task WriteContributorsToRepo(string username, string password) { var nameOfThankyouBranch = "thankyou"; var repoUrl = _parsedOptions.repositoryUrl; var contributorsHeader = _parsedOptions.acknowledgementSection; var fileHoldingContributorsInfo = _parsedOptions.fileInRepoForAcknowledgement; var cloneOptions = new CloneOptions(); var gitCredentialsHandler = new CredentialsHandler( (url, usernameFromUrl, types) => new UsernamePasswordCredentials() { Username = username, Password = password }); cloneOptions.CredentialsProvider = gitCredentialsHandler; var tempPath = Path.GetTempPath(); var tempPathForRepo = Path.Combine(tempPath, "Jaan"); if (Directory.Exists(tempPathForRepo)) { Directory.Delete(tempPathForRepo, true); //TODO: Don't remove and re-clone, clone only if doesn't exist } var tempPathGitFolder = Path.Combine(tempPath, "Jaan"); if (!Directory.Exists(tempPathGitFolder)) { var directoryInfo = Directory.CreateDirectory(tempPathGitFolder); } LibGit2Sharp.Repository.Clone(repoUrl, tempPathGitFolder, cloneOptions); //TODO: if the repo clone is already here, should we delete and reclone? or should we assume correct repo here. using (var repo = new LibGit2Sharp.Repository(tempPathGitFolder)) { var remote = repo.Network.Remotes["origin"]; var defaultBranch = repo.Branches.FirstOrDefault(b => b.IsCurrentRepositoryHead == true); var refSpecs = remote.FetchRefSpecs.Select(x => x.Specification); var remoteThankYouBranch = repo.Branches.FirstOrDefault(b => b.FriendlyName == repo.Network.Remotes.FirstOrDefault()?.Name + "/" + nameOfThankyouBranch); if (remoteThankYouBranch != null) { Commands.Checkout(repo, remoteThankYouBranch); } if (repo.Head.FriendlyName != nameOfThankyouBranch) { var newThankyouBranch = repo.CreateBranch(nameOfThankyouBranch); repo.Branches.Update(newThankyouBranch, b => b.UpstreamBranch = newThankyouBranch.CanonicalName, b => b.Remote = repo.Network.Remotes.First().Name); Commands.Checkout(repo, newThankyouBranch); } var pathToReadme = Path.Combine(tempPathGitFolder, fileHoldingContributorsInfo); // Change the file and save it using (StreamWriter sw = File.AppendText(pathToReadme)) { foreach (var contributor in _contributorsToday) { sw.WriteLine(contributor); } } // Commit the file to the repo, on a non-master branch repo.Index.Add(fileHoldingContributorsInfo); repo.Index.Write(); // Create the committer's signature and commit var author = new LibGit2Sharp.Signature(_parsedOptions.gitAuthorName, _parsedOptions.gitAuthorEmail, DateTime.Now); var committer = author; // Commit to the repository var commit = repo.Commit("A new list of awesome contributors", author, committer); //Push the commit to origin LibGit2Sharp.PushOptions options = new LibGit2Sharp.PushOptions(); options.CredentialsProvider = gitCredentialsHandler; repo.Network.Push(repo.Head, options); // Login to GitHub with Octokit var githubClient = new GitHubClient(new ProductHeaderValue(username)); githubClient.Credentials = new Octokit.Credentials(password); try { // Create a PR on the repo for the branch "thank you" await githubClient.PullRequest.Create(username, "thankyou", new NewPullRequest("Give credit for people on Twitch chat", nameOfThankyouBranch, defaultBranch.FriendlyName)); } catch (Exception ex) { Console.WriteLine(ex); } } }
public void Commit_succeeds_if_two_transactions_created_the_same_branch_pointing_to_the_same_commit() { const string branchName = "newBranch"; var transaction1 = CreateTransaction(); var transaction2 = CreateTransaction(); transaction1.Begin(); transaction2.Begin(); // transaction 1: create branch using (var localRepository1 = new Repository(transaction1.LocalPath)) { localRepository1.CreateBranch(branchName, localRepository1.Commits.Single()); } // transaction 2: create branch using (var localRepository2 = new Repository(transaction2.LocalPath)) { localRepository2.CreateBranch(branchName, localRepository2.Commits.Single()); } // commit both transactions transaction1.Commit(); transaction2.Commit(); Assert.True(m_RemoteRepository.Branches.Any(x => x.FriendlyName == branchName)); }
public Branch CreateBranch(string branch, string baseBranchName) { using (var repo = new Repository(_settings.Workspace)) { var baseBranch = repo.Lookup<Commit>(baseBranchName); return repo.CreateBranch(branch, baseBranch); } }
public void NewPost(Post post) { using (var repo = new Repository(_directory.FullName)) { var json = JsonConvert.SerializeObject(post); var sig = new Signature(post.Author.Name, post.Author.Identifier, post.Timestamp); // Create post structure var votesDir = repo.ObjectDatabase.CreateTree(new TreeDefinition()); var repliesDir = repo.ObjectDatabase.CreateTree(new TreeDefinition()); var postRoot = new TreeDefinition(); postRoot.Add(VOTES_DIR, votesDir); postRoot.Add(REPLIES_DIR, repliesDir); var commit = CommitToBranch(repo, CONTENT_BRANCH, json, sig, repo.ObjectDatabase.CreateTree(postRoot)); // Create a named branch for all future content on this post repo.CreateBranch(commit.Sha, commit); } }
public override int Execute(UpdateSettings settings, ILookup <string, string> remaining) { // Get the user. var client = new GitHubClient(new ProductHeaderValue("Cake-Addin-Updater")) { Credentials = new Octokit.Credentials(settings.Token) }; // Validate the provided version. if (!System.Version.TryParse(settings.Version, out var _)) { _log.Error("The provided version is not valid."); return(1); } // Get the root. var root = settings.WorkingDirectory ?? new DirectoryPath("."); root = root.MakeAbsolute(_environment); // Get the user. var user = client.User.Get(settings.User).Result; var userEmail = GetUserEmail(client); // Get the repository parts. var info = GetRepositoryInfo(settings); // Does the directory contains anything? var path = CreateRepositoryDirectory(root, info); if (_filesystem.Directory.GetFiles(path, "*.*", SearchScope.Current).Any() || _filesystem.Directory.GetDirectories(path, "*.*", SearchScope.Current).Any()) { _log.Error($"Repository '{path}' already exist on disk."); _log.Write("Remove it and try again."); return(1); } // Fork the repository. var repository = ForkRepository(client, info); if (string.IsNullOrWhiteSpace(repository?.Name)) { _log.Error("Could not fork repository."); return(1); } // Get the default branch. var defaultBranch = repository.DefaultBranch; if (string.IsNullOrWhiteSpace(defaultBranch)) { _log.Error("Could not get default branch for repository."); return(1); } // Clone the repository at the specified path. _log.Write("Cloning repository..."); GitRepository.Clone($"https://github.com/{settings.User}/{repository.Name}", path.FullPath, new CloneOptions { Checkout = true }); using (var gitRepository = new GitRepository(path.FullPath)) { // Create a new branch in the repository. _log.Write("Creating branch..."); gitRepository.CreateBranch($"feature/cake-{settings.Version}"); _log.Write("Checking out branch..."); GitCommands.Checkout(gitRepository, $"feature/cake-{settings.Version}"); // Update all package references in project. var processed = _processor.Process(root, path, settings.Version); if (processed == 0) { _log.Error("Nothing was updated. Probably a newer repository."); return(1); } // Commit? if (settings.Commit) { _log.Write("Staging changes..."); GitCommands.Stage(gitRepository, "*"); var status = gitRepository.RetrieveStatus(); if (status.Any()) { _log.Write("Committing changes..."); var author = new GitSignature(user.Name, userEmail, DateTime.Now); gitRepository.Commit($"Updated to Cake {settings.Version}.", author, author); // Push? if (settings.Push) { // Build everything first. if (!BuildProject(path)) { return(1); } // Push the commit. if (!Push(settings, path)) { return(1); } // Create a pull request? if (settings.OpenPullRequest) { CreatePullRequest(client, settings, info); } } } else { _log.Error("No changes in repository. Already updated?"); } } } return(0); }
public void FetchWithoutConflict(string remoteUrl, string branchName) { var tracer = _tracerFactory.GetTracer(); try { using (var repo = new LibGit2Sharp.Repository(RepositoryPath)) { var trackedBranchName = string.Format("{0}/{1}", _remoteAlias, branchName); var refSpec = string.Format("+refs/heads/{0}:refs/remotes/{1}", branchName, trackedBranchName); LibGit2Sharp.Remote remote = null; using (tracer.Step("LibGit2SharpRepository Add Remote")) { // only add if matching remote does not exist // to address strange LibGit2SharpRepository remove and add remote issue (remote already exists!) remote = repo.Network.Remotes[_remoteAlias]; if (remote != null && string.Equals(remote.Url, remoteUrl, StringComparison.OrdinalIgnoreCase) && remote.FetchRefSpecs.Any(rf => string.Equals(rf.Specification, refSpec, StringComparison.OrdinalIgnoreCase))) { tracer.Trace("Git remote exists"); } else { // Remove it if it already exists (does not throw if it doesn't) repo.Network.Remotes.Remove(_remoteAlias); // Configure the remote remote = repo.Network.Remotes.Add(_remoteAlias, remoteUrl, refSpec); tracer.Trace("Git remote added"); } } using (tracer.Step("LibGit2SharpRepository Fetch")) { // This will only retrieve the "master" repo.Network.Fetch(remote); } using (tracer.Step("LibGit2SharpRepository Update")) { // Are we fetching a tag? if (branchName.Trim().StartsWith("refs/tags/", StringComparison.OrdinalIgnoreCase)) { var trackedTag = repo.Tags[branchName]; if (trackedTag == null) { throw new BranchNotFoundException(branchName, null); } // Update the raw ref to point to the tag UpdateRawRef(branchName, branchName); // Now checkout out the tag, which points to the right place Update(branchName); } else { // Optionally set up the branch tracking configuration var trackedBranch = repo.Branches[trackedBranchName]; if (trackedBranch == null) { throw new BranchNotFoundException(branchName, null); } var branch = repo.Branches[branchName] ?? repo.CreateBranch(branchName, trackedBranch.Tip); repo.Branches.Update(branch, b => b.TrackedBranch = trackedBranch.CanonicalName); // Update the raw ref to point the head of branchName to the latest fetched branch UpdateRawRef(string.Format("refs/heads/{0}", branchName), trackedBranchName); // Now checkout out our branch, which points to the right place Update(branchName); } } } } catch (LibGit2SharpException exception) { // LibGit2Sharp doesn't support SSH yet. Use GitExeRepository // LibGit2Sharp only supports smart Http protocol if (exception.Message.Equals("Unsupported URL protocol") || exception.Message.Equals("Received unexpected content-type")) { tracer.TraceWarning("LibGit2SharpRepository fallback to git.exe due to {0}", exception.Message); _legacyGitExeRepository.FetchWithoutConflict(remoteUrl, branchName); } else { throw; } } }
public void When_The_Main_Branch_Has_More_Commits_Than_A_Ref_Branch_It_Should_Not_Be_Deletable() { /* Setup */ // First commit File.WriteAllText(Path.Combine(_repoPath, "file1.txt"), "File1's content..."); _repo.Stage("file1.txt"); _repo.Commit("First commit..."); // Checkout new branch _repo.CreateBranch("newBranch"); _repo.Checkout("newBranch"); // Second commit File.WriteAllText(Path.Combine(_repoPath, "file2.txt"), "File2's content..."); _repo.Stage("file2.txt"); _repo.Commit("Second commit..."); // Prepare for comparison var mainBranch = _repo.Branches["newBranch"]; var refBranch = _repo.Branches["master"]; /* Test */ var result = _selector.CompareBranches(new Gitcomparer.Core.Model.Branch(mainBranch), new Gitcomparer.Core.Model.Branch(refBranch)); /* Assert */ Assert.That(result.MainBranch.Name, Is.EqualTo(mainBranch.Name)); Assert.That(result.RefBranch.Name, Is.EqualTo(refBranch.Name)); Assert.That(result.Status, Is.EqualTo(ResultStatus.No)); }
protected virtual void HandleFixedVersioning_Commit(Dependency dependency, Repository otherRepository) { var dependencyCommit = otherRepository.Lookup(dependency.Commit) as Commit; if (dependencyCommit == null) throw new InvalidOperationException($"Dependency {dependency}: Commit '{dependency.Commit}' is invalid"); var buildBranch = (from branch in otherRepository.Branches where branch.FriendlyName == VersionResolver.BuildBranchName select branch).SingleOrDefault(); if (buildBranch == null) { Log($"Dependency {dependency}: fixed versioning: '{VersionResolver.BuildBranchName}' branch not found => creating it at Commit = '{dependency.Commit}'..."); otherRepository.CreateBranch(VersionResolver.BuildBranchName, dependency.Commit); } else { Log($"Dependency {dependency}: fixed versioning: '{VersionResolver.BuildBranchName}' branch found => checking it out and hard resetting it to Commit = '{dependency.Commit}'..."); otherRepository.Checkout(buildBranch, new CheckoutOptions() { CheckoutModifiers = CheckoutModifiers.Force }); otherRepository.Reset(ResetMode.Hard, dependencyCommit); } }
public void Begin_creates_new_local_branches_for_branches_created_in_the_remote_repository() { const string branchName = "newTestBranch"; var transaction1 = CreateTransaction(); var transaction2 = CreateTransaction(); transaction1.Begin(); transaction2.Begin(); // in transaction1 create a branch and push it to the remote directory using (var repository = new Repository(transaction1.LocalPath)) { repository.CreateBranch(branchName, repository.Commits.Single()); } transaction1.Commit(); var transaction3 = CreateCachingTransaction(transaction2.LocalPath); transaction3.Begin(); using (var repository = new Repository(transaction3.LocalPath)) { Assert.True(repository.Branches[branchName] != null); } }
/// <summary> /// Creates local tracking branches for all remote branches /// </summary> protected void CreateLocalBranches() { using (var repository = new Repository(LocalPath)) { // for every remote branch, create a local branch if it does not already exist foreach (var remoteBranch in repository.Branches.GetRemoteBranches()) { var branchName = remoteBranch.FriendlyName.Replace($"{s_Origin}/", ""); var localBranch = repository.Branches[branchName] ?? repository.CreateBranch(branchName, remoteBranch.Tip); // set up the local branch to track the remote branch repository.Branches.Update(localBranch, b => b.TrackedBranch = remoteBranch.CanonicalName); } } }
public Task <bool> Commit(string localRepository, string baseBranch, string branch, string commitMessage, string author, string email) { try { var repo = new Repository(localRepository); var signature = new LibGit2Sharp.Signature(author, email, DateTimeOffset.UtcNow); // if we're working on empty repository, create master branch if (repo.Branches == null || repo.Branches.Count() == 0) { var readmeFile = Path.Combine(localRepository, "README.md"); if (!File.Exists(readmeFile)) { File.WriteAllText(Path.Combine(localRepository, "README.md"), "# Catapult-generated"); } Commands.Stage(repo, "README.md"); if (File.Exists(Path.Combine(localRepository, ".gitignore"))) { Commands.Stage(repo, ".gitignore"); } repo.Commit("Initial commit", signature, signature); var masterBranch = repo.Branches[baseBranch]; var remote = repo.Network.Remotes["origin"]; repo.Branches.Update(masterBranch, b => b.Remote = remote.Name, b => b.UpstreamBranch = masterBranch.CanonicalName); _logger.LogInformation("Repository has been initialized"); } // checkout base branch var branchObj = repo.Branches[baseBranch] != null ? repo.Branches[baseBranch] : repo.Branches[$"origin/{baseBranch}"]; if (branch == null) { _logger.LogError($"Base branch {baseBranch} was not found"); return(Task.FromResult(false)); } if (repo.Head.Commits.FirstOrDefault() != branchObj.Commits.FirstOrDefault()) { Commands.Checkout(repo, branchObj); } if (repo.Branches[branch] == null) { var newBranch = repo.CreateBranch(branch); var remote = repo.Network.Remotes["origin"]; repo.Branches.Update(newBranch, b => b.Remote = remote.Name, b => b.UpstreamBranch = newBranch.CanonicalName); _logger.LogInformation("Branch {branch} has been created.", branch); } Commands.Checkout(repo, repo.Branches[branch]); Commands.Stage(repo, "*"); var commit = repo.Commit(commitMessage, signature, signature); return(Task.FromResult(commit != null)); } catch (Exception ex) { _logger.LogError(ex, ex.Message); return(Task.FromResult(false)); } }
/// <summary> /// Adds the standard .NET targets to the build. /// </summary> /// <param name="build">The build to which to add targets.</param> /// <param name="settings">The build settings.</param> public static void AddDotNetTargets(this BuildApp build, DotNetBuildSettings?settings = null) { settings ??= new DotNetBuildSettings(); var buildOptions = settings.BuildOptions ?? (settings.BuildOptions = new DotNetBuildOptions()); var configurationOption = buildOptions.ConfigurationOption ?? (buildOptions.ConfigurationOption = build.AddOption("-c|--configuration <name>", "The configuration to build (default Release)", "Release")); var platformOption = buildOptions.PlatformOption ?? (buildOptions.PlatformOption = build.AddOption("-p|--platform <name>", "The solution platform to build")); var verbosityOption = buildOptions.VerbosityOption ?? (buildOptions.VerbosityOption = build.AddOption("-v|--verbosity <level>", "The build verbosity (q[uiet], m[inimal], n[ormal], d[etailed])")); var versionSuffixOption = buildOptions.VersionSuffixOption ?? (buildOptions.VersionSuffixOption = build.AddOption("--version-suffix <suffix>", "Generates a prerelease package")); var nugetOutputOption = buildOptions.NuGetOutputOption ?? (buildOptions.NuGetOutputOption = build.AddOption("--nuget-output <path>", "Directory for generated package (default release)", "release")); var triggerOption = buildOptions.TriggerOption ?? (buildOptions.TriggerOption = build.AddOption("--trigger <name>", "The git branch or tag that triggered the build")); var buildNumberOption = buildOptions.BuildNumberOption ?? (buildOptions.BuildNumberOption = build.AddOption("--build-number <number>", "The automated build number")); var noTestFlag = buildOptions.NoTestFlag ?? (buildOptions.NoTestFlag = build.AddFlag("--no-test", "Skip the unit tests")); var solutionName = settings.SolutionName; var nugetSource = settings.NuGetSource ?? "https://api.nuget.org/v3/index.json"; var msbuildSettings = settings.MSBuildSettings; var packagePaths = new List <string>(); string?trigger = null; var ignoreIfAlreadyPushed = false; build.Target("clean") .Describe("Deletes all build output") .Does(() => { var findDirectoriesToDelete = settings.CleanSettings?.FindDirectoriesToDelete ?? (() => FindDirectories("{src,tests,tools}/**/{bin,obj}").Except(FindDirectories("tools/bin")).ToList()); foreach (var directoryToDelete in findDirectoriesToDelete()) { DeleteDirectory(directoryToDelete); } var verbosity = GetVerbosity(); var extraProperties = GetExtraProperties("clean"); if (msbuildSettings == null) { RunDotNet(new[] { "clean", solutionName, "-c", configurationOption.Value, GetPlatformArg(), "--verbosity", verbosity, GetMaxCpuCountArg() }.Concat(extraProperties)); } else { MSBuild(new[] { solutionName, "-t:Clean", $"-p:Configuration={configurationOption.Value}", GetPlatformArg(), $"-v:{verbosity}", GetMaxCpuCountArg() }.Concat(extraProperties)); } }); build.Target("restore") .Describe("Restores NuGet packages") .Does(() => { var verbosity = GetVerbosity(); var extraProperties = GetExtraProperties("restore"); if (msbuildSettings == null) { RunDotNet(new[] { "restore", solutionName, GetPlatformArg(), "--verbosity", verbosity, GetMaxCpuCountArg() }.Concat(extraProperties)); } else { MSBuild(new[] { solutionName, "-t:Restore", $"-p:Configuration={configurationOption.Value}", GetPlatformArg(), $"-v:{verbosity}", GetMaxCpuCountArg() }.Concat(extraProperties)); } if (DotNetLocalTool.Any()) { RunDotNet("tool", "restore"); } }); build.Target("build") .DependsOn("restore") .Describe("Builds the solution") .Does(() => { var buildNumberArg = GetBuildNumberArg(); var verbosity = GetVerbosity(); var extraProperties = GetExtraProperties("build"); if (msbuildSettings == null) { RunDotNet(new[] { "build", solutionName, "-c", configurationOption.Value, GetPlatformArg(), buildNumberArg, "--no-restore", "--verbosity", verbosity, GetMaxCpuCountArg() }.Concat(extraProperties)); } else { MSBuild(new[] { solutionName, $"-p:Configuration={configurationOption.Value}", GetPlatformArg(), buildNumberArg, $"-v:{verbosity}", GetMaxCpuCountArg() }.Concat(extraProperties)); } }); build.Target("test") .DependsOn("build") .Describe("Runs the unit tests") .Does(() => { if (noTestFlag.Value) { Console.WriteLine("Skipping unit tests due to --no-test."); } else { var extraProperties = GetExtraProperties("test").ToList(); var findTestAssemblies = settings.TestSettings?.FindTestAssemblies; if (findTestAssemblies != null) { foreach (var testAssembly in findTestAssemblies()) { if (settings.TestSettings?.RunTests != null) { settings.TestSettings.RunTests(testAssembly); } else { RunDotNet(new AppRunnerSettings { Arguments = new[] { "vstest", Path.GetFileName(testAssembly) }.Concat(extraProperties), WorkingDirectory = Path.GetDirectoryName(testAssembly) }); } } } else { var testProjects = new List <string?>(); var findTestProjects = settings.TestSettings?.FindProjects; if (findTestProjects != null) { testProjects.AddRange(findTestProjects()); } else { testProjects.Add(solutionName); } foreach (var testProject in testProjects) { if (settings.TestSettings?.RunTests != null) { settings.TestSettings.RunTests(testProject); } else { RunDotNet(new[] { "test", testProject, "-c", configurationOption.Value, GetPlatformArg(), "--no-build", GetMaxCpuCountArg() }.Concat(extraProperties)); } } } } }); build.Target("package") .DependsOn("clean", "test") .Describe("Builds NuGet packages") .Does(() => { trigger = triggerOption.Value; if (trigger == "detect") { using var repository = new Repository("."); var headSha = repository.Head.Tip.Sha; var autoTrigger = GetBestTriggerFromTags(repository.Tags.Where(x => x.Target.Sha == headSha).Select(x => x.FriendlyName).ToList()); if (autoTrigger != null) { trigger = autoTrigger; ignoreIfAlreadyPushed = true; Console.WriteLine($"Detected trigger: {trigger}"); } } var versionSuffix = versionSuffixOption.Value; if (versionSuffix == null && trigger != null) { versionSuffix = GetVersionFromTrigger(trigger) is string triggerVersion ? SplitVersion(triggerVersion).Suffix : null; } var nugetOutputPath = Path.GetFullPath(nugetOutputOption.Value !); var tempOutputPath = Path.Combine(nugetOutputPath, Path.GetRandomFileName()); var packageProjects = new List <string?>(); var findPackageProjects = settings.PackageSettings?.FindProjects; if (findPackageProjects != null) { packageProjects.AddRange(findPackageProjects()); } else { packageProjects.Add(solutionName); } var extraProperties = GetExtraProperties("package").ToList(); foreach (var packageProject in packageProjects) { if (msbuildSettings == null) { RunDotNet(new[] { "pack", packageProject, "-c", configurationOption.Value, GetPlatformArg(), "--no-build", "--output", tempOutputPath, versionSuffix != null ? "--version-suffix" : null, versionSuffix, GetMaxCpuCountArg(), }.Concat(extraProperties)); } else { MSBuild(new[] { packageProject, "-t:Pack", $"-p:Configuration={configurationOption.Value}", GetPlatformArg(), "-p:NoBuild=true", $"-p:PackageOutputPath={tempOutputPath}", versionSuffix != null ? $"-p:VersionSuffix={versionSuffix}" : null, $"-v:{GetVerbosity()}", GetMaxCpuCountArg(), }.Concat(extraProperties)); } } var tempPackagePaths = FindFilesFrom(tempOutputPath, "*.nupkg"); foreach (var tempPackagePath in tempPackagePaths) { var packagePath = Path.Combine(nugetOutputPath, Path.GetFileName(tempPackagePath) ?? throw new InvalidOperationException()); if (File.Exists(packagePath)) { File.Delete(packagePath); } File.Move(tempPackagePath, packagePath); packagePaths.Add(packagePath); Console.WriteLine($"NuGet package: {packagePath}"); } DeleteDirectory(tempOutputPath); if (packagePaths.Count == 0) { throw new BuildException("No NuGet packages created."); } }); build.Target("publish") .Describe("Publishes NuGet packages and documentation") .DependsOn("package") .Does(() => { if (packagePaths.Count == 0) { throw new BuildException("No NuGet packages found."); } if (trigger is null) { if (packagePaths.Any(x => GetPackageInfo(x).Version == "0.0.0")) { Console.WriteLine("Not publishing package with version 0.0.0. Change package version to publish."); return; } trigger = "publish-all"; } var triggerParts = trigger.Split('-'); var publishTrigger = triggerParts.Length >= 2 && triggerParts[0] == "publish" ? triggerParts[1] : null; var shouldPublishPackages = publishTrigger == "package" || publishTrigger == "packages" || publishTrigger == "all"; var shouldPublishDocs = publishTrigger == "docs" || publishTrigger == "all"; var shouldSkipDuplicates = publishTrigger == "all"; var triggerVersion = GetVersionFromTrigger(trigger); if (triggerVersion != null) { var mismatches = packagePaths.Where(x => GetPackageInfo(x).Version != triggerVersion).ToList(); if (mismatches.Count != 0) { throw new BuildException($"Trigger '{trigger}' doesn't match package version: {string.Join(", ", mismatches.Select(Path.GetFileName))}"); } shouldPublishPackages = true; shouldPublishDocs = triggerVersion.IndexOf('-') == -1; } if (shouldPublishPackages || shouldPublishDocs) { var docsSettings = settings.DocsSettings; var shouldPushDocs = false; string?cloneDirectory = null; string?repoDirectory = null; string?gitBranchName = null; if (shouldPublishDocs && docsSettings != null) { if (docsSettings.GitLogin == null || docsSettings.GitAuthor == null) { throw new BuildException("GitLogin and GitAuthor must be set on DocsSettings."); } var gitRepositoryUrl = docsSettings.GitRepositoryUrl; gitBranchName = docsSettings.GitBranchName; if (gitRepositoryUrl != null) { cloneDirectory = "docs_repo_" + Path.GetRandomFileName(); Repository.Clone(sourceUrl: gitRepositoryUrl, workdirPath: cloneDirectory, options: new CloneOptions { BranchName = gitBranchName, CredentialsProvider = ProvideCredentials }); repoDirectory = cloneDirectory; } else { repoDirectory = "."; } using var repository = new Repository(repoDirectory); if (gitRepositoryUrl != null) { gitBranchName ??= repository.Head.FriendlyName; } else if (gitBranchName != null) { if (gitBranchName != repository.Head.FriendlyName) { var branch = repository.Branches[gitBranchName] ?? repository.CreateBranch(gitBranchName); Commands.Checkout(repository, branch); } } else { var branch = repository.Branches.FirstOrDefault(x => x.IsCurrentRepositoryHead); if (branch == null) { var autoBranchName = Environment.GetEnvironmentVariable("APPVEYOR_REPO_BRANCH"); if (autoBranchName == null) { var gitRef = Environment.GetEnvironmentVariable("GITHUB_REF"); const string prefix = "refs/heads/"; if (gitRef != null && gitRef.StartsWith(prefix, StringComparison.Ordinal)) { autoBranchName = gitRef.Substring(prefix.Length); } } if (autoBranchName != null) { branch = repository.Branches[autoBranchName] ?? repository.CreateBranch(autoBranchName); } else { branch = repository.Branches.FirstOrDefault(x => x.Tip.Sha == repository.Head.Tip.Sha); } if (branch != null) { Commands.Checkout(repository, branch); } } if (branch == null) { throw new BuildException("Could not determine repository branch for publishing docs."); } gitBranchName = branch.FriendlyName; } var docsPath = Path.Combine(repoDirectory, docsSettings.TargetDirectory ?? "docs"); string?xmlDocGenPath = null; var xmlDocGenProject = FindFiles("tools/XmlDocGen/XmlDocGen.csproj").FirstOrDefault(); if (xmlDocGenProject != null) { RunDotNet("publish", xmlDocGenProject, "--output", Path.Combine("tools", "bin", "XmlDocGen"), "--nologo", "--verbosity", "quiet"); xmlDocGenPath = Path.Combine("tools", "bin", "XmlDocGen", "XmlDocGen.dll"); } var projectHasDocs = docsSettings.ProjectHasDocs ?? (_ => true); foreach (var projectName in packagePaths.Select(x => GetPackageInfo(x).Name).Where(projectHasDocs)) { if (xmlDocGenPath != null) { RunDotNet(new[] { xmlDocGenPath }.Concat(GetXmlDocArgs(projectName))); } else { var assemblyPaths = new List <string>(); if (docsSettings.FindAssemblies != null) { assemblyPaths.AddRange(docsSettings.FindAssemblies(projectName)); } else { var assemblyPath = (docsSettings.FindAssembly ?? FindAssembly)(projectName); if (assemblyPath != null) { assemblyPaths.Add(assemblyPath); } } if (assemblyPaths.Count != 0) { if (DotNetLocalTool.TryCreate("xmldocmd") is DotNetLocalTool xmldocmd) { foreach (var assemblyPath in assemblyPaths) { xmldocmd.Run(GetXmlDocArgs(assemblyPath)); } } else { var dotNetTools = settings.DotNetTools ?? new DotNetTools(Path.Combine("tools", "bin")); var xmlDocMarkdownVersion = settings.DocsSettings?.ToolVersion ?? "2.0.1"; foreach (var assemblyPath in assemblyPaths) { RunApp(dotNetTools.GetToolPath($"xmldocmd/{xmlDocMarkdownVersion}"), GetXmlDocArgs(assemblyPath)); } } } else { Console.WriteLine($"Documentation not generated for {projectName}; assembly not found."); }
/// <summary> /// Creates a new branch with branchName. /// </summary> /// <param name="repositoryPath"></param> /// <param name="branchName"></param> /// <returns>CommandStatus</returns> private ECommandStatus Branch(string repositoryPath, string branchName, bool delete, bool isRemote) { try { using (var repo = new Repository(repositoryPath)) { var localBranch = repo.Branches[branchName]; if (localBranch == null) { if (delete) { return ECommandStatus.BranchNotFound; } else { Branch branch = repo.CreateBranch(branchName); return ECommandStatus.OK; } } else { if (delete) { repo.Branches.Remove(branchName, isRemote); return ECommandStatus.OK; } else { return ECommandStatus.BranchAlreadyExists; } } } } catch (Exception ex) { System.Diagnostics.Debug.WriteLine(ex.Message); return ECommandStatus.FAIL; } }