path.h

#pragma once
 
#include <algorithm>
#include <cctype>
#include <filesystem>
#include <string>
#include <vector>
 
namespace pixelbullet::filesystem
{
[[nodiscard]] inline std::filesystem::path normalized_path(const std::filesystem::path& path)
{
    std::filesystem::path normalized = path.lexically_normal();
    while (!normalized.empty() && !normalized.has_filename())
    {
        const std::filesystem::path parent = normalized.parent_path();
        if (parent.empty() || parent == normalized)
        {
            break;
        }
        normalized = parent;
    }
    return normalized;
}
 
[[nodiscard]] inline std::string normalized_path_key(const std::filesystem::path& path)
{
    std::string key = normalized_path(path).generic_string();
#ifdef _WIN32
    for (char& value : key)
    {
        value = static_cast<char>(std::tolower(static_cast<unsigned char>(value)));
    }
#endif
    return key;
}
 
[[nodiscard]] inline bool paths_equal(const std::filesystem::path& lhs, const std::filesystem::path& rhs)
{
    return normalized_path_key(lhs) == normalized_path_key(rhs);
}
 
[[nodiscard]] inline bool path_is_within(const std::filesystem::path& path, const std::filesystem::path& directory)
{
    if (path.empty() || directory.empty())
    {
        return false;
    }
 
    const std::filesystem::path normalized_target = normalized_path(path);
    const std::filesystem::path normalized_directory = normalized_path(directory);
    auto target_it = normalized_target.begin();
    for (auto directory_it = normalized_directory.begin(); directory_it != normalized_directory.end(); ++directory_it, ++target_it)
    {
        if (target_it == normalized_target.end() || normalized_path_key(*target_it) != normalized_path_key(*directory_it))
        {
            return false;
        }
    }
 
    return true;
}
 
inline void normalize_sort_unique_paths(std::vector<std::filesystem::path>& paths)
{
    for (std::filesystem::path& path : paths)
    {
        path = normalized_path(path);
    }
 
    std::sort(paths.begin(), paths.end(),
              [](const std::filesystem::path& lhs, const std::filesystem::path& rhs)
              {
                  const std::string lhs_key = normalized_path_key(lhs);
                  const std::string rhs_key = normalized_path_key(rhs);
                  if (lhs_key != rhs_key)
                  {
                      return lhs_key < rhs_key;
                  }
                  return lhs.generic_string() < rhs.generic_string();
              });
    paths.erase(std::unique(paths.begin(), paths.end(),
                            [](const std::filesystem::path& lhs, const std::filesystem::path& rhs) { return paths_equal(lhs, rhs); }),
                paths.end());
}
} // namespace pixelbullet::filesystem