Add branches to push subcommand

Author: SandrineP

src/subcommand/push_subcommand.cpp

@@ -3,18 +3,22 @@
 #include <iostream>
 
 #include <git2/remote.h>
+#include <git2/types.h>
 
 #include "../utils/credentials.hpp"
 #include "../utils/progress.hpp"
+#include "../utils/ansi_code.hpp"
 #include "../wrapper/repository_wrapper.hpp"
 
 push_subcommand::push_subcommand(const libgit2_object&, CLI::App& app)
 {
     auto* sub = app.add_subcommand("push", "Update remote refs along with associated objects");
 
     sub->add_option("<remote>", m_remote_name, "The remote to push to")->default_val("origin");
-
+    sub->add_option("<branch>", m_branch_name, "The branch to push");
     sub->add_option("<refspec>", m_refspecs, "The refspec(s) to push");
+    sub->add_flag("--all,--branches", m_branches_flag, "Push all branches (i.e. refs under " + ansi_code::bold + "refs/heads/" + ansi_code::reset + "); cannot be used with other <refspec>.");
+
 
     sub->callback(
         [this]()
@@ -37,19 +41,38 @@ void push_subcommand::run()
     push_opts.callbacks.push_transfer_progress = push_transfer_progress;
     push_opts.callbacks.push_update_reference = push_update_reference;
 
-    if (m_refspecs.empty())
+    if (m_branches_flag)
     {
-        try
+        auto iter = repo.iterate_branches(GIT_BRANCH_LOCAL);
+        auto br = iter.next();
+        while (br)
         {
-            auto head_ref = repo.head();
-            std::string short_name = head_ref.short_name();
-            std::string refspec = "refs/heads/" + short_name;
+            std::string refspec = "refs/head/" + std::string(br->name());
             m_refspecs.push_back(refspec);
+            br = iter.next();
+        }
+    }
+    else if (m_refspecs.empty())
+    {
+        std::string branch;
+        if (!m_branch_name.empty())
+        {
+            branch = m_branch_name;
         }
-        catch (...)
+        else
         {
-            std::cerr << "Could not determine current branch to push." << std::endl;
-            return;
+            try
+            {
+                auto head_ref = repo.head();
+                branch = head_ref.short_name();
+                std::string refspec = "refs/heads/" + branch;
+                m_refspecs.push_back(refspec);
+            }
+            catch (...)
+            {
+                std::cerr << "Could not determine current branch to push." << std::endl;
+                return;
+            }
         }
     }
     git_strarray_wrapper refspecs_wrapper(m_refspecs);

src/subcommand/push_subcommand.hpp

@@ -17,5 +17,7 @@ class push_subcommand
 private:
 
     std::string m_remote_name;
+    std::string m_branch_name;
     std::vector<std::string> m_refspecs;
+    bool m_branches_flag = false;
 };

src/utils/ansi_code.hpp

@@ -19,6 +19,9 @@ namespace ansi_code
     const std::string hide_cursor = "\e[?25l";
     const std::string show_cursor = "\e[?25h";
 
+    const std::string bold = "\033[1m";
+    const std::string reset = "\033[0m";
+
     // Functions.
     std::string cursor_to_row(size_t row);
 

test/test_push.py

@@ -62,3 +62,97 @@ def test_push_private_repo(
     assert p_push.stdout.count("Username:") == 2
     assert p_push.stdout.count("Password:") == 2
     assert "Pushed to origin" in p_push.stdout
+    print(p_push.stdout)
+
+
+# def test_push_branch_private_repo(
+#     git2cpp_path, tmp_path, run_in_tmp_path, private_test_repo, commit_env_config
+# ):
+#     """Test push with an explicit branch name: git2cpp push <remote> <branch>."""
+#     branch_name = f"test-{uuid4()}"
+
+#     username = "abc"
+#     password = private_test_repo["token"]
+#     input = f"{username}\n{password}"
+#     repo_path = tmp_path / private_test_repo["repo_name"]
+#     url = private_test_repo["https_url"]
+
+#     # Clone the private repo.
+#     clone_cmd = [git2cpp_path, "clone", url]
+#     p_clone = subprocess.run(clone_cmd, capture_output=True, text=True, input=input)
+#     assert p_clone.returncode == 0
+#     assert repo_path.exists()
+
+#     # Create a new branch and commit on it.
+#     checkout_cmd = [git2cpp_path, "checkout", "-b", branch_name]
+#     p_checkout = subprocess.run(checkout_cmd, cwd=repo_path, capture_output=True, text=True)
+#     assert p_checkout.returncode == 0
+
+#     (repo_path / "push_branch_file.txt").write_text("push branch test")
+#     subprocess.run([git2cpp_path, "add", "push_branch_file.txt"], cwd=repo_path, check=True)
+#     subprocess.run([git2cpp_path, "commit", "-m", "branch commit"], cwd=repo_path, check=True)
+
+#     # Switch back to main so HEAD is NOT on the branch we want to push.
+#     subprocess.run(
+#         [git2cpp_path, "checkout", "main"], capture_output=True, check=True, cwd=repo_path
+#     )
+
+#     status_cmd = [git2cpp_path, "status"]
+#     p_status = subprocess.run(status_cmd, cwd=repo_path, capture_output=True, text=True)
+#     assert p_status.returncode == 0
+#     assert "On branch main" in p_status.stdout
+
+#     # Push specifying the branch explicitly (HEAD is on main, not the test branch).
+#     input = f"{username}\n{password}"
+#     push_cmd = [git2cpp_path, "push", "origin", branch_name]
+#     p_push = subprocess.run(push_cmd, cwd=repo_path, capture_output=True, text=True, input=input)
+#     assert p_push.returncode == 0
+#     assert "Pushed to origin" in p_push.stdout
+
+
+# def test_push_branches_flag_private_repo(
+#     git2cpp_path, tmp_path, run_in_tmp_path, private_test_repo, commit_env_config
+# ):
+#     """Test push --branches pushes all local branches."""
+#     branch_a = f"test-a-{uuid4()}"
+#     branch_b = f"test-b-{uuid4()}"
+
+#     username = "abc"
+#     password = private_test_repo["token"]
+#     input = f"{username}\n{password}"
+#     repo_path = tmp_path / private_test_repo["repo_name"]
+#     url = private_test_repo["https_url"]
+
+#     # Clone the private repo.
+#     clone_cmd = [git2cpp_path, "clone", url]
+#     p_clone = subprocess.run(clone_cmd, capture_output=True, text=True, input=input)
+#     assert p_clone.returncode == 0
+#     assert repo_path.exists()
+
+#     # Create two extra branches with commits.
+#     for branch_name in [branch_a, branch_b]:
+#         subprocess.run(
+#             [git2cpp_path, "checkout", "-b", branch_name],
+#             capture_output=True,
+#             check=True,
+#             cwd=repo_path,
+#         )
+#         (repo_path / f"{branch_name}.txt").write_text(f"content for {branch_name}")
+#         subprocess.run([git2cpp_path, "add", f"{branch_name}.txt"], cwd=repo_path, check=True)
+#         subprocess.run(
+#             [git2cpp_path, "commit", "-m", f"commit on {branch_name}"],
+#             cwd=repo_path,
+#             check=True,
+#         )
+
+#     # Go back to main.
+#     subprocess.run(
+#         [git2cpp_path, "checkout", "main"], capture_output=True, check=True, cwd=repo_path
+#     )
+
+#     # Push all branches at once.
+#     input = f"{username}\n{password}"
+#     push_cmd = [git2cpp_path, "push", "origin", "--branches"]
+#     p_push = subprocess.run(push_cmd, cwd=repo_path, capture_output=True, text=True, input=input)
+#     assert p_push.returncode == 0
+#     assert "Pushed to origin" in p_push.stdout