Clone a branch is tested.

Author: takev

src/utility/git.cpp

@@ -35,7 +35,7 @@ void git_references::sort() noexcept
         return it;
     }
 
-    if (auto const it = find_ref(std::format("ref/tags/{}", name)); it != end()) {
+    if (auto const it = find_ref(std::format("refs/tags/{}", name)); it != end()) {
         return it;
     }
 
@@ -158,17 +158,18 @@ class git_lib {
     if (auto const r = ::git_remote_create_anonymous(&remote, nullptr, url.c_str()); r != GIT_OK) {
         return std::unexpected{make_git_error(r)};
     }
+    auto const d1 = defer{[&] {
+        ::git_remote_free(remote);
+    }};
 
     if (auto const r = ::git_remote_connect(remote, GIT_DIRECTION_FETCH, nullptr, nullptr, nullptr); r != GIT_OK) {
-        ::git_remote_free(remote);
         return std::unexpected{make_git_error(r)};
     }
 
     ::git_remote_head const** list_head = nullptr;
     size_t list_size = 0;
 
     if (auto const r = ::git_remote_ls(&list_head, &list_size, remote); r != GIT_OK) {
-        ::git_remote_free(remote);
         return std::unexpected{make_git_error(r)};
     }
 
@@ -187,7 +188,6 @@ class git_lib {
         r.emplace_back(std::move(name), std::move(oid_str));
     }
 
-    ::git_remote_free(remote);
     r.sort();
     return r;
 }
@@ -315,7 +315,7 @@ repository_fetch(::git_repository* repository, std::string const& remote_name =
     if (auto result = ::git_remote_lookup(&remote, repository, remote_name.c_str()); result != GIT_OK) {
         return make_git_error(result);
     }
-    defer{[&] {
+    auto const d1 = defer{[&] {
         ::git_remote_free(remote);
     }};
 
@@ -532,7 +532,7 @@ git_fetch_and_update(std::string const& url, std::string const& rev, std::filesy
     return git_error::ok;
 }
 
-[[nodiscard]] git_error git_clone(std::string const& url, std::string const& branch, std::filesystem::path path)
+[[nodiscard]] git_error git_clone(std::string const& url, std::string const& git_rev, std::filesystem::path path)
 {
     auto const& _ = git_lib_initialize();
 
@@ -550,10 +550,10 @@ git_fetch_and_update(std::string const& url, std::string const& rev, std::filesy
         return make_git_error(r);
     }
 
-    auto branch_it = ref_list.find(branch);
+    auto branch_it = ref_list.find(git_rev);
     if (branch_it != ref_list.end()) {
         if (branch_it->is_branch()) {
-            options.checkout_branch = branch.c_str();
+            options.checkout_branch = git_rev.c_str();
             options.fetch_opts.depth = 1;
             force_checkout = true;
 
@@ -572,6 +572,9 @@ git_fetch_and_update(std::string const& url, std::string const& rev, std::filesy
     if (auto r = ::git_clone(&repository, url.c_str(), path.string().c_str(), &options); r != GIT_OK) {
         return make_git_error(r);
     }
+    auto d1 = defer{[&] { ::git_repository_free(repository); }};
+
+    return git_error::ok;
 }
 
 //[[nodiscard]] git_error git_checkout_or_clone(

src/utility/git.hpp

@@ -143,7 +143,15 @@ class git_references : public std::vector<git_reference> {
  */
 [[nodiscard]] std::expected<git_references, git_error> git_list(std::string const& url);
 
-[[nodiscard]] git_error git_clone(std::string const& url, std::string const& branch, std::filesystem::path path);
+/** Clone a repository.
+ * 
+ * @param url The (remote) location of the repository
+ * @param git_rev The branch to checkout.
+ *                If git_rev is a branch the checkout is done with depth 1.
+ *                If git_rev is a tag then the default branch is checked with
+ *                full depth.
+ */
+[[nodiscard]] git_error git_clone(std::string const& url, std::string const& git_rev, std::filesystem::path path);
 
 /** This function will open the repository and update to the latest version.
  * 

src/utility/git_tests.cpp

@@ -1,15 +1,25 @@
 
 #include "git.hpp"
+#include "path.hpp"
 #include <hikotest/hikotest.hpp>
 
 TEST_SUITE(git_suite) 
 {
     TEST_CASE(git_list) {
-        auto optional_list = hk::git_list("https://github.com/hikogui/hikogui.git");
+        auto optional_list = hk::git_list("https://github.com/hikogui/hikolang-test-a.git");
         REQUIRE(static_cast<bool>(optional_list));
         auto list = std::move(optional_list).value();
         REQUIRE(not list.empty());
         auto it = list.find("main");
         REQUIRE(it != list.end());
+        it = list.find("v1.0.0");
+        REQUIRE(it != list.end());
+    }
+
+    TEST_CASE(git_clone) {
+        auto const tmp_dir = hk::scoped_temporary_directory("git_clone");
+
+        auto const r = hk::git_clone("https://github.com/hikogui/hikolang-test-a.git", "main", tmp_dir.path());
+        REQUIRE(r == hk::git_error::ok);
     }
 };

src/utility/path.cpp

@@ -1,11 +1,15 @@
 
 
 #include "path.hpp"
+#include <format>
+#include <chrono>
+#include <system_error>
+#include <print>
 
 namespace hk {
 
-[[nodiscard]] std::expected<std::filesystem::path, std::error_code> absolute_to(
-    std::filesystem::path const& path, std::filesystem::path const& base)
+[[nodiscard]] std::expected<std::filesystem::path, std::error_code>
+absolute_to(std::filesystem::path const& path, std::filesystem::path const& base)
 {
     auto ec = std::error_code{};
 
@@ -36,12 +40,12 @@ namespace hk {
     auto ec = std::error_code{};
 
     auto const path_ = std::filesystem::canonical(path, ec);
-    if (not ec) {
+    if (ec) {
         return false;
     }
 
-    auto const base_ = std::filesystem::canonical(path, ec);
-    if (not ec) {
+    auto const base_ = std::filesystem::canonical(base, ec);
+    if (ec) {
         return false;
     }
 
@@ -60,4 +64,65 @@ namespace hk {
     return true;
 }
 
-}
+scoped_temporary_directory::~scoped_temporary_directory()
+{
+    if (_path.empty()) {
+        return;
+    }
+
+    auto const base_dir = std::filesystem::temp_directory_path();
+
+    if (not is_subpath(_path, base_dir)) {
+        std::println(
+            stderr,
+            "Security error: tried to remove scoped-temporary-directory '{}', while not being a subdirectory of '{}'.",
+            _path.string(),
+            base_dir.string());
+        std::terminate();
+    }
+
+    if (not std::filesystem::exists(_path)) {
+        return;
+    }
+
+    auto ec = std::error_code{};
+    if (std::filesystem::remove_all(_path, ec) == static_cast<std::uintmax_t>(-1)) {
+        std::println(stderr, "Could not remove scoped-temporary-directory '{}': {}", _path.string(), ec.message());
+    }
+}
+
+scoped_temporary_directory::scoped_temporary_directory(std::string prefix)
+{
+    auto const _ = std::unique_lock(_mutex);
+
+    if (prefix.empty()) {
+        prefix = "tmp";
+    }
+
+    auto const base_dir = std::filesystem::temp_directory_path();
+    auto count = 0uz;
+    do {
+        if (count++ > 10) {
+            throw std::runtime_error("Too many tries to create scoped-temporary-directory");
+        }
+
+        auto const now = std::chrono::system_clock::now();
+        auto const name = std::format("{0:}-{1:%Y%m%d}-{1:%H%M%S}-{2:}", prefix, now, count);
+        _path = base_dir / name;
+        if (std::filesystem::exists(_path)) {
+            continue;
+        }
+
+        std::error_code ec;
+        if (not std::filesystem::create_directory(_path, ec)) {
+            if (ec and ec != std::errc::file_exists) {
+                throw std::system_error(ec, std::format("Could not create directory: {}", _path.string()));
+            }
+            continue;
+        }
+
+
+    } while (false);
+}
+
+} // namespace hk

src/utility/path.hpp

@@ -9,6 +9,7 @@
 #include <system_error>
 #include <cassert>
 #include <expected>
+#include <mutex>
 
 namespace hk {
 
@@ -39,4 +40,19 @@ namespace hk {
  */
 [[nodiscard]] bool is_subpath(std::filesystem::path const& path, std::filesystem::path const& base);
 
+class scoped_temporary_directory {
+public:
+    ~scoped_temporary_directory();
+    scoped_temporary_directory(std::string prefix = std::string{"tmp"});
+
+    [[nodiscard]] std::filesystem::path const &path() const noexcept
+    {
+        return _path;
+    }
+
+private:
+    inline static std::mutex _mutex;
+    std::filesystem::path _path;
+};
+
 }