git

Author: takev

CMakeLists.txt

@@ -34,17 +34,21 @@ endif()
 find_package(ICU REQUIRED COMPONENTS i18n uc data)
 find_package(Microsoft.GSL CONFIG REQUIRED)
 find_package(LibGit2 CONFIG REQUIRED)
+find_package(OpenSSL REQUIRED)
 
 add_library(hk_objects OBJECT
     "${CMAKE_CURRENT_SOURCE_DIR}/src/ast/expression_node.hpp"
+    "${CMAKE_CURRENT_SOURCE_DIR}/src/ast/import_declaration_node.cpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/src/ast/import_declaration_node.hpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/src/ast/module_declaration_node.hpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/src/ast/module_node.hpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/src/ast/node.hpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/src/ast/nodes.hpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/src/error/error_code.hpp"
+    "${CMAKE_CURRENT_SOURCE_DIR}/src/error/error_item.hpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/src/error/error_list.hpp"
-    "${CMAKE_CURRENT_SOURCE_DIR}/src/error/error.hpp"
+    "${CMAKE_CURRENT_SOURCE_DIR}/src/error/errors.hpp"
+    "${CMAKE_CURRENT_SOURCE_DIR}/src/error/make_error.hpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/src/parser/consume.hpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/src/parser/parse_fqname.cpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/src/parser/parse_import_declaration.cpp"
@@ -70,6 +74,8 @@ add_library(hk_objects OBJECT
     "${CMAKE_CURRENT_SOURCE_DIR}/src/tokenizer/tokenizer.cpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/src/tokenizer/tokenizer.hpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/src/tokenizer/token_parsers.hpp"
+    "${CMAKE_CURRENT_SOURCE_DIR}/src/utility/base32.cpp"
+    "${CMAKE_CURRENT_SOURCE_DIR}/src/utility/base32.hpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/src/utility/char_category.cpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/src/utility/char_category.hpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/src/utility/command_line.cpp"
@@ -85,12 +91,16 @@ add_library(hk_objects OBJECT
     "${CMAKE_CURRENT_SOURCE_DIR}/src/utility/file.hpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/src/utility/fixed_fifo.hpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/src/utility/fqname.hpp"
+    "${CMAKE_CURRENT_SOURCE_DIR}/src/utility/git.cpp"
+    "${CMAKE_CURRENT_SOURCE_DIR}/src/utility/git.hpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/src/utility/module.cpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/src/utility/module.hpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/src/utility/path.cpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/src/utility/path.hpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/src/utility/semantic_version.cpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/src/utility/semantic_version.hpp"
+    "${CMAKE_CURRENT_SOURCE_DIR}/src/utility/sha.cpp"
+    "${CMAKE_CURRENT_SOURCE_DIR}/src/utility/sha.hpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/src/utility/strings.cpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/src/utility/strings.hpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/src/utility/unicode.cpp"
@@ -131,12 +141,14 @@ target_link_libraries(hkc PRIVATE ICU::i18n)
 target_link_libraries(hkc PRIVATE ICU::uc)
 target_link_libraries(hkc PRIVATE ICU::data)
 target_link_libraries(hkc PRIVATE libgit2::libgit2package)
-
+target_link_libraries(hkc PRIVATE OpenSSL::SSL)
+target_link_libraries(hkc PRIVATE OpenSSL::Crypto)
 
 if(BUILD_TESTING)
     add_executable(hktests)
     target_sources(hktests PRIVATE
         $<TARGET_OBJECTS:hk_objects>
+        "${CMAKE_CURRENT_SOURCE_DIR}/src/utility/git_tests.cpp"
         "${CMAKE_CURRENT_SOURCE_DIR}/src/utility/unit_test.cpp"
         "${CMAKE_CURRENT_SOURCE_DIR}/src/utility/unit_test.hpp"
         "${CMAKE_CURRENT_SOURCE_DIR}/src/prologue/prologue_scan_tests.cpp"
@@ -151,6 +163,8 @@ if(BUILD_TESTING)
     target_link_libraries(hktests PRIVATE ICU::uc)
     target_link_libraries(hktests PRIVATE ICU::data)
     target_link_libraries(hktests PRIVATE libgit2::libgit2package)
+    target_link_libraries(hktests PRIVATE OpenSSL::SSL)
+    target_link_libraries(hktests PRIVATE OpenSSL::Crypto)
     target_link_libraries(hktests PRIVATE hikotest)
     target_include_directories(hktests PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/src")
 

launch.json

@@ -0,0 +1,8 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+      {
+          "type": "lldb"
+      }
+  ]
+}

src/ast/import_declaration_node.cpp

@@ -0,0 +1,59 @@
+
+#include "import_declaration_node.hpp"
+#include "utility/sha.hpp"
+#include "utility/base32.hpp"
+#include <format>
+
+namespace hk::ast {
+
+[[nodiscard]] std::string import_declaration_node::path_hash() const
+{
+    auto const full_path = [this] {
+        switch (kind) {
+        case kind_type::git:
+            return std::format("{}:{}", path, branch);
+        case kind_type::zip:
+            return path;
+        case kind_type::mod:
+            return static_cast<std::string>(name);
+        case kind_type::lib:
+            return path;
+        }
+        std::unreachable();
+    }();
+
+    auto const hash = sha256(full_path);
+    return base32_encode(hash);
+}
+
+[[nodiscard]] std::string import_declaration_node::path_stem() const
+{
+    if (kind == kind_type::mod) {
+        return static_cast<std::string>(name);
+    }
+
+    auto first = path.rfind('/');
+    if (first == std::string::npos) {
+        first = path.rfind('\\');
+    }
+    if (first == std::string::npos) {
+        first = 0;
+    } else {
+        ++first;
+    }
+
+    auto last = path.rfind('.');
+    if (last == std::string::npos or last <= first) {
+        last = path.size();
+    }
+    
+    return path.substr(first, last - first);
+}
+
+[[nodiscard]] std::string import_declaration_node::directory_name() const
+{
+    return std::format("{}-{}", path_stem(), path_hash().substr(0, 10));
+}
+
+
+}

src/ast/import_declaration_node.hpp

@@ -11,9 +11,57 @@ class import_declaration_node : public node {
 public:
     using node::node;
 
+    enum class kind_type {
+        /** Import a module.
+         */
+        mod,
+
+        /** Import a git repository.
+         */
+        git,
+
+        /** Import a zip-file repository.
+         */
+        zip,
+
+        /** Import a FFI/system library.
+         */
+        lib
+    };
+
+    /** The kind of import
+     */
+    kind_type kind = kind_type::mod;
+
     /** The fully qualified name of the imported module.
      */
-    fqname name;
+    fqname name = {};
+
+    /** The name to import the module to.
+     */
+    std::string as = {};
+
+    /** Path to the repository or library.
+     */
+    std::string path = {};
+
+    /** Git brach/tag/sha to checkout. 
+     */
+    std::string branch = {};
+
+
+    /** Create the dependency directory-name.
+     * 
+     * This is based around the following parts:
+     *  - The filename (excluding extension)
+     *  - A dash `-`
+     *  - A hash of the full path and branch.
+     */
+    [[nodiscard]] std::string directory_name() const;
+
+private:
+    [[nodiscard]] std::string path_hash() const;
+    [[nodiscard]] std::string path_stem() const;
 
 };
 

src/error/error_code.hpp

@@ -61,21 +61,4 @@ struct error_code {
     }
 };
 
-inline std::set<error_code> all_unique_error_codes = {};
-
-template<fixed_string Fmt>
-struct unique_error_code_helper {
-    error_code code;
-
-    unique_error_code_helper() {
-        code = error_code{Fmt};
-        auto const [_, inserted] = all_unique_error_codes.insert(code);
-
-        assert(inserted);
-    }
-};
-
-template<fixed_string Fmt>
-inline unique_error_code_helper<Fmt> unique_error_code = {};
-
 }

src/error/error.hpp src/error/error_item.hppsrc/error/error.hpp renamed to src/error/error_item.hpp

@@ -9,7 +9,7 @@
 
 namespace hk {
 
-class cause {
+class error_cause {
 public:
 
 private:
@@ -18,16 +18,16 @@ class cause {
     std::string _message;
 };
 
-class error {
+class error_item {
 public:
-    constexpr error() noexcept = default;
-    error(error const&) = default;
-    error(error&&) = default;
-    error& operator=(error const&) = default;
-    error& operator=(error&&) = default;
+    constexpr error_item() noexcept = default;
+    error_item(error_item const&) = default;
+    error_item(error_item&&) = default;
+    error_item& operator=(error_item const&) = default;
+    error_item& operator=(error_item&&) = default;
 
     template<typename... Args>
-    error(file_location first, file_location last, error_code code, std::format_string<Args...> fmt, Args&&... args)
+    error_item(file_location first, file_location last, error_code code, std::format_string<Args...> fmt, Args&&... args)
         : _first(first), _last(last), _code(code), _message(std::format(std::move(fmt), std::forward<Args>(args)...))
     {
         assert(_code.has_value());
@@ -56,7 +56,7 @@ class error {
     file_location _last = {};
     error_code _code = {};
     std::string _message = {};
-    std::vector<cause> _causes = {};
+    std::vector<error_cause> _causes = {};
 };
 
 }

src/error/error_list.hpp

@@ -1,7 +1,7 @@
 
 #pragma once
 
-#include "error.hpp"
+#include "error_item.hpp"
 #include "error_code.hpp"
 #include "utility/file_location.hpp"
 #include "utility/fixed_string.hpp"
@@ -10,9 +10,9 @@
 
 namespace hk {
 
-class error_list : public std::vector<error> {
+class error_list : public std::vector<error_item> {
 public:
-    using element_type = error;
+    using element_type = error_item;
 
     /** Add an error to the list. 
      * 
@@ -23,15 +23,12 @@ class error_list : public std::vector<error> {
      *  @param args The arguments to format the error message.
      *  @return A unexpected error containing the error code.
      */
-    template<fixed_string Fmt, typename... Args>
+    template<typename ErrorType, typename... Args>
     std::unexpected<error_code> add(file_location first, file_location last, Args&&... args)
     {
-        auto const code = unique_error_code<Fmt>.code;
-        assert(code.has_value());
-
-        auto e = error{first, last, code, Fmt, std::forward<Args>(args)...};
+        auto e = error_item{first, last, ErrorType::code, ErrorType::fmt, std::forward<Args>(args)...};
         this->push_back(std::move(e));
-        return std::unexpected{code};
+        return std::unexpected{ErrorType::code};
     }
 
 private:

src/error/errors.hpp

@@ -0,0 +1,28 @@
+
+#pragma once
+
+#include "make_error.hpp"
+
+namespace hk::error {
+
+#define E(name, fmt) struct name : public make_error<fmt> {}
+
+E(missing_module_declaration_name, "E0001: Module declaration requires fqname.");
+E(missing_module_application_declaration_exe, "E0002: Module application declaration requires an executable name.");
+E(missing_module_library_declaration_bin, "E0003: Module library declaration requires a binary name.");
+E(missing_module_package_declaration_version, "E0004: Module package declaration requires a version number.");
+E(unimplemented_module_declaration_if, "E0005: module-if expression is not implemented.");
+E(missing_module_declaration_semicolon, "E0006: Expecting ';' at end of module declaration.");
+E(missing_import_git_declaration_url, "E0007: Expecting a URL string literal after 'git' keyword in a import-declaration.");
+E(missing_import_git_declaration_branch, "E0008: Expecting a branch string literal after 'git' keyword in a import-declaration.");
+E(missing_import_zip_declaration_path, "E0009: Expect a path string literal after 'zip' keyword in a import-declaration.");
+E(missing_import_lib_declaration_path, "E0010: Expect a path string literal after 'lib' keyword in a import-declaration.");
+E(missing_import_mod_declaration_as_name, "E0011: Expected a name after 'as' keyword in a import-declaration.");
+E(missing_import_mod_declaration_name, "E0012: Expected fully qualified name after 'import' keyword in a import-declaration.");
+E(missing_import_declaration_semicolon, "E0013: Expected ';' after a import-declaration.");
+E(missing_fqname_identifier_after_dot, "E0014: Expected identifier after '.' in fully qualified name.");
+
+
+#undef E
+
+}

src/error/make_error.hpp

@@ -0,0 +1,16 @@
+
+#pragma once
+
+#include "utility/fixed_string.hpp"
+#include "error_code.hpp"
+
+namespace hk {
+
+template<fixed_string Fmt>
+struct make_error {
+    constexpr static decltype(Fmt) fmt = Fmt;
+    constexpr static error_code code = error_code{fmt};
+};
+
+
+}

src/parser/parse_fqname.cpp

@@ -1,6 +1,7 @@
 
 #include "parsers.hpp"
 #include "utility/fqname.hpp"
+#include "error/errors.hpp"
 
 namespace hk {
 
@@ -16,13 +17,13 @@ namespace hk {
     ++it;
 
     while (true) {
-        if (*it != '.') {
+        if (*it != ".") {
             return r;
         }
 
         ++it;
         if (*it != token::identifier) {
-            return e.add<"E0004: Expected identifier after '.' in fully qualified name.">(first, it->last);
+            return e.add<error::missing_fqname_identifier_after_dot>(first, it->last);
         }
 
         r += it->text;