Add --deepen flag to the fetch command

Author: SandrineP

src/subcommand/fetch_subcommand.cpp

@@ -14,7 +14,7 @@ fetch_subcommand::fetch_subcommand(const libgit2_object&, CLI::App& app)
     sub->add_option("<remote>", m_remote_name, "The remote to fetch from")
         ->default_val("origin");
     sub->add_option("--depth", m_depth, "deepen or shorten history of shallow clone");
-    // sub->add_option("--deepen", m_deepen, "deepen history of shallow clone");
+    sub->add_option("--deepen", m_deepen, "deepen history of shallow clone");
     // sub->add_option("--shallow-since", m_shallow_since, "<time>\ndeepen history of shallow repository based on time.");
     // sub->add_option("--shallow-exclude", m_shallow_exclude, "<ref>\ndeepen history of shallow clone, excluding ref");
     sub->add_flag("--unshallow", m_unshallow, "convert to a complete repository");
@@ -45,6 +45,11 @@ void fetch_subcommand::run()
         {
             fetch_opts.depth = GIT_FETCH_DEPTH_UNSHALLOW;
         }
+        else if (m_deepen > 0)
+            {
+                size_t shallow_size = repo.shallow_depth_from_head();
+                fetch_opts.depth = shallow_size + m_deepen;
+            }
         else
         {
             fetch_opts.depth = m_depth;

src/subcommand/fetch_subcommand.hpp

@@ -16,7 +16,7 @@ class fetch_subcommand
 
     std::string m_remote_name;
     size_t m_depth = 0;
-    // size_t m_deepen = 0;
+    size_t m_deepen = 0;
     // std::string m_shallow_since;
     // std::string m_shallow_exclude;
     bool m_unshallow = false;

src/wrapper/commit_wrapper.cpp

@@ -26,3 +26,18 @@ std::string commit_wrapper::commit_oid_tostr() const
     char buf[GIT_OID_SHA1_HEXSIZE + 1];
     return git_oid_tostr(buf, sizeof(buf), &this->oid());
 }
+
+commit_list_wrapper commit_wrapper::get_parents_list() const
+{
+    size_t parent_count = git_commit_parentcount(*this);
+    std::vector<commit_wrapper> parents_list;
+    parents_list.reserve(parent_count);
+
+    for (size_t i=0; parent_count; ++i)
+    {
+        git_commit* parent;
+        git_commit_parent(&parent, *this, i);
+        parents_list.push_back(std::move(commit_wrapper(parent)));
+    }
+    return commit_list_wrapper(std::move(parents_list));
+}

src/wrapper/commit_wrapper.hpp

@@ -1,11 +1,13 @@
 #pragma once
 
 #include <git2.h>
-#include <vector>
 #include <string>
 
 #include "../wrapper/wrapper_base.hpp"
 
+class commit_wrapper;
+using commit_list_wrapper = list_wrapper<commit_wrapper>;
+
 class commit_wrapper : public wrapper_base<git_commit>
 {
 public:
@@ -22,12 +24,12 @@ class commit_wrapper : public wrapper_base<git_commit>
     const git_oid& oid() const;
     std::string commit_oid_tostr() const;
 
+    commit_list_wrapper get_parents_list() const;
+
 private:
 
     commit_wrapper(git_commit* commit);
 
     friend class repository_wrapper;
     friend class reference_wrapper;
 };
-
-using commit_list_wrapper = list_wrapper<commit_wrapper>;

src/wrapper/repository_wrapper.cpp

@@ -1,5 +1,12 @@
+#include <algorithm>
+#include <fstream>
 #include <iostream>
 
+#include "../utils/git_exception.hpp"
+#include "../wrapper/index_wrapper.hpp"
+#include "../wrapper/object_wrapper.hpp"
+#include "../wrapper/commit_wrapper.hpp"
+#include "../wrapper/remote_wrapper.hpp"
 #include "../wrapper/repository_wrapper.hpp"
 
 repository_wrapper::~repository_wrapper()
@@ -29,6 +36,11 @@ repository_wrapper repository_wrapper::clone(std::string_view url, std::string_v
     return rw;
 }
 
+std::string repository_wrapper::git_path() const
+{
+    return git_repository_path(*this);
+}
+
 git_repository_state_t repository_wrapper::state() const
 {
     return git_repository_state_t(git_repository_state(*this));
@@ -271,6 +283,86 @@ void repository_wrapper::reset(const object_wrapper& target, git_reset_t reset_t
     throw_if_error(git_reset(*this, target, reset_type, &checkout_options));
 }
 
+size_t repository_wrapper::shallow_depth_from_head() const
+{
+    size_t depth = 0;
+    if (!this->is_shallow())
+    {
+        return depth;
+    }
+
+    std::string git_path = this->git_path();
+    std::string shallow_path = git_path + "shallow";
+
+    std::vector<git_oid> boundaries_list;
+    std::ifstream f(shallow_path);
+    std::string line;
+    while (std::getline(f, line))
+    {
+        if (!line.empty())
+        {
+            git_oid commit_oid;
+            git_oid_fromstrp(&commit_oid, line.c_str());
+            boundaries_list.push_back(commit_oid);
+        }
+    }
+
+    if (boundaries_list.size()==0)
+    {
+        return depth;
+    }
+
+    commit_wrapper head_commit = this->find_commit("HEAD");
+    commit_list_wrapper commits_list = head_commit.get_parents_list();
+    std::vector<size_t> depth_list(commits_list.size(), 0);
+    std::vector<size_t> final_depths(boundaries_list.size(), 0);
+    size_t has_parent = commits_list.size() > 0;
+    while (has_parent)
+    {
+        has_parent = 0;
+        std::vector<commit_wrapper> temp_commits_list;
+        std::vector<size_t> temp_depth_list;
+        commit_list_wrapper parent_list({});
+        std::vector<size_t> has_parent_list;
+
+        for (size_t i = 0; commits_list.size(); i++)
+        {
+            const commit_wrapper& commit = commits_list[i];
+            size_t depth = depth_list[i];
+            const git_oid& oid = commit.oid();
+            bool is_boundary = std::find_if(boundaries_list.cbegin(), boundaries_list.cend(), [oid](const git_oid& val) {return git_oid_equal(&oid, &val);}) != boundaries_list.cend();
+            if (is_boundary)
+            {
+                final_depths.push_back(depth + 1);
+            }
+            else
+            {
+                parent_list = commit.get_parents_list();
+                if (parent_list.size() > 0)
+                {
+                    has_parent_list.push_back(1);
+                    for (size_t j = 0; parent_list.size(); j++)
+                    {
+                        const commit_wrapper& c = parent_list[j];
+                        temp_commits_list.push_back(std::move(const_cast<commit_wrapper&>(c)));
+                        temp_depth_list.push_back(depth + 1);
+                    }
+                }
+                else
+                {
+                    has_parent_list.push_back(0);
+                }
+            }
+        }
+        depth_list = temp_depth_list;
+        commits_list = commit_list_wrapper(std::move(temp_commits_list));
+        has_parent = *std::max_element(has_parent_list.begin(), has_parent_list.end());
+    }
+
+    depth = *std::max_element(final_depths.begin(), final_depths.end());
+    return depth;
+}
+
 // Trees
 
 void repository_wrapper::checkout_tree(const object_wrapper& target, const git_checkout_options opts)

src/wrapper/repository_wrapper.hpp

@@ -31,6 +31,7 @@ class repository_wrapper : public wrapper_base<git_repository>
     static repository_wrapper open(std::string_view directory);
     static repository_wrapper clone(std::string_view url, std::string_view path, const git_clone_options& opts);
 
+    std::string git_path() const;
     git_repository_state_t state() const;
     void state_cleanup();
 
@@ -81,6 +82,9 @@ class repository_wrapper : public wrapper_base<git_repository>
     void set_head_detached(const annotated_commit_wrapper& commit);
     void reset(const object_wrapper& target, git_reset_t reset_type, const git_checkout_options& checkout_options);
 
+    // TODO: check if it's the right place to put the following
+    size_t shallow_depth_from_head() const;
+
     // Trees
     void checkout_tree(const object_wrapper& target, const git_checkout_options opts);
 

test/test_remote.py

@@ -365,6 +365,29 @@ def test_unshallow(git2cpp_path, tmp_path, run_in_tmp_path):
     assert p_log_2.stdout.count("Author") > 1
 
 
+def test_fetch_deepen(git2cpp_path, tmp_path, run_in_tmp_path):
+    url = "https://github.com/xtensor-stack/xtl.git"
+    clone_cmd = [git2cpp_path, "clone", "--depth", "1", url]
+    p_clone = subprocess.run(clone_cmd, capture_output=True, cwd=tmp_path, text=True)
+    assert p_clone.returncode == 0
+    assert (tmp_path / "xtl").exists()
+
+    xtl_path = tmp_path / "xtl"
+
+    cmd_log = [git2cpp_path, "log"]
+    p_log = subprocess.run(cmd_log, capture_output=True, cwd=xtl_path, text=True)
+    assert p_log.returncode == 0
+    assert p_log.stdout.count("Author") == 1
+
+    deepen_cmd = [git2cpp_path, "fetch", "--deepen", "2"]
+    p_deepen = subprocess.run(deepen_cmd, capture_output=True, cwd=xtl_path, text=True)
+    assert p_deepen.returncode == 0
+
+    p_log_2 = subprocess.run(cmd_log, capture_output=True, cwd=xtl_path, text=True)
+    assert p_log_2.returncode == 0
+    assert p_log_2.stdout.count("Author") > 1
+
+
 def test_remote_in_cloned_repo(xtl_clone, git2cpp_path, tmp_path):
     """Test that cloned repos have remotes configured."""
     assert (tmp_path / "xtl").exists()