Add highlevel git_checkout_or_clone test

Author: takev

src/utility/git.cpp

@@ -366,7 +366,6 @@ repository_fetch(::git_repository* repository, std::string const& remote_name =
 
     status_opts.show = GIT_STATUS_SHOW_WORKDIR_ONLY;
     status_opts.flags |= GIT_STATUS_OPT_INCLUDE_UNTRACKED;
-    status_opts.flags |= GIT_STATUS_OPT_RECURSE_UNTRACKED_DIRS;
     status_opts.flags |= GIT_STATUS_OPT_INCLUDE_IGNORED;
 
     ::git_status_list* status_list = nullptr;
@@ -380,26 +379,30 @@ repository_fetch(::git_repository* repository, std::string const& remote_name =
     auto const count = ::git_status_list_entrycount(status_list);
     for (auto i = 0uz; i != count; ++i) {
         auto const* entry = ::git_status_byindex(status_list, i);
-        if (entry->head_to_index == nullptr) {
-            continue;
-
-        } else if (entry->status == GIT_STATUS_WT_NEW or entry->status == GIT_STATUS_IGNORED) {
-            auto path = repository_dir / entry->head_to_index->new_file.path;
-            path = std::filesystem::canonical(path);
-
-            if (not is_subpath(path, repository_dir)) {
-                std::print(
-                    stderr,
-                    "security: file '{}' is outside of directory of repository at '{}'",
-                    path.string(),
-                    repository_dir.string());
-                std::terminate();
-            }
-
-            std::print(stderr, "info: removing file '{}'", path.string());
-            auto ec = std::error_code{};
-            if (not std::filesystem::remove(path, ec)) {
-                std::print(stderr, "error: failed removing file '{}': {}", path.string(), ec.message());
+        assert(entry != nullptr);
+
+        if (entry->index_to_workdir != nullptr) {
+            if (entry->status == GIT_STATUS_WT_NEW or entry->status == GIT_STATUS_IGNORED) {
+                auto path = repository_dir / entry->index_to_workdir->new_file.path;
+                path = std::filesystem::canonical(path);
+
+                if (not is_subpath(path, repository_dir)) {
+                    std::print(
+                        stderr,
+                        "security: file '{}' is outside of directory of repository at '{}'",
+                        path.string(),
+                        repository_dir.string());
+                    std::terminate();
+                }
+
+                std::print(stderr, "info: removing file '{}'", path.string());
+
+                // The untracked files in untracked directories are not listed,
+                // only the directories themselves.
+                auto ec = std::error_code{};
+                if (not std::filesystem::remove_all(path, ec)) {
+                    std::print(stderr, "error: failed removing file '{}': {}", path.string(), ec.message());
+                }
             }
         }
     }
@@ -468,7 +471,7 @@ git_fetch_and_update(std::string const& url, std::string const& rev, std::filesy
         ::git_repository_free(repository);
     }};
 
-    if (auto remote_url_o = repository_remote_url(repository, url)) {
+    if (auto remote_url_o = repository_remote_url(repository)) {
         if (*remote_url_o != url) {
             std::print("The repository at {}, does not have a remote with the url {}", path.string(), url);
             return git_error::remote_url_mismatch;
@@ -477,15 +480,20 @@ git_fetch_and_update(std::string const& url, std::string const& rev, std::filesy
         return remote_url_o.error();
     }
 
-    auto fetch = to_bool(flags & git_checkout_flags::force_checkout);
+    auto fetch = to_bool(flags & git_checkout_flags::force_fetch);
     if (auto result = repository_matches_rev(repository, rev)) {
         switch (*result) {
         case rev_match::rev_not_found:
+            if (to_bool(flags & git_checkout_flags::fresh_clone)) {
+                return git_error::rev_not_found;
+            }
+            [[fallthrough]];
         case rev_match::not_checked_out:
         case rev_match::checked_out_branch:
-            fetch = true;
+            fetch |= not to_bool(flags & git_checkout_flags::fresh_clone);
             break;
         case rev_match::checked_out:
+            // Revisions that are tags or commits will not cause a fetch.
             break;
         }
 
@@ -503,7 +511,7 @@ git_fetch_and_update(std::string const& url, std::string const& rev, std::filesy
     if (auto result = repository_matches_rev(repository, rev)) {
         switch (*result) {
         case rev_match::rev_not_found:
-            return git_error::not_found;
+            return git_error::rev_not_found;
         case rev_match::not_checked_out:
             checkout = true;
             break;
@@ -515,8 +523,10 @@ git_fetch_and_update(std::string const& url, std::string const& rev, std::filesy
         return result.error();
     }
 
-    auto clean = to_bool(flags & git_checkout_flags::clean);
-    clean |= checkout;
+    auto clean = checkout;
+    clean |= to_bool(flags & git_checkout_flags::force_clean);
+    // A fresh clone does not need to be cleaned.
+    clean &= not to_bool(flags & git_checkout_flags::fresh_clone);
 
     if (clean) {
         if (auto result = repository_clean(repository); result != git_error::ok) {
@@ -578,28 +588,33 @@ git_fetch_and_update(std::string const& url, std::string const& rev, std::filesy
     return git_error::ok;
 }
 
-//[[nodiscard]] git_error git_checkout_or_clone(
-//    std::string const& url, std::string const& branch, std::filesystem::path path, git_checkout_flags flags)
-//{
-//    if (git_is_checked_out(path)) {
-//        // Check if the repository should be checked out again.
-//
-//        return git_error::ok;
-//    }
-//
-//    if (git_is_branch(url, branch)) {
-//        git_clone_shallow(url, branch, path);
-//
-//    } else if (git_is_tag(url, branch)) {
-//        git_clone(url, path);
-//        git_checkout(path, branch);
-//
-//    } else {
-//        git_clone(url, path);
-//        git_checkout_oid(path, branch);
-//
-//    }
-//
-//}
+[[nodiscard]] git_error git_checkout_or_clone(
+    std::string const& url, std::string const& rev, std::filesystem::path path, git_checkout_flags flags)
+{
+    // First try and just update the repository.
+    switch(git_fetch_and_update(url, rev, path, flags)) {
+    case git_error::ok:
+        return git_error::ok;
+
+    case git_error::rev_not_found:
+        // Repository was found but not the ref.
+        return git_error::rev_not_found;
+
+    case git_error::not_found:
+        // The repository was not found, try and clone instead.
+        break;
+
+    default:
+        return git_error::error;
+    }
+
+    if (auto r = git_clone(url, rev, path); r != git_error::ok) {
+        return r;
+    }
+
+    // In case rev is a tag or commit, checkout/update the repository.
+    flags |= git_checkout_flags::fresh_clone;
+    return git_fetch_and_update(url, rev, path, flags);
+}
 
 } // namespace hk

src/utility/git.hpp

@@ -51,7 +51,11 @@ enum class git_error {
     not_supported,
     read_only,
 
-    /** The repository does have a remote that matches the expected URL. 
+    /** The revision was not found in this repository.
+     */
+    rev_not_found,
+
+    /** The repository does have a remote that matches the expected URL.
      */
     remote_url_mismatch,
 
@@ -60,15 +64,24 @@ enum class git_error {
     relative_workdir,
 
     /** Found a file outside of the work dir.
-     * 
+     *
      * This is a security issue.
      */
     file_outside_workdir
 };
 
 enum class git_checkout_flags {
-    force_checkout = 0x1,
-    clean = 0x2
+    /** The repository was freshly cloned, not need for a fetch.
+     */
+    fresh_clone = 0x1,
+
+    /** Fetch, even when the rev points to a tag or commit.
+     */
+    force_fetch = 0x2,
+
+    /** Force the repository to be cleaned, even if no checkout is performed.
+     */
+    force_clean = 0x4
 };
 
 [[nodiscard]] constexpr git_checkout_flags operator|(git_checkout_flags lhs, git_checkout_flags rhs) noexcept
@@ -81,6 +94,21 @@ enum class git_checkout_flags {
     return static_cast<git_checkout_flags>(std::to_underlying(lhs) & std::to_underlying(rhs));
 }
 
+[[nodiscard]] constexpr git_checkout_flags operator~(git_checkout_flags rhs) noexcept
+{
+    return static_cast<git_checkout_flags>(~std::to_underlying(rhs));
+}
+
+constexpr git_checkout_flags& operator|=(git_checkout_flags &lhs, git_checkout_flags rhs) noexcept
+{
+    return lhs = lhs | rhs;
+}
+
+constexpr git_checkout_flags& operator&=(git_checkout_flags &lhs, git_checkout_flags rhs) noexcept
+{
+    return lhs = lhs & rhs;
+}
+
 [[nodiscard]] constexpr bool to_bool(git_checkout_flags rhs) noexcept
 {
     return static_cast<bool>(std::to_underlying(rhs));
@@ -107,7 +135,7 @@ struct git_reference {
 
     [[nodiscard]] constexpr bool is_tag() const noexcept
     {
-        return name.starts_with("ref/tags/");
+        return name.starts_with("refs/tags/");
     }
 };
 
@@ -116,15 +144,15 @@ class git_references : public std::vector<git_reference> {
     using std::vector<git_reference>::vector;
 
     /** Find a specific ref.
-     * 
+     *
      * @pre sort() must be called first.
      * @param ref_name The full ref-name.
      * @return An iterator to the reference, or end() if not found.
      */
     [[nodiscard]] const_iterator find_ref(std::string const& ref_name) const;
 
     /** Find a name.
-     * 
+     *
      * @pre sort() must be called first.
      * @param name A branch, tag or hex-oid.
      * @return An iterator to the reference, or end() if not found.
@@ -137,14 +165,14 @@ class git_references : public std::vector<git_reference> {
 };
 
 /** Get a list of references.
- * 
+ *
  * @param url URL to remote repository
  * @return List of references, or error.
  */
 [[nodiscard]] std::expected<git_references, git_error> git_list(std::string const& url);
 
 /** 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.
@@ -154,25 +182,33 @@ class git_references : public std::vector<git_reference> {
 [[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.
- * 
+ *
  * @param url The remote url, used to check if the repository at the path
  *            has the same remote url.
  * @param rev The rev (branch/tag/sha) to checkout. If the repository is of a different
  *            rev this branch is checked out, and the repository is cleaned.
  * @param path The path where the repository is located.
  * @param flags Flags for the way the repository should be checked out.
  */
-[[nodiscard]] git_error git_fetch_and_update(std::string const& url, std::string const& rev, std::filesystem::path path, git_checkout_flags flags);
+[[nodiscard]] git_error git_fetch_and_update(
+    std::string const& url,
+    std::string const& rev,
+    std::filesystem::path path,
+    git_checkout_flags flags = git_checkout_flags{});
 
 /** Checkout or clone the repository.
- * 
+ *
  * @param url The location of the remote repository.
- * @param branch The branch, tag, or hex-oid
+ * @param rev The rev (branch/tag/sha) to checkout. If the repository is of a different
+ *            rev this branch is checked out, and the repository is cleaned.
  * @param path The location where to clone/checkout the repository to.
  * @param flags Flags for what to do with an already cloned repository.
  * @return An error, or git_error::ok.
  */
 [[nodiscard]] git_error git_checkout_or_clone(
-    std::string const& url, std::string const& branch, std::filesystem::path path, git_checkout_flags flags);
+    std::string const& url,
+    std::string const& rev,
+    std::filesystem::path path,
+    git_checkout_flags flags = git_checkout_flags{});
 
-}
+} // namespace hk