Add branches to push subcommand

Author: SandrineP

src/subcommand/push_subcommand.cpp

@@ -1,9 +1,11 @@
 #include "../subcommand/push_subcommand.hpp"
 
 #include <iostream>
+#include <unordered_map>
 
 #include <git2/remote.h>
 
+#include "../utils/ansi_code.hpp"
 #include "../utils/credentials.hpp"
 #include "../utils/progress.hpp"
 #include "../wasm/scope.hpp"
@@ -14,8 +16,14 @@ 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("<refspec>", m_refspecs, "The refspec(s) to push");
+    sub->add_option("<refspec>", m_refspecs, "The refspec(s) to push")
+        ->expected(0,-1);
+    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]()
@@ -25,6 +33,15 @@ push_subcommand::push_subcommand(const libgit2_object&, CLI::App& app)
     );
 }
 
+// TODO: put in common
+static std::string oid_to_hex(const git_oid& oid)
+{
+    char oid_str[GIT_OID_SHA1_HEXSIZE + 1];
+    git_oid_fmt(oid_str, &oid);
+    oid_str[GIT_OID_SHA1_HEXSIZE] = '\0';
+    return std::string(oid_str);
+}
+
 void push_subcommand::run()
 {
     wasm_http_transport_scope transport;  // Enables wasm http(s) transport.
@@ -40,25 +57,133 @@ 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)
+    {
+        auto iter = repo.iterate_branches(GIT_BRANCH_LOCAL);
+        auto br = iter.next();
+        while (br)
+        {
+            std::string refspec = "refs/heads/" + std::string(br->name());
+            m_refspecs.push_back(refspec);
+            br = iter.next();
+        }
+    }
+    else if (m_refspecs.empty())
     {
+        std::string branch;
         try
         {
             auto head_ref = repo.head();
-            std::string short_name = head_ref.short_name();
-            std::string refspec = "refs/heads/" + short_name;
-            m_refspecs.push_back(refspec);
+            branch = head_ref.short_name();
         }
         catch (...)
         {
             std::cerr << "Could not determine current branch to push." << std::endl;
             return;
         }
+        std::string refspec = "refs/heads/" + branch;
+        m_refspecs.push_back(refspec);
+    }
+    else
+    {
+        for (auto& r : m_refspecs)
+        {
+            if (r.rfind("refs/", 0) == 0)
+            {
+                continue;
+            }
+
+            r = "refs/heads/" + r;
+        }
     }
     git_strarray_wrapper refspecs_wrapper(m_refspecs);
-    git_strarray* refspecs_ptr = nullptr;
-    refspecs_ptr = refspecs_wrapper;
+    git_strarray* refspecs_ptr = refspecs_wrapper;
+
+    // Take a snapshot of repo's references to check which ones are new after push
+    auto repo_refs = repo.reference_list();
+    std::unordered_map<std::string, git_oid> remote_refs_before_oids;
+    const std::string prefix = std::string("refs/remotes/") + remote_name + "/";
+    for (const auto &r : repo_refs)
+    {
+        if (r.size() > prefix.size() && r.compare(0, prefix.size(), prefix) == 0)
+        {
+            // r is like "refs/remotes/origin/main"
+            std::string short_name = r.substr(prefix.size()); // "main" or "feature/x"
+            std::string canonical_remote_ref = std::string("refs/heads/") + short_name;
+
+            git_oid oid = repo.ref_name_to_id(r);
+            remote_refs_before_oids.emplace(std::move(canonical_remote_ref), oid);
+        }
+    }
 
     remote.push(refspecs_ptr, &push_opts);
-    std::cout << "Pushed to " << remote_name << std::endl;
+
+    std::cout << "To " << remote.url() << std::endl;
+    for (const auto& refspec : m_refspecs)
+    {
+        std::string_view ref_view(refspec);
+        std::string_view prefix_local = "refs/heads/";
+        std::string local_short_name;
+        if (ref_view.size() >= prefix_local.size() && ref_view.substr(0, prefix_local.size()) == prefix_local)
+        {
+            local_short_name = std::string(ref_view.substr(prefix_local.size()));
+        }
+        else
+        {
+            local_short_name = std::string(refspec);
+        }
+
+        std::optional<std::string> upstream_opt = repo.branch_upstream_name(local_short_name);
+
+        std::string remote_branch = local_short_name;
+        std::string canonical_remote_ref = "refs/heads/" + local_short_name;
+        if (upstream_opt.has_value())
+        {
+            const std::string up_name = upstream_opt.value();
+            auto pos = up_name.find('/');
+            if (pos != std::string::npos && pos + 1 < up_name.size())
+            {
+                std::string up_remote = up_name.substr(0, pos);
+                std::string up_branch = up_name.substr(pos + 1);
+                if (up_remote == remote_name)
+                {
+                    remote_branch = up_branch;
+                    canonical_remote_ref = "refs/heads/" + remote_branch;
+                }
+            }
+        }
+
+        auto it = remote_refs_before_oids.find(canonical_remote_ref);
+        if (it == remote_refs_before_oids.end())
+        {
+            std::cout << " * [new branch]      " << local_short_name << " -> " << remote_branch << std::endl;
+            continue;
+        }
+
+        git_oid remote_oid = it->second;
+
+        std::optional<git_oid> local_oid_opt;
+        if (auto ref_opt = repo.find_reference_dwim(("refs/heads/" + local_short_name)))
+        {
+            const git_oid* target = ref_opt->target();
+            local_oid_opt = *target;  // TODO: pas comprenu pourquoi je ne peux pas faire local_oid_opt =
+                                        // ref_opt->target();
+        }
+
+        if (!local_oid_opt)
+        {
+            std::cout << "   " << local_short_name << " -> " << remote_branch << std::endl;
+            continue;
+        }
+        git_oid local_oid = local_oid_opt.value();
+
+        if (!git_oid_equal(&remote_oid, &local_oid))
+        {
+            std::string old_hex = oid_to_hex(remote_oid);
+            std::string new_hex = oid_to_hex(local_oid);
+            // TODO: check order of hex codes
+            std::cout << "   " << old_hex.substr(0, 7) << ".." << new_hex.substr(0, 7) << "  "
+                        << local_short_name << " -> " << local_short_name << std::endl;
+        }
+    }
 }

src/subcommand/push_subcommand.hpp

@@ -18,4 +18,5 @@ class push_subcommand
 
     std::string m_remote_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);
 

src/utils/progress.cpp

@@ -139,11 +139,9 @@ int push_update_reference(const char* refname, const char* status, void*)
 {
     if (status)
     {
-        std::cout << "  " << refname << " " << status << std::endl;
-    }
-    else
-    {
-        std::cout << "  " << refname << std::endl;
+        std::cout << " ! [remote rejected] " << refname << " (" << status << ")" << std::endl;
+        return -1;
     }
+
     return 0;
 }

src/wrapper/remote_wrapper.cpp

@@ -3,8 +3,6 @@
 #include <string>
 #include <vector>
 
-#include <git2/remote.h>
-
 #include "../utils/git_exception.hpp"
 
 remote_wrapper::remote_wrapper(git_remote* remote)

src/wrapper/remote_wrapper.hpp

@@ -4,7 +4,6 @@
 #include <vector>
 
 #include <git2.h>
-#include <git2/remote.h>
 
 #include "../wrapper/wrapper_base.hpp"
 

src/wrapper/repository_wrapper.cpp

@@ -134,6 +134,26 @@ std::optional<reference_wrapper> repository_wrapper::find_reference_dwim(std::st
     return rc == 0 ? std::make_optional(reference_wrapper(ref)) : std::nullopt;
 }
 
+std::vector<std::string> repository_wrapper::reference_list() const
+{
+    git_strarray refs = {0};
+    throw_if_error(git_reference_list(&refs, *this));
+    std::vector<std::string> result;
+    for (size_t i = 0; i < refs.count; ++i)
+    {
+        result.push_back(refs.strings[i]);
+    }
+    git_strarray_free(&refs);
+    return result;
+}
+
+const git_oid repository_wrapper::ref_name_to_id(std::string ref_name) const
+{
+    git_oid ref_id;
+    throw_if_error(git_reference_name_to_id(&ref_id, *this, ref_name.c_str()));
+    return ref_id;
+}
+
 // Index
 
 index_wrapper repository_wrapper::make_index()
@@ -194,6 +214,21 @@ std::optional<reference_wrapper> repository_wrapper::upstream() const
     }
 }
 
+std::optional<std::string> repository_wrapper::branch_upstream_name(std::string local_branch) const
+{
+    git_buf buf = GIT_BUF_INIT;
+    int error = git_branch_upstream_name(&buf, *this, local_branch.c_str());
+    if (error != 0)
+    {
+        git_buf_dispose(&buf);
+        return std::nullopt;
+    }
+
+    std::string result(buf.ptr ? buf.ptr : "");
+    git_buf_dispose(&buf);
+    return result;
+}
+
 branch_tracking_info repository_wrapper::get_tracking_info() const
 {
     branch_tracking_info info;

src/wrapper/repository_wrapper.hpp

@@ -6,7 +6,6 @@
 
 #include <git2.h>
 
-#include "../utils/common.hpp"
 #include "../utils/git_exception.hpp"
 #include "../wrapper/annotated_commit_wrapper.hpp"
 #include "../wrapper/branch_wrapper.hpp"
@@ -63,6 +62,8 @@ class repository_wrapper : public wrapper_base<git_repository>
     // References
     reference_wrapper find_reference(std::string_view ref_name) const;
     std::optional<reference_wrapper> find_reference_dwim(std::string_view ref_name) const;
+    std::vector<std::string> reference_list() const;
+    const git_oid ref_name_to_id(std::string ref_name) const;
 
     // Index
     index_wrapper make_index();
@@ -74,6 +75,7 @@ class repository_wrapper : public wrapper_base<git_repository>
     branch_wrapper find_branch(std::string_view name) const;
     branch_iterator iterate_branches(git_branch_t type) const;
     std::optional<reference_wrapper> upstream() const;
+    std::optional<std::string> branch_upstream_name(std::string local_branch) const;
     branch_tracking_info get_tracking_info() const;
 
     // Commits