new_build_system (#18)

Reviewed-on: #18

support/include/utils/path.hpp

@@ -30,8 +30,12 @@ inline constexpr const std::string_view backslash{"\\"};
 inline constexpr const std::wstring_view backslash_w{L"\\"};
 inline constexpr const std::string_view dot{"."};
 inline constexpr const std::wstring_view dot_w{L"."};
+inline constexpr const std::string_view dot_backslash{".\\"};
+inline constexpr const std::wstring_view dot_backslash_w{L".\\"};
 inline constexpr const std::string_view dot_slash{"./"};
 inline constexpr const std::wstring_view dot_slash_w{L"./"};
+inline constexpr const std::string_view long_notation{"\\\\?\\"};
+inline constexpr const std::wstring_view long_notation_w{L"\\\\?\\"};
 inline constexpr const std::string_view slash{"/"};
 inline constexpr const std::wstring_view slash_w{L"/"};
 #if defined(_WIN32)
@@ -39,6 +43,8 @@ inline constexpr const std::string_view directory_seperator{backslash};
 inline constexpr const std::wstring_view directory_seperator_w{backslash_w};
 inline constexpr const std::string_view not_directory_seperator{slash};
 inline constexpr const std::wstring_view not_directory_seperator_w{slash_w};
+inline constexpr const std::string_view unc_notation{"\\\\"};
+inline constexpr const std::wstring_view unc_notation_w{L"\\\\"};
 #else  // !defined(_WIN32)
 inline constexpr const std::string_view directory_seperator{slash};
 inline constexpr const std::wstring_view directory_seperator_w{slash_w};
@@ -62,53 +68,6 @@ get_backslash<wchar_t>() -> std::basic_string_view<wchar_t> {
   return backslash_w;
 }
 
-template <typename char_t>
-[[nodiscard]] inline constexpr auto get_dot() -> std::basic_string_view<char_t>;
-
-template <>
-[[nodiscard]] inline constexpr auto
-get_dot<char>() -> std::basic_string_view<char> {
-  return dot;
-}
-
-template <>
-[[nodiscard]] inline constexpr auto
-get_dot<wchar_t>() -> std::basic_string_view<wchar_t> {
-  return dot_w;
-}
-
-template <typename char_t>
-[[nodiscard]] inline constexpr auto
-get_dot_slash() -> std::basic_string_view<char_t>;
-
-template <>
-[[nodiscard]] inline constexpr auto
-get_dot_slash<char>() -> std::basic_string_view<char> {
-  return dot_slash;
-}
-
-template <>
-[[nodiscard]] inline constexpr auto
-get_dot_slash<wchar_t>() -> std::basic_string_view<wchar_t> {
-  return dot_slash_w;
-}
-
-template <typename char_t>
-[[nodiscard]] inline constexpr auto
-get_slash() -> std::basic_string_view<char_t>;
-
-template <>
-[[nodiscard]] inline constexpr auto
-get_slash<char>() -> std::basic_string_view<char> {
-  return slash;
-}
-
-template <>
-[[nodiscard]] inline constexpr auto
-get_slash<wchar_t>() -> std::basic_string_view<wchar_t> {
-  return slash_w;
-}
-
 template <typename char_t>
 [[nodiscard]] inline constexpr auto
 get_directory_seperator() -> std::basic_string_view<char_t>;
@@ -141,37 +100,130 @@ get_not_directory_seperator<wchar_t>() -> std::basic_string_view<wchar_t> {
   return not_directory_seperator_w;
 }
 
+template <typename char_t>
+[[nodiscard]] inline constexpr auto get_dot() -> std::basic_string_view<char_t>;
+
+template <>
+[[nodiscard]] inline constexpr auto
+get_dot<char>() -> std::basic_string_view<char> {
+  return dot;
+}
+
+template <>
+[[nodiscard]] inline constexpr auto
+get_dot<wchar_t>() -> std::basic_string_view<wchar_t> {
+  return dot_w;
+}
+
+template <typename char_t>
+[[nodiscard]] inline constexpr auto
+get_dot_backslash() -> std::basic_string_view<char_t>;
+
+template <>
+[[nodiscard]] inline constexpr auto
+get_dot_backslash<char>() -> std::basic_string_view<char> {
+  return dot_backslash;
+}
+
+template <>
+[[nodiscard]] inline constexpr auto
+get_dot_backslash<wchar_t>() -> std::basic_string_view<wchar_t> {
+  return dot_backslash_w;
+}
+
+template <typename char_t>
+[[nodiscard]] inline constexpr auto
+get_dot_slash() -> std::basic_string_view<char_t>;
+
+template <>
+[[nodiscard]] inline constexpr auto
+get_dot_slash<char>() -> std::basic_string_view<char> {
+  return dot_slash;
+}
+
+template <>
+[[nodiscard]] inline constexpr auto
+get_dot_slash<wchar_t>() -> std::basic_string_view<wchar_t> {
+  return dot_slash_w;
+}
+
+template <typename char_t>
+[[nodiscard]] inline constexpr auto
+get_long_notation() -> std::basic_string_view<char_t>;
+
+template <>
+[[nodiscard]] inline constexpr auto
+get_long_notation<char>() -> std::basic_string_view<char> {
+  return long_notation;
+}
+
+template <>
+[[nodiscard]] inline constexpr auto
+get_long_notation<wchar_t>() -> std::basic_string_view<wchar_t> {
+  return long_notation_w;
+}
+
+template <typename char_t>
+[[nodiscard]] inline constexpr auto
+get_slash() -> std::basic_string_view<char_t>;
+
+template <>
+[[nodiscard]] inline constexpr auto
+get_slash<char>() -> std::basic_string_view<char> {
+  return slash;
+}
+
+template <>
+[[nodiscard]] inline constexpr auto
+get_slash<wchar_t>() -> std::basic_string_view<wchar_t> {
+  return slash_w;
+}
+
+#if defined(_WIN32)
+template <typename char_t>
+[[nodiscard]] inline constexpr auto
+get_unc_notation() -> std::basic_string_view<char_t>;
+
+template <>
+[[nodiscard]] inline constexpr auto
+get_unc_notation<char>() -> std::basic_string_view<char> {
+  return unc_notation;
+}
+
+template <>
+[[nodiscard]] inline constexpr auto
+get_unc_notation<wchar_t>() -> std::basic_string_view<wchar_t> {
+  return unc_notation_w;
+}
+#endif // defined(_WIN32)
+
+template <typename string_t>
+[[nodiscard]] inline auto get_current_path() -> string_t;
+
 [[nodiscard]] auto absolute(std::string_view path) -> std::string;
 
 [[nodiscard]] auto absolute(std::wstring_view path) -> std::wstring;
 
 [[nodiscard]] inline auto
-combine(std::string path,
+combine(std::string_view path,
         const std::vector<std::string_view> &paths) -> std::string;
 
 [[nodiscard]] inline auto
-combine(std::wstring path,
+combine(std::wstring_view path,
         const std::vector<std::wstring_view> &paths) -> std::wstring;
 
+[[nodiscard]] auto contains_trash_directory(std::string_view path) -> bool;
+
+[[nodiscard]] auto contains_trash_directory(std::wstring_view path) -> bool;
+
 [[nodiscard]] auto inline create_api_path(std::string_view path) -> std::string;
 
 [[nodiscard]] auto inline create_api_path(std::wstring_view path)
     -> std::wstring;
 
-[[nodiscard]] inline auto
-directory_exists_in_path(std::string_view path,
-                         std::string_view sub_directory) -> bool;
+[[nodiscard]] auto exists(std::string_view path) -> bool;
 
-[[nodiscard]] inline auto
-directory_exists_in_path(std::wstring_view path,
-                         std::wstring_view sub_directory) -> bool;
-
-[[nodiscard]] inline auto
-file_exists_in_path(std::string_view path, std::string_view file_name) -> bool;
-
-[[nodiscard]] inline auto
-file_exists_in_path(std::wstring_view path,
-                    std::wstring_view file_name) -> bool;
+[[nodiscard]] auto exists(std::wstring_view path) -> bool;
 
 [[nodiscard]] inline auto finalize(std::string_view path) -> std::string;
 
@@ -196,22 +248,27 @@ get_parent_api_path(std::string_view path) -> std::string;
 [[nodiscard]] inline auto
 get_parent_api_path(std::wstring_view path) -> std::wstring;
 
-[[nodiscard]] auto get_parent_directory(std::string_view path) -> std::string;
+[[nodiscard]] auto get_parent_path(std::string_view path) -> std::string;
 
-[[nodiscard]] auto get_parent_directory(std::wstring_view path) -> std::wstring;
+[[nodiscard]] auto get_parent_path(std::wstring_view path) -> std::wstring;
 
-[[nodiscard]] auto is_trash_directory(std::string_view path) -> bool;
+[[nodiscard]] inline auto
+get_parts(std::string_view path) -> std::vector<std::string>;
 
-[[nodiscard]] auto is_trash_directory(std::wstring_view path) -> bool;
+[[nodiscard]] inline auto
+get_parts_w(std::wstring_view path) -> std::vector<std::wstring>;
+
+[[nodiscard]] auto get_relative_path(std::string_view path,
+                                     std::string_view root_path) -> std::string;
+
+[[nodiscard]] auto
+get_relative_path(std::wstring_view path,
+                  std::wstring_view root_path) -> std::wstring;
 
 [[nodiscard]] auto make_file_uri(std::string_view path) -> std::string;
 
 [[nodiscard]] auto make_file_uri(std::wstring_view path) -> std::wstring;
 
-[[nodiscard]] auto remove_file_name(std::string_view path) -> std::string;
-
-[[nodiscard]] auto remove_file_name(std::wstring_view path) -> std::wstring;
-
 [[nodiscard]] auto strip_to_file_name(std::string path) -> std::string;
 
 [[nodiscard]] auto strip_to_file_name(std::wstring path) -> std::wstring;
@@ -222,31 +279,30 @@ get_parent_api_path(std::wstring_view path) -> std::wstring;
 
 template <typename string_t>
 [[nodiscard]] inline auto combine_t(
-    string_t path,
+    std::basic_string_view<typename string_t::value_type> path,
     const std::vector<std::basic_string_view<typename string_t::value_type>>
         &paths) -> string_t {
-  path = std::accumulate(
-      paths.begin(), paths.end(), path, [](auto next_path, auto &&path_part) {
-        if (next_path.empty()) {
-          return string_t{path_part};
-        }
+  auto dir_sep_t =
+      string_t{get_directory_seperator<typename string_t::value_type>()};
+  return absolute(
+      std::accumulate(paths.begin(), paths.end(),
+                      std::basic_string<typename string_t::value_type>{path},
+                      [&dir_sep_t](auto next_path, auto &&path_part) {
+                        if (next_path.empty()) {
+                          return string_t{path_part};
+                        }
 
-        return next_path +
-               string_t{
-                   get_directory_seperator<typename string_t::value_type>()} +
-               string_t{path_part};
-      });
-
-  return absolute(path);
+                        return next_path + dir_sep_t + string_t{path_part};
+                      }));
 }
 
-inline auto combine(std::string path,
+inline auto combine(std::string_view path,
                     const std::vector<std::string_view> &paths) -> std::string {
   return combine_t<std::string>(path, paths);
 }
 
 inline auto
-combine(std::wstring path,
+combine(std::wstring_view path,
         const std::vector<std::wstring_view> &paths) -> std::wstring {
   return combine_t<std::wstring>(path, paths);
 }
@@ -255,12 +311,20 @@ template <typename string_t>
 [[nodiscard]] inline auto create_api_path_t(
     std::basic_string_view<typename string_t::value_type> path) -> string_t {
   auto backslash_t = get_backslash<typename string_t::value_type>();
-  auto dot_t = get_dot<typename string_t::value_type>();
+  auto dot_backslash_t = get_dot_backslash<typename string_t::value_type>();
   auto dot_slash_t = get_dot_slash<typename string_t::value_type>();
+  auto dot_t = get_dot<typename string_t::value_type>();
   auto slash_t = get_slash<typename string_t::value_type>();
 
+#if defined(_WIN32)
+  auto long_notation_t = get_long_notation<typename string_t::value_type>();
+  if (utils::string::begins_with(path, long_notation_t)) {
+    path = path.substr(long_notation_t.size());
+  }
+#endif // defined(_WIN32)
+
   if (path.empty() || path == backslash_t || path == dot_t ||
-      path == dot_slash_t || path == slash_t) {
+      path == dot_slash_t || path == slash_t || path == dot_backslash_t) {
     return string_t{slash_t};
   }
 
@@ -271,16 +335,12 @@ template <typename string_t>
   }
 #endif // defined(_WIN32)
 
+  format_path(api_path, slash_t, backslash_t);
+
   while (utils::string::begins_with(api_path, dot_slash_t)) {
     api_path = api_path.substr(dot_slash_t.size());
   }
 
-  while (utils::string::begins_with(api_path, dot_t)) {
-    api_path = api_path.substr(dot_t.size());
-  }
-
-  format_path(api_path, slash_t, backslash_t);
-
   if (api_path.at(0U) != slash_t.at(0U)) {
     return string_t{slash_t} + api_path;
   }
@@ -296,50 +356,57 @@ inline auto create_api_path(std::wstring_view path) -> std::wstring {
   return create_api_path_t<std::wstring>(path);
 }
 
-template <typename string_t>
-[[nodiscard]] inline auto directory_exists_in_path_t(
-    std::basic_string_view<typename string_t::value_type> path,
-    std::basic_string_view<typename string_t::value_type> sub_directory)
-    -> bool {
-  return std::filesystem::is_directory(
-      std::filesystem::path(path).append(sub_directory));
-}
-
-inline auto directory_exists_in_path(std::string_view path,
-                                     std::string_view sub_directory) -> bool {
-  return directory_exists_in_path_t<std::string>(path, sub_directory);
-}
-
-inline auto directory_exists_in_path(std::wstring_view path,
-                                     std::wstring_view sub_directory) -> bool {
-  return directory_exists_in_path_t<std::wstring>(path, sub_directory);
-}
-
-template <typename string_t>
-[[nodiscard]] inline auto file_exists_in_path_t(
-    std::basic_string_view<typename string_t::value_type> path,
-    std::basic_string_view<typename string_t::value_type> file_name) -> bool {
-  return std::filesystem::is_regular_file(
-      std::filesystem::path(path).append(file_name));
-}
-
-inline auto file_exists_in_path(std::string_view path,
-                                std::string_view file_name) -> bool {
-  return file_exists_in_path_t<std::string>(path, file_name);
-}
-
-inline auto file_exists_in_path(std::wstring_view path,
-                                std::wstring_view file_name) -> bool {
-  return file_exists_in_path_t<std::wstring>(path, file_name);
-}
-
 template <typename string_t>
 [[nodiscard]] inline auto finalize_t(
     std::basic_string_view<typename string_t::value_type> path) -> string_t {
+  string_t dir_sep_t{get_directory_seperator<typename string_t::value_type>()};
   string_t fmt_path{path};
-  format_path(fmt_path,
-              get_directory_seperator<typename string_t::value_type>(),
+  if (fmt_path.empty()) {
+    return fmt_path;
+  }
+
+  format_path(fmt_path, dir_sep_t,
               get_not_directory_seperator<typename string_t::value_type>());
+
+#if defined(_WIN32)
+  auto unc_notation_t = get_unc_notation<typename string_t::value_type>();
+  if (utils::string::begins_with(fmt_path, unc_notation_t)) {
+    return fmt_path;
+  }
+
+  auto dot_t = get_dot<typename string_t::value_type>();
+  auto dot_sep_t = string_t{dot_t} + dir_sep_t;
+  if (fmt_path == dot_t || fmt_path == dot_sep_t) {
+    return get_current_path<string_t>();
+  }
+
+  if (fmt_path == dir_sep_t) {
+#if defined(PROJECT_ENABLE_WIN32_LONG_PATH_NAMES)
+    return get_current_path<string_t>().substr(0U, long_notation.size() + 2U);
+#else  // !defined(PROJECT_ENABLE_WIN32_LONG_PATH_NAMES)
+    return get_current_path<string_t>().substr(0U, 2U);
+#endif // defined(PROJECT_ENABLE_WIN32_LONG_PATH_NAMES)
+  }
+
+  if (utils::string::begins_with(fmt_path, dir_sep_t)) {
+#if defined(PROJECT_ENABLE_WIN32_LONG_PATH_NAMES)
+    return get_current_path<string_t>().substr(0U, long_notation.size() + 2U) +
+           fmt_path;
+#else  // !defined(PROJECT_ENABLE_WIN32_LONG_PATH_NAMES)
+    return get_current_path<string_t>().substr(0U, 2U) + fmt_path;
+#endif // defined(PROJECT_ENABLE_WIN32_LONG_PATH_NAMES)
+  }
+
+  if (utils::string::begins_with(fmt_path, dot_sep_t)) {
+    return get_current_path<string_t>() + dir_sep_t + fmt_path.substr(2U);
+  }
+
+#if defined(PROJECT_ENABLE_WIN32_LONG_PATH_NAMES)
+  return string_t{get_long_notation<typename string_t::value_type>()} +
+         fmt_path;
+#endif // defined(PROJECT_ENABLE_WIN32_LONG_PATH_NAMES)
+#endif // defined(_WIN32)
+
   return fmt_path;
 }
 
@@ -359,6 +426,19 @@ format_path(string_t &path,
     -> string_t & {
   utils::string::replace(path, not_sep, sep);
 
+#if defined(_WIN32)
+  auto is_unc{false};
+  auto long_notation_t = get_long_notation<typename string_t::value_type>();
+  auto unc_notation_t = get_unc_notation<typename string_t::value_type>();
+  if (utils::string::begins_with(path, long_notation_t)) {
+    path = path.substr(long_notation_t.size());
+  } else if (utils::string::begins_with(path, unc_notation_t)) {
+    path = path.substr(unc_notation_t.size());
+    utils::string::left_trim(path, sep.at(0U));
+    is_unc = true;
+  }
+#endif // defined(_WIN32)
+
   string_t double_sep(2U, sep.at(0U));
   while (utils::string::contains(path, double_sep)) {
     utils::string::replace(path, double_sep, sep);
@@ -369,7 +449,9 @@ format_path(string_t &path,
   }
 
 #if defined(_WIN32)
-  if ((path.size() >= 2U) && (path.at(1U) == ':')) {
+  if (is_unc) {
+    path = string_t{unc_notation_t} + path;
+  } else if ((path.size() >= 2U) && (path.at(1U) == ':')) {
     path[0U] = utils::string::to_lower(string_t(1U, path.at(0U))).at(0U);
   }
 #endif // defined(_WIN32)
@@ -377,6 +459,24 @@ format_path(string_t &path,
   return path;
 }
 
+template <>
+[[nodiscard]] inline auto get_current_path<std::string>() -> std::string {
+#if defined(_WIN32)
+  std::string path;
+  path.resize(repertory::max_path_length + 1);
+  ::GetCurrentDirectoryA(static_cast<DWORD>(path.size()), path.data());
+  path = path.c_str();
+  return finalize(path);
+#else  // !defined(_WIN32)
+  return finalize(std::filesystem::current_path().string());
+#endif // defined(_WIN32)
+}
+
+template <>
+[[nodiscard]] inline auto get_current_path<std::wstring>() -> std::wstring {
+  return utils::string::from_utf8(get_current_path<std::string>());
+}
+
 template <typename string_t>
 [[nodiscard]] inline auto get_parent_api_path_t(
     std::basic_string_view<typename string_t::value_type> path) -> string_t {
@@ -387,12 +487,12 @@ template <typename string_t>
     return ret;
   }
 
-  ret = path.substr(0, path.rfind('/') + 1);
+  ret = path.substr(0, path.rfind(slash_t) + 1);
   if (ret == slash_t) {
     return ret;
   }
 
-  return utils::string::right_trim(ret, '/');
+  return utils::string::right_trim(ret, slash_t.at(0U));
 }
 
 inline auto get_parent_api_path(std::string_view path) -> std::string {
@@ -402,6 +502,23 @@ inline auto get_parent_api_path(std::string_view path) -> std::string {
 inline auto get_parent_api_path(std::wstring_view path) -> std::wstring {
   return get_parent_api_path_t<std::wstring>(path);
 }
+
+template <typename string_t>
+[[nodiscard]] inline auto
+get_parts_t(std::basic_string_view<typename string_t::value_type> path)
+    -> std::vector<string_t> {
+  return utils::string::split(
+      path, get_directory_seperator<typename string_t::value_type>().at(0U),
+      false);
+}
+
+inline auto get_parts(std::string_view path) -> std::vector<std::string> {
+  return get_parts_t<std::string>(path);
+}
+
+inline auto get_parts_w(std::wstring_view path) -> std::vector<std::wstring> {
+  return get_parts_t<std::wstring>(path);
+}
 } // namespace repertory::utils::path
 
 #endif // REPERTORY_INCLUDE_UTILS_PATH_HPP_