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/mutator/init.lua

@@ -0,0 +1,626 @@
+local Progress = require('oil.mutator.progress')
+local Trie = require('oil.mutator.trie')
+local cache = require('oil.cache')
+local columns = require('oil.columns')
+local config = require('oil.config')
+local confirmation = require('oil.mutator.confirmation')
+local constants = require('oil.constants')
+local fs = require('oil.fs')
+local lsp_helpers = require('oil.lsp.helpers')
+local oil = require('oil')
+local parser = require('oil.mutator.parser')
+local util = require('oil.util')
+local view = require('oil.view')
+local M = {}
+
+local FIELD_NAME = constants.FIELD_NAME
+local FIELD_TYPE = constants.FIELD_TYPE
+
+---@alias oil.Action oil.CreateAction|oil.DeleteAction|oil.MoveAction|oil.CopyAction|oil.ChangeAction
+
+---@class (exact) oil.CreateAction
+---@field type "create"
+---@field url string
+---@field entry_type oil.EntryType
+---@field link nil|string
+
+---@class (exact) oil.DeleteAction
+---@field type "delete"
+---@field url string
+---@field entry_type oil.EntryType
+
+---@class (exact) oil.MoveAction
+---@field type "move"
+---@field entry_type oil.EntryType
+---@field src_url string
+---@field dest_url string
+
+---@class (exact) oil.CopyAction
+---@field type "copy"
+---@field entry_type oil.EntryType
+---@field src_url string
+---@field dest_url string
+
+---@class (exact) oil.ChangeAction
+---@field type "change"
+---@field entry_type oil.EntryType
+---@field url string
+---@field column string
+---@field value any
+
+---@param all_diffs table<integer, oil.Diff[]>
+---@return oil.Action[]
+M.create_actions_from_diffs = function(all_diffs)
+  ---@type oil.Action[]
+  local actions = {}
+
+  ---@type table<integer, oil.Diff[]>
+  local diff_by_id = setmetatable({}, {
+    __index = function(t, key)
+      local list = {}
+      rawset(t, key, list)
+      return list
+    end,
+  })
+
+  -- To deduplicate create actions
+  -- This can happen when creating deep nested files e.g.
+  -- > foo/bar/a.txt
+  -- > foo/bar/b.txt
+  local seen_creates = {}
+
+  ---@param action oil.Action
+  local function add_action(action)
+    local adapter = assert(config.get_adapter_by_scheme(action.dest_url or action.url))
+    if not adapter.filter_action or adapter.filter_action(action) then
+      if action.type == 'create' then
+        if seen_creates[action.url] then
+          return
+        else
+          seen_creates[action.url] = true
+        end
+      end
+
+      table.insert(actions, action)
+    end
+  end
+  for bufnr, diffs in pairs(all_diffs) do
+    local adapter = util.get_adapter(bufnr, true)
+    if not adapter then
+      error('Missing adapter')
+    end
+    local parent_url = vim.api.nvim_buf_get_name(bufnr)
+    for _, diff in ipairs(diffs) do
+      if diff.type == 'new' then
+        if diff.id then
+          local by_id = diff_by_id[diff.id]
+          ---HACK: set the destination on this diff for use later
+          ---@diagnostic disable-next-line: inject-field
+          diff.dest = parent_url .. diff.name
+          table.insert(by_id, diff)
+        else
+          -- Parse nested files like foo/bar/baz
+          local path_sep = fs.is_windows and '[/\\]' or '/'
+          local pieces = vim.split(diff.name, path_sep)
+          local url = parent_url:gsub('/$', '')
+          for i, v in ipairs(pieces) do
+            local is_last = i == #pieces
+            local entry_type = is_last and diff.entry_type or 'directory'
+            local alternation = v:match('{([^}]+)}')
+            if is_last and alternation then
+              -- Parse alternations like foo.{js,test.js}
+              for _, alt in ipairs(vim.split(alternation, ',')) do
+                local alt_url = url .. '/' .. v:gsub('{[^}]+}', alt)
+                add_action({
+                  type = 'create',
+                  url = alt_url,
+                  entry_type = entry_type,
+                  link = diff.link,
+                })
+              end
+            else
+              url = url .. '/' .. v
+              add_action({
+                type = 'create',
+                url = url,
+                entry_type = entry_type,
+                link = diff.link,
+              })
+            end
+          end
+        end
+      elseif diff.type == 'change' then
+        add_action({
+          type = 'change',
+          url = parent_url .. diff.name,
+          entry_type = diff.entry_type,
+          column = diff.column,
+          value = diff.value,
+        })
+      else
+        local by_id = diff_by_id[diff.id]
+        -- HACK: set has_delete field on a list-like table of diffs
+        ---@diagnostic disable-next-line: inject-field
+        by_id.has_delete = true
+        -- Don't insert the delete. We already know that there is a delete because of the presence
+        -- in the diff_by_id map. The list will only include the 'new' diffs.
+      end
+    end
+  end
+
+  for id, diffs in pairs(diff_by_id) do
+    local entry = cache.get_entry_by_id(id)
+    if not entry then
+      error(string.format('Could not find entry %d', id))
+    end
+    ---HACK: access the has_delete field on the list-like table of diffs
+    ---@diagnostic disable-next-line: undefined-field
+    if diffs.has_delete then
+      local has_create = #diffs > 0
+      if has_create then
+        -- MOVE (+ optional copies) when has both creates and delete
+        for i, diff in ipairs(diffs) do
+          add_action({
+            type = i == #diffs and 'move' or 'copy',
+            entry_type = entry[FIELD_TYPE],
+            ---HACK: access the dest field we set above
+            ---@diagnostic disable-next-line: undefined-field
+            dest_url = diff.dest,
+            src_url = cache.get_parent_url(id) .. entry[FIELD_NAME],
+          })
+        end
+      else
+        -- DELETE when no create
+        add_action({
+          type = 'delete',
+          entry_type = entry[FIELD_TYPE],
+          url = cache.get_parent_url(id) .. entry[FIELD_NAME],
+        })
+      end
+    else
+      -- COPY when create but no delete
+      for _, diff in ipairs(diffs) do
+        add_action({
+          type = 'copy',
+          entry_type = entry[FIELD_TYPE],
+          src_url = cache.get_parent_url(id) .. entry[FIELD_NAME],
+          ---HACK: access the dest field we set above
+          ---@diagnostic disable-next-line: undefined-field
+          dest_url = diff.dest,
+        })
+      end
+    end
+  end
+
+  return M.enforce_action_order(actions)
+end
+
+---@param actions oil.Action[]
+---@return oil.Action[]
+M.enforce_action_order = function(actions)
+  local src_trie = Trie.new()
+  local dest_trie = Trie.new()
+  for _, action in ipairs(actions) do
+    if action.type == 'delete' or action.type == 'change' then
+      src_trie:insert_action(action.url, action)
+    elseif action.type == 'create' then
+      dest_trie:insert_action(action.url, action)
+    else
+      dest_trie:insert_action(action.dest_url, action)
+      src_trie:insert_action(action.src_url, action)
+    end
+  end
+
+  -- 1. create a graph, each node points to all of its dependencies
+  -- 2. for each action, if not added, find it in the graph
+  -- 3. traverse through the graph until you reach a node that has no dependencies (leaf)
+  -- 4. append that action to the return value, and remove it from the graph
+  --   a. TODO optimization: check immediate parents to see if they have no dependencies now
+  -- 5. repeat
+
+  ---Gets the dependencies of a particular action. Effectively dynamically calculates the dependency
+  ---"edges" of the graph.
+  ---@param action oil.Action
+  local function get_deps(action)
+    local ret = {}
+    if action.type == 'delete' then
+      src_trie:accum_children_of(action.url, ret)
+    elseif action.type == 'create' then
+      -- Finish operating on parents first
+      -- e.g. NEW /a BEFORE NEW /a/b
+      dest_trie:accum_first_parents_of(action.url, ret)
+      -- Process remove path before creating new path
+      -- e.g. DELETE /a BEFORE NEW /a
+      src_trie:accum_actions_at(action.url, ret, function(a)
+        return a.type == 'move' or a.type == 'delete'
+      end)
+    elseif action.type == 'change' then
+      -- Finish operating on parents first
+      -- e.g. NEW /a BEFORE CHANGE /a/b
+      dest_trie:accum_first_parents_of(action.url, ret)
+      -- Finish operations on this path first
+      -- e.g. NEW /a BEFORE CHANGE /a
+      dest_trie:accum_actions_at(action.url, ret)
+      -- Finish copy from operations first
+      -- e.g. COPY /a -> /b BEFORE CHANGE /a
+      src_trie:accum_actions_at(action.url, ret, function(entry)
+        return entry.type == 'copy'
+      end)
+    elseif action.type == 'move' then
+      -- Finish operating on parents first
+      -- e.g. NEW /a BEFORE MOVE /z -> /a/b
+      dest_trie:accum_first_parents_of(action.dest_url, ret)
+      -- Process children before moving
+      -- e.g. NEW /a/b BEFORE MOVE /a -> /b
+      dest_trie:accum_children_of(action.src_url, ret)
+      -- Process children before moving parent dir
+      -- e.g. COPY /a/b -> /b BEFORE MOVE /a -> /d
+      -- e.g. CHANGE /a/b BEFORE MOVE /a -> /d
+      src_trie:accum_children_of(action.src_url, ret)
+      -- Process remove path before moving to new path
+      -- e.g. MOVE /a -> /b BEFORE MOVE /c -> /a
+      src_trie:accum_actions_at(action.dest_url, ret, function(a)
+        return a.type == 'move' or a.type == 'delete'
+      end)
+    elseif action.type == 'copy' then
+      -- Finish operating on parents first
+      -- e.g. NEW /a BEFORE COPY /z -> /a/b
+      dest_trie:accum_first_parents_of(action.dest_url, ret)
+      -- Process children before copying
+      -- e.g. NEW /a/b BEFORE COPY /a -> /b
+      dest_trie:accum_children_of(action.src_url, ret)
+      -- Process remove path before copying to new path
+      -- e.g. MOVE /a -> /b BEFORE COPY /c -> /a
+      src_trie:accum_actions_at(action.dest_url, ret, function(a)
+        return a.type == 'move' or a.type == 'delete'
+      end)
+    end
+    return ret
+  end
+
+  ---@return nil|oil.Action The leaf action
+  ---@return nil|oil.Action When no leaves found, this is the last action in the loop
+  local function find_leaf(action, seen)
+    if not seen then
+      seen = {}
+    elseif seen[action] then
+      return nil, action
+    end
+    seen[action] = true
+    local deps = get_deps(action)
+    if vim.tbl_isempty(deps) then
+      return action
+    end
+    local action_in_loop
+    for _, dep in ipairs(deps) do
+      local leaf, loop_action = find_leaf(dep, seen)
+      if leaf then
+        return leaf
+      elseif not action_in_loop and loop_action then
+        action_in_loop = loop_action
+      end
+    end
+    return nil, action_in_loop
+  end
+
+  local ret = {}
+  local after = {}
+  while not vim.tbl_isempty(actions) do
+    local action = actions[1]
+    local selected, loop_action = find_leaf(action)
+    local to_remove
+    if selected then
+      to_remove = selected
+    else
+      if loop_action and loop_action.type == 'move' then
+        -- If this is moving a parent into itself, that's an error
+        if vim.startswith(loop_action.dest_url, loop_action.src_url) then
+          error('Detected cycle in desired paths')
+        end
+
+        -- We've detected a move cycle (e.g. MOVE /a -> /b + MOVE /b -> /a)
+        -- Split one of the moves and retry
+        local intermediate_url =
+          string.format('%s__oil_tmp_%05d', loop_action.src_url, math.random(999999))
+        local move_1 = {
+          type = 'move',
+          entry_type = loop_action.entry_type,
+          src_url = loop_action.src_url,
+          dest_url = intermediate_url,
+        }
+        local move_2 = {
+          type = 'move',
+          entry_type = loop_action.entry_type,
+          src_url = intermediate_url,
+          dest_url = loop_action.dest_url,
+        }
+        to_remove = loop_action
+        table.insert(actions, move_1)
+        table.insert(after, move_2)
+        dest_trie:insert_action(move_1.dest_url, move_1)
+        src_trie:insert_action(move_1.src_url, move_1)
+      else
+        error('Detected cycle in desired paths')
+      end
+    end
+
+    if selected then
+      if selected.type == 'move' or selected.type == 'copy' then
+        if vim.startswith(selected.dest_url, selected.src_url .. '/') then
+          error(
+            string.format(
+              'Cannot move or copy parent into itself: %s -> %s',
+              selected.src_url,
+              selected.dest_url
+            )
+          )
+        end
+      end
+      table.insert(ret, selected)
+    end
+
+    if to_remove then
+      if to_remove.type == 'delete' or to_remove.type == 'change' then
+        src_trie:remove_action(to_remove.url, to_remove)
+      elseif to_remove.type == 'create' then
+        dest_trie:remove_action(to_remove.url, to_remove)
+      else
+        dest_trie:remove_action(to_remove.dest_url, to_remove)
+        src_trie:remove_action(to_remove.src_url, to_remove)
+      end
+      for i, a in ipairs(actions) do
+        if a == to_remove then
+          table.remove(actions, i)
+          break
+        end
+      end
+    end
+  end
+
+  vim.list_extend(ret, after)
+  return ret
+end
+
+local progress
+
+---@param actions oil.Action[]
+---@param cb fun(err: nil|string)
+M.process_actions = function(actions, cb)
+  vim.api.nvim_exec_autocmds(
+    'User',
+    { pattern = 'OilActionsPre', modeline = false, data = { actions = actions } }
+  )
+
+  local did_complete = nil
+  if config.lsp_file_methods.enabled then
+    did_complete = lsp_helpers.will_perform_file_operations(actions)
+  end
+
+  -- Convert some cross-adapter moves to a copy + delete
+  for _, action in ipairs(actions) do
+    if action.type == 'move' then
+      local _, cross_action = util.get_adapter_for_action(action)
+      -- Only do the conversion if the cross-adapter support is "copy"
+      if cross_action == 'copy' then
+        ---@diagnostic disable-next-line: assign-type-mismatch
+        action.type = 'copy'
+        table.insert(actions, {
+          type = 'delete',
+          url = action.src_url,
+          entry_type = action.entry_type,
+        })
+      end
+    end
+  end
+
+  local finished = false
+  progress = Progress.new()
+  local function finish(err)
+    if not finished then
+      finished = true
+      progress:close()
+      progress = nil
+      if config.cleanup_buffers_on_delete and not err then
+        for _, action in ipairs(actions) do
+          if action.type == 'delete' then
+            local scheme, path = util.parse_url(action.url)
+            if config.adapters[scheme] == 'files' then
+              assert(path)
+              local os_path = fs.posix_to_os_path(path)
+              local bufnr = vim.fn.bufnr(os_path)
+              if bufnr ~= -1 then
+                vim.api.nvim_buf_delete(bufnr, { force = true })
+              end
+            end
+          end
+        end
+      end
+      vim.api.nvim_exec_autocmds(
+        'User',
+        { pattern = 'OilActionsPost', modeline = false, data = { err = err, actions = actions } }
+      )
+      cb(err)
+    end
+  end
+
+  -- Defer showing the progress to avoid flicker for fast operations
+  vim.defer_fn(function()
+    if not finished then
+      progress:show({
+        -- TODO some actions are actually cancelable.
+        -- We should stop them instead of stopping after the current action
+        cancel = function()
+          finish('Canceled')
+        end,
+      })
+    end
+  end, 100)
+
+  local idx = 1
+  local next_action
+  next_action = function()
+    if finished then
+      return
+    end
+    if idx > #actions then
+      if did_complete then
+        did_complete()
+      end
+      finish()
+      return
+    end
+    local action = actions[idx]
+    progress:set_action(action, idx, #actions)
+    idx = idx + 1
+    local ok, adapter = pcall(util.get_adapter_for_action, action)
+    if not ok then
+      return finish(adapter)
+    end
+    local callback = vim.schedule_wrap(function(err)
+      if finished then
+        -- This can happen if the user canceled out of the progress window
+        return
+      elseif err then
+        finish(err)
+      else
+        cache.perform_action(action)
+        next_action()
+      end
+    end)
+    if action.type == 'change' then
+      ---@cast action oil.ChangeAction
+      columns.perform_change_action(adapter, action, callback)
+    else
+      adapter.perform_action(action, callback)
+    end
+  end
+  next_action()
+end
+
+M.show_progress = function()
+  if progress then
+    progress:restore()
+  end
+end
+
+local mutation_in_progress = false
+
+---@return boolean
+M.is_mutating = function()
+  return mutation_in_progress
+end
+
+---@param confirm nil|boolean
+---@param cb? fun(err: nil|string)
+M.try_write_changes = function(confirm, cb)
+  if not cb then
+    cb = function(_err) end
+  end
+  if mutation_in_progress then
+    cb('Cannot perform mutation when already in progress')
+    return
+  end
+  local current_buf = vim.api.nvim_get_current_buf()
+  local was_modified = vim.bo.modified
+  local buffers = view.get_all_buffers()
+  local all_diffs = {}
+  ---@type table<integer, oil.ParseError[]>
+  local all_errors = {}
+
+  mutation_in_progress = true
+  -- Lock the buffer to prevent race conditions from the user modifying them during parsing
+  view.lock_buffers()
+  for _, bufnr in ipairs(buffers) do
+    if vim.bo[bufnr].modified then
+      local diffs, errors = parser.parse(bufnr)
+      all_diffs[bufnr] = diffs
+      local adapter = assert(util.get_adapter(bufnr, true))
+      if adapter.filter_error then
+        errors = vim.tbl_filter(adapter.filter_error, errors)
+      end
+      if not vim.tbl_isempty(errors) then
+        all_errors[bufnr] = errors
+      end
+    end
+  end
+  local function unlock()
+    view.unlock_buffers()
+    -- The ":write" will set nomodified even if we cancel here, so we need to restore it
+    if was_modified then
+      vim.bo[current_buf].modified = true
+    end
+    mutation_in_progress = false
+  end
+
+  local ns = vim.api.nvim_create_namespace('Oil')
+  vim.diagnostic.reset(ns)
+  if not vim.tbl_isempty(all_errors) then
+    for bufnr, errors in pairs(all_errors) do
+      vim.diagnostic.set(ns, bufnr, errors)
+    end
+
+    -- Jump to an error
+    local curbuf = vim.api.nvim_get_current_buf()
+    if all_errors[curbuf] then
+      pcall(
+        vim.api.nvim_win_set_cursor,
+        0,
+        { all_errors[curbuf][1].lnum + 1, all_errors[curbuf][1].col }
+      )
+    else
+      local bufnr, errs = next(all_errors)
+      assert(bufnr)
+      assert(errs)
+      -- HACK: This is a workaround for the fact that we can't switch buffers in the middle of a
+      -- BufWriteCmd.
+      vim.schedule(function()
+        vim.api.nvim_win_set_buf(0, bufnr)
+        pcall(vim.api.nvim_win_set_cursor, 0, { errs[1].lnum + 1, errs[1].col })
+      end)
+    end
+    unlock()
+    cb('Error parsing oil buffers')
+    return
+  end
+
+  local actions = M.create_actions_from_diffs(all_diffs)
+  confirmation.show(actions, confirm, function(proceed)
+    if not proceed then
+      unlock()
+      cb('Canceled')
+      return
+    end
+
+    M.process_actions(
+      actions,
+      vim.schedule_wrap(function(err)
+        view.unlock_buffers()
+        if err then
+          err = string.format('[oil] Error applying actions: %s', err)
+          view.rerender_all_oil_buffers(nil, function()
+            cb(err)
+          end)
+        else
+          local current_entry = oil.get_cursor_entry()
+          if current_entry then
+            -- get the entry under the cursor and make sure the cursor stays on it
+            view.set_last_cursor(
+              vim.api.nvim_buf_get_name(0),
+              vim.split(current_entry.parsed_name or current_entry.name, '/')[1]
+            )
+          end
+          view.rerender_all_oil_buffers(nil, function(render_err)
+            vim.api.nvim_exec_autocmds(
+              'User',
+              { pattern = 'OilMutationComplete', modeline = false }
+            )
+            cb(render_err)
+          end)
+        end
+        mutation_in_progress = false
+      end)
+    )
+  end)
+end
+
+return M