[prompt] try to handle windows paths

Author: tstack

src/base/fs_util.cc

@@ -45,6 +45,7 @@
 #include "itertools.hh"
 #include "lnav_log.hh"
 #include "opt_util.hh"
+#include "pcrepp/pcre2pp.hh"
 #include "scn/scan.h"
 #include "short_alloc.h"
 
@@ -147,6 +148,9 @@ escape_path(const std::filesystem::path& p, path_type pt)
             case '?':
                 switch (pt) {
                     case path_type::normal:
+                    case path_type::windows:
+                    case path_type::remote:
+                    case path_type::url:
                         retval.push_back('\\');
                         break;
                     case path_type::pattern:
@@ -162,6 +166,59 @@ escape_path(const std::filesystem::path& p, path_type pt)
     return retval;
 }
 
+bool
+is_url(const std::string& fn)
+{
+    static const auto url_re
+        = lnav::pcre2pp::code::from_const("^(file|https?|ftps?|scp|sftp):.*");
+
+    return url_re.find_in(fn).ignore_error().has_value();
+}
+
+path_type
+determine_path_type(const std::string& arg)
+{
+    if (is_glob(arg)) {
+        return path_type::pattern;
+    }
+
+    if (is_url(arg)) {
+        return path_type::url;
+    }
+
+    switch (arg.find(':')) {
+        case 0:
+            return path_type::normal;
+        case 1:
+            return path_type::windows;
+        default:
+            return path_type::remote;
+    }
+}
+
+std::filesystem::path
+to_posix_path(std::string arg)
+{
+    if (cget(arg, 1).value_or('\0') != ':') {
+        return {arg};
+    }
+
+    switch (cget(arg, 2).value_or('\0')) {
+        case '\\':
+        case '/':
+            arg.erase(1, 1);
+            break;
+        default:
+            arg[1] = '/';
+            break;
+    }
+
+    arg.insert(arg.begin(), '/');
+    std::replace(arg.begin(), arg.end(), '\\', '/');
+
+    return {arg};
+}
+
 std::pair<std::string, file_location_t>
 split_file_location(const std::string& file_path_str)
 {

src/base/fs_util.hh

@@ -60,14 +60,23 @@ is_glob(const std::string& fn)
             || fn.find('[') != std::string::npos);
 }
 
+bool is_url(const std::string& fn);
+
 enum class path_type {
     normal,
     pattern,
+    windows,
+    remote,
+    url,
 };
 
 std::string escape_path(const std::filesystem::path& p,
                         path_type pt = path_type::normal);
 
+path_type determine_path_type(const std::string& arg);
+
+std::filesystem::path to_posix_path(std::string arg);
+
 std::pair<std::string, file_location_t> split_file_location(
     const std::string& path);
 

src/base/fs_util.tests.cc

@@ -35,6 +35,20 @@
 #include "config.h"
 #include "doctest/doctest.h"
 
+TEST_CASE("fs_util::to_posix_path")
+{
+    CHECK("/c/foo/bar" == lnav::filesystem::to_posix_path("c:\\foo\\bar"));
+
+    CHECK("/c/" == lnav::filesystem::to_posix_path("c:"));
+
+    CHECK("/c/" == lnav::filesystem::to_posix_path("c:\\"));
+
+    // XXX what should this be?
+    CHECK("/c/foo/bar" == lnav::filesystem::to_posix_path("c:foo\\bar"));
+
+    CHECK("" == lnav::filesystem::to_posix_path(""));
+}
+
 TEST_CASE("fs_util::build_path")
 {
     auto* old_path = getenv("PATH");

src/base/humanize.network.cc

@@ -42,7 +42,7 @@ from_str(string_fragment sf)
 {
     static const auto REMOTE_PATTERN = lnav::pcre2pp::code::from_const(
         "^(?:(?<username>[\\w\\._\\-]+)@)?"
-        "(?:\\[(?<ipv6>[^\\]]+)\\]|(?<hostname>[^\\[/:]+)):"
+        "(?:\\[(?<ipv6>[^\\]]+)\\]|(?<hostname>[^\\[/:]{2,})):"
         "(?<path>.*)$");
     thread_local auto REMOTE_MATCH_DATA = REMOTE_PATTERN.create_match_data();
 

src/base/string_util.cc

@@ -213,13 +213,6 @@ utf8_char_to_byte_index(const std::string& str, ssize_t ch_index)
 
     return retval;
 }
-bool
-is_url(const std::string& fn)
-{
-    static const auto url_re = std::regex("^(file|https?|ftps?|scp|sftp):.*");
-
-    return std::regex_match(fn, url_re);
-}
 
 size_t
 last_word_str(char* str, size_t len, size_t max_len)

src/base/string_util.hh

@@ -207,8 +207,6 @@ utf8_string_length(const std::string& str)
     return utf8_string_length(str.c_str(), str.length());
 }
 
-bool is_url(const std::string& fn);
-
 bool is_blank(const std::string& str);
 
 size_t abbreviate_str(char* str, size_t len, size_t max_len);

src/cmds.io.cc

@@ -940,7 +940,7 @@ com_open(exec_context& ec, std::string cmdline, std::vector<std::string>& args)
             }
 #endif
 
-            if (is_url(fn.c_str())) {
+            if (lnav::filesystem::is_url(fn)) {
 #ifndef HAVE_LIBCURL
                 retval = "error: lnav was not compiled with libcurl";
 #else
@@ -1502,7 +1502,7 @@ com_close(exec_context& ec, std::string cmdline, std::vector<std::string>& args)
                 const auto& fn = fn_v[lpc];
                 const auto& actual_path = actual_path_v[lpc];
 
-                if (is_url(fn.c_str())) {
+                if (lnav::filesystem::is_url(fn)) {
                     isc::to<curl_looper&, services::curl_streamer_t>().send(
                         [fn](auto& clooper) { clooper.close_request(fn); });
                 }

src/command_executor.cc

@@ -690,7 +690,7 @@ execute_file(exec_context& ec, const std::string& path_and_args)
     if (iter != scripts.as_scripts.end()) {
         paths_to_exec = iter->second;
     }
-    if (is_url(script_name)) {
+    if (lnav::filesystem::is_url(script_name)) {
         auto_mem<CURLU> cu(curl_url_cleanup);
         cu = curl_url();
         auto set_rc = curl_url_set(cu, CURLUPART_URL, script_name.c_str(), 0);

src/file_collection.cc

@@ -650,7 +650,7 @@ file_collection::expand_filename(
         }
     }
 
-    if (is_url(path)) {
+    if (lnav::filesystem::is_url(path)) {
         return;
     }
 

src/lnav.cc

@@ -3580,16 +3580,19 @@ SELECT tbl_name FROM sqlite_master WHERE sql LIKE 'CREATE VIRTUAL TABLE%'
         auto_mem<char> abspath;
         struct stat st;
 
-        auto file_path = std::filesystem::path(
+        auto file_path = lnav::filesystem::to_posix_path(
             stat(file_path_without_trailer.c_str(), &st) == 0
                 ? file_path_without_trailer
                 : file_path_str);
 
+        auto file_path_type
+            = lnav::filesystem::determine_path_type(file_path.string());
+
         if (file_path_str == "-") {
             load_stdin = true;
         }
 #ifdef HAVE_LIBCURL
-        else if (is_url(file_path_str))
+        else if (file_path_type == lnav::filesystem::path_type::url)
         {
             auto ul = std::make_shared<url_loader>(file_path_str);
 
@@ -3603,12 +3606,12 @@ SELECT tbl_name FROM sqlite_master WHERE sql LIKE 'CREATE VIRTUAL TABLE%'
                 fmt::format(FMT_STRING(":open {}"), file_path_str));
         }
 #endif
-        else if (lnav::filesystem::is_glob(file_path))
+        else if (file_path_type == lnav::filesystem::path_type::pattern)
         {
             lnav_data.ld_active_files.fc_file_names[file_path].with_follow(
                 !(lnav_data.ld_flags & LNF_HEADLESS));
         } else if (lnav::filesystem::statp(file_path, &st) == -1) {
-            if (file_path_str.find(':') != std::string::npos) {
+            if (file_path_type == lnav::filesystem::path_type::remote) {
                 lnav_data.ld_active_files.fc_file_names[file_path].with_follow(
                     !(lnav_data.ld_flags & LNF_HEADLESS));
             } else {