Barrett Ruth
e6bbd362bb
Problem: DELE, RMD, MKD, and RNFR/RNTO were implemented using curl --quote, which requires a subsequent LIST or STOR to trigger the FTP connection. That data-channel operation hangs on slow or busy servers, making every mutation appear stuck. Solution: replace the curl --quote approach with a python3 ftplib one-liner for all control-channel operations. ftplib executes DELE, RMD, MKD, RNFR/RNTO, and SITE CHMOD without opening a data channel, so they complete instantly. The curl wrapper is retained for LIST, read_file, and write_file, which genuinely need a data channel.
633 lines
18 KiB
Lua
633 lines
18 KiB
Lua
local config = require('oil.config')
|
|
local constants = require('oil.constants')
|
|
local files = require('oil.adapters.files')
|
|
local fs = require('oil.fs')
|
|
local loading = require('oil.loading')
|
|
local pathutil = require('oil.pathutil')
|
|
local permissions = require('oil.adapters.files.permissions')
|
|
local shell = require('oil.shell')
|
|
local util = require('oil.util')
|
|
local M = {}
|
|
|
|
local FIELD_TYPE = constants.FIELD_TYPE
|
|
local FIELD_META = constants.FIELD_META
|
|
|
|
---@class (exact) oil.ftpUrl
|
|
---@field scheme string
|
|
---@field host string
|
|
---@field user nil|string
|
|
---@field password nil|string
|
|
---@field port nil|integer
|
|
---@field path string
|
|
|
|
---@param oil_url string
|
|
---@return oil.ftpUrl
|
|
M.parse_url = function(oil_url)
|
|
local scheme, url = util.parse_url(oil_url)
|
|
assert(scheme and url, string.format("Malformed input url '%s'", oil_url))
|
|
local ret = { scheme = scheme }
|
|
local userinfo, rem = url:match('^([^@%s]+)@(.*)$')
|
|
if userinfo then
|
|
local user, pass = userinfo:match('^([^:]+):(.+)$')
|
|
if user then
|
|
ret.user = user
|
|
ret.password = pass
|
|
else
|
|
ret.user = userinfo
|
|
end
|
|
url = rem
|
|
end
|
|
local host, port, path = url:match('^([^:]+):(%d+)/(.*)$')
|
|
if host then
|
|
ret.host = host
|
|
ret.port = tonumber(port)
|
|
ret.path = path
|
|
else
|
|
host, path = url:match('^([^/]+)/(.*)$')
|
|
ret.host = host
|
|
ret.path = path
|
|
end
|
|
if not ret.host or not ret.path then
|
|
error(string.format('Malformed FTP url: %s', oil_url))
|
|
end
|
|
---@cast ret oil.ftpUrl
|
|
return ret
|
|
end
|
|
|
|
---@param url oil.ftpUrl
|
|
---@return string
|
|
local function url_to_str(url)
|
|
local pieces = { url.scheme }
|
|
if url.user then
|
|
table.insert(pieces, url.user)
|
|
if url.password then
|
|
table.insert(pieces, ':')
|
|
table.insert(pieces, url.password)
|
|
end
|
|
table.insert(pieces, '@')
|
|
end
|
|
table.insert(pieces, url.host)
|
|
if url.port then
|
|
table.insert(pieces, string.format(':%d', url.port))
|
|
end
|
|
table.insert(pieces, '/')
|
|
table.insert(pieces, url.path)
|
|
return table.concat(pieces, '')
|
|
end
|
|
|
|
---@param url oil.ftpUrl
|
|
---@return string
|
|
local function curl_ftp_url(url)
|
|
local scheme = url.scheme == 'oil-ftps://' and 'ftps://' or 'ftp://'
|
|
local pieces = { scheme }
|
|
if url.user then
|
|
table.insert(pieces, url.user)
|
|
if url.password then
|
|
table.insert(pieces, ':')
|
|
table.insert(pieces, url.password)
|
|
end
|
|
table.insert(pieces, '@')
|
|
end
|
|
table.insert(pieces, url.host)
|
|
if url.port then
|
|
table.insert(pieces, string.format(':%d', url.port))
|
|
end
|
|
table.insert(pieces, '/')
|
|
table.insert(pieces, url.path)
|
|
return table.concat(pieces, '')
|
|
end
|
|
|
|
---@param url oil.ftpUrl
|
|
---@param commands string[]
|
|
---@param cb fun(err: nil|string)
|
|
local function ftpcmd(url, commands, cb)
|
|
local lines = {}
|
|
local use_tls = url.scheme == 'oil-ftps://'
|
|
if use_tls then
|
|
table.insert(lines, 'import ftplib, ssl')
|
|
table.insert(lines, 'ctx = ssl.create_default_context()')
|
|
table.insert(lines, 'ftp = ftplib.FTP_TLS(context=ctx)')
|
|
else
|
|
table.insert(lines, 'import ftplib')
|
|
table.insert(lines, 'ftp = ftplib.FTP()')
|
|
end
|
|
table.insert(lines, string.format('ftp.connect(%q, %d)', url.host, url.port or 21))
|
|
if use_tls then
|
|
table.insert(lines, 'ftp.auth()')
|
|
end
|
|
local user = url.user or 'anonymous'
|
|
local password = url.password or ''
|
|
table.insert(lines, string.format('ftp.login(%q, %q)', user, password))
|
|
if use_tls then
|
|
table.insert(lines, 'ftp.prot_p()')
|
|
end
|
|
for _, cmd in ipairs(commands) do
|
|
table.insert(lines, string.format('ftp.voidcmd(%q)', cmd))
|
|
end
|
|
table.insert(lines, 'ftp.quit()')
|
|
local script = table.concat(lines, '\n')
|
|
shell.run({ 'python3', '-c', script }, function(err)
|
|
if err then
|
|
cb(err:match('ftplib%.[^:]+: (.+)$') or err:match('[^\n]+$') or err)
|
|
else
|
|
cb(nil)
|
|
end
|
|
end)
|
|
end
|
|
|
|
---@param url oil.ftpUrl
|
|
---@return string[]
|
|
local function ssl_args(url)
|
|
if url.scheme == 'oil-ftps://' then
|
|
return { '--ssl-reqd' }
|
|
end
|
|
return {}
|
|
end
|
|
|
|
---@param url oil.ftpUrl
|
|
---@param extra_args string[]
|
|
---@param cb fun(err: nil|string, output: nil|string[])
|
|
local function curl(url, extra_args, cb)
|
|
local cmd = { 'curl', '-s', '--netrc-optional' }
|
|
vim.list_extend(cmd, ssl_args(url))
|
|
vim.list_extend(cmd, config.extra_curl_args)
|
|
vim.list_extend(cmd, extra_args)
|
|
shell.run(cmd, cb)
|
|
end
|
|
|
|
---@param url oil.ftpUrl
|
|
---@return string
|
|
local function ftp_abs_path(url)
|
|
return '/' .. url.path
|
|
end
|
|
|
|
---@param url1 oil.ftpUrl
|
|
---@param url2 oil.ftpUrl
|
|
---@return boolean
|
|
local function url_hosts_equal(url1, url2)
|
|
return url1.host == url2.host and url1.port == url2.port and url1.user == url2.user
|
|
end
|
|
|
|
local month_map = {
|
|
Jan = 1,
|
|
Feb = 2,
|
|
Mar = 3,
|
|
Apr = 4,
|
|
May = 5,
|
|
Jun = 6,
|
|
Jul = 7,
|
|
Aug = 8,
|
|
Sep = 9,
|
|
Oct = 10,
|
|
Nov = 11,
|
|
Dec = 12,
|
|
}
|
|
|
|
---@param line string
|
|
---@return nil|string, nil|string, nil|table
|
|
local function parse_unix_list_line(line)
|
|
local perms, size, month, day, timeoryear, name =
|
|
line:match('^([dlrwxstST%-]+)%s+%d+%s+%S+%s+%S+%s+(%d+)%s+(%a+)%s+(%d+)%s+(%S+)%s+(.+)$')
|
|
if not perms then
|
|
return nil
|
|
end
|
|
local entry_type
|
|
local first = perms:sub(1, 1)
|
|
if first == 'd' then
|
|
entry_type = 'directory'
|
|
elseif first == 'l' then
|
|
entry_type = 'link'
|
|
else
|
|
entry_type = 'file'
|
|
end
|
|
local link_target
|
|
if entry_type == 'link' then
|
|
local link_name, target = name:match('^(.+) %-> (.+)$')
|
|
if link_name then
|
|
name = link_name
|
|
link_target = target
|
|
end
|
|
end
|
|
local mtime
|
|
local mon = month_map[month]
|
|
if mon then
|
|
local hour, min = timeoryear:match('^(%d+):(%d+)$')
|
|
if hour then
|
|
local now = os.time()
|
|
local t = os.date('*t', now)
|
|
---@cast t osdate
|
|
mtime = os.time({
|
|
year = t.year,
|
|
month = mon,
|
|
day = tonumber(day),
|
|
hour = tonumber(hour),
|
|
min = tonumber(min),
|
|
sec = 0,
|
|
})
|
|
if mtime > now + 86400 then
|
|
mtime = os.time({
|
|
year = t.year - 1,
|
|
month = mon,
|
|
day = tonumber(day),
|
|
hour = tonumber(hour),
|
|
min = tonumber(min),
|
|
sec = 0,
|
|
})
|
|
end
|
|
else
|
|
local year = tonumber(timeoryear)
|
|
if year then
|
|
mtime =
|
|
os.time({ year = year, month = mon, day = tonumber(day), hour = 0, min = 0, sec = 0 })
|
|
end
|
|
end
|
|
end
|
|
local mode = permissions.parse(perms:sub(2))
|
|
local meta = { size = tonumber(size), mtime = mtime, mode = mode }
|
|
if link_target then
|
|
meta.link = link_target
|
|
end
|
|
return name, entry_type, meta
|
|
end
|
|
|
|
---@param line string
|
|
---@return nil|string, nil|string, nil|table
|
|
local function parse_iis_list_line(line)
|
|
local size_or_dir, name = line:match('^%d+%-%d+%-%d+%s+%d+:%d+%a+%s+(%S+)%s+(.+)$')
|
|
if not size_or_dir then
|
|
return nil
|
|
end
|
|
local entry_type, size
|
|
if size_or_dir == '<DIR>' then
|
|
entry_type = 'directory'
|
|
else
|
|
entry_type = 'file'
|
|
size = tonumber(size_or_dir)
|
|
end
|
|
local meta = { size = size }
|
|
return name, entry_type, meta
|
|
end
|
|
|
|
local ftp_columns = {}
|
|
ftp_columns.size = {
|
|
render = function(entry, conf)
|
|
local meta = entry[FIELD_META]
|
|
if not meta or not meta.size then
|
|
return ''
|
|
end
|
|
if entry[FIELD_TYPE] == 'directory' then
|
|
return ''
|
|
end
|
|
if meta.size >= 1e9 then
|
|
return string.format('%.1fG', meta.size / 1e9)
|
|
elseif meta.size >= 1e6 then
|
|
return string.format('%.1fM', meta.size / 1e6)
|
|
elseif meta.size >= 1e3 then
|
|
return string.format('%.1fk', meta.size / 1e3)
|
|
else
|
|
return string.format('%d', meta.size)
|
|
end
|
|
end,
|
|
|
|
parse = function(line, conf)
|
|
return line:match('^(%d+%S*)%s+(.*)$')
|
|
end,
|
|
|
|
get_sort_value = function(entry)
|
|
local meta = entry[FIELD_META]
|
|
if meta and meta.size then
|
|
return meta.size
|
|
else
|
|
return 0
|
|
end
|
|
end,
|
|
}
|
|
|
|
ftp_columns.mtime = {
|
|
render = function(entry, conf)
|
|
local meta = entry[FIELD_META]
|
|
if not meta or not meta.mtime then
|
|
return ''
|
|
end
|
|
return os.date('%Y-%m-%d %H:%M', meta.mtime)
|
|
end,
|
|
|
|
parse = function(line, conf)
|
|
return line:match('^(%d+%-%d+%-%d+%s%d+:%d+)%s+(.*)$')
|
|
end,
|
|
|
|
get_sort_value = function(entry)
|
|
local meta = entry[FIELD_META]
|
|
if meta and meta.mtime then
|
|
return meta.mtime
|
|
else
|
|
return 0
|
|
end
|
|
end,
|
|
}
|
|
|
|
ftp_columns.permissions = {
|
|
render = function(entry, conf)
|
|
local meta = entry[FIELD_META]
|
|
if not meta or not meta.mode then
|
|
return
|
|
end
|
|
local str = permissions.mode_to_str(meta.mode)
|
|
return { str, permissions.mode_to_highlights(str) }
|
|
end,
|
|
|
|
parse = function(line, conf)
|
|
return permissions.parse(line)
|
|
end,
|
|
|
|
compare = function(entry, parsed_value)
|
|
local meta = entry[FIELD_META]
|
|
if parsed_value and meta and meta.mode then
|
|
local mask = bit.lshift(1, 12) - 1
|
|
local old_mode = bit.band(meta.mode, mask)
|
|
if parsed_value ~= old_mode then
|
|
return true
|
|
end
|
|
end
|
|
return false
|
|
end,
|
|
|
|
render_action = function(action)
|
|
return string.format('CHMOD %s %s', permissions.mode_to_octal_str(action.value), action.url)
|
|
end,
|
|
|
|
perform_action = function(action, callback)
|
|
local res = M.parse_url(action.url)
|
|
local octal = permissions.mode_to_octal_str(action.value)
|
|
local ftp_path = ftp_abs_path(res)
|
|
ftpcmd(res, { string.format('SITE CHMOD %s %s', octal, ftp_path) }, callback)
|
|
end,
|
|
}
|
|
|
|
---@param name string
|
|
---@return nil|oil.ColumnDefinition
|
|
M.get_column = function(name)
|
|
return ftp_columns[name]
|
|
end
|
|
|
|
---@param bufname string
|
|
---@return string
|
|
M.get_parent = function(bufname)
|
|
local res = M.parse_url(bufname)
|
|
res.path = pathutil.parent(res.path)
|
|
return url_to_str(res)
|
|
end
|
|
|
|
---@param url string
|
|
---@param callback fun(url: string)
|
|
M.normalize_url = function(url, callback)
|
|
local res = M.parse_url(url)
|
|
callback(url_to_str(res))
|
|
end
|
|
|
|
---@param url string
|
|
---@param column_defs string[]
|
|
---@param callback fun(err?: string, entries?: oil.InternalEntry[], fetch_more?: fun())
|
|
M.list = function(url, column_defs, callback)
|
|
if vim.fn.executable('curl') ~= 1 then
|
|
callback('`curl` is not executable. Can you run `curl --version`?')
|
|
return
|
|
end
|
|
local res = M.parse_url(url)
|
|
curl(res, { curl_ftp_url(res) }, function(err, output)
|
|
if err then
|
|
callback(err)
|
|
return
|
|
end
|
|
local entries = {}
|
|
for _, line in ipairs(output or {}) do
|
|
if line ~= '' then
|
|
local name, entry_type, meta = parse_unix_list_line(line)
|
|
if not name then
|
|
name, entry_type, meta = parse_iis_list_line(line)
|
|
end
|
|
if name and entry_type and name ~= '.' and name ~= '..' then
|
|
table.insert(entries, { 0, name, entry_type, meta })
|
|
end
|
|
end
|
|
end
|
|
callback(nil, entries)
|
|
end)
|
|
end
|
|
|
|
---@param bufnr integer
|
|
---@return boolean
|
|
M.is_modifiable = function(bufnr)
|
|
return true
|
|
end
|
|
|
|
---@param action oil.Action
|
|
---@return string
|
|
M.render_action = function(action)
|
|
if action.type == 'create' then
|
|
local ret = string.format('CREATE %s', action.url)
|
|
if action.link then
|
|
ret = ret .. ' -> ' .. action.link
|
|
end
|
|
return ret
|
|
elseif action.type == 'delete' then
|
|
return string.format('DELETE %s', action.url)
|
|
elseif action.type == 'move' or action.type == 'copy' then
|
|
local src = action.src_url
|
|
local dest = action.dest_url
|
|
if config.get_adapter_by_scheme(src) ~= M then
|
|
local _, path = util.parse_url(src)
|
|
assert(path)
|
|
src = files.to_short_os_path(path, action.entry_type)
|
|
end
|
|
if config.get_adapter_by_scheme(dest) ~= M then
|
|
local _, path = util.parse_url(dest)
|
|
assert(path)
|
|
dest = files.to_short_os_path(path, action.entry_type)
|
|
end
|
|
return string.format(' %s %s -> %s', action.type:upper(), src, dest)
|
|
else
|
|
error(string.format("Bad action type: '%s'", action.type))
|
|
end
|
|
end
|
|
|
|
---@param src_res oil.ftpUrl
|
|
---@param dest_res oil.ftpUrl
|
|
---@param cb fun(err: nil|string)
|
|
local function ftp_copy_file(src_res, dest_res, cb)
|
|
local cache_dir = vim.fn.stdpath('cache')
|
|
assert(type(cache_dir) == 'string')
|
|
local tmpdir = fs.join(cache_dir, 'oil')
|
|
fs.mkdirp(tmpdir)
|
|
local fd, tmpfile = vim.loop.fs_mkstemp(fs.join(tmpdir, 'ftp_XXXXXX'))
|
|
if fd then
|
|
vim.loop.fs_close(fd)
|
|
end
|
|
curl(src_res, { curl_ftp_url(src_res), '-o', tmpfile }, function(err)
|
|
if err then
|
|
vim.loop.fs_unlink(tmpfile)
|
|
return cb(err)
|
|
end
|
|
curl(dest_res, { '-T', tmpfile, curl_ftp_url(dest_res) }, function(err2)
|
|
vim.loop.fs_unlink(tmpfile)
|
|
cb(err2)
|
|
end)
|
|
end)
|
|
end
|
|
|
|
---@param action oil.Action
|
|
---@param cb fun(err: nil|string)
|
|
M.perform_action = function(action, cb)
|
|
if action.type == 'create' then
|
|
local res = M.parse_url(action.url)
|
|
local ftp_path = ftp_abs_path(res)
|
|
if action.entry_type == 'directory' then
|
|
ftpcmd(res, { string.format('MKD %s', ftp_path) }, cb)
|
|
elseif action.entry_type == 'link' then
|
|
cb('FTP does not support symbolic links')
|
|
else
|
|
curl(res, { '-T', '/dev/null', curl_ftp_url(res) }, cb)
|
|
end
|
|
elseif action.type == 'delete' then
|
|
local res = M.parse_url(action.url)
|
|
local ftp_path = ftp_abs_path(res)
|
|
if action.entry_type == 'directory' then
|
|
ftpcmd(res, { string.format('RMD %s', ftp_path) }, cb)
|
|
else
|
|
ftpcmd(res, { string.format('DELE %s', ftp_path) }, cb)
|
|
end
|
|
elseif action.type == 'move' then
|
|
local src_adapter = assert(config.get_adapter_by_scheme(action.src_url))
|
|
local dest_adapter = assert(config.get_adapter_by_scheme(action.dest_url))
|
|
if src_adapter == M and dest_adapter == M then
|
|
local src_res = M.parse_url(action.src_url)
|
|
local dest_res = M.parse_url(action.dest_url)
|
|
if url_hosts_equal(src_res, dest_res) then
|
|
ftpcmd(src_res, {
|
|
string.format('RNFR %s', ftp_abs_path(src_res)),
|
|
string.format('RNTO %s', ftp_abs_path(dest_res)),
|
|
}, cb)
|
|
else
|
|
if action.entry_type == 'directory' then
|
|
cb('Cannot move directories across FTP hosts')
|
|
return
|
|
end
|
|
ftp_copy_file(src_res, dest_res, function(err)
|
|
if err then
|
|
return cb(err)
|
|
end
|
|
ftpcmd(src_res, { string.format('DELE %s', ftp_abs_path(src_res)) }, cb)
|
|
end)
|
|
end
|
|
else
|
|
cb('We should never attempt to move across adapters')
|
|
end
|
|
elseif action.type == 'copy' then
|
|
local src_adapter = assert(config.get_adapter_by_scheme(action.src_url))
|
|
local dest_adapter = assert(config.get_adapter_by_scheme(action.dest_url))
|
|
if src_adapter == M and dest_adapter == M then
|
|
if action.entry_type == 'directory' then
|
|
cb('Cannot copy directories over FTP; copy individual files instead')
|
|
return
|
|
end
|
|
local src_res = M.parse_url(action.src_url)
|
|
local dest_res = M.parse_url(action.dest_url)
|
|
ftp_copy_file(src_res, dest_res, cb)
|
|
elseif src_adapter == M then
|
|
if action.entry_type == 'directory' then
|
|
cb('Cannot copy FTP directories to local filesystem via curl')
|
|
return
|
|
end
|
|
local src_res = M.parse_url(action.src_url)
|
|
local _, dest_path = util.parse_url(action.dest_url)
|
|
assert(dest_path)
|
|
local local_path = fs.posix_to_os_path(dest_path)
|
|
curl(src_res, { curl_ftp_url(src_res), '-o', local_path }, cb)
|
|
else
|
|
if action.entry_type == 'directory' then
|
|
cb('Cannot copy local directories to FTP via curl')
|
|
return
|
|
end
|
|
local _, src_path = util.parse_url(action.src_url)
|
|
assert(src_path)
|
|
local local_path = fs.posix_to_os_path(src_path)
|
|
local dest_res = M.parse_url(action.dest_url)
|
|
curl(dest_res, { '-T', local_path, curl_ftp_url(dest_res) }, cb)
|
|
end
|
|
else
|
|
cb(string.format('Bad action type: %s', action.type))
|
|
end
|
|
end
|
|
|
|
M.supported_cross_adapter_actions = { files = 'copy' }
|
|
|
|
---@param bufnr integer
|
|
M.read_file = function(bufnr)
|
|
loading.set_loading(bufnr, true)
|
|
local bufname = vim.api.nvim_buf_get_name(bufnr)
|
|
local url = M.parse_url(bufname)
|
|
local basename = pathutil.basename(bufname)
|
|
local cache_dir = vim.fn.stdpath('cache')
|
|
assert(type(cache_dir) == 'string')
|
|
local tmpdir = fs.join(cache_dir, 'oil')
|
|
fs.mkdirp(tmpdir)
|
|
local fd, tmpfile = vim.loop.fs_mkstemp(fs.join(tmpdir, 'ftp_XXXXXX'))
|
|
if fd then
|
|
vim.loop.fs_close(fd)
|
|
end
|
|
local tmp_bufnr = vim.fn.bufadd(tmpfile)
|
|
|
|
curl(url, { curl_ftp_url(url), '-o', tmpfile }, function(err)
|
|
loading.set_loading(bufnr, false)
|
|
vim.bo[bufnr].modifiable = true
|
|
vim.cmd.doautocmd({ args = { 'BufReadPre', bufname }, mods = { silent = true } })
|
|
if err then
|
|
vim.api.nvim_buf_set_lines(bufnr, 0, -1, true, vim.split(err, '\n'))
|
|
else
|
|
vim.api.nvim_buf_set_lines(bufnr, 0, -1, true, {})
|
|
vim.api.nvim_buf_call(bufnr, function()
|
|
vim.cmd.read({ args = { tmpfile }, mods = { silent = true } })
|
|
end)
|
|
vim.loop.fs_unlink(tmpfile)
|
|
vim.api.nvim_buf_set_lines(bufnr, 0, 1, true, {})
|
|
end
|
|
vim.bo[bufnr].modified = false
|
|
local filetype = vim.filetype.match({ buf = bufnr, filename = basename })
|
|
if filetype then
|
|
vim.bo[bufnr].filetype = filetype
|
|
end
|
|
vim.cmd.doautocmd({ args = { 'BufReadPost', bufname }, mods = { silent = true } })
|
|
vim.api.nvim_buf_delete(tmp_bufnr, { force = true })
|
|
end)
|
|
end
|
|
|
|
---@param bufnr integer
|
|
M.write_file = function(bufnr)
|
|
local bufname = vim.api.nvim_buf_get_name(bufnr)
|
|
local url = M.parse_url(bufname)
|
|
local cache_dir = vim.fn.stdpath('cache')
|
|
assert(type(cache_dir) == 'string')
|
|
local tmpdir = fs.join(cache_dir, 'oil')
|
|
local fd, tmpfile = vim.loop.fs_mkstemp(fs.join(tmpdir, 'ftp_XXXXXXXX'))
|
|
if fd then
|
|
vim.loop.fs_close(fd)
|
|
end
|
|
vim.cmd.doautocmd({ args = { 'BufWritePre', bufname }, mods = { silent = true } })
|
|
vim.bo[bufnr].modifiable = false
|
|
vim.cmd.write({ args = { tmpfile }, bang = true, mods = { silent = true, noautocmd = true } })
|
|
local tmp_bufnr = vim.fn.bufadd(tmpfile)
|
|
|
|
curl(url, { '-T', tmpfile, curl_ftp_url(url) }, function(err)
|
|
vim.bo[bufnr].modifiable = true
|
|
if err then
|
|
vim.notify(string.format('Error writing file: %s', err), vim.log.levels.ERROR)
|
|
else
|
|
vim.bo[bufnr].modified = false
|
|
vim.cmd.doautocmd({ args = { 'BufWritePost', bufname }, mods = { silent = true } })
|
|
end
|
|
vim.loop.fs_unlink(tmpfile)
|
|
vim.api.nvim_buf_delete(tmp_bufnr, { force = true })
|
|
end)
|
|
end
|
|
|
|
return M
|