Move functions from os/fs.c into path.c

Move unit tests from os/fs.moon to path.moon

src/path.c

@@ -30,6 +30,9 @@
 #define URL_SLASH       1               /* path_is_url() has found "://" */
 #define URL_BACKSLASH   2               /* path_is_url() has found ":\\" */
 
+static bool is_executable(const char_u *name);
+static bool is_executable_in_path(const char_u *name);
+
 FileComparison path_full_compare(char_u *s1, char_u *s2, int checkname)
 {
   assert(s1 && s2);
@@ -1938,3 +1941,192 @@ int match_suffix(char_u *fname)
   }
   return setsuflen != 0;
 }
+
+/// Get the absolute name of the given relative directory.
+///
+/// @param directory Directory name, relative to current directory.
+/// @return `FAIL` for failure, `OK` for success.
+int os_full_dir_name(char *directory, char *buffer, int len)
+{
+  int SUCCESS = 0;
+  int retval = OK;
+
+  if (STRLEN(directory) == 0) {
+    return os_dirname((char_u *) buffer, len);
+  }
+
+  char old_dir[MAXPATHL];
+
+  // Get current directory name.
+  if (os_dirname((char_u *) old_dir, MAXPATHL) == FAIL) {
+    return FAIL;
+  }
+
+  // We have to get back to the current dir at the end, check if that works.
+  if (os_chdir(old_dir) != SUCCESS) {
+    return FAIL;
+  }
+
+  if (os_chdir(directory) != SUCCESS) {
+    // Do not return immediatly since we may be in the wrong directory.
+    retval = FAIL;
+  }
+
+  if (retval == FAIL || os_dirname((char_u *) buffer, len) == FAIL) {
+    // Do not return immediatly since we are in the wrong directory.
+    retval = FAIL;
+  }
+
+  if (os_chdir(old_dir) != SUCCESS) {
+    // That shouldn't happen, since we've tested if it works.
+    retval = FAIL;
+    EMSG(_(e_prev_dir));
+  }
+
+  return retval;
+}
+
+// Append to_append to path with a slash in between.
+int append_path(char *path, const char *to_append, int max_len)
+{
+  int current_length = STRLEN(path);
+  int to_append_length = STRLEN(to_append);
+
+  // Do not append empty strings.
+  if (to_append_length == 0) {
+    return OK;
+  }
+
+  // Do not append a dot.
+  if (STRCMP(to_append, ".") == 0) {
+    return OK;
+  }
+
+  // Glue both paths with a slash.
+  if (current_length > 0 && path[current_length-1] != '/') {
+    current_length += 1;  // Count the trailing slash.
+
+    // +1 for the NUL at the end.
+    if (current_length + 1 > max_len) {
+      return FAIL;
+    }
+
+    STRCAT(path, "/");
+  }
+
+  // +1 for the NUL at the end.
+  if (current_length + to_append_length + 1 > max_len) {
+    return FAIL;
+  }
+
+  STRCAT(path, to_append);
+  return OK;
+}
+
+int os_get_absolute_path(char_u *fname, char_u *buf, int len, int force)
+{
+  char_u *p;
+  *buf = NUL;
+
+  char relative_directory[len];
+  char *end_of_path = (char *) fname;
+
+  // expand it if forced or not an absolute path
+  if (force || !os_is_absolute_path(fname)) {
+    if ((p = vim_strrchr(fname, '/')) != NULL) {
+      STRNCPY(relative_directory, fname, p-fname);
+      relative_directory[p-fname] = NUL;
+      end_of_path = (char *) (p + 1);
+    } else {
+      relative_directory[0] = NUL;
+      end_of_path = (char *) fname;
+    }
+
+    if (FAIL == os_full_dir_name(relative_directory, (char *) buf, len)) {
+      return FAIL;
+    }
+  }
+  return append_path((char *) buf, (char *) end_of_path, len);
+}
+
+int os_is_absolute_path(const char_u *fname)
+{
+  return *fname == '/' || *fname == '~';
+}
+
+bool os_can_exe(const char_u *name)
+{
+  // If it's an absolute or relative path don't need to use $PATH.
+  if (os_is_absolute_path(name) ||
+     (name[0] == '.' && (name[1] == '/' ||
+                        (name[1] == '.' && name[2] == '/')))) {
+    return is_executable(name);
+  }
+
+  return is_executable_in_path(name);
+}
+
+// Return true if "name" is an executable file, false if not or it doesn't
+// exist.
+static bool is_executable(const char_u *name)
+{
+  int32_t mode = os_getperm(name);
+
+  if (mode < 0) {
+    return false;
+  }
+
+  if (S_ISREG(mode) && (S_IEXEC & mode)) {
+    return true;
+  }
+
+  return false;
+}
+
+/// Check if a file is inside the $PATH and is executable.
+///
+/// @return `true` if `name` is an executable inside $PATH.
+static bool is_executable_in_path(const char_u *name)
+{
+  const char *path = getenv("PATH");
+  // PATH environment variable does not exist or is empty.
+  if (path == NULL || *path == NUL) {
+    return false;
+  }
+
+  int buf_len = STRLEN(name) + STRLEN(path) + 2;
+  char_u *buf = alloc((unsigned)(buf_len));
+
+  // Walk through all entries in $PATH to check if "name" exists there and
+  // is an executable file.
+  for (;; ) {
+    const char *e = strchr(path, ':');
+    if (e == NULL) {
+      e = path + STRLEN(path);
+    }
+
+    // Glue together the given directory from $PATH with name and save into
+    // buf.
+    vim_strncpy(buf, (char_u *) path, e - path);
+    append_path((char *) buf, (const char *) name, buf_len);
+
+    if (is_executable(buf)) {
+      // Found our executable. Free buf and return.
+      vim_free(buf);
+      return true;
+    }
+
+    if (*e != ':') {
+      // End of $PATH without finding any executable called name.
+      vim_free(buf);
+      return false;
+    }
+
+    path = e + 1;
+  }
+
+  // We should never get to this point.
+  assert(false);
+  return false;
+}
+