Work on repository scan

Author: takev

CMakeLists.txt

@@ -135,6 +135,8 @@ target_sources(hkc PRIVATE
     "${CMAKE_CURRENT_SOURCE_DIR}/src/hkc/hkc.cpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/src/hkc/options.cpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/src/hkc/options.hpp"
+    "${CMAKE_CURRENT_SOURCE_DIR}/src/hkc/repository.cpp"
+    "${CMAKE_CURRENT_SOURCE_DIR}/src/hkc/repository.hpp"
 )
 
 target_include_directories(hkc PRIVATE "${CMAKE_SOURCE_DIR}/src")

src/hkc/repository.cpp

@@ -0,0 +1,99 @@
+
+#include "repository.hpp"
+#include "utility/path.hpp"
+#include "utility/vector_set.hpp"
+#include "utility/file_cursor.hpp"
+#include "parser/parsers.hpp"
+#include <cassert>
+#include <algorithm>
+
+namespace hk {
+
+repository::repository(std::filesystem::path path) : _path(std::move(path))
+{
+    assert(std::filesystem::canonical(_path) == _path);
+}
+
+void repository::scan_prologues(bool force)
+{
+    untouch(false);
+
+    auto first = std::filesystem::recursive_directory_iterator{_path};
+    auto last = std::filesystem::recursive_directory_iterator{};
+
+    auto visited = vector_set<std::filesystem::path>{};
+    for (auto it = first; it != last; ++it) {
+        auto const& entry = *it;
+
+        if (entry.path().filename().string().starts_with(".")) {
+            // Do not recursively scan hidden directories.
+            if (entry.is_directory()) {
+                it.disable_recursion_pending();
+            }
+            continue;
+        }
+
+        auto module_path = std::filesystem::canonical(entry.path());
+        if (not visited.add(module_path)) {
+            // This directory has already been visited; a potential symlink loop.
+            if (entry.is_directory()) {
+                it.disable_recursion_pending();
+            }
+            continue;
+        }
+            
+        if (not entry.is_regular_file()) {
+            continue;
+        }
+
+        if (entry.path().extension() != ".hkm") {
+            continue;
+        }
+
+        auto &m = get_module(module_path);
+        m.touched = true;
+
+        if (m.ast and m.time == entry.last_write_time()) {
+            // The prologue for this module has already been scanned.
+            continue;
+        }
+
+        auto cursor = file_cursor(module_path);
+        m.ast = parse_module(cursor, true);
+    }
+
+    untouch(true);
+}
+
+void repository::untouch(bool remove)
+{
+    auto it = _modules.begin();
+    while (it != _modules.end()) {
+        if (not it->touched) {
+            it = _modules.erase(it, it + 1);
+        } else {
+            it->touched = false;
+            ++it;
+        }
+    }
+}
+
+repository::module_type& repository::get_module(std::filesystem::path const& module_path)
+{
+    assert(is_subpath(module_path, _path));
+
+    auto it = std::lower_bound(_modules.begin(), _modules.end(), module_path, [](auto const &item, auto const &key) {
+        return item.path < key;
+    });
+    if (it == _modules.end() or it->path != module_path) {
+        it = _modules.insert(it, module_type{module_path});
+    }
+    return *it;
+}
+
+repository::module_type::module_type(std::filesystem::path path) : path(std::move(path))
+{
+    assert(std::filesystem::canonical(this->path) == this->path);
+}
+
+}

src/hkc/repository.hpp

@@ -0,0 +1,64 @@
+
+#pragma once
+
+#include "ast/module_node.hpp"
+#include <filesystem>
+#include <memory>
+#include <chrono>
+#include <vector>
+
+namespace hk {
+
+class repository {
+public:
+    repository(std::filesystem::path path);
+
+    /** Scan the prologue of each *.hkm in the repository.
+     * 
+     * @param force Force scanning even on files that were already parsed.
+     */
+    void scan_prologues(bool force);
+
+
+
+private:
+    struct module_type {
+        std::filesystem::path path;
+
+        /** This is the timestamp of the file when it was parsed.
+         */
+        std::filesystem::file_time_type time;
+
+        std::unique_ptr<ast::module_node> ast;
+
+        /** This flag is used to determine if a module has been removed from
+         * the filesystem.
+         */
+        bool touched = false;
+
+        module_type(std::filesystem::path path);
+    };
+
+    std::filesystem::path _path;
+
+    /** modules, sorted by path.
+     */
+    std::vector<module_type> _modules;
+
+    /** Unset the touch flag on all modules.
+     * 
+     * @param remove Remove modules if already not touched.
+     */
+    void untouch(bool remove);
+
+    /** Get or make a module based on the path.
+     * 
+     * @note It is UNDEFINED BEHAVIOR if @a path is not canonical or is not
+     *       inside the repository.
+     * @param path The path the module.
+     */
+    [[nodiscard]] module_type &get_module(std::filesystem::path const& path);
+};
+
+
+}

src/utility/git.hpp

@@ -103,12 +103,12 @@ enum class git_checkout_flags {
     return static_cast<git_checkout_flags>(~std::to_underlying(rhs));
 }
 
-constexpr git_checkout_flags& operator|=(git_checkout_flags &lhs, git_checkout_flags rhs) noexcept
+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
+constexpr git_checkout_flags& operator&=(git_checkout_flags& lhs, git_checkout_flags rhs) noexcept
 {
     return lhs = lhs & rhs;
 }
@@ -118,6 +118,11 @@ constexpr git_checkout_flags& operator&=(git_checkout_flags &lhs, git_checkout_f
     return static_cast<bool>(std::to_underlying(rhs));
 }
 
+struct git_url {
+    std::string url;
+    std::string rev;
+};
+
 struct git_reference {
     std::string name = {};
     std::string oid = {};
@@ -215,4 +220,14 @@ class git_references : public std::vector<git_reference> {
     std::filesystem::path path,
     git_checkout_flags flags = git_checkout_flags{});
 
+/** Checkout or clone the repository.
+ *
+ * @see git_checkout_or_clone
+ */
+[[nodiscard]] git_error
+git_checkout_or_clone(git_url const& url, std::filesystem::path path, git_checkout_flags flags = git_checkout_flags{})
+{
+    return git_checkout_or_clone(url.url, url.rev, path, flags);
+}
+
 } // namespace hk