Add 'is_absolute_path()' function

Also, the 'get_relative_path(pathA, pathB)' function has been made
case-insensitive. This is done to correctly calculate common folders
in case one of the entered paths has a case difference.

Author: Gasparoken

base/fs.cpp

@@ -1,5 +1,5 @@
 // LAF Base Library
-// Copyright (c) 2021-2024 Igara Studio S.A.
+// Copyright (c) 2021-2025 Igara Studio S.A.
 // Copyright (c) 2001-2018 David Capello
 //
 // This file is released under the terms of the MIT license.
@@ -20,6 +20,11 @@
   #include "base/fs_unix.h"
 #endif
 
+#if LAF_MACOS
+  #include <fstream>
+  #include <cstdio>
+#endif
+
 #include <algorithm>
 #include <cctype>
 #include <cstdlib>
@@ -35,6 +40,46 @@ const std::string::value_type* path_separators = "\\/";
 const std::string::value_type* path_separators = "/";
 #endif
 
+#if LAF_MACOS
+static bool* g_is_filesystem_case_sensitive = nullptr;
+
+bool isFilesystemCaseSensitive() {
+  if (g_is_filesystem_case_sensitive)
+    return *g_is_filesystem_case_sensitive;
+  std::string path1 = get_current_path() + "/filesystemTest.txt";
+  std::string path2 = get_current_path() + "/FilesystemTest.TXT";
+
+  std::ofstream file1(path1);
+  if (!file1) {
+    // Just in case, the case-sensitive approach is adopted.
+    *g_is_filesystem_case_sensitive = true;
+    return true;
+  }
+  file1.close();
+
+  std::ofstream file2(path2);
+  bool caseSensitive = file2.is_open();
+  if (caseSensitive) file2.close();
+
+  std::remove(path1.c_str());
+  std::remove(path2.c_str());
+
+  *g_is_filesystem_case_sensitive = caseSensitive;
+  return caseSensitive;
+}
+#endif
+
+bool is_absolute_path(const std::string& path)
+{
+#if LAF_WINDOWS
+  return (path.size() > 2 && std::isalpha(path[0]) && path[1] == ':' && path[2] == path_separator)
+         // Network path (UNC)
+         || (path.size() > 1 && path[0] == path_separator && path[1] == path_separator);
+#else
+  return !path.empty() && path[0] == path_separator;
+#endif
+}
+
 void make_all_directories(const std::string& path)
 {
   std::vector<std::string> parts;
@@ -194,7 +239,17 @@ std::string get_relative_path(const std::string& filename, const std::string& ba
   auto itFrom = baseDirs.begin();
   auto itTo = toParts.begin();
 
-  while (itFrom != baseDirs.end() && itTo != toParts.end() && *itFrom == *itTo) {
+  while (itFrom != baseDirs.end() && itTo != toParts.end()
+// Linux OS is case sensitive
+#if LAF_LINUX
+         && *itFrom == *itTo
+#elif LAF_WINDOWS
+         && base::string_to_lower(*itFrom) == base::string_to_lower((*itTo))
+#elif LAF_MACOS
+         && ((!isFilesystemCaseSensitive() && (base::string_to_lower(*itFrom) == base::string_to_lower(*itTo)))
+         || (isFilesystemCaseSensitive() && (*itFrom == *itTo)))
+#endif
+  ) {
     ++itFrom;
     ++itTo;
   }

base/fs.h

@@ -1,5 +1,5 @@
 // LAF Base Library
-// Copyright (c) 2020-2024 Igara Studio S.A.
+// Copyright (c) 2020-2025 Igara Studio S.A.
 // Copyright (c) 2001-2018 David Capello
 //
 // This file is released under the terms of the MIT license.
@@ -28,6 +28,7 @@ extern const std::string::value_type* path_separators;
 
 bool is_file(const std::string& path);
 bool is_directory(const std::string& path);
+bool is_absolute_path(const std::string& path);
 
 size_t file_size(const std::string& path);
 

base/fs_tests.cpp

@@ -258,6 +258,31 @@ TEST(FS, GetAbsolutePath)
 #endif
 }
 
+TEST(FS, IsAbsolutePath)
+{
+  EXPECT_FALSE(is_absolute_path(""));
+  EXPECT_FALSE(is_absolute_path("a"));
+  EXPECT_FALSE(is_absolute_path("./a"));
+  EXPECT_FALSE(is_absolute_path("../a"));
+  EXPECT_FALSE(is_absolute_path("."));
+  EXPECT_FALSE(is_absolute_path("./."));
+  EXPECT_FALSE(is_absolute_path("./a/.."));
+  EXPECT_FALSE(is_absolute_path(".\\//."));
+
+#if LAF_WINDOWS
+  EXPECT_TRUE(is_absolute_path("C:\\path\\..\\file"));
+  EXPECT_TRUE(is_absolute_path("\\\\network\\path"));
+  EXPECT_FALSE(is_absolute_path("C:user\\name\\"));
+  EXPECT_FALSE(is_absolute_path("C\\user\\name\\"));
+  EXPECT_FALSE(is_absolute_path("\\user\\path\\"));
+  EXPECT_FALSE(is_absolute_path(".:\\user\\name"));
+  EXPECT_FALSE(is_absolute_path("\\:\\user\\name"));
+#else
+  EXPECT_TRUE(is_absolute_path("/path/../file"));
+  EXPECT_FALSE(is_absolute_path("path/../file"));
+#endif
+}
+
 TEST(FS, GetCanonicalPath)
 {
   const auto cp = get_current_path();

base/fs_unix.h

@@ -1,5 +1,5 @@
 // LAF Base Library
-// Copyright (c) 2021-2024 Igara Studio S.A.
+// Copyright (c) 2021-2025 Igara Studio S.A.
 // Copyright (c) 2001-2018 David Capello
 //
 // This file is released under the terms of the MIT license.
@@ -213,7 +213,7 @@ std::string get_canonical_path(const std::string& path)
 std::string get_absolute_path(const std::string& path)
 {
   std::string full = path;
-  if (!full.empty() && full[0] != '/')
+  if (!full.empty() && !is_absolute_path(full))
     full = join_path(get_current_path(), full);
   full = normalize_path(full);
   if (!full.empty() && full.back() == path_separator)

base/fs_win32.h

@@ -161,7 +161,7 @@ std::string get_canonical_path(const std::string& path)
 std::string get_absolute_path(const std::string& path)
 {
   std::string full;
-  if (path.size() > 2 && path[1] != ':')
+  if (!full.empty() && !base::is_absolute_path(path))
     full = base::join_path(base::get_current_path(), path);
   else
     full = path;