refactor: revert module namespace from canola back to oil

Problem: the canola rename creates unnecessary friction for users
migrating from stevearc/oil.nvim — every `require('oil')` call and
config reference must change.

Solution: revert all module paths, URL schemes, autocmd groups,
highlight groups, and filetype names back to `oil`. The repo stays
`canola.nvim` for identity; the code is a drop-in replacement.

lua/oil/fs.lua

@@ -0,0 +1,385 @@
+local log = require('oil.log')
+local M = {}
+
+local uv = vim.uv or vim.loop
+
+---@type boolean
+M.is_windows = uv.os_uname().version:match('Windows')
+
+M.is_mac = uv.os_uname().sysname == 'Darwin'
+
+M.is_linux = not M.is_windows and not M.is_mac
+
+---@type string
+M.sep = M.is_windows and '\\' or '/'
+
+---@param ... string
+M.join = function(...)
+  return table.concat({ ... }, M.sep)
+end
+
+---Check if OS path is absolute
+---@param dir string
+---@return boolean
+M.is_absolute = function(dir)
+  if M.is_windows then
+    return dir:match('^%a:\\')
+  else
+    return vim.startswith(dir, '/')
+  end
+end
+
+M.abspath = function(path)
+  if not M.is_absolute(path) then
+    path = vim.fn.fnamemodify(path, ':p')
+  end
+  return path
+end
+
+---@param path string
+---@param mode? integer File mode in decimal (default 420 = 0644)
+---@param cb fun(err: nil|string)
+M.touch = function(path, mode, cb)
+  if type(mode) == 'function' then
+    cb = mode
+    mode = 420
+  end
+  uv.fs_open(path, 'a', mode or 420, function(err, fd)
+    if err then
+      cb(err)
+    else
+      assert(fd)
+      uv.fs_close(fd, cb)
+    end
+  end)
+end
+
+--- Returns true if candidate is a subpath of root, or if they are the same path.
+---@param root string
+---@param candidate string
+---@return boolean
+M.is_subpath = function(root, candidate)
+  if candidate == '' then
+    return false
+  end
+  root = vim.fs.normalize(M.abspath(root))
+  -- Trim trailing "/" from the root
+  if root:find('/', -1) then
+    root = root:sub(1, -2)
+  end
+  candidate = vim.fs.normalize(M.abspath(candidate))
+  if M.is_windows then
+    root = root:lower()
+    candidate = candidate:lower()
+  end
+  if root == candidate then
+    return true
+  end
+  local prefix = candidate:sub(1, root:len())
+  if prefix ~= root then
+    return false
+  end
+
+  local candidate_starts_with_sep = candidate:find('/', root:len() + 1, true) == root:len() + 1
+  local root_ends_with_sep = root:find('/', root:len(), true) == root:len()
+
+  return candidate_starts_with_sep or root_ends_with_sep
+end
+
+---@param path string
+---@return string
+M.posix_to_os_path = function(path)
+  if M.is_windows then
+    if vim.startswith(path, '/') then
+      local drive = path:match('^/(%a+)')
+      if not drive then
+        return path
+      end
+      local rem = path:sub(drive:len() + 2)
+      return string.format('%s:%s', drive, rem:gsub('/', '\\'))
+    else
+      local newpath = path:gsub('/', '\\')
+      return newpath
+    end
+  else
+    return path
+  end
+end
+
+---@param path string
+---@return string
+M.os_to_posix_path = function(path)
+  if M.is_windows then
+    if M.is_absolute(path) then
+      local drive, rem = path:match('^([^:]+):\\(.*)$')
+      return string.format('/%s/%s', drive:upper(), rem:gsub('\\', '/'))
+    else
+      local newpath = path:gsub('\\', '/')
+      return newpath
+    end
+  else
+    return path
+  end
+end
+
+local home_dir = assert(uv.os_homedir())
+
+---@param path string
+---@param relative_to? string Shorten relative to this path (default cwd)
+---@return string
+M.shorten_path = function(path, relative_to)
+  if not relative_to then
+    relative_to = vim.fn.getcwd()
+  end
+  local relpath
+  if M.is_subpath(relative_to, path) then
+    local idx = relative_to:len() + 1
+    -- Trim the dividing slash if it's not included in relative_to
+    if not vim.endswith(relative_to, '/') and not vim.endswith(relative_to, '\\') then
+      idx = idx + 1
+    end
+    relpath = path:sub(idx)
+    if relpath == '' then
+      relpath = '.'
+    end
+  end
+  if M.is_subpath(home_dir, path) then
+    local homepath = '~' .. path:sub(home_dir:len() + 1)
+    if not relpath or homepath:len() < relpath:len() then
+      return homepath
+    end
+  end
+  return relpath or path
+end
+
+---@param dir string
+---@param mode? integer
+M.mkdirp = function(dir, mode)
+  mode = mode or 493
+  local mod = ''
+  local path = dir
+  while vim.fn.isdirectory(path) == 0 do
+    mod = mod .. ':h'
+    path = vim.fn.fnamemodify(dir, mod)
+  end
+  while mod ~= '' do
+    mod = mod:sub(3)
+    path = vim.fn.fnamemodify(dir, mod)
+    uv.fs_mkdir(path, mode)
+  end
+end
+
+---@param dir string
+---@param cb fun(err: nil|string, entries: nil|{type: oil.EntryType, name: string})
+M.listdir = function(dir, cb)
+  ---@diagnostic disable-next-line: param-type-mismatch, discard-returns
+  uv.fs_opendir(dir, function(open_err, fd)
+    if open_err then
+      return cb(open_err)
+    end
+    local read_next
+    read_next = function()
+      uv.fs_readdir(fd, function(err, entries)
+        if err then
+          uv.fs_closedir(fd, function()
+            cb(err)
+          end)
+          return
+        elseif entries then
+          ---@diagnostic disable-next-line: param-type-mismatch
+          cb(nil, entries)
+          read_next()
+        else
+          uv.fs_closedir(fd, function(close_err)
+            if close_err then
+              cb(close_err)
+            else
+              cb()
+            end
+          end)
+        end
+      end)
+    end
+    read_next()
+    ---@diagnostic disable-next-line: param-type-mismatch
+  end, 10000)
+end
+
+---@param entry_type oil.EntryType
+---@param path string
+---@param cb fun(err: nil|string)
+M.recursive_delete = function(entry_type, path, cb)
+  if entry_type ~= 'directory' then
+    return uv.fs_unlink(path, cb)
+  end
+  ---@diagnostic disable-next-line: param-type-mismatch, discard-returns
+  uv.fs_opendir(path, function(open_err, fd)
+    if open_err then
+      return cb(open_err)
+    end
+    local poll
+    poll = function(inner_cb)
+      uv.fs_readdir(fd, function(err, entries)
+        if err then
+          return inner_cb(err)
+        elseif entries then
+          local waiting = #entries
+          local complete
+          complete = function(err2)
+            if err2 then
+              complete = function() end
+              return inner_cb(err2)
+            end
+            waiting = waiting - 1
+            if waiting == 0 then
+              poll(inner_cb)
+            end
+          end
+          for _, entry in ipairs(entries) do
+            M.recursive_delete(entry.type, path .. M.sep .. entry.name, complete)
+          end
+        else
+          inner_cb()
+        end
+      end)
+    end
+    poll(function(err)
+      uv.fs_closedir(fd)
+      if err then
+        return cb(err)
+      end
+      uv.fs_rmdir(path, cb)
+    end)
+    ---@diagnostic disable-next-line: param-type-mismatch
+  end, 10000)
+end
+
+---Move the undofile for the file at src_path to dest_path
+---@param src_path string
+---@param dest_path string
+---@param copy boolean
+local move_undofile = vim.schedule_wrap(function(src_path, dest_path, copy)
+  local undofile = vim.fn.undofile(src_path)
+  uv.fs_stat(
+    undofile,
+    vim.schedule_wrap(function(stat_err)
+      if stat_err then
+        -- undofile doesn't exist
+        return
+      end
+      local dest_undofile = vim.fn.undofile(dest_path)
+      if copy then
+        uv.fs_copyfile(src_path, dest_path, function(err)
+          if err then
+            log.warn('Error copying undofile %s: %s', undofile, err)
+          end
+        end)
+      else
+        uv.fs_rename(undofile, dest_undofile, function(err)
+          if err then
+            log.warn('Error moving undofile %s: %s', undofile, err)
+          end
+        end)
+      end
+    end)
+  )
+end)
+
+---@param entry_type oil.EntryType
+---@param src_path string
+---@param dest_path string
+---@param cb fun(err: nil|string)
+M.recursive_copy = function(entry_type, src_path, dest_path, cb)
+  if entry_type == 'link' then
+    uv.fs_readlink(src_path, function(link_err, link)
+      if link_err then
+        return cb(link_err)
+      end
+      assert(link)
+      uv.fs_symlink(link, dest_path, 0, cb)
+    end)
+    return
+  end
+  if entry_type ~= 'directory' then
+    uv.fs_copyfile(src_path, dest_path, { excl = true }, cb)
+    move_undofile(src_path, dest_path, true)
+    return
+  end
+  uv.fs_stat(src_path, function(stat_err, src_stat)
+    if stat_err then
+      return cb(stat_err)
+    end
+    assert(src_stat)
+    uv.fs_mkdir(dest_path, src_stat.mode, function(mkdir_err)
+      if mkdir_err then
+        return cb(mkdir_err)
+      end
+      ---@diagnostic disable-next-line: param-type-mismatch, discard-returns
+      uv.fs_opendir(src_path, function(open_err, fd)
+        if open_err then
+          return cb(open_err)
+        end
+        local poll
+        poll = function(inner_cb)
+          uv.fs_readdir(fd, function(err, entries)
+            if err then
+              return inner_cb(err)
+            elseif entries then
+              local waiting = #entries
+              local complete
+              complete = function(err2)
+                if err2 then
+                  complete = function() end
+                  return inner_cb(err2)
+                end
+                waiting = waiting - 1
+                if waiting == 0 then
+                  poll(inner_cb)
+                end
+              end
+              for _, entry in ipairs(entries) do
+                M.recursive_copy(
+                  entry.type,
+                  src_path .. M.sep .. entry.name,
+                  dest_path .. M.sep .. entry.name,
+                  complete
+                )
+              end
+            else
+              inner_cb()
+            end
+          end)
+        end
+        poll(cb)
+        ---@diagnostic disable-next-line: param-type-mismatch
+      end, 10000)
+    end)
+  end)
+end
+
+---@param entry_type oil.EntryType
+---@param src_path string
+---@param dest_path string
+---@param cb fun(err: nil|string)
+M.recursive_move = function(entry_type, src_path, dest_path, cb)
+  uv.fs_rename(src_path, dest_path, function(err)
+    if err then
+      -- fs_rename fails for cross-partition or cross-device operations.
+      -- We then fall back to a copy + delete
+      M.recursive_copy(entry_type, src_path, dest_path, function(err2)
+        if err2 then
+          cb(err2)
+        else
+          M.recursive_delete(entry_type, src_path, cb)
+        end
+      end)
+    else
+      if entry_type ~= 'directory' then
+        move_undofile(src_path, dest_path, false)
+      end
+      cb()
+    end
+  end)
+end
+
+return M