feat: builtin support for editing files over ssh (#27)

lua/oil/adapters/ssh/sshfs.lua

@@ -0,0 +1,228 @@
+local cache = require("oil.cache")
+local permissions = require("oil.adapters.files.permissions")
+local SSHConnection = require("oil.adapters.ssh.connection")
+local util = require("oil.util")
+local FIELD = require("oil.constants").FIELD
+local SSHFS = {}
+
+local typechar_map = {
+  l = "link",
+  d = "directory",
+  p = "fifo",
+  s = "socket",
+  ["-"] = "file",
+  c = "file", -- character special file
+  b = "file", -- block special file
+}
+---@param line string
+---@return string Name of entry
+---@return oil.EntryType
+---@return nil|table Metadata for entry
+local function parse_ls_line(line)
+  local typechar, perms, refcount, user, group, rem =
+    line:match("^(.)(%S+)%s+(%d+)%s+(%S+)%s+(%S+)%s+(.*)$")
+  if not typechar then
+    error(string.format("Could not parse '%s'", line))
+  end
+  local type = typechar_map[typechar] or "file"
+
+  local meta = {
+    user = user,
+    group = group,
+    mode = permissions.parse(perms),
+    refcount = tonumber(refcount),
+  }
+  local name, size, date, major, minor
+  if typechar == "c" or typechar == "b" then
+    major, minor, date, name = rem:match("^(%d+)%s*,%s*(%d+)%s+(%S+%s+%d+%s+%d%d:?%d%d)%s+(.*)")
+    meta.major = tonumber(major)
+    meta.minor = tonumber(minor)
+  else
+    size, date, name = rem:match("^(%d+)%s+(%S+%s+%d+%s+%d%d:?%d%d)%s+(.*)")
+    meta.size = tonumber(size)
+  end
+  meta.iso_modified_date = date
+  if type == "link" then
+    local link
+    name, link = unpack(vim.split(name, " -> ", { plain = true }))
+    if vim.endswith(link, "/") then
+      link = link:sub(1, #link - 1)
+    end
+    meta.link = link
+  end
+
+  return name, type, meta
+end
+
+---@param url oil.sshUrl
+function SSHFS.new(url)
+  return setmetatable({
+    conn = SSHConnection.new(url),
+  }, {
+    __index = SSHFS,
+  })
+end
+
+function SSHFS:get_connection_error()
+  return self.conn.connection_error
+end
+
+---@param value integer
+---@param path string
+---@param callback fun(err: nil|string)
+function SSHFS:chmod(value, path, callback)
+  local octal = permissions.mode_to_octal_str(value)
+  self.conn:run(string.format("chmod %s '%s'", octal, path), callback)
+end
+
+function SSHFS:open_terminal()
+  self.conn:open_terminal()
+end
+
+function SSHFS:realpath(path, callback)
+  local cmd = string.format(
+    'if ! readlink -f "%s" 2>/dev/null; then [[ "%s" == /* ]] && echo "%s" || echo "$PWD/%s"; fi',
+    path,
+    path,
+    path,
+    path
+  )
+  self.conn:run(cmd, function(err, lines)
+    if err then
+      return callback(err)
+    end
+    local abspath = table.concat(lines, "")
+    -- If the path was "." then the abspath might be /path/to/., so we need to trim that final '.'
+    if vim.endswith(abspath, ".") then
+      abspath = abspath:sub(1, #abspath - 1)
+    end
+    self.conn:run(string.format("ls -fld '%s'", abspath), function(ls_err, ls_lines)
+      local type
+      if ls_err then
+        -- If the file doesn't exist, treat it like a not-yet-existing directory
+        type = "directory"
+      else
+        local _
+        _, type = parse_ls_line(ls_lines[1])
+      end
+      if type == "directory" then
+        abspath = util.addslash(abspath)
+      end
+      callback(nil, abspath)
+    end)
+  end)
+end
+
+local dir_meta = {}
+
+function SSHFS:list_dir(url, path, callback)
+  local path_postfix = ""
+  if path ~= "" then
+    path_postfix = string.format(" '%s'", path)
+  end
+  self.conn:run("ls -fl" .. path_postfix, function(err, lines)
+    if err then
+      if err:match("No such file or directory%s*$") then
+        -- If the directory doesn't exist, treat the list as a success. We will be able to traverse
+        -- and edit a not-yet-existing directory.
+        return callback()
+      else
+        return callback(err)
+      end
+    end
+    local any_links = false
+    local entries = {}
+    for _, line in ipairs(lines) do
+      if line ~= "" and not line:match("^total") then
+        local name, type, meta = parse_ls_line(line)
+        if name == "." then
+          dir_meta[url] = meta
+        elseif name ~= ".." then
+          if type == "link" then
+            any_links = true
+          end
+          local cache_entry = cache.create_entry(url, name, type)
+          entries[name] = cache_entry
+          cache_entry[FIELD.meta] = meta
+          cache.store_entry(url, cache_entry)
+        end
+      end
+    end
+    if any_links then
+      -- If there were any soft links, then we need to run another ls command with -L so that we can
+      -- resolve the type of the link target
+      self.conn:run("ls -fLl" .. path_postfix, function(link_err, link_lines)
+        -- Ignore exit code 1. That just means one of the links could not be resolved.
+        if link_err and not link_err:match("^1:") then
+          return callback(link_err)
+        end
+        for _, line in ipairs(link_lines) do
+          if line ~= "" and not line:match("^total") then
+            local ok, name, type, meta = pcall(parse_ls_line, line)
+            if ok and name ~= "." and name ~= ".." then
+              local cache_entry = entries[name]
+              if cache_entry[FIELD.type] == "link" then
+                cache_entry[FIELD.meta].link_stat = {
+                  type = type,
+                  size = meta.size,
+                }
+              end
+            end
+          end
+        end
+        callback()
+      end)
+    else
+      callback()
+    end
+  end)
+end
+
+---@param path string
+---@param callback fun(err: nil|string)
+function SSHFS:mkdir(path, callback)
+  self.conn:run(string.format("mkdir -p '%s'", path), callback)
+end
+
+---@param path string
+---@param callback fun(err: nil|string)
+function SSHFS:touch(path, callback)
+  self.conn:run(string.format("touch '%s'", path), callback)
+end
+
+---@param path string
+---@param link string
+---@param callback fun(err: nil|string)
+function SSHFS:mklink(path, link, callback)
+  self.conn:run(string.format("ln -s '%s' '%s'", link, path), callback)
+end
+
+---@param path string
+---@param callback fun(err: nil|string)
+function SSHFS:rm(path, callback)
+  self.conn:run(string.format("rm -rf '%s'", path), callback)
+end
+
+---@param src string
+---@param dest string
+---@param callback fun(err: nil|string)
+function SSHFS:mv(src, dest, callback)
+  self.conn:run(string.format("mv '%s' '%s'", src, dest), callback)
+end
+
+---@param src string
+---@param dest string
+---@param callback fun(err: nil|string)
+function SSHFS:cp(src, dest, callback)
+  self.conn:run(string.format("cp -r '%s' '%s'", src, dest), callback)
+end
+
+function SSHFS:get_dir_meta(url)
+  return dir_meta[url]
+end
+
+function SSHFS:get_meta()
+  return self.conn.meta
+end
+
+return SSHFS