diff --git a/.busted b/.busted
deleted file mode 100644
index f729b3e..0000000
--- a/.busted
+++ /dev/null
@@ -1,9 +0,0 @@
-return {
- _all = {
- lua = "nlua",
- },
- default = {
- ROOT = { "./spec/" },
- helper = "spec/minimal_init.lua",
- },
-}
diff --git a/.editorconfig b/.editorconfig
deleted file mode 100644
index b9de190..0000000
--- a/.editorconfig
+++ /dev/null
@@ -1,9 +0,0 @@
-root = true
-
-[*]
-insert_final_newline = true
-charset = utf-8
-
-[*.lua]
-indent_style = space
-indent_size = 2
diff --git a/.envrc b/.envrc
new file mode 100644
index 0000000..3550a30
--- /dev/null
+++ b/.envrc
@@ -0,0 +1 @@
+use flake
diff --git a/.github/ISSUE_TEMPLATE/bug_report.yaml b/.github/ISSUE_TEMPLATE/bug_report.yaml
deleted file mode 100644
index 61ca0f8..0000000
--- a/.github/ISSUE_TEMPLATE/bug_report.yaml
+++ /dev/null
@@ -1,80 +0,0 @@
-name: Bug Report
-description: Report a bug
-title: 'bug: '
-labels: [bug]
-body:
- - type: checkboxes
- attributes:
- label: Prerequisites
- options:
- - label:
- I have searched [existing
- issues](https://github.com/barrettruth/canola.nvim/issues)
- required: true
- - label: I have updated to the latest version
- required: true
-
- - type: textarea
- attributes:
- label: 'Neovim version'
- description: 'Output of `nvim --version`'
- render: text
- validations:
- required: true
-
- - type: input
- attributes:
- label: 'Operating system'
- placeholder: 'e.g. Arch Linux, macOS 15, Ubuntu 24.04'
- validations:
- required: true
-
- - type: textarea
- attributes:
- label: Description
- description: What happened? What did you expect?
- validations:
- required: true
-
- - type: textarea
- attributes:
- label: Steps to reproduce
- description: Minimal steps to trigger the bug
- value: |
- 1.
- 2.
- 3.
- validations:
- required: true
-
- - type: textarea
- attributes:
- label: 'Health check'
- description: 'Output of `:checkhealth canola`'
- render: text
-
- - type: textarea
- attributes:
- label: Minimal reproduction
- description: |
- Save the script below as `repro.lua`, edit if needed, and run:
- ```
- nvim -u repro.lua
- ```
- Confirm the bug reproduces with this config before submitting.
- render: lua
- value: |
- vim.env.LAZY_STDPATH = '.repro'
- load(vim.fn.system('curl -s https://raw.githubusercontent.com/folke/lazy.nvim/main/bootstrap.lua'))()
- require('lazy.nvim').setup({
- spec = {
- {
- 'barrettruth/canola.nvim',
- init = function()
- vim.g.canola = {}
- end,
- },
- },
- })
- validations:
- required: true
diff --git a/.github/ISSUE_TEMPLATE/bug_report.yml b/.github/ISSUE_TEMPLATE/bug_report.yml
new file mode 100644
index 0000000..327aaf2
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/bug_report.yml
@@ -0,0 +1,131 @@
+name: Bug Report
+description: File a bug/issue
+title: "bug: "
+labels: [bug]
+body:
+ - type: markdown
+ attributes:
+ value: |
+ Before reporting a bug, make sure to search [existing issues](https://github.com/stevearc/oil.nvim/issues)
+ - type: checkboxes
+ attributes:
+ label: Did you check the docs and existing issues?
+ options:
+ - label: I have read the docs
+ required: true
+ - label: I have searched the existing issues
+ required: true
+ - type: input
+ attributes:
+ label: "Neovim version (nvim -v)"
+ placeholder: "0.8.0 commit db1b0ee3b30f"
+ validations:
+ required: true
+ - type: input
+ attributes:
+ label: "Operating system/version"
+ placeholder: "MacOS 11.5"
+ validations:
+ required: true
+ - type: textarea
+ attributes:
+ label: Describe the bug
+ description: A clear and concise description of what the bug is. Please include any related errors you see in Neovim.
+ validations:
+ required: true
+ - type: dropdown
+ attributes:
+ label: What is the severity of this bug?
+ options:
+ - minor (annoyance)
+ - tolerable (can work around it)
+ - breaking (some functionality is broken)
+ - blocking (cannot use plugin)
+ validations:
+ required: true
+ - type: textarea
+ attributes:
+ label: Steps To Reproduce
+ description: Steps to reproduce the behavior.
+ placeholder: |
+ 1. nvim -u repro.lua
+ 2.
+ 3.
+ validations:
+ required: true
+ - type: textarea
+ attributes:
+ label: Expected Behavior
+ description: A concise description of what you expected to happen.
+ validations:
+ required: true
+ - type: textarea
+ attributes:
+ label: Directory structure
+ description: The structure of the directory used to reproduce the bug
+ placeholder: |
+ a/b/foo.txt
+ a/bar.md
+ a/c/baz.txt
+ validations:
+ required: false
+ - type: textarea
+ attributes:
+ label: Repro
+ description:
+ Minimal `init.lua` to reproduce this issue. Save as `repro.lua` and run with `nvim -u repro.lua`
+ This uses lazy.nvim (a plugin manager).
+ You can add your config with the `config` key the same way you can do with packer.nvim.
+ value: |
+ -- save as repro.lua
+ -- run with nvim -u repro.lua
+ -- DO NOT change the paths
+ local root = vim.fn.fnamemodify("./.repro", ":p")
+
+ -- set stdpaths to use .repro
+ for _, name in ipairs({ "config", "data", "state", "runtime", "cache" }) do
+ vim.env[("XDG_%s_HOME"):format(name:upper())] = root .. "/" .. name
+ end
+
+ -- bootstrap lazy
+ local lazypath = root .. "/plugins/lazy.nvim"
+ if not vim.loop.fs_stat(lazypath) then
+ vim.fn.system({
+ "git",
+ "clone",
+ "--filter=blob:none",
+ "--single-branch",
+ "https://github.com/folke/lazy.nvim.git",
+ lazypath,
+ })
+ end
+ vim.opt.runtimepath:prepend(lazypath)
+
+ -- install plugins
+ local plugins = {
+ "folke/tokyonight.nvim",
+ {
+ "stevearc/oil.nvim",
+ config = function()
+ require("oil").setup({
+ -- add any needed settings here
+ })
+ end,
+ },
+ -- add any other plugins here
+ }
+ require("lazy").setup(plugins, {
+ root = root .. "/plugins",
+ })
+
+ vim.cmd.colorscheme("tokyonight")
+ -- add anything else here
+ render: Lua
+ validations:
+ required: true
+ - type: checkboxes
+ attributes:
+ label: Did you check the bug with a clean config?
+ options:
+ - label: I have confirmed that the bug reproduces with `nvim -u repro.lua` using the repro.lua file above.
+ required: true
diff --git a/.github/ISSUE_TEMPLATE/config.yaml b/.github/ISSUE_TEMPLATE/config.yaml
deleted file mode 100644
index c1d9d46..0000000
--- a/.github/ISSUE_TEMPLATE/config.yaml
+++ /dev/null
@@ -1,5 +0,0 @@
-blank_issues_enabled: false
-contact_links:
- - name: Questions
- url: https://github.com/barrettruth/canola.nvim/discussions
- about: Ask questions and discuss ideas
diff --git a/.github/ISSUE_TEMPLATE/feature_request.yaml b/.github/ISSUE_TEMPLATE/feature_request.yaml
deleted file mode 100644
index 2a0fad8..0000000
--- a/.github/ISSUE_TEMPLATE/feature_request.yaml
+++ /dev/null
@@ -1,30 +0,0 @@
-name: Feature Request
-description: Suggest a feature
-title: 'feat: '
-labels: [enhancement]
-body:
- - type: checkboxes
- attributes:
- label: Prerequisites
- options:
- - label:
- I have searched [existing
- issues](https://github.com/barrettruth/canola.nvim/issues)
- required: true
-
- - type: textarea
- attributes:
- label: Problem
- description: What problem does this solve?
- validations:
- required: true
-
- - type: textarea
- attributes:
- label: Proposed solution
- validations:
- required: true
-
- - type: textarea
- attributes:
- label: Alternatives considered
diff --git a/.github/ISSUE_TEMPLATE/feature_request.yml b/.github/ISSUE_TEMPLATE/feature_request.yml
new file mode 100644
index 0000000..9916836
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/feature_request.yml
@@ -0,0 +1,43 @@
+name: Feature Request
+description: Submit a feature request
+title: "feature request: "
+labels: [enhancement]
+body:
+ - type: markdown
+ attributes:
+ value: |
+ Before submitting a feature request, make sure to search for [existing requests](https://github.com/stevearc/oil.nvim/issues)
+ - type: checkboxes
+ attributes:
+ label: Did you check existing requests?
+ options:
+ - label: I have searched the existing issues
+ required: true
+ - type: textarea
+ attributes:
+ label: Describe the feature
+ description: A short summary of the feature you want
+ validations:
+ required: true
+ - type: textarea
+ attributes:
+ label: Provide background
+ description: Describe the reasoning behind why you want the feature.
+ placeholder: I am trying to do X. My current workflow is Y.
+ validations:
+ required: false
+ - type: dropdown
+ attributes:
+ label: What is the significance of this feature?
+ options:
+ - nice to have
+ - strongly desired
+ - cannot use this plugin without it
+ validations:
+ required: true
+ - type: textarea
+ attributes:
+ label: Additional details
+ description: Any additional information you would like to provide. Things you've tried, alternatives considered, examples from other plugins, etc.
+ validations:
+ required: false
diff --git a/.github/scripts/upstream_digest.py b/.github/scripts/upstream_digest.py
deleted file mode 100644
index 2f0e949..0000000
--- a/.github/scripts/upstream_digest.py
+++ /dev/null
@@ -1,158 +0,0 @@
-#!/usr/bin/env python3
-import json
-import os
-import re
-import subprocess
-import sys
-from datetime import date, timedelta
-
-
-UPSTREAM = "stevearc/oil.nvim"
-UPSTREAM_MD = "doc/upstream.md"
-
-PRS_HEADING = "## Open upstream PRs"
-ISSUES_HEADING = "## Upstream issues"
-
-
-def get_last_tracked_number():
- try:
- with open(UPSTREAM_MD) as f:
- content = f.read()
- numbers = re.findall(
- r"\[#(\d+)\]\(https://github\.com/stevearc/oil\.nvim", content
- )
- if numbers:
- return max(int(n) for n in numbers)
- except OSError:
- pass
- return None
-
-
-def gh(*args):
- result = subprocess.run(
- ["gh"] + list(args),
- capture_output=True,
- text=True,
- check=True,
- )
- return result.stdout.strip()
-
-
-def fetch_items(last_number, since_date):
- merged_prs = json.loads(
- gh(
- "pr", "list",
- "--repo", UPSTREAM,
- "--state", "merged",
- "--limit", "100",
- "--json", "number,title,url",
- )
- )
- open_prs = json.loads(
- gh(
- "pr", "list",
- "--repo", UPSTREAM,
- "--state", "open",
- "--limit", "100",
- "--json", "number,title,createdAt,url",
- )
- )
- open_issues = json.loads(
- gh(
- "issue", "list",
- "--repo", UPSTREAM,
- "--state", "open",
- "--limit", "100",
- "--json", "number,title,createdAt,url",
- )
- )
-
- if last_number is not None:
- merged_prs = [x for x in merged_prs if x["number"] > last_number]
- open_prs = [x for x in open_prs if x["number"] > last_number]
- open_issues = [x for x in open_issues if x["number"] > last_number]
- else:
- cutoff = since_date.isoformat()
- merged_prs = []
- open_prs = [x for x in open_prs if x.get("createdAt", "") >= cutoff]
- open_issues = [x for x in open_issues if x.get("createdAt", "") >= cutoff]
-
- merged_prs.sort(key=lambda x: x["number"])
- open_prs.sort(key=lambda x: x["number"])
- open_issues.sort(key=lambda x: x["number"])
-
- return merged_prs, open_prs, open_issues
-
-
-def append_to_section(content, heading, new_rows):
- lines = content.split("\n")
- in_section = False
- last_table_row = -1
-
- for i, line in enumerate(lines):
- if line.startswith("## "):
- in_section = line.strip() == heading
- if in_section and line.startswith("|"):
- last_table_row = i
-
- if last_table_row == -1:
- return content
-
- return "\n".join(
- lines[: last_table_row + 1] + new_rows + lines[last_table_row + 1 :]
- )
-
-
-def main():
- last_number = get_last_tracked_number()
- since_date = date.today() - timedelta(days=30)
-
- merged_prs, open_prs, open_issues = fetch_items(last_number, since_date)
-
- total = len(merged_prs) + len(open_prs) + len(open_issues)
- if total == 0:
- print("No new upstream activity.")
- return
-
- with open(UPSTREAM_MD) as f:
- content = f.read()
-
- pr_rows = []
- for pr in open_prs:
- pr_rows.append(f"| [#{pr['number']}]({pr['url']}) | {pr['title']} | open |")
- for pr in merged_prs:
- pr_rows.append(
- f"| [#{pr['number']}]({pr['url']}) | {pr['title']} | merged — not cherry-picked |"
- )
-
- issue_rows = []
- for issue in open_issues:
- issue_rows.append(
- f"| [#{issue['number']}]({issue['url']}) | open | {issue['title']} |"
- )
-
- if pr_rows:
- content = append_to_section(content, PRS_HEADING, pr_rows)
- if issue_rows:
- content = append_to_section(content, ISSUES_HEADING, issue_rows)
-
- with open(UPSTREAM_MD, "w") as f:
- f.write(content)
-
- github_output = os.environ.get("GITHUB_OUTPUT")
- if github_output:
- with open(github_output, "a") as f:
- f.write("changed=true\n")
-
- print(
- f"Added {len(open_prs)} open PR(s), {len(merged_prs)} merged PR(s), "
- f"{len(open_issues)} issue(s) to {UPSTREAM_MD}"
- )
-
-
-if __name__ == "__main__":
- try:
- main()
- except subprocess.CalledProcessError as e:
- print(f"gh command failed: {e.stderr}", file=sys.stderr)
- sys.exit(1)
diff --git a/.github/workflows/automation_remove_question_label_on_comment.yml b/.github/workflows/automation_remove_question_label_on_comment.yml
index 36f9336..f99bba8 100644
--- a/.github/workflows/automation_remove_question_label_on_comment.yml
+++ b/.github/workflows/automation_remove_question_label_on_comment.yml
@@ -8,7 +8,7 @@ jobs:
# issues in my "needs triage" filter.
remove_question:
runs-on: ubuntu-latest
- if: github.event.sender.login != 'barrettruth'
+ if: github.event.sender.login != 'stevearc'
steps:
- uses: actions/checkout@v4
- uses: actions-ecosystem/action-remove-labels@v1
diff --git a/.github/workflows/install_nvim.sh b/.github/workflows/install_nvim.sh
new file mode 100644
index 0000000..9ba2d26
--- /dev/null
+++ b/.github/workflows/install_nvim.sh
@@ -0,0 +1,16 @@
+#!/bin/bash
+set -e
+version="${NVIM_TAG-stable}"
+dl_name="nvim-linux-x86_64.appimage"
+# The appimage name changed in v0.10.4
+if python -c 'from packaging.version import Version; import sys; sys.exit(not (Version(sys.argv[1]) < Version("v0.10.4")))' "$version" 2>/dev/null; then
+ dl_name="nvim.appimage"
+fi
+curl -sL "https://github.com/neovim/neovim/releases/download/${version}/${dl_name}" -o nvim.appimage
+chmod +x nvim.appimage
+./nvim.appimage --appimage-extract >/dev/null
+rm -f nvim.appimage
+mkdir -p ~/.local/share/nvim
+mv squashfs-root ~/.local/share/nvim/appimage
+sudo ln -s "$HOME/.local/share/nvim/appimage/AppRun" /usr/bin/nvim
+/usr/bin/nvim --version
diff --git a/.github/workflows/luarocks.yaml b/.github/workflows/luarocks.yaml
index 9b6664e..4dc366c 100644
--- a/.github/workflows/luarocks.yaml
+++ b/.github/workflows/luarocks.yaml
@@ -7,7 +7,7 @@ on:
jobs:
quality:
- uses: ./.github/workflows/quality.yaml
+ uses: ./.github/workflows/tests.yml
publish:
needs: quality
diff --git a/.github/workflows/mirror_upstream_prs.yml b/.github/workflows/mirror_upstream_prs.yml
new file mode 100644
index 0000000..af9cdb0
--- /dev/null
+++ b/.github/workflows/mirror_upstream_prs.yml
@@ -0,0 +1,85 @@
+name: Mirror Upstream PRs
+on:
+ schedule:
+ - cron: "0 8 * * *"
+ workflow_dispatch:
+
+permissions:
+ issues: write
+
+jobs:
+ mirror:
+ runs-on: ubuntu-latest
+ steps:
+ - name: Mirror new upstream PRs
+ uses: actions/github-script@v7
+ with:
+ github-token: ${{ secrets.GITHUB_TOKEN }}
+ script: |
+ const upstream = { owner: 'stevearc', repo: 'oil.nvim' };
+ const fork = { owner: 'barrettruth', repo: 'oil.nvim' };
+
+ const since = new Date();
+ since.setDate(since.getDate() - 1);
+ const sinceISO = since.toISOString();
+
+ const { data: prs } = await github.rest.pulls.list({
+ ...upstream,
+ state: 'open',
+ sort: 'created',
+ direction: 'desc',
+ per_page: 30,
+ });
+
+ const recentPRs = prs.filter(pr => {
+ if (new Date(pr.created_at) < since) return false;
+ if (pr.user.login === 'dependabot[bot]') return false;
+ if (pr.user.login === 'dependabot-preview[bot]') return false;
+ return true;
+ });
+
+ if (recentPRs.length === 0) {
+ console.log('No new upstream PRs in the last 24 hours.');
+ return;
+ }
+
+ const { data: existingIssues } = await github.rest.issues.listForRepo({
+ ...fork,
+ state: 'all',
+ labels: 'upstream/pr',
+ per_page: 100,
+ });
+
+ const mirroredNumbers = new Set();
+ for (const issue of existingIssues) {
+ const match = issue.title.match(/^upstream#(\d+)/);
+ if (match) mirroredNumbers.add(parseInt(match[1]));
+ }
+
+ for (const pr of recentPRs) {
+ if (mirroredNumbers.has(pr.number)) {
+ console.log(`Skipping PR #${pr.number} — already mirrored.`);
+ continue;
+ }
+
+ const labels = pr.labels.map(l => l.name).join(', ') || 'none';
+
+ await github.rest.issues.create({
+ ...fork,
+ title: `upstream#${pr.number}: ${pr.title}`,
+ body: [
+ `Mirrored from [stevearc/oil.nvim#${pr.number}](${pr.html_url}).`,
+ '',
+ `**Author:** @${pr.user.login}`,
+ `**Labels:** ${labels}`,
+ `**Created:** ${pr.created_at}`,
+ '',
+ '---',
+ '',
+ pr.body || '*No description provided.*',
+ ].join('\n'),
+ labels: ['upstream/pr'],
+ });
+
+ console.log(`Created issue for upstream PR #${pr.number}: ${pr.title}`);
+ }
diff --git a/.github/workflows/quality.yaml b/.github/workflows/quality.yaml
deleted file mode 100644
index f1c28fb..0000000
--- a/.github/workflows/quality.yaml
+++ /dev/null
@@ -1,73 +0,0 @@
-name: quality
-
-on:
- workflow_call:
- pull_request:
- branches: [main]
- push:
- branches: [main, ci/upstream-digest]
-
-jobs:
- changes:
- runs-on: ubuntu-latest
- outputs:
- lua: ${{ steps.changes.outputs.lua }}
- markdown: ${{ steps.changes.outputs.markdown }}
- steps:
- - uses: actions/checkout@v4
- - uses: dorny/paths-filter@v3
- id: changes
- with:
- filters: |
- lua:
- - 'lua/**'
- - 'plugin/**'
- - 'spec/**'
- - '*.lua'
- - '.luarc.json'
- - '*.toml'
- - 'vim.yaml'
- markdown:
- - '*.md'
-
- lua-format:
- name: Lua Format Check
- runs-on: ubuntu-latest
- needs: changes
- if: ${{ needs.changes.outputs.lua == 'true' }}
- steps:
- - uses: actions/checkout@v4
- - uses: cachix/install-nix-action@v31
- - run: nix develop --command stylua --check lua spec
-
- lua-lint:
- name: Lua Lint Check
- runs-on: ubuntu-latest
- needs: changes
- if: ${{ needs.changes.outputs.lua == 'true' }}
- steps:
- - uses: actions/checkout@v4
- - uses: cachix/install-nix-action@v31
- - run: nix develop --command selene --display-style quiet .
-
- lua-typecheck:
- name: Lua Type Check
- runs-on: ubuntu-latest
- needs: changes
- if: ${{ needs.changes.outputs.lua == 'true' }}
- steps:
- - uses: actions/checkout@v4
- - uses: stevearc/nvim-typecheck-action@v2
- with:
- path: lua
- luals-version: 3.16.4
-
- markdown-format:
- name: Markdown Format Check
- runs-on: ubuntu-latest
- needs: changes
- if: ${{ needs.changes.outputs.markdown == 'true' }}
- steps:
- - uses: actions/checkout@v4
- - uses: cachix/install-nix-action@v31
- - run: nix develop --command prettier --check .
diff --git a/.github/workflows/test.yaml b/.github/workflows/test.yaml
deleted file mode 100644
index 7950fc7..0000000
--- a/.github/workflows/test.yaml
+++ /dev/null
@@ -1,22 +0,0 @@
-name: test
-
-on:
- pull_request:
- branches: [main]
- push:
- branches: [main, ci/upstream-digest]
-
-jobs:
- test:
- runs-on: ubuntu-latest
- strategy:
- fail-fast: false
- matrix:
- nvim: [stable, nightly]
- name: Test (Neovim ${{ matrix.nvim }})
- steps:
- - uses: actions/checkout@v4
-
- - uses: nvim-neorocks/nvim-busted-action@v1
- with:
- nvim_version: ${{ matrix.nvim }}
diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
new file mode 100644
index 0000000..8b1cc58
--- /dev/null
+++ b/.github/workflows/tests.yml
@@ -0,0 +1,65 @@
+name: Tests
+
+on:
+ workflow_call:
+ push:
+ branches:
+ - main
+ pull_request:
+ branches:
+ - main
+
+jobs:
+ selene:
+ name: Selene
+ runs-on: ubuntu-22.04
+ steps:
+ - uses: actions/checkout@v4
+ - uses: NTBBloodbath/selene-action@v1.0.0
+ with:
+ args: --display-style quiet .
+
+ stylua:
+ name: StyLua
+ runs-on: ubuntu-22.04
+ steps:
+ - uses: actions/checkout@v4
+ - name: Stylua
+ uses: JohnnyMorganz/stylua-action@v4
+ with:
+ token: ${{ secrets.GITHUB_TOKEN }}
+ version: v2.0.2
+ args: --check lua tests
+
+ typecheck:
+ name: typecheck
+ runs-on: ubuntu-22.04
+ steps:
+ - uses: actions/checkout@v4
+ - uses: stevearc/nvim-typecheck-action@v2
+ with:
+ path: lua
+
+ run_tests:
+ strategy:
+ matrix:
+ include:
+ - nvim_tag: v0.8.3
+ - nvim_tag: v0.9.4
+ - nvim_tag: v0.10.4
+ - nvim_tag: v0.11.0
+
+ name: Run tests
+ runs-on: ubuntu-22.04
+ env:
+ NVIM_TAG: ${{ matrix.nvim_tag }}
+ steps:
+ - uses: actions/checkout@v4
+
+ - name: Install Neovim and dependencies
+ run: |
+ bash ./.github/workflows/install_nvim.sh
+
+ - name: Run tests
+ run: |
+ bash ./run_tests.sh
diff --git a/.github/workflows/upstream-digest.yaml b/.github/workflows/upstream-digest.yaml
deleted file mode 100644
index 17020d4..0000000
--- a/.github/workflows/upstream-digest.yaml
+++ /dev/null
@@ -1,50 +0,0 @@
-name: upstream digest
-
-on:
- schedule:
- - cron: '0 9 * * 1'
- workflow_dispatch:
-
-permissions:
- contents: write
- pull-requests: write
-
-jobs:
- digest:
- runs-on: ubuntu-latest
- steps:
- - uses: actions/checkout@v4
-
- - name: Update upstream tracker
- id: digest
- env:
- GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
- run: python3 .github/scripts/upstream_digest.py
-
- - name: Format doc/upstream.md
- if: steps.digest.outputs.changed == 'true'
- run: npx --yes prettier --write doc/upstream.md
-
- - name: Push and open PR if needed
- if: steps.digest.outputs.changed == 'true'
- env:
- GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
- run: |
- BRANCH="ci/upstream-digest"
- git config user.name "github-actions[bot]"
- git config user.email "github-actions[bot]@users.noreply.github.com"
- git checkout -b "${BRANCH}"
- git add doc/upstream.md
- git commit -m "docs(upstream): upstream digest $(date +%Y-%m-%d)"
- git config --unset http.https://github.com/.extraheader
- git remote set-url origin "https://x-access-token:${{ secrets.DIGEST_PAT }}@github.com/barrettruth/canola.nvim.git"
- git push --force origin "${BRANCH}"
- if ! GH_TOKEN="${{ secrets.GITHUB_TOKEN }}" gh pr list --head "${BRANCH}" --state open --json number --jq '.[0].number' | grep -q .; then
- PR_URL=$(GH_TOKEN="${{ secrets.GITHUB_TOKEN }}" gh pr create \
- --title "docs(upstream): upstream digest" \
- --body "Automated weekly digest of new upstream activity. Triage by updating statuses and notes." \
- --base main \
- --head "${BRANCH}")
- GH_TOKEN="${{ secrets.DIGEST_PAT }}" gh pr review "${PR_URL}" --approve
- gh pr merge "${PR_URL}" --auto --squash
- fi
diff --git a/.gitignore b/.gitignore
index 6cb6d15..c3b7755 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,14 +1,48 @@
-doc/tags
-doc/upstream.html
-*.log
-.*cache*
-CLAUDE.md
-.claude/
-node_modules/
+# Compiled Lua sources
+luac.out
+
+# luarocks build files
+*.src.rock
+*.zip
+*.tar.gz
+
+# Object files
+*.o
+*.os
+*.ko
+*.obj
+*.elf
+
+# Precompiled Headers
+*.gch
+*.pch
+
+# Libraries
+*.lib
+*.a
+*.la
+*.lo
+*.def
+*.exp
+
+# Shared objects (inc. Windows DLLs)
+*.dll
+*.so
+*.so.*
+*.dylib
+
+# Executables
+*.exe
+*.out
+*.app
+*.i*86
+*.x86_64
+*.hex
+
.direnv/
-.envrc
-venv/
-perf/tmp/
+.testenv/
+doc/tags
+scripts/nvim-typecheck-action
scripts/benchmark.nvim
+perf/tmp/
profile.json
-.worktrees/
diff --git a/.gitmodules b/.gitmodules
new file mode 100644
index 0000000..e69de29
diff --git a/.luarc.json b/.luarc.json
index 78a7d8a..68da2f2 100644
--- a/.luarc.json
+++ b/.luarc.json
@@ -3,14 +3,7 @@
"version": "LuaJIT",
"pathStrict": true
},
- "workspace": {
- "checkThirdParty": false,
- "ignoreDir": [".direnv"]
- },
"type": {
"checkTableShape": true
- },
- "completion": {
- "callSnippet": "Replace"
}
}
diff --git a/.prettierrc b/.prettierrc
deleted file mode 100644
index 0663621..0000000
--- a/.prettierrc
+++ /dev/null
@@ -1,9 +0,0 @@
-{
- "proseWrap": "always",
- "printWidth": 80,
- "tabWidth": 2,
- "useTabs": false,
- "trailingComma": "none",
- "semi": false,
- "singleQuote": true
-}
diff --git a/.stylua.toml b/.stylua.toml
index 01ded03..020ce91 100644
--- a/.stylua.toml
+++ b/.stylua.toml
@@ -1,8 +1,5 @@
column_width = 100
-line_endings = "Unix"
indent_type = "Spaces"
indent_width = 2
-quote_style = "AutoPreferSingle"
-call_parentheses = "Always"
[sort_requires]
enabled = true
diff --git a/.styluaignore b/.styluaignore
deleted file mode 100644
index 9b42106..0000000
--- a/.styluaignore
+++ /dev/null
@@ -1 +0,0 @@
-.direnv/
diff --git a/LICENSE b/LICENSE
index ccff038..4928e96 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,7 +1,6 @@
MIT License
Copyright (c) 2022 Steven Arcangeli
-Copyright (c) 2025 Barrett Ruth
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..db15dd5
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,48 @@
+## help: print this help message
+.PHONY: help
+help:
+ @echo 'Usage:'
+ @sed -n 's/^##//p' ${MAKEFILE_LIST} | column -t -s ':' | sed -e 's/^/ /'
+
+## all: lint and run tests
+.PHONY: all
+all: lint test
+
+## test: run tests
+.PHONY: test
+test:
+ ./run_tests.sh
+
+## lint: run linters and LuaLS typechecking
+.PHONY: lint
+lint: scripts/nvim-typecheck-action
+ ./scripts/nvim-typecheck-action/typecheck.sh --workdir scripts/nvim-typecheck-action lua
+ selene --display-style quiet .
+ stylua --check lua tests
+
+## profile: use LuaJIT profiler to profile the plugin
+.PHONY: profile
+profile: scripts/benchmark.nvim
+ nvim --clean -u perf/bootstrap.lua -c 'lua jit_profile()'
+
+## flame_profile: create a trace in the chrome profiler format
+.PHONY: flame_profile
+flame_profile: scripts/benchmark.nvim
+ nvim --clean -u perf/bootstrap.lua -c 'lua flame_profile()'
+
+## benchmark: benchmark performance opening directory with many files
+.PHONY: benchmark
+benchmark: scripts/benchmark.nvim
+ nvim --clean -u perf/bootstrap.lua -c 'lua benchmark()'
+ @cat perf/tmp/benchmark.txt
+
+scripts/nvim-typecheck-action:
+ git clone https://github.com/stevearc/nvim-typecheck-action scripts/nvim-typecheck-action
+
+scripts/benchmark.nvim:
+ git clone https://github.com/stevearc/benchmark.nvim scripts/benchmark.nvim
+
+## clean: reset the repository to a clean state
+.PHONY: clean
+clean:
+ rm -rf scripts/nvim-typecheck-action .testenv perf/tmp profile.json
diff --git a/README.md b/README.md
index 122216e..3792191 100644
--- a/README.md
+++ b/README.md
@@ -1,108 +1,145 @@
-# canola.nvim
+# oil.nvim
-A refined [oil.nvim](https://github.com/stevearc/oil.nvim) — edit your
-filesystem like a buffer, with bug fixes and community PRs that haven't landed
-upstream.
-
-[Upstream tracker](doc/upstream.md) — full PR and issue triage against
-[oil.nvim](https://github.com/stevearc/oil.nvim)
+A [vim-vinegar](https://github.com/tpope/vim-vinegar) like file explorer that lets you edit your filesystem like a normal Neovim buffer.
https://user-images.githubusercontent.com/506791/209727111-6b4a11f4-634a-4efa-9461-80e9717cea94.mp4
-## Features
+This is a maintained fork of [stevearc/oil.nvim](https://github.com/stevearc/oil.nvim)
+with cherry-picked upstream PRs and original bug fixes that haven't landed
+upstream yet.
-- Edit directory listings as normal buffers — mutations are derived by diffing
-- Cross-directory move, copy, and rename across any adapter
-- Adapters for local filesystem, SSH, S3, and OS trash
-- File preview in split or floating window
-- Configurable columns (icon, size, permissions, timestamps)
-- Executable file highlighting and filetype-aware icons
-- Floating window and split layouts
+
+Changes from upstream
+
+### PRs
+
+Upstream PRs cherry-picked or adapted into this fork.
+
+| PR | Description | Commit |
+|---|---|---|
+| [#495](https://github.com/stevearc/oil.nvim/pull/495) | Cancel visual/operator-pending mode on close instead of closing buffer | [`16f3d7b`](https://github.com/barrettruth/oil.nvim/commit/16f3d7b) |
+| [#537](https://github.com/stevearc/oil.nvim/pull/537) | Configurable file and directory creation permissions (`new_file_mode`, `new_dir_mode`) | [`c6b4a7a`](https://github.com/barrettruth/oil.nvim/commit/c6b4a7a) |
+| [#578](https://github.com/stevearc/oil.nvim/issues/578) | Recipe to disable hidden file dimming by relinking `Oil*Hidden` groups | [`38db6cf`](https://github.com/barrettruth/oil.nvim/commit/38db6cf) |
+| [#618](https://github.com/stevearc/oil.nvim/pull/618) | Opt-in filetype detection for icons via `use_slow_filetype_detection` | [`ded1725`](https://github.com/barrettruth/oil.nvim/commit/ded1725) |
+| [#644](https://github.com/stevearc/oil.nvim/pull/644) | Pass full entry to `is_hidden_file` and `is_always_hidden` callbacks | [`4ab4765`](https://github.com/barrettruth/oil.nvim/commit/4ab4765) |
+| [#645](https://github.com/stevearc/oil.nvim/pull/645) | Add `close_float` action (close only floating oil windows) | [`f6bcdda`](https://github.com/barrettruth/oil.nvim/commit/f6bcdda) |
+| [#690](https://github.com/stevearc/oil.nvim/pull/690) | Add `OilFileIcon` highlight group as fallback for unrecognized icons | [`ce64ae1`](https://github.com/barrettruth/oil.nvim/commit/ce64ae1) |
+| [#697](https://github.com/stevearc/oil.nvim/pull/697) | Recipe for custom file extension column with sorting | [`dcb3a08`](https://github.com/barrettruth/oil.nvim/commit/dcb3a08) |
+| [#698](https://github.com/stevearc/oil.nvim/pull/698) | Executable file highlighting (`OilExecutable`, `OilExecutableHidden`) | [`41556ec`](https://github.com/barrettruth/oil.nvim/commit/41556ec), [`85ed9b8`](https://github.com/barrettruth/oil.nvim/commit/85ed9b8) |
+| [#717](https://github.com/stevearc/oil.nvim/pull/717) | Add malewicz1337/oil-git.nvim to third-party extensions | [`582d9fc`](https://github.com/barrettruth/oil.nvim/commit/582d9fc) |
+| [#720](https://github.com/stevearc/oil.nvim/pull/720) | Gate `BufAdd` autocmd behind `default_file_explorer` check | [`2228f80`](https://github.com/barrettruth/oil.nvim/commit/2228f80) |
+| [#722](https://github.com/stevearc/oil.nvim/pull/722) | Fix dead freedesktop trash specification URL | [`b92ecb0`](https://github.com/barrettruth/oil.nvim/commit/b92ecb0) |
+| [#723](https://github.com/stevearc/oil.nvim/pull/723) | Emit `OilReadPost` user event after every buffer render | [`29239d5`](https://github.com/barrettruth/oil.nvim/commit/29239d5) |
+| [#725](https://github.com/stevearc/oil.nvim/pull/725) | Normalize keymap keys before config merge (`` = ``) | [`723145c`](https://github.com/barrettruth/oil.nvim/commit/723145c) |
+| [#727](https://github.com/stevearc/oil.nvim/pull/727) | Clarify `get_current_dir` nil return and add Telescope recipe | [`eed6697`](https://github.com/barrettruth/oil.nvim/commit/eed6697) |
+
+### Issues
+
+Upstream issues triaged against this fork.
+
+| Issue | Status | Resolution |
+|---|---|---|
+| [#446](https://github.com/stevearc/oil.nvim/issues/446) | resolved | Executable highlighting — implemented by PR [#698](https://github.com/stevearc/oil.nvim/pull/698) |
+| [#483](https://github.com/stevearc/oil.nvim/issues/483) | not actionable | Spell downloads depend on netrw — fixed in neovim ([neovim#34940](https://github.com/neovim/neovim/pull/34940)) |
+| [#492](https://github.com/stevearc/oil.nvim/issues/492) | not actionable | Question — j/k remapping, answered in comments |
+| [#533](https://github.com/stevearc/oil.nvim/issues/533) | not actionable | `constrain_cursor` — needs repro from reporter |
+| [#587](https://github.com/stevearc/oil.nvim/issues/587) | not actionable | Alt+h keymap — user config issue |
+| [#623](https://github.com/stevearc/oil.nvim/issues/623) | not actionable | bufferline.nvim interaction — cross-plugin issue |
+| [#624](https://github.com/stevearc/oil.nvim/issues/624) | not actionable | Mutation-in-progress race — no reliable repro |
+| [#632](https://github.com/stevearc/oil.nvim/issues/632) | fixed | Preview + move = copy — [`fe16993`](https://github.com/barrettruth/oil.nvim/commit/fe16993) |
+| [#642](https://github.com/stevearc/oil.nvim/issues/642) | fixed | W10 warning under `nvim -R` — [`ca834cf`](https://github.com/barrettruth/oil.nvim/commit/ca834cf) |
+| [#664](https://github.com/stevearc/oil.nvim/issues/664) | not actionable | Extra buffer on session reload — no repro |
+| [#670](https://github.com/stevearc/oil.nvim/issues/670) | fixed | Multi-directory cmdline — [`70861e5`](https://github.com/barrettruth/oil.nvim/commit/70861e5) |
+| [#673](https://github.com/stevearc/oil.nvim/issues/673) | fixed | Symlink newlines crash — [`9110a1a`](https://github.com/barrettruth/oil.nvim/commit/9110a1a) |
+| [#679](https://github.com/stevearc/oil.nvim/issues/679) | resolved | Executable file sign — implemented by PR [#698](https://github.com/stevearc/oil.nvim/pull/698) |
+| [#692](https://github.com/stevearc/oil.nvim/issues/692) | resolved | Keymap normalization — fixed by PR [#725](https://github.com/stevearc/oil.nvim/pull/725) |
+| [#710](https://github.com/stevearc/oil.nvim/issues/710) | fixed | buftype empty on BufEnter — [`01b860e`](https://github.com/barrettruth/oil.nvim/commit/01b860e) |
+| [#714](https://github.com/stevearc/oil.nvim/issues/714) | not actionable | Support question — already answered |
+| [#719](https://github.com/stevearc/oil.nvim/issues/719) | not actionable | Neovim crash on node_modules delete — libuv/neovim bug |
+| [#726](https://github.com/stevearc/oil.nvim/issues/726) | not actionable | Meta discussion/roadmap |
+
+
## Requirements
-- Neovim 0.10+
-- (Optionally) any of the following icon providers:
- - [mini.icons](https://github.com/nvim-mini/mini.nvim/blob/main/readmes/mini-icons.md)
- - [nvim-web-devicons](https://github.com/nvim-tree/nvim-web-devicons)
- - [nonicons.nvim](https://github.com/barrettruth/nonicons.nvim)
+Neovim 0.8+ and optionally [mini.icons](https://github.com/nvim-mini/mini.nvim/blob/main/readmes/mini-icons.md) or [nvim-web-devicons](https://github.com/nvim-tree/nvim-web-devicons) for file icons.
## Installation
-Install with your package manager of choice or via
-[luarocks](https://luarocks.org/modules/barrettruth/canola.nvim):
+Install with your favorite package manager or with luarocks:
-```
-luarocks install canola.nvim
+```console
+luarocks install oil.nvim
```
## Documentation
```vim
-:help canola.nvim
+:help oil.nvim
```
## FAQ
-**Q: How do I migrate from `stevearc/oil.nvim`?**
+**Q: How do I migrate from `stevearc/oil.nvim` to `barrettruth/oil.nvim`?**
-Change the plugin source and replace `setup()` with `vim.g.canola` in `init`.
-The configuration table is identical — only the entry point changes. For
-example, with [lazy.nvim](https://github.com/folke/lazy.nvim):
-
-Before (`stevearc/oil.nvim`):
+Replace your `setup()` call with a `vim.g.oil` assignment. For example, with
+[lazy.nvim](https://github.com/folke/lazy.nvim):
```lua
+-- before
{
'stevearc/oil.nvim',
- opts = { ... },
config = function(_, opts)
- require('canola').setup(opts)
+ require('oil').setup(opts)
end,
+ opts = {
+ ...
+ }
}
-```
-After (`barrettruth/canola.nvim`):
-
-```lua
+-- after
{
- 'barrettruth/canola.nvim',
+ 'barrettruth/oil.nvim',
init = function()
- vim.g.canola = { ... }
+ vim.g.oil = {
+ columns = { "icon", "size" },
+ delete_to_trash = true,
+ }
end,
}
```
-`init` runs before the plugin loads; `config` runs after. oil.nvim reads
-`vim.g.canola` at load time, so `init` is the correct hook. Do not use `config`,
-`opts`, or `lazy` — oil.nvim loads itself when you open a directory.
-
-**Q: Why "canola"?**
-
-Canola oil! But...
-
**Q: Why "oil"?**
-From the [vim-vinegar](https://github.com/tpope/vim-vinegar) README, a quote by
-Drew Neil:
+**A:** From the [vim-vinegar](https://github.com/tpope/vim-vinegar) README, a quote by Drew Neil:
> Split windows and the project drawer go together like oil and vinegar
+Vinegar was taken. Let's be oil.
+Plus, I think it's pretty slick ;)
+
+**Q: Why would I want to use oil vs any other plugin?**
+
+**A:**
+
+- You like to use a netrw-like view to browse directories (as opposed to a file tree)
+- AND you want to be able to edit your filesystem like a buffer
+- AND you want to perform cross-directory actions. AFAIK there is no other plugin that does this. (update: [mini.files](https://github.com/nvim-mini/mini.nvim/blob/main/readmes/mini-files.md) also offers this functionality)
+
+If you don't need those features specifically, check out the alternatives listed below
+
+**Q: Can oil display files as a tree view?**
+
+**A:** No. A tree view would require a completely different methodology, necessitating a complete rewrite.
+
**Q: What are some alternatives?**
-- [stevearc/oil.nvim](https://github.com/stevearc/oil.nvim): the original
-- [mini.files](https://github.com/nvim-mini/mini.nvim/blob/main/readmes/mini-files.md):
- cross-directory filesystem-as-buffer with a column view
-- [vim-vinegar](https://github.com/tpope/vim-vinegar): the granddaddy of
- single-directory file browsing
-- [dirbuf.nvim](https://github.com/elihunter173/dirbuf.nvim): filesystem as
- buffer without cross-directory edits
-- [lir.nvim](https://github.com/tamago324/lir.nvim): vim-vinegar style with
- Neovim integration
-- [vim-dirvish](https://github.com/justinmk/vim-dirvish): stable, simple
- directory browser
+**A:**
-## Acknowledgements
-
-- [stevearc](https://github.com/stevearc):
- [oil.nvim](https://github.com/stevearc/oil.nvim)
+- [the original](https://github.com/stevearc/oil.nvim): the lesser-maintained but
+ official `oil.nvim`
+- [mini.files](https://github.com/nvim-mini/mini.nvim/blob/main/readmes/mini-files.md): Also supports cross-directory filesystem-as-buffer edits with a column view.
+- [vim-vinegar](https://github.com/tpope/vim-vinegar): The granddaddy of single-directory file browsing.
+- [dirbuf.nvim](https://github.com/elihunter173/dirbuf.nvim): Edit filesystem like a buffer, but no cross-directory edits.
+- [lir.nvim](https://github.com/tamago324/lir.nvim): Similar to vim-vinegar with better Neovim integration.
+- [vim-dirvish](https://github.com/justinmk/vim-dirvish): Stable, simple directory browser.
diff --git a/canola.nvim-scm-1.rockspec b/canola.nvim-scm-1.rockspec
deleted file mode 100644
index 988d6a2..0000000
--- a/canola.nvim-scm-1.rockspec
+++ /dev/null
@@ -1,30 +0,0 @@
-rockspec_format = '3.0'
-package = 'canola.nvim'
-version = 'scm-1'
-
-source = {
- url = 'git+https://github.com/barrettruth/canola.nvim.git',
-}
-
-description = {
- summary = 'Neovim file explorer: edit your filesystem like a buffer',
- homepage = 'https://github.com/barrettruth/canola.nvim',
- license = 'MIT',
-}
-
-dependencies = {
- 'lua >= 5.1',
-}
-
-test_dependencies = {
- 'nlua',
- 'busted >= 2.1.1',
-}
-
-test = {
- type = 'busted',
-}
-
-build = {
- type = 'builtin',
-}
diff --git a/doc/canola.txt b/doc/oil.txt
similarity index 66%
rename from doc/canola.txt
rename to doc/oil.txt
index bd302f0..431eff1 100644
--- a/doc/canola.txt
+++ b/doc/oil.txt
@@ -1,38 +1,38 @@
-*canola.txt*
-*Canola* *canola* *canola.nvim*
+*oil.txt*
+*Oil* *oil* *oil.nvim*
--------------------------------------------------------------------------------
-CONTENTS *canola-contents*
+CONTENTS *oil-contents*
- 1. Introduction |canola-introduction|
- 2. Requirements |canola-requirements|
- 3. Config |canola-config|
- 4. Options |canola-options|
- 5. Api |canola-api|
- 6. Columns |canola-columns|
- 7. Actions |canola-actions|
- 8. Highlights |canola-highlights|
- 9. Adapters |canola-adapters|
- 10. Recipes |canola-recipes|
- 11. Events |canola-events|
- 12. Trash |canola-trash|
+ 1. Introduction |oil-introduction|
+ 2. Requirements |oil-requirements|
+ 3. Config |oil-config|
+ 4. Options |oil-options|
+ 5. Api |oil-api|
+ 6. Columns |oil-columns|
+ 7. Actions |oil-actions|
+ 8. Highlights |oil-highlights|
+ 9. Adapters |oil-adapters|
+ 10. Recipes |oil-recipes|
+ 11. Events |oil-events|
+ 12. Trash |oil-trash|
--------------------------------------------------------------------------------
-INTRODUCTION *canola-introduction*
+INTRODUCTION *oil-introduction*
-canola.nvim is a file explorer for Neovim in the style of vim-vinegar. It lets
+oil.nvim is a file explorer for Neovim in the style of vim-vinegar. It lets
you edit your filesystem like a normal buffer: create files and directories by
typing new lines, delete them by removing lines, rename or move them by
-changing the text. When you save the buffer, canola diffs it against the original
+changing the text. When you save the buffer, oil diffs it against the original
listing and performs the corresponding filesystem operations.
-Open a directory with `nvim .`, `:edit `, or `:Canola `. Use ``
+Open a directory with `nvim .`, `:edit `, or `:Oil `. Use ``
to open a file or descend into a directory, and `-` to go up. Treat the
listing like any other buffer — edit freely, then `:w` to apply changes.
-To open canola in a floating window, use `:Canola --float `.
+To open oil in a floating window, use `:Oil --float `.
To mimic vim-vinegar's parent-directory keymap: >lua
- vim.keymap.set("n", "-", "Canola", { desc = "Open parent directory" })
+ vim.keymap.set("n", "-", "Oil", { desc = "Open parent directory" })
<
File operations work across adapters. You can copy files between your local
@@ -40,54 +40,54 @@ machine and a remote server over SSH, or between local directories and S3
buckets, using the same buffer-editing workflow.
--------------------------------------------------------------------------------
-REQUIREMENTS *canola-requirements*
+REQUIREMENTS *oil-requirements*
- Neovim 0.8+
- (optional) mini.icons or nvim-web-devicons for file icons
--------------------------------------------------------------------------------
-CONFIG *canola-config*
+CONFIG *oil-config*
-Canola can be configured in two ways:
+Oil can be configured in two ways:
1. The traditional `setup()` call: >lua
- require("canola").setup({
+ require("oil").setup({
-- your opts here
})
<
-2. Declarative configuration via `vim.g.canola`, which does not require calling
+2. Declarative configuration via `vim.g.oil`, which does not require calling
`setup()`: >lua
- vim.g.canola = {
+ vim.g.oil = {
-- your opts here
}
<
- When `vim.g.canola` is set, canola initializes automatically during plugin
+ When `vim.g.oil` is set, oil initializes automatically during plugin
loading. If `setup()` is called with explicit opts, those take precedence
- over `vim.g.canola`.
+ over `vim.g.oil`.
The full list of options with their defaults:
>lua
- require("canola").setup({
- -- Canola will take over directory buffers (e.g. `vim .` or `:e src/`)
+ require("oil").setup({
+ -- Oil will take over directory buffers (e.g. `vim .` or `:e src/`)
-- Set to false if you want some other plugin (e.g. netrw) to open when you edit directories.
default_file_explorer = true,
-- Id is automatically added at the beginning, and name at the end
- -- See :help canola-columns
+ -- See :help oil-columns
columns = {
"icon",
-- "permissions",
-- "size",
-- "mtime",
},
- -- Buffer-local options to use for canola buffers
+ -- Buffer-local options to use for oil buffers
buf_options = {
buflisted = false,
bufhidden = "hide",
},
- -- Window-local options to use for canola buffers
+ -- Window-local options to use for oil buffers
win_options = {
wrap = false,
signcolumn = "no",
@@ -98,16 +98,16 @@ The full list of options with their defaults:
conceallevel = 3,
concealcursor = "nvic",
},
- -- Send deleted files to the trash instead of permanently deleting them (:help canola-trash)
+ -- Send deleted files to the trash instead of permanently deleting them (:help oil-trash)
delete_to_trash = false,
- -- Skip the confirmation popup for simple operations (:help canola.skip_confirm_for_simple_edits)
+ -- Skip the confirmation popup for simple operations (:help oil.skip_confirm_for_simple_edits)
skip_confirm_for_simple_edits = false,
-- Selecting a new/moved/renamed file or directory will prompt you to save changes first
-- (:help prompt_save_on_select_new_entry)
prompt_save_on_select_new_entry = true,
- -- Canola will automatically delete hidden buffers after this delay
+ -- Oil will automatically delete hidden buffers after this delay
-- You can set the delay to false to disable cleanup entirely
- -- Note that the cleanup process only starts when none of the canola buffers are currently displayed
+ -- Note that the cleanup process only starts when none of the oil buffers are currently displayed
cleanup_delay_ms = 2000,
lsp_file_methods = {
-- Enable or disable LSP file operations
@@ -118,17 +118,17 @@ The full list of options with their defaults:
-- Set to "unmodified" to only save unmodified buffers
autosave_changes = false,
},
- -- Constrain the cursor to the editable parts of the canola buffer
+ -- Constrain the cursor to the editable parts of the oil buffer
-- Set to `false` to disable, or "name" to keep it on the file names
constrain_cursor = "editable",
- -- Set to true to watch the filesystem for changes and reload canola
+ -- Set to true to watch the filesystem for changes and reload oil
watch_for_changes = false,
- -- Keymaps in canola buffer. Can be any value that `vim.keymap.set` accepts OR a table of keymap
+ -- Keymaps in oil buffer. Can be any value that `vim.keymap.set` accepts OR a table of keymap
-- options with a `callback` (e.g. { callback = function() ... end, desc = "", mode = "n" })
-- Additionally, if it is a string that matches "actions.",
- -- it will use the mapping at require("canola.actions").
+ -- it will use the mapping at require("oil.actions").
-- Set to `false` to remove a keymap
- -- See :help canola-actions for a list of all available actions
+ -- See :help oil-actions for a list of all available actions
keymaps = {
["g?"] = { "actions.show_help", mode = "n" },
[""] = "actions.select",
@@ -152,9 +152,6 @@ The full list of options with their defaults:
view_options = {
-- Show files and directories that start with "."
show_hidden = false,
- -- When true and a directory has no visible entries, show hidden entries
- -- instead of an empty listing. is_always_hidden entries are never shown.
- show_hidden_when_empty = false,
-- This function defines what is considered a "hidden" file
is_hidden_file = function(name, bufnr)
local m = name:match("^%.")
@@ -171,7 +168,7 @@ The full list of options with their defaults:
case_insensitive = false,
sort = {
-- sort order can be "asc" or "desc"
- -- see :help canola-columns to see which columns are sortable
+ -- see :help oil-columns to see which columns are sortable
{ "type", "asc" },
{ "name", "asc" },
},
@@ -199,7 +196,7 @@ The full list of options with their defaults:
return false
end,
},
- -- Configuration for the floating window in canola.open_float
+ -- Configuration for the floating window in oil.open_float
float = {
-- Padding around the floating window
padding = 2,
@@ -210,7 +207,7 @@ The full list of options with their defaults:
win_options = {
winblend = 0,
},
- -- optionally override the canola buffers window title with custom function: fun(winid: integer): string
+ -- optionally override the oil buffers window title with custom function: fun(winid: integer): string
get_win_title = nil,
-- preview_split: Split direction: "auto", "left", "right", "above", "below".
preview_split = "auto",
@@ -230,10 +227,6 @@ The full list of options with their defaults:
disable_preview = function(filename)
return false
end,
- -- Maximum file size in MB to load into the preview window. Files larger
- -- than this limit will show a placeholder message instead of being loaded.
- -- Set to nil to disable the limit.
- max_file_size = 10,
-- Window-local options to use for preview window buffers
win_options = {},
},
@@ -286,12 +279,12 @@ The full list of options with their defaults:
<
--------------------------------------------------------------------------------
-OPTIONS *canola-options*
+OPTIONS *oil-options*
-skip_confirm_for_simple_edits *canola.skip_confirm_for_simple_edits*
+skip_confirm_for_simple_edits *oil.skip_confirm_for_simple_edits*
type: `boolean` default: `false`
- Before performing filesystem operations, Canola displays a confirmation popup to ensure
+ Before performing filesystem operations, Oil displays a confirmation popup to ensure
that all operations are intentional. When this option is `true`, the popup will be
skipped if the operations:
* contain no deletes
@@ -299,12 +292,7 @@ skip_confirm_for_simple_edits *canola.skip_confirm_for_simple_e
* contain at most one copy or move
* contain at most five creates
-skip_confirm_for_delete *canola.skip_confirm_for_delete*
- type: `boolean` default: `false`
- When this option is `true`, the confirmation popup will be skipped if all pending
- actions are deletes.
-
-prompt_save_on_select_new_entry *canola.prompt_save_on_select_new_entry*
+prompt_save_on_select_new_entry *oil.prompt_save_on_select_new_entry*
type: `boolean` default: `true`
There are two cases where this option is relevant:
1. You copy a file to a new location, then you select it and make edits before
@@ -313,177 +301,126 @@ prompt_save_on_select_new_entry *canola.prompt_save_on_select_new_e
changes before saving.
In case 1, when you edit the file you are actually editing the original file because
- canola has not yet moved/copied it to its new location. This means that the original
+ oil has not yet moved/copied it to its new location. This means that the original
file will, perhaps unexpectedly, also be changed by any edits you make.
Case 2 is similar; when you edit the directory you are again actually editing the
original location of the directory. If you add new files, those files will be
created in both the original location and the copied directory.
- When this option is `true`, Canola will prompt you to save before entering a file or
- directory that is pending within canola, but does not exist on disk.
-
-auto_save_on_select_new_entry *canola.auto_save_on_select_new_entry*
- type: `boolean` default: `false`
- When `prompt_save_on_select_new_entry` is true and you select a
- new/moved/renamed entry, automatically save without prompting instead of
- showing a confirmation dialog.
-
-cleanup_buffers_on_delete *canola.cleanup_buffers_on_delete*
- type: `boolean` default: `false`
- When `true`, canola will wipe any open buffer whose path matches a file that
- was successfully deleted via canola. This prevents stale buffers from
- appearing in the jumplist after a deletion.
-
-show_hidden_when_empty *canola.show_hidden_when_empty*
- type: `boolean` default: `false`
- When `true` and a directory contains no visible entries (because all
- entries are hidden), canola will display the hidden entries anyway.
- Entries matching `is_always_hidden` are never shown. Hidden entries
- are still rendered with the dimmed hidden style.
-
-preview_win.max_file_size *canola.preview_win*
- type: `number` default: `10`
- Maximum file size in MB to load into the preview window. Files larger
- than this limit will show a placeholder message instead of being loaded.
- Set to `nil` to disable the limit.
+ When this option is `true`, Oil will prompt you to save before entering a file or
+ directory that is pending within oil, but does not exist on disk.
--------------------------------------------------------------------------------
-API *canola-api*
+API *oil-api*
-get_entry_on_line({bufnr}, {lnum}): nil|canola.Entry *canola.get_entry_on_line*
+get_entry_on_line({bufnr}, {lnum}): nil|oil.Entry *oil.get_entry_on_line*
Get the entry on a specific line (1-indexed)
Parameters:
{bufnr} `integer`
{lnum} `integer`
-get_cursor_entry(): nil|canola.Entry *canola.get_cursor_entry*
+get_cursor_entry(): nil|oil.Entry *oil.get_cursor_entry*
Get the entry currently under the cursor
-discard_all_changes() *canola.discard_all_changes*
- Discard all changes made to canola buffers
+discard_all_changes() *oil.discard_all_changes*
+ Discard all changes made to oil buffers
-set_columns({cols}) *canola.set_columns*
- Change the display columns for canola
+set_columns({cols}) *oil.set_columns*
+ Change the display columns for oil
Parameters:
- {cols} `canola.ColumnSpec[]`
+ {cols} `oil.ColumnSpec[]`
-set_sort({sort}) *canola.set_sort*
- Change the sort order for canola
+set_sort({sort}) *oil.set_sort*
+ Change the sort order for oil
Parameters:
- {sort} `canola.SortSpec[]` List of columns plus direction. See :help canola-
+ {sort} `oil.SortSpec[]` List of columns plus direction. See :help oil-
columns to see which ones are sortable.
Examples: >lua
- require("canola").set_sort({ { "type", "asc" }, { "size", "desc" } })
+ require("oil").set_sort({ { "type", "asc" }, { "size", "desc" } })
<
-set_is_hidden_file({is_hidden_file}) *canola.set_is_hidden_file*
- Change how canola determines if the file is hidden
+set_is_hidden_file({is_hidden_file}) *oil.set_is_hidden_file*
+ Change how oil determines if the file is hidden
Parameters:
- {is_hidden_file} `fun(filename: string, bufnr: integer, entry: canola.Entry): boolean`
+ {is_hidden_file} `fun(filename: string, bufnr: integer, entry: oil.Entry): boolean`
Return true if the file/dir should be hidden
-toggle_hidden() *canola.toggle_hidden*
+toggle_hidden() *oil.toggle_hidden*
Toggle hidden files and directories
-get_current_dir({bufnr}): nil|string *canola.get_current_dir*
+get_current_dir({bufnr}): nil|string *oil.get_current_dir*
Get the current directory
Parameters:
{bufnr} `nil|integer`
-open_float({dir}, {opts}, {cb}) *canola.open_float*
- Open canola browser in a floating window
+open_float({dir}, {opts}, {cb}) *oil.open_float*
+ Open oil browser in a floating window
Parameters:
{dir} `nil|string` When nil, open the parent of the current buffer, or
the cwd if current buffer is not a file
- {opts} `nil|canola.OpenOpts`
- {preview} `nil|canola.OpenPreviewOpts` When present, open the preview
- window after opening canola
+ {opts} `nil|oil.OpenOpts`
+ {preview} `nil|oil.OpenPreviewOpts` When present, open the preview
+ window after opening oil
{vertical} `nil|boolean` Open the buffer in a vertical split
{horizontal} `nil|boolean` Open the buffer in a horizontal split
{split} `nil|"aboveleft"|"belowright"|"topleft"|"botright"` S
plit modifier
- {cb} `nil|fun()` Called after the canola buffer is ready
+ {cb} `nil|fun()` Called after the oil buffer is ready
-toggle_float({dir}, {opts}, {cb}) *canola.toggle_float*
- Open canola browser in a floating window, or close it if open
+toggle_float({dir}, {opts}, {cb}) *oil.toggle_float*
+ Open oil browser in a floating window, or close it if open
Parameters:
{dir} `nil|string` When nil, open the parent of the current buffer, or
the cwd if current buffer is not a file
- {opts} `nil|canola.OpenOpts`
- {preview} `nil|canola.OpenPreviewOpts` When present, open the preview
- window after opening canola
+ {opts} `nil|oil.OpenOpts`
+ {preview} `nil|oil.OpenPreviewOpts` When present, open the preview
+ window after opening oil
{vertical} `nil|boolean` Open the buffer in a vertical split
{horizontal} `nil|boolean` Open the buffer in a horizontal split
{split} `nil|"aboveleft"|"belowright"|"topleft"|"botright"` S
plit modifier
- {cb} `nil|fun()` Called after the canola buffer is ready
+ {cb} `nil|fun()` Called after the oil buffer is ready
-open_split({dir}, {opts}, {cb}) *canola.open_split*
- Open canola browser in a split window
+open({dir}, {opts}, {cb}) *oil.open*
+ Open oil browser for a directory
Parameters:
{dir} `nil|string` When nil, open the parent of the current buffer, or
the cwd if current buffer is not a file
- {opts} `nil|canola.OpenSplitOpts`
- {vertical} `nil|boolean` Open the buffer in a vertical split
- {horizontal} `nil|boolean` Open the buffer in a horizontal split
- {split} `nil|"aboveleft"|"belowright"|"topleft"|"botright"` Split
- modifier
- {cb} `nil|fun()` Called after the canola buffer is ready
-
-toggle_split({dir}, {opts}, {cb}) *canola.toggle_split*
- Open canola browser in a split window, or close it if open
-
- Parameters:
- {dir} `nil|string` When nil, open the parent of the current buffer, or
- the cwd if current buffer is not a file
- {opts} `nil|canola.OpenSplitOpts`
- {vertical} `nil|boolean` Open the buffer in a vertical split
- {horizontal} `nil|boolean` Open the buffer in a horizontal split
- {split} `nil|"aboveleft"|"belowright"|"topleft"|"botright"` Split
- modifier
- {cb} `nil|fun()` Called after the canola buffer is ready
-
-open({dir}, {opts}, {cb}) *canola.open*
- Open canola browser for a directory
-
- Parameters:
- {dir} `nil|string` When nil, open the parent of the current buffer, or
- the cwd if current buffer is not a file
- {opts} `nil|canola.OpenOpts`
- {preview} `nil|canola.OpenPreviewOpts` When present, open the preview
- window after opening canola
+ {opts} `nil|oil.OpenOpts`
+ {preview} `nil|oil.OpenPreviewOpts` When present, open the preview
+ window after opening oil
{vertical} `nil|boolean` Open the buffer in a vertical split
{horizontal} `nil|boolean` Open the buffer in a horizontal split
{split} `nil|"aboveleft"|"belowright"|"topleft"|"botright"` S
plit modifier
- {cb} `nil|fun()` Called after the canola buffer is ready
+ {cb} `nil|fun()` Called after the oil buffer is ready
-close({opts}) *canola.close*
- Restore the buffer that was present when canola was opened
+close({opts}) *oil.close*
+ Restore the buffer that was present when oil was opened
Parameters:
- {opts} `nil|canola.CloseOpts`
- {exit_if_last_buf} `nil|boolean` Exit vim if this canola buffer is the
+ {opts} `nil|oil.CloseOpts`
+ {exit_if_last_buf} `nil|boolean` Exit vim if this oil buffer is the
last open buffer
-open_preview({opts}, {callback}) *canola.open_preview*
+open_preview({opts}, {callback}) *oil.open_preview*
Preview the entry under the cursor in a split
Parameters:
- {opts} `nil|canola.OpenPreviewOpts`
+ {opts} `nil|oil.OpenPreviewOpts`
{vertical} `nil|boolean` Open the buffer in a vertical split
{horizontal} `nil|boolean` Open the buffer in a horizontal split
{split} `nil|"aboveleft"|"belowright"|"topleft"|"botright"` Split
@@ -491,17 +428,17 @@ open_preview({opts}, {callback}) *canola.open_pre
{callback} `nil|fun(err: nil|string)` Called once the preview window has
been opened
-select({opts}, {callback}) *canola.select*
+select({opts}, {callback}) *oil.select*
Select the entry under the cursor
Parameters:
- {opts} `nil|canola.SelectOpts`
+ {opts} `nil|oil.SelectOpts`
{vertical} `nil|boolean` Open the buffer in a vertical split
{horizontal} `nil|boolean` Open the buffer in a horizontal split
{split} `nil|"aboveleft"|"belowright"|"topleft"|"botright"` Split
modifier
{tab} `nil|boolean` Open the buffer in a new tab
- {close} `nil|boolean` Close the original canola buffer once
+ {close} `nil|boolean` Close the original oil buffer once
selection is made
{handle_buffer_callback} `nil|fun(buf_id: integer)` If defined, all
other buffer related options here would be ignored. This
@@ -510,7 +447,7 @@ select({opts}, {callback}) *canola.se
{callback} `nil|fun(err: nil|string)` Called once all entries have been
opened
-save({opts}, {cb}) *canola.save*
+save({opts}, {cb}) *oil.save*
Save all changes
Parameters:
@@ -522,14 +459,14 @@ save({opts}, {cb}) *canola.
Note:
If you provide your own callback function, there will be no notification for errors.
-setup({opts}) *canola.setup*
- Initialize canola
+setup({opts}) *oil.setup*
+ Initialize oil
Parameters:
- {opts} `canola.setupOpts|nil`
+ {opts} `oil.setupOpts|nil`
--------------------------------------------------------------------------------
-COLUMNS *canola-columns*
+COLUMNS *oil-columns*
Columns can be specified as a string to use default arguments (e.g. `"icon"`),
or as a table to pass parameters (e.g. `{"size", highlight = "Special"}`)
@@ -626,23 +563,23 @@ birthtime *column-birthtim
{format} `string` Format string (see :help strftime)
--------------------------------------------------------------------------------
-ACTIONS *canola-actions*
+ACTIONS *oil-actions*
-The `keymaps` option in `canola.setup` allow you to create mappings using all the same parameters as |vim.keymap.set|.
+The `keymaps` option in `oil.setup` allow you to create mappings using all the same parameters as |vim.keymap.set|.
>lua
keymaps = {
-- Mappings can be a string
["~"] = "edit $HOME",
-- Mappings can be a function
["gd"] = function()
- require("canola").set_columns({ "icon", "permissions", "size", "mtime" })
+ require("oil").set_columns({ "icon", "permissions", "size", "mtime" })
end,
-- You can pass additional opts to vim.keymap.set by using
-- a table with the mapping as the first element.
["ff"] = {
function()
require("telescope.builtin").find_files({
- cwd = require("canola").get_current_dir()
+ cwd = require("oil").get_current_dir()
})
end,
mode = "n",
@@ -666,10 +603,10 @@ The `keymaps` option in `canola.setup` allow you to create mappings using all th
Below are the actions that can be used in the `keymaps` section of config
options. You can refer to them as strings (e.g. "actions.") or you
can use the functions directly with
-`require("canola.actions").action_name.callback()`
+`require("oil.actions").action_name.callback()`
cd *actions.cd*
- :cd to the current canola directory
+ :cd to the current oil directory
Parameters:
{scope} `nil|"tab"|"win"` Scope of the directory change (e.g. use |:tcd|
@@ -680,20 +617,20 @@ change_sort *actions.change_sor
Change the sort order
Parameters:
- {sort} `canola.SortSpec[]` List of columns plus direction (see
- |canola.set_sort|) instead of interactive selection
+ {sort} `oil.SortSpec[]` List of columns plus direction (see
+ |oil.set_sort|) instead of interactive selection
close *actions.close*
- Close canola and restore original buffer
+ Close oil and restore original buffer
Parameters:
- {exit_if_last_buf} `boolean` Exit vim if canola is closed as the last buffer
+ {exit_if_last_buf} `boolean` Exit vim if oil is closed as the last buffer
close_float *actions.close_float*
- Close canola if the window is floating, otherwise do nothing
+ Close oil if the window is floating, otherwise do nothing
Parameters:
- {exit_if_last_buf} `boolean` Exit vim if canola is closed as the last buffer
+ {exit_if_last_buf} `boolean` Exit vim if oil is closed as the last buffer
copy_to_system_clipboard *actions.copy_to_system_clipboard*
Copy the entry under the cursor to the system clipboard
@@ -707,7 +644,7 @@ open_cmdline *actions.open_cmdlin
{shorten_path} `boolean` Use relative paths when possible
open_cwd *actions.open_cwd*
- Open canola in Neovim's current working directory
+ Open oil in Neovim's current working directory
open_external *actions.open_external*
Open the entry under the cursor in an external program
@@ -719,7 +656,7 @@ parent *actions.paren
Navigate to the parent path
paste_from_system_clipboard *actions.paste_from_system_clipboard*
- Paste the system clipboard into the current canola directory
+ Paste the system clipboard into the current oil directory
Parameters:
{delete_original} `boolean` Delete the original file after copying
@@ -757,7 +694,7 @@ select *actions.selec
Open the entry under the cursor
Parameters:
- {close} `boolean` Close the original canola buffer once selection is
+ {close} `boolean` Close the original oil buffer once selection is
made
{horizontal} `boolean` Open the buffer in a horizontal split
{split} `"aboveleft"|"belowright"|"topleft"|"botright"` Split
@@ -766,7 +703,7 @@ select *actions.selec
{vertical} `boolean` Open the buffer in a vertical split
send_to_qflist *actions.send_to_qflist*
- Sends files in the current canola directory to the quickfix list, replacing the
+ Sends files in the current oil directory to the quickfix list, replacing the
previous entries.
Parameters:
@@ -794,109 +731,109 @@ yank_entry *actions.yank_entr
mods argument
--------------------------------------------------------------------------------
-HIGHLIGHTS *canola-highlights*
+HIGHLIGHTS *oil-highlights*
-CanolaEmpty *hl-CanolaEmpty*
+OilEmpty *hl-OilEmpty*
Empty column values
-CanolaHidden *hl-CanolaHidden*
- Hidden entry in an canola buffer
+OilHidden *hl-OilHidden*
+ Hidden entry in an oil buffer
-CanolaDir *hl-CanolaDir*
- Directory names in an canola buffer
+OilDir *hl-OilDir*
+ Directory names in an oil buffer
-CanolaDirHidden *hl-CanolaDirHidden*
- Hidden directory names in an canola buffer
+OilDirHidden *hl-OilDirHidden*
+ Hidden directory names in an oil buffer
-CanolaDirIcon *hl-CanolaDirIcon*
+OilDirIcon *hl-OilDirIcon*
Icon for directories
-CanolaFileIcon *hl-CanolaFileIcon*
+OilFileIcon *hl-OilFileIcon*
Icon for files
-CanolaSocket *hl-CanolaSocket*
- Socket files in an canola buffer
+OilSocket *hl-OilSocket*
+ Socket files in an oil buffer
-CanolaSocketHidden *hl-CanolaSocketHidden*
- Hidden socket files in an canola buffer
+OilSocketHidden *hl-OilSocketHidden*
+ Hidden socket files in an oil buffer
-CanolaLink *hl-CanolaLink*
- Soft links in an canola buffer
+OilLink *hl-OilLink*
+ Soft links in an oil buffer
-CanolaOrphanLink *hl-CanolaOrphanLink*
- Orphaned soft links in an canola buffer
+OilOrphanLink *hl-OilOrphanLink*
+ Orphaned soft links in an oil buffer
-CanolaLinkHidden *hl-CanolaLinkHidden*
- Hidden soft links in an canola buffer
+OilLinkHidden *hl-OilLinkHidden*
+ Hidden soft links in an oil buffer
-CanolaOrphanLinkHidden *hl-CanolaOrphanLinkHidden*
- Hidden orphaned soft links in an canola buffer
+OilOrphanLinkHidden *hl-OilOrphanLinkHidden*
+ Hidden orphaned soft links in an oil buffer
-CanolaLinkTarget *hl-CanolaLinkTarget*
+OilLinkTarget *hl-OilLinkTarget*
The target of a soft link
-CanolaOrphanLinkTarget *hl-CanolaOrphanLinkTarget*
+OilOrphanLinkTarget *hl-OilOrphanLinkTarget*
The target of an orphaned soft link
-CanolaLinkTargetHidden *hl-CanolaLinkTargetHidden*
+OilLinkTargetHidden *hl-OilLinkTargetHidden*
The target of a hidden soft link
-CanolaOrphanLinkTargetHidden *hl-CanolaOrphanLinkTargetHidden*
+OilOrphanLinkTargetHidden *hl-OilOrphanLinkTargetHidden*
The target of an hidden orphaned soft link
-CanolaFile *hl-CanolaFile*
- Normal files in an canola buffer
+OilFile *hl-OilFile*
+ Normal files in an oil buffer
-CanolaFileHidden *hl-CanolaFileHidden*
- Hidden normal files in an canola buffer
+OilFileHidden *hl-OilFileHidden*
+ Hidden normal files in an oil buffer
-CanolaExecutable *hl-CanolaExecutable*
- Executable files in an canola buffer
+OilExecutable *hl-OilExecutable*
+ Executable files in an oil buffer
-CanolaExecutableHidden *hl-CanolaExecutableHidden*
- Hidden executable files in an canola buffer
+OilExecutableHidden *hl-OilExecutableHidden*
+ Hidden executable files in an oil buffer
-CanolaCreate *hl-CanolaCreate*
- Create action in the canola preview window
+OilCreate *hl-OilCreate*
+ Create action in the oil preview window
-CanolaDelete *hl-CanolaDelete*
- Delete action in the canola preview window
+OilDelete *hl-OilDelete*
+ Delete action in the oil preview window
-CanolaMove *hl-CanolaMove*
- Move action in the canola preview window
+OilMove *hl-OilMove*
+ Move action in the oil preview window
-CanolaCopy *hl-CanolaCopy*
- Copy action in the canola preview window
+OilCopy *hl-OilCopy*
+ Copy action in the oil preview window
-CanolaChange *hl-CanolaChange*
- Change action in the canola preview window
+OilChange *hl-OilChange*
+ Change action in the oil preview window
-CanolaRestore *hl-CanolaRestore*
- Restore (from the trash) action in the canola preview window
+OilRestore *hl-OilRestore*
+ Restore (from the trash) action in the oil preview window
-CanolaPurge *hl-CanolaPurge*
- Purge (Permanently delete a file from trash) action in the canola preview
+OilPurge *hl-OilPurge*
+ Purge (Permanently delete a file from trash) action in the oil preview
window
-CanolaTrash *hl-CanolaTrash*
- Trash (delete a file to trash) action in the canola preview window
+OilTrash *hl-OilTrash*
+ Trash (delete a file to trash) action in the oil preview window
-CanolaTrashSourcePath *hl-CanolaTrashSourcePath*
+OilTrashSourcePath *hl-OilTrashSourcePath*
Virtual text that shows the original path of file in the trash
--------------------------------------------------------------------------------
-ADAPTERS *canola-adapters*
+ADAPTERS *oil-adapters*
-Canola performs all filesystem interaction through an adapter abstraction. This
-means canola can view and modify files in places beyond the local filesystem, as
+Oil performs all filesystem interaction through an adapter abstraction. This
+means oil can view and modify files in places beyond the local filesystem, as
long as the destination has an adapter implementation. File operations work
across adapters — you can copy files between local and remote with the same
buffer-editing workflow.
-SSH *canola-adapter-ssh*
+SSH *oil-adapter-ssh*
Browse files over SSH, much like netrw. Open a buffer with: >
- nvim canola-ssh://[username@]hostname[:port]/[path]
+ nvim oil-ssh://[username@]hostname[:port]/[path]
<
This is the same URL format that netrw uses.
@@ -904,36 +841,36 @@ SSH *canola-adapter
server to have `/bin/sh` as well as standard unix commands (`ls`, `rm`,
`mv`, `mkdir`, `chmod`, `cp`, `touch`, `ln`, `echo`).
-S3 *canola-adapter-s3*
+S3 *oil-adapter-s3*
Browse files stored in AWS S3. Make sure `aws` is configured correctly,
then open a buffer with: >
- nvim canola-s3://[bucket]/[path]
+ nvim oil-s3://[bucket]/[path]
<
Older versions of Neovim (0.11 and earlier) don't support numbers in the
- URL scheme, so use `canola-sss` instead of `canola-s3`.
+ URL scheme, so use `oil-sss` instead of `oil-s3`.
-Trash *canola-adapter-trash*
+Trash *oil-adapter-trash*
- See |canola-trash| for details on the built-in trash adapter.
+ See |oil-trash| for details on the built-in trash adapter.
--------------------------------------------------------------------------------
-RECIPES *canola-recipes*
+RECIPES *oil-recipes*
Toggle file detail view ~
- *canola-recipe-toggle-detail-view*
+ *oil-recipe-toggle-detail-view*
>lua
local detail = false
- require("canola").setup({
+ require("oil").setup({
keymaps = {
["gd"] = {
desc = "Toggle file detail view",
callback = function()
detail = not detail
if detail then
- require("canola").set_columns({ "icon", "permissions", "size", "mtime" })
+ require("oil").set_columns({ "icon", "permissions", "size", "mtime" })
else
- require("canola").set_columns({ "icon" })
+ require("oil").set_columns({ "icon" })
end
end,
},
@@ -942,11 +879,11 @@ Toggle file detail view ~
<
Show CWD in the winbar ~
- *canola-recipe-cwd-winbar*
+ *oil-recipe-cwd-winbar*
>lua
- function _G.get_canola_winbar()
+ function _G.get_oil_winbar()
local bufnr = vim.api.nvim_win_get_buf(vim.g.statusline_winid)
- local dir = require("canola").get_current_dir(bufnr)
+ local dir = require("oil").get_current_dir(bufnr)
if dir then
return vim.fn.fnamemodify(dir, ":~")
else
@@ -954,15 +891,15 @@ Show CWD in the winbar ~
end
end
- require("canola").setup({
+ require("oil").setup({
win_options = {
- winbar = "%!v:lua.get_canola_winbar()",
+ winbar = "%!v:lua.get_oil_winbar()",
},
})
<
Hide gitignored files and show git tracked hidden files ~
- *canola-recipe-git-is-hidden*
+ *oil-recipe-git-is-hidden*
>lua
local function parse_output(proc)
local result = proc:wait()
@@ -1002,17 +939,17 @@ Hide gitignored files and show git tracked hidden files ~
end
local git_status = new_git_status()
- local refresh = require("canola.actions").refresh
+ local refresh = require("oil.actions").refresh
local orig_refresh = refresh.callback
refresh.callback = function(...)
git_status = new_git_status()
orig_refresh(...)
end
- require("canola").setup({
+ require("oil").setup({
view_options = {
is_hidden_file = function(name, bufnr)
- local dir = require("canola").get_current_dir(bufnr)
+ local dir = require("oil").get_current_dir(bufnr)
local is_dotfile = vim.startswith(name, ".") and name ~= ".."
if not dir then
return is_dotfile
@@ -1027,21 +964,21 @@ Hide gitignored files and show git tracked hidden files ~
})
<
-Open Telescope file finder in the current canola directory ~
- *canola-recipe-telescope*
+Open Telescope file finder in the current oil directory ~
+ *oil-recipe-telescope*
When using `get_current_dir()` in a keymap that also opens another plugin's UI
(like Telescope), capture the directory in a local variable before the call
that changes the buffer context.
>lua
- require("canola").setup({
+ require("oil").setup({
keymaps = {
["ff"] = {
desc = "Find files in the current directory",
callback = function()
- local dir = require("canola").get_current_dir()
+ local dir = require("oil").get_current_dir()
if not dir then
- vim.notify("Could not get canola directory", vim.log.levels.WARN)
+ vim.notify("Could not get oil directory", vim.log.levels.WARN)
return
end
require("telescope.builtin").find_files({ cwd = dir })
@@ -1050,9 +987,9 @@ that changes the buffer context.
["fg"] = {
desc = "Live grep in the current directory",
callback = function()
- local dir = require("canola").get_current_dir()
+ local dir = require("oil").get_current_dir()
if not dir then
- vim.notify("Could not get canola directory", vim.log.levels.WARN)
+ vim.notify("Could not get oil directory", vim.log.levels.WARN)
return
end
require("telescope.builtin").live_grep({ cwd = dir })
@@ -1066,18 +1003,18 @@ If you need the directory after an operation that might change the current
buffer, pass the buffer number explicitly: >lua
local bufnr = vim.api.nvim_get_current_buf()
-- ... some operation that changes the current buffer ...
- local dir = require("canola").get_current_dir(bufnr)
+ local dir = require("oil").get_current_dir(bufnr)
<
Add custom column for file extension ~
- *canola-recipe-extension-column*
+ *oil-recipe-extension-column*
>lua
- local canola_cfg = require "canola.config"
- local canola_constant = require "canola.constants"
- local canola_column = require "canola.columns"
+ local oil_cfg = require "oil.config"
+ local oil_constant = require "oil.constants"
+ local oil_column = require "oil.columns"
- local FIELD_TYPE = canola_constant.FIELD_TYPE
- local FIELD_NAME = canola_constant.FIELD_NAME
+ local FIELD_TYPE = oil_constant.FIELD_TYPE
+ local FIELD_NAME = oil_constant.FIELD_NAME
local function adjust_number(int)
return string.format("%03d%s", #int, int)
@@ -1087,7 +1024,7 @@ Add custom column for file extension ~
return vim.fn.fnamemodify(output, ":e")
end
- canola_column.register("extension", {
+ oil_column.register("extension", {
render = function(entry, _)
local field_type = entry[FIELD_TYPE]
local name = entry[FIELD_NAME]
@@ -1107,8 +1044,8 @@ Add custom column for file extension ~
end,
create_sort_value_factory = function(num_entries)
if
- canola_cfg.view_options.natural_order == false
- or (canola_cfg.view_options.natural_order == "fast" and num_entries > 5000)
+ oil_cfg.view_options.natural_order == false
+ or (oil_cfg.view_options.natural_order == "fast" and num_entries > 5000)
then
return function(entry)
return format(entry[FIELD_NAME]:lower())
@@ -1129,7 +1066,7 @@ Add custom column for file extension ~
end,
})
- require("canola").setup({
+ require("oil").setup({
columns = {
"size",
"extension",
@@ -1146,103 +1083,78 @@ Add custom column for file extension ~
<
Disable dimming of hidden files ~
- *canola-recipe-no-hidden-dimming*
+ *oil-recipe-no-hidden-dimming*
-By default, hidden files (toggled with `g.`) are dimmed via the `CanolaHidden`
+By default, hidden files (toggled with `g.`) are dimmed via the `OilHidden`
highlight group, which links to `Comment`. To make hidden files look identical
to their visible counterparts, relink each hidden group to its non-hidden
variant after calling `setup()`:
>lua
- for _, hl in ipairs(require("canola")._get_highlights()) do
- local base = hl.name:match("^(Canola.+)Hidden$")
+ for _, hl in ipairs(require("oil")._get_highlights()) do
+ local base = hl.name:match("^(Oil.+)Hidden$")
if base then
vim.api.nvim_set_hl(0, hl.name, { link = base })
end
end
<
-Use FreeDesktop trash on macOS ~
- *canola-recipe-macos-freedesktop-trash*
-
-For full FreeDesktop spec compliance on macOS (list, restore operations), or
-for compatibility with FreeDesktop-compliant trash programs like gtrash:
->lua
- package.loaded["canola.adapters.trash.mac"] = require("canola.adapters.trash.freedesktop")
-<
-
--------------------------------------------------------------------------------
-EVENTS *canola-events*
+EVENTS *oil-events*
-Canola emits the following |User| autocmd events. Listen for them with
+Oil emits the following |User| autocmd events. Listen for them with
|nvim_create_autocmd|: >lua
vim.api.nvim_create_autocmd("User", {
- pattern = "CanolaEnter",
+ pattern = "OilEnter",
callback = function(args)
- vim.print("Entered canola buffer: " .. args.data.buf)
+ vim.print("Entered oil buffer: " .. args.data.buf)
end,
})
<
-CanolaEnter *CanolaEnter*
- Fired once per canola buffer, after the initial directory listing has been
+OilEnter *OilEnter*
+ Fired once per oil buffer, after the initial directory listing has been
rendered and the buffer is ready. The `args.data.buf` field contains the
buffer number. Use this event for one-time buffer setup such as setting
keymaps or window options.
-CanolaReadPost *CanolaReadPost*
+OilReadPost *OilReadPost*
Fired after every successful buffer render, including the initial render
and all subsequent re-renders (e.g. after directory changes, refreshes, or
mutations). The `args.data.buf` field contains the buffer number. Use this
event for logic that must run each time the directory listing updates.
-CanolaMutationComplete *CanolaMutationComplete*
+OilMutationComplete *OilMutationComplete*
Fired after all pending mutations (create, delete, rename, move, copy)
have been executed and the affected buffers have been re-rendered. No
additional data fields. Use this event for post-mutation side effects such
as refreshing external status indicators.
-CanolaFileCreated *CanolaFileCreated*
- Fired after a new file is successfully created on the local filesystem.
- The `args.data.path` field contains the absolute path of the created file.
- Use this event to populate initial file contents, run formatters, or
- perform any other setup on newly created files. >lua
- vim.api.nvim_create_autocmd("User", {
- pattern = "CanolaFileCreated",
- callback = function(args)
- local path = args.data.path
- if path:match("%.sh$") then
- vim.fn.writefile({ "#!/usr/bin/env bash" }, path)
- end
- end,
- })
-<
-
--------------------------------------------------------------------------------
-TRASH *canola-trash*
+TRASH *oil-trash*
-Canola has built-in support for using the system trash. When
+Oil has built-in support for using the system trash. When
`delete_to_trash = true`, any deleted files will be sent to the trash instead
of being permanently deleted. You can browse the trash for a directory using
the `toggle_trash` action (bound to `g\` by default). You can view all files
-in the trash with `:Canola --trash /`.
+in the trash with `:Oil --trash /`.
To restore files, simply move them from the trash to the desired destination,
the same as any other file operation. If you delete files from the trash they
will be permanently deleted (purged).
Linux:
- Canola supports the FreeDesktop trash specification.
+ Oil supports the FreeDesktop trash specification.
https://specifications.freedesktop.org/trash/1.0/
All features should work.
Mac:
- Canola has limited support for MacOS due to the proprietary nature of the
+ Oil has limited support for MacOS due to the proprietary nature of the
implementation. The trash bin can only be viewed as a single dir
(instead of being able to see files that were trashed from a directory).
Windows:
- Canola supports the Windows Recycle Bin. All features should work.
+ Oil supports the Windows Recycle Bin. All features should work.
================================================================================
vim:tw=80:ts=2:ft=help:norl:syntax=help:
diff --git a/doc/upstream.md b/doc/upstream.md
deleted file mode 100644
index 81c4311..0000000
--- a/doc/upstream.md
+++ /dev/null
@@ -1,166 +0,0 @@
-# Upstream Tracker
-
-Triage of [stevearc/oil.nvim](https://github.com/stevearc/oil.nvim) PRs and
-issues against this fork.
-
-## Cherry-picked PRs
-
-Upstream PRs cherry-picked or adapted into this fork.
-
-| PR | Description | Commit |
-| ----------------------------------------------------- | ------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
-| [#495](https://github.com/stevearc/oil.nvim/pull/495) | Cancel visual/operator-pending mode on close | [`16f3d7b`](https://github.com/barrettruth/canola.nvim/commit/16f3d7b) |
-| [#537](https://github.com/stevearc/oil.nvim/pull/537) | Configurable file/directory creation permissions | [`c6b4a7a`](https://github.com/barrettruth/canola.nvim/commit/c6b4a7a) |
-| [#618](https://github.com/stevearc/oil.nvim/pull/618) | Opt-in filetype detection for icons | [`ded1725`](https://github.com/barrettruth/canola.nvim/commit/ded1725) |
-| [#644](https://github.com/stevearc/oil.nvim/pull/644) | Pass entry to `is_hidden_file`/`is_always_hidden` | [`4ab4765`](https://github.com/barrettruth/canola.nvim/commit/4ab4765) |
-| [#697](https://github.com/stevearc/oil.nvim/pull/697) | Recipe for file extension column | [`dcb3a08`](https://github.com/barrettruth/canola.nvim/commit/dcb3a08) |
-| [#698](https://github.com/stevearc/oil.nvim/pull/698) | Executable file highlighting | [`41556ec`](https://github.com/barrettruth/canola.nvim/commit/41556ec), [`85ed9b8`](https://github.com/barrettruth/canola.nvim/commit/85ed9b8) |
-| [#717](https://github.com/stevearc/oil.nvim/pull/717) | Add oil-git.nvim to extensions | [`582d9fc`](https://github.com/barrettruth/canola.nvim/commit/582d9fc) |
-| [#720](https://github.com/stevearc/oil.nvim/pull/720) | Gate `BufAdd` autocmd behind config check | [`2228f80`](https://github.com/barrettruth/canola.nvim/commit/2228f80) |
-| [#722](https://github.com/stevearc/oil.nvim/pull/722) | Fix freedesktop trash URL | [`b92ecb0`](https://github.com/barrettruth/canola.nvim/commit/b92ecb0) |
-| [#723](https://github.com/stevearc/oil.nvim/pull/723) | Emit `OilReadPost` event after render | [`29239d5`](https://github.com/barrettruth/canola.nvim/commit/29239d5) |
-| [#725](https://github.com/stevearc/oil.nvim/pull/725) | Normalize keymap keys before config merge | [`723145c`](https://github.com/barrettruth/canola.nvim/commit/723145c) |
-| [#727](https://github.com/stevearc/oil.nvim/pull/727) | Clarify `get_current_dir` nil + Telescope recipe | [`eed6697`](https://github.com/barrettruth/canola.nvim/commit/eed6697) |
-| [#739](https://github.com/stevearc/oil.nvim/pull/739) | macOS FreeDesktop trash recipe | `doc/canola.txt` (`canola-recipe-macos-freedesktop-trash`) |
-
-## Original fixes
-
-Bugs fixed in this fork that remain open upstream.
-
-| Upstream issue | Description | PR |
-| ------------------------------------------------------- | ------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------- |
-| [#302](https://github.com/stevearc/oil.nvim/issues/302) | `buflisted=true` after jumplist nav | [#71](https://github.com/barrettruth/canola.nvim/pull/71) ([`a078bcf`](https://github.com/barrettruth/canola.nvim/commit/a078bcf)) |
-| [#632](https://github.com/stevearc/oil.nvim/issues/632) | Preview + move = copy | [#12](https://github.com/barrettruth/canola.nvim/pull/12) ([`fe16993`](https://github.com/barrettruth/canola.nvim/commit/fe16993)) |
-| [#642](https://github.com/stevearc/oil.nvim/issues/642) | W10 warning under `nvim -R` | [`ca834cf`](https://github.com/barrettruth/canola.nvim/commit/ca834cf) |
-| [#670](https://github.com/stevearc/oil.nvim/issues/670) | Multi-directory cmdline args ignored | [#11](https://github.com/barrettruth/canola.nvim/pull/11) ([`70861e5`](https://github.com/barrettruth/canola.nvim/commit/70861e5)) |
-| [#673](https://github.com/stevearc/oil.nvim/issues/673) | Symlink newlines crash | [`9110a1a`](https://github.com/barrettruth/canola.nvim/commit/9110a1a) |
-| [#710](https://github.com/stevearc/oil.nvim/issues/710) | buftype empty on BufEnter | [#10](https://github.com/barrettruth/canola.nvim/pull/10) ([`01b860e`](https://github.com/barrettruth/canola.nvim/commit/01b860e)) |
-| [#213](https://github.com/stevearc/oil.nvim/issues/213) | Max file size for preview | [#85](https://github.com/barrettruth/canola.nvim/pull/85) ([`4b32ada`](https://github.com/barrettruth/canola.nvim/commit/4b32ada)) |
-| [#473](https://github.com/stevearc/oil.nvim/issues/473) | Show hidden when dir is all-hidden | [#85](https://github.com/barrettruth/canola.nvim/pull/85) ([`2fe4e78`](https://github.com/barrettruth/canola.nvim/commit/2fe4e78)) |
-
-## Open upstream PRs
-
-| PR | Description | Status |
-| ----------------------------------------------------- | ---------------------------------------- | ----------------------------------------------------------------------------------------------------- |
-| [#488](https://github.com/stevearc/oil.nvim/pull/488) | Parent directory in a split | not actionable — empty PR |
-| [#493](https://github.com/stevearc/oil.nvim/pull/493) | UNC paths on Windows | not actionable — superseded by [#686](https://github.com/stevearc/oil.nvim/pull/686) |
-| [#591](https://github.com/stevearc/oil.nvim/pull/591) | release-please changelog | not applicable |
-| [#667](https://github.com/stevearc/oil.nvim/pull/667) | Virtual text columns + headers | deferred — WIP, conflicting |
-| [#686](https://github.com/stevearc/oil.nvim/pull/686) | Windows path conversion fix | not actionable — Windows-only |
-| [#708](https://github.com/stevearc/oil.nvim/pull/708) | Move file into new dir by renaming | deferred — needs rewrite |
-| [#721](https://github.com/stevearc/oil.nvim/pull/721) | `create_hook` to populate file contents | deferred — fixing via autocmd event on file create |
-| [#728](https://github.com/stevearc/oil.nvim/pull/728) | `open_split` for opening oil in a split | tracked — [#2](https://github.com/barrettruth/canola.nvim/issues/2) |
-| [#735](https://github.com/stevearc/oil.nvim/pull/735) | gX opens external program with selection | not actionable — hardcoded Linux-only program list, no config surface, author-acknowledged incomplete |
-
-## Upstream issues
-
-| Issue | Status | Notes |
-| ------------------------------------------------------- | -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| [#85](https://github.com/stevearc/oil.nvim/issues/85) | open | Git status column (P2) |
-| [#95](https://github.com/stevearc/oil.nvim/issues/95) | open | Undo after renaming files (P1) |
-| [#117](https://github.com/stevearc/oil.nvim/issues/117) | open | Move file into new dir via slash in name (P1, related to [#708](https://github.com/stevearc/oil.nvim/pull/708)) |
-| [#156](https://github.com/stevearc/oil.nvim/issues/156) | open | Paste path of files into oil buffer (P2) |
-| [#200](https://github.com/stevearc/oil.nvim/issues/200) | open | Highlights not working when opening a file (P2) |
-| [#207](https://github.com/stevearc/oil.nvim/issues/207) | open | Suppress "no longer available" message (P1) |
-| [#210](https://github.com/stevearc/oil.nvim/issues/210) | open | FTP support (P2) |
-| [#213](https://github.com/stevearc/oil.nvim/issues/213) | fixed | Disable preview for large files — `preview_win.max_file_size` (P1) |
-| [#226](https://github.com/stevearc/oil.nvim/issues/226) | open | K8s/Docker adapter (P2) |
-| [#232](https://github.com/stevearc/oil.nvim/issues/232) | open | Cannot close last window (P2) |
-| [#254](https://github.com/stevearc/oil.nvim/issues/254) | open | Buffer modified highlight group (P2) |
-| [#263](https://github.com/stevearc/oil.nvim/issues/263) | open | Diff mode (P2) |
-| [#276](https://github.com/stevearc/oil.nvim/issues/276) | open | Archives manipulation (P2) |
-| [#280](https://github.com/stevearc/oil.nvim/issues/280) | open | vim-projectionist support (P2) |
-| [#288](https://github.com/stevearc/oil.nvim/issues/288) | not actionable | No reliable repro; likely lazy.nvim timing issue — setting `lazy = false` resolves it for affected users |
-| [#289](https://github.com/stevearc/oil.nvim/issues/289) | open | Show absolute path toggle (P2) |
-| [#294](https://github.com/stevearc/oil.nvim/issues/294) | open | Can't handle emojis in filenames (P2) |
-| [#298](https://github.com/stevearc/oil.nvim/issues/298) | open | Open float on neovim directory startup (P2) |
-| [#302](https://github.com/stevearc/oil.nvim/issues/302) | fixed | `buflisted=true` after jumplist nav — [#71](https://github.com/barrettruth/canola.nvim/pull/71) ([`a078bcf`](https://github.com/barrettruth/canola.nvim/commit/a078bcf)) |
-| [#303](https://github.com/stevearc/oil.nvim/issues/303) | open | Preview in float window mode (P2) |
-| [#325](https://github.com/stevearc/oil.nvim/issues/325) | open | oil-ssh error from command line (P0) |
-| [#330](https://github.com/stevearc/oil.nvim/issues/330) | not actionable | Telescope opens file in oil float — cross-plugin interaction, no repro provided |
-| [#332](https://github.com/stevearc/oil.nvim/issues/332) | open | Buffer not fixed to floating window (P2) |
-| [#335](https://github.com/stevearc/oil.nvim/issues/335) | open | Disable editing outside root dir |
-| [#349](https://github.com/stevearc/oil.nvim/issues/349) | open | Parent directory as column/vsplit (P2) |
-| [#351](https://github.com/stevearc/oil.nvim/issues/351) | open | Paste deleted file from register |
-| [#359](https://github.com/stevearc/oil.nvim/issues/359) | open | Parse error on filenames differing by space (P1) |
-| [#360](https://github.com/stevearc/oil.nvim/issues/360) | open | Pick window to open file into |
-| [#362](https://github.com/stevearc/oil.nvim/issues/362) | not actionable | "Could not find oil adapter for scheme" — no minimal repro provided, old nvim version (0.9.5) |
-| [#363](https://github.com/stevearc/oil.nvim/issues/363) | fixed | `prompt_save_on_select_new_entry` uses wrong prompt — escape now cancels select |
-| [#371](https://github.com/stevearc/oil.nvim/issues/371) | open | Constrain cursor in insert mode |
-| [#373](https://github.com/stevearc/oil.nvim/issues/373) | open | Dir from quickfix with bqf/trouble broken (P1) |
-| [#375](https://github.com/stevearc/oil.nvim/issues/375) | open | Highlights for file types and permissions (P2) |
-| [#380](https://github.com/stevearc/oil.nvim/issues/380) | not actionable | Silently overriding `show_hidden` based on buffer state is counter to the config's intent |
-| [#382](https://github.com/stevearc/oil.nvim/issues/382) | open | Relative path in window title (P2) |
-| [#392](https://github.com/stevearc/oil.nvim/issues/392) | fixed | Option to skip delete prompt — fixed — `skip_confirm_for_delete` option |
-| [#393](https://github.com/stevearc/oil.nvim/issues/393) | fixed | Auto-save on select — `auto_save_on_select_new_entry` option |
-| [#396](https://github.com/stevearc/oil.nvim/issues/396) | open | Customize preview content (P2) |
-| [#399](https://github.com/stevearc/oil.nvim/issues/399) | open | Open file without closing Oil (P1) |
-| [#404](https://github.com/stevearc/oil.nvim/issues/404) | not actionable | Restricted UNC paths — Windows-only (P2) |
-| [#416](https://github.com/stevearc/oil.nvim/issues/416) | open | Cannot remap key to open split |
-| [#431](https://github.com/stevearc/oil.nvim/issues/431) | open | More SSH adapter documentation |
-| [#435](https://github.com/stevearc/oil.nvim/issues/435) | open | Error previewing with semantic tokens LSP |
-| [#436](https://github.com/stevearc/oil.nvim/issues/436) | open | Owner and group columns (P2) |
-| [#444](https://github.com/stevearc/oil.nvim/issues/444) | open | Opening behaviour customization |
-| [#446](https://github.com/stevearc/oil.nvim/issues/446) | resolved | Executable highlighting — PR [#698](https://github.com/stevearc/oil.nvim/pull/698) |
-| [#449](https://github.com/stevearc/oil.nvim/issues/449) | open | Renaming TypeScript files stopped working |
-| [#450](https://github.com/stevearc/oil.nvim/issues/450) | open | Highlight opened file in directory listing |
-| [#457](https://github.com/stevearc/oil.nvim/issues/457) | open | Custom column API |
-| [#466](https://github.com/stevearc/oil.nvim/issues/466) | open | Select into window on right |
-| [#473](https://github.com/stevearc/oil.nvim/issues/473) | fixed | Show all hidden files if dir only has hidden — `view_options.show_hidden_when_empty` |
-| [#479](https://github.com/stevearc/oil.nvim/issues/479) | open | Harpoon integration recipe |
-| [#483](https://github.com/stevearc/oil.nvim/issues/483) | not actionable | Spell downloads depend on netrw — fixed in [neovim#34940](https://github.com/neovim/neovim/pull/34940) |
-| [#486](https://github.com/stevearc/oil.nvim/issues/486) | open | All directory sizes show 4.1k |
-| [#492](https://github.com/stevearc/oil.nvim/issues/492) | not actionable | j/k remapping question — answered in comments |
-| [#507](https://github.com/stevearc/oil.nvim/issues/507) | not actionable | lacasitos.nvim conflict on Windows — cross-plugin + Windows-only, no actionable fix |
-| [#521](https://github.com/stevearc/oil.nvim/issues/521) | open | oil-ssh connection issues |
-| [#525](https://github.com/stevearc/oil.nvim/issues/525) | open | SSH adapter documentation (P2) |
-| [#531](https://github.com/stevearc/oil.nvim/issues/531) | not actionable | Windows — incomplete drive letters (P1) |
-| [#533](https://github.com/stevearc/oil.nvim/issues/533) | not actionable | `constrain_cursor` — needs repro |
-| [#570](https://github.com/stevearc/oil.nvim/issues/570) | open | Improve c0/d0 for renaming |
-| [#571](https://github.com/stevearc/oil.nvim/issues/571) | open | Callback before `highlight_filename` (P2) |
-| [#578](https://github.com/stevearc/oil.nvim/issues/578) | resolved | Hidden file dimming recipe — [`38db6cf`](https://github.com/barrettruth/canola.nvim/commit/38db6cf) |
-| [#587](https://github.com/stevearc/oil.nvim/issues/587) | not actionable | Alt+h keymap — user config issue |
-| [#599](https://github.com/stevearc/oil.nvim/issues/599) | open | user:group display and manipulation (P2) |
-| [#607](https://github.com/stevearc/oil.nvim/issues/607) | open | Per-host SCP args (P2) |
-| [#609](https://github.com/stevearc/oil.nvim/issues/609) | open | Cursor placement via Snacks picker |
-| [#612](https://github.com/stevearc/oil.nvim/issues/612) | fixed | Delete buffers on file delete — `cleanup_buffers_on_delete` option |
-| [#615](https://github.com/stevearc/oil.nvim/issues/615) | fixed | Cursor at name column on o/O — [#72](https://github.com/barrettruth/canola.nvim/pull/72) ([`69d85b8`](https://github.com/barrettruth/canola.nvim/commit/69d85b8)) |
-| [#617](https://github.com/stevearc/oil.nvim/issues/617) | open | Filetype by actual filetype (P2) |
-| [#621](https://github.com/stevearc/oil.nvim/issues/621) | open | Toggle function for regular windows (P2) |
-| [#623](https://github.com/stevearc/oil.nvim/issues/623) | not actionable | bufferline.nvim interaction — cross-plugin |
-| [#624](https://github.com/stevearc/oil.nvim/issues/624) | not actionable | Mutation race — no reliable repro |
-| [#625](https://github.com/stevearc/oil.nvim/issues/625) | not actionable | E19 mark invalid line — intractable without neovim API changes |
-| [#632](https://github.com/stevearc/oil.nvim/issues/632) | fixed | Preview + move = copy — [#12](https://github.com/barrettruth/canola.nvim/pull/12) ([`fe16993`](https://github.com/barrettruth/canola.nvim/commit/fe16993)) |
-| [#636](https://github.com/stevearc/oil.nvim/issues/636) | open | Telescope picker opens in active buffer |
-| [#637](https://github.com/stevearc/oil.nvim/issues/637) | open | Inconsistent symlink resolution |
-| [#641](https://github.com/stevearc/oil.nvim/issues/641) | open | Flicker on `actions.parent` |
-| [#642](https://github.com/stevearc/oil.nvim/issues/642) | fixed | W10 warning under `nvim -R` — [`ca834cf`](https://github.com/barrettruth/canola.nvim/commit/ca834cf) |
-| [#645](https://github.com/stevearc/oil.nvim/issues/645) | resolved | `close_float` action — [`f6bcdda`](https://github.com/barrettruth/canola.nvim/commit/f6bcdda) |
-| [#646](https://github.com/stevearc/oil.nvim/issues/646) | open | `get_current_dir` nil on SSH |
-| [#650](https://github.com/stevearc/oil.nvim/issues/650) | resolved | LSP `workspace.fileOperations` events — implemented in `lua/canola/lsp/workspace.lua` |
-| [#655](https://github.com/stevearc/oil.nvim/issues/655) | open | File statistics as virtual text |
-| [#659](https://github.com/stevearc/oil.nvim/issues/659) | open | Mark and diff files in buffer |
-| [#664](https://github.com/stevearc/oil.nvim/issues/664) | not actionable | Session reload extra buffer — no repro |
-| [#665](https://github.com/stevearc/oil.nvim/issues/665) | open | Hot load preview fast-scratch buffers |
-| [#668](https://github.com/stevearc/oil.nvim/issues/668) | open | Custom yes/no confirmation |
-| [#670](https://github.com/stevearc/oil.nvim/issues/670) | fixed | Multi-directory cmdline — [#11](https://github.com/barrettruth/canola.nvim/pull/11) ([`70861e5`](https://github.com/barrettruth/canola.nvim/commit/70861e5)) |
-| [#671](https://github.com/stevearc/oil.nvim/issues/671) | open | Yanking between nvim instances |
-| [#673](https://github.com/stevearc/oil.nvim/issues/673) | fixed | Symlink newlines crash — [`9110a1a`](https://github.com/barrettruth/canola.nvim/commit/9110a1a) |
-| [#675](https://github.com/stevearc/oil.nvim/issues/675) | open | Move file into folder by renaming (related to [#708](https://github.com/stevearc/oil.nvim/pull/708)) |
-| [#676](https://github.com/stevearc/oil.nvim/issues/676) | not actionable | Windows — path conversion |
-| [#678](https://github.com/stevearc/oil.nvim/issues/678) | tracking | `buftype='acwrite'` causes `mksession` to skip oil windows |
-| [#679](https://github.com/stevearc/oil.nvim/issues/679) | resolved | Executable file sign — PR [#698](https://github.com/stevearc/oil.nvim/pull/698) |
-| [#682](https://github.com/stevearc/oil.nvim/issues/682) | resolved | `get_current_dir()` nil — clarified via [`eed6697`](https://github.com/barrettruth/canola.nvim/commit/eed6697) (cherry-pick of [#727](https://github.com/stevearc/oil.nvim/pull/727)) |
-| [#683](https://github.com/stevearc/oil.nvim/issues/683) | fixed | Path not shown in floating mode — title shown via fallback when border is nil |
-| [#684](https://github.com/stevearc/oil.nvim/issues/684) | open | User and group columns |
-| [#685](https://github.com/stevearc/oil.nvim/issues/685) | open | Plain directory paths in buffer names |
-| [#690](https://github.com/stevearc/oil.nvim/issues/690) | resolved | `OilFileIcon` highlight group — [`ce64ae1`](https://github.com/barrettruth/canola.nvim/commit/ce64ae1) |
-| [#692](https://github.com/stevearc/oil.nvim/issues/692) | resolved | Keymap normalization — PR [#725](https://github.com/stevearc/oil.nvim/pull/725) |
-| [#699](https://github.com/stevearc/oil.nvim/issues/699) | open | `select` blocks UI with slow FileType autocmd |
-| [#707](https://github.com/stevearc/oil.nvim/issues/707) | open | Move file/dir into new dir by renaming (related to [#708](https://github.com/stevearc/oil.nvim/pull/708)) |
-| [#710](https://github.com/stevearc/oil.nvim/issues/710) | fixed | buftype empty on BufEnter — [#10](https://github.com/barrettruth/canola.nvim/pull/10) ([`01b860e`](https://github.com/barrettruth/canola.nvim/commit/01b860e)) |
-| [#714](https://github.com/stevearc/oil.nvim/issues/714) | not actionable | Support question — answered |
-| [#719](https://github.com/stevearc/oil.nvim/issues/719) | not actionable | Neovim crash on node_modules — libuv/neovim bug |
-| [#726](https://github.com/stevearc/oil.nvim/issues/726) | not actionable | Meta discussion/roadmap |
-| [#736](https://github.com/stevearc/oil.nvim/issues/736) | open | Make icons virtual text — related to [#667](https://github.com/stevearc/oil.nvim/pull/667) (virtual text columns, deferred) |
-| [#738](https://github.com/stevearc/oil.nvim/issues/738) | open | Allow changing mtime/atime via time column (P2) |
diff --git a/flake.nix b/flake.nix
index 76ef696..5670f55 100644
--- a/flake.nix
+++ b/flake.nix
@@ -1,5 +1,5 @@
{
- description = "canola.nvim — refined fork of oil.nvim";
+ description = "oil.nvim — Neovim file explorer: edit your filesystem like a buffer";
inputs = {
nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable";
@@ -13,22 +13,15 @@
...
}:
let
- forEachSystem =
- f: nixpkgs.lib.genAttrs (import systems) (system: f nixpkgs.legacyPackages.${system});
+ forEachSystem = f: nixpkgs.lib.genAttrs (import systems) (system: f nixpkgs.legacyPackages.${system});
in
{
- formatter = forEachSystem (pkgs: pkgs.nixfmt-tree);
-
devShells = forEachSystem (pkgs: {
default = pkgs.mkShell {
packages = [
pkgs.prettier
pkgs.stylua
pkgs.selene
- (pkgs.luajit.withPackages (ps: [
- ps.busted
- ps.nlua
- ]))
];
};
});
diff --git a/lua/canola/adapters/trash.lua b/lua/canola/adapters/trash.lua
deleted file mode 100644
index 42b82d5..0000000
--- a/lua/canola/adapters/trash.lua
+++ /dev/null
@@ -1,9 +0,0 @@
-local fs = require('canola.fs')
-
-if fs.is_mac then
- return require('canola.adapters.trash.mac')
-elseif fs.is_windows then
- return require('canola.adapters.trash.windows')
-else
- return require('canola.adapters.trash.freedesktop')
-end
diff --git a/lua/canola/pathutil.lua b/lua/canola/pathutil.lua
deleted file mode 100644
index cfd4d82..0000000
--- a/lua/canola/pathutil.lua
+++ /dev/null
@@ -1,29 +0,0 @@
-local M = {}
-
----@param path string
----@return string
-M.parent = function(path)
- if path == '/' then
- return '/'
- elseif path == '' then
- return ''
- elseif vim.endswith(path, '/') then
- return path:match('^(.*/)[^/]*/$') or ''
- else
- return path:match('^(.*/)[^/]*$') or ''
- end
-end
-
----@param path string
----@return nil|string
-M.basename = function(path)
- if path == '/' or path == '' then
- return
- elseif vim.endswith(path, '/') then
- return path:match('^.*/([^/]*)/$')
- else
- return path:match('^.*/([^/]*)$')
- end
-end
-
-return M
diff --git a/lua/canola/actions.lua b/lua/oil/actions.lua
similarity index 51%
rename from lua/canola/actions.lua
rename to lua/oil/actions.lua
index b3d7942..edd44ba 100644
--- a/lua/canola/actions.lua
+++ b/lua/oil/actions.lua
@@ -1,119 +1,119 @@
-local canola = require('canola')
-local util = require('canola.util')
+local oil = require("oil")
+local util = require("oil.util")
local M = {}
M.show_help = {
callback = function()
- local config = require('canola.config')
- require('canola.keymap_util').show_help(config.keymaps)
+ local config = require("oil.config")
+ require("oil.keymap_util").show_help(config.keymaps)
end,
- desc = 'Show default keymaps',
+ desc = "Show default keymaps",
}
M.select = {
- desc = 'Open the entry under the cursor',
+ desc = "Open the entry under the cursor",
callback = function(opts)
opts = opts or {}
local callback = opts.callback
opts.callback = nil
- canola.select(opts, callback)
+ oil.select(opts, callback)
end,
parameters = {
vertical = {
- type = 'boolean',
- desc = 'Open the buffer in a vertical split',
+ type = "boolean",
+ desc = "Open the buffer in a vertical split",
},
horizontal = {
- type = 'boolean',
- desc = 'Open the buffer in a horizontal split',
+ type = "boolean",
+ desc = "Open the buffer in a horizontal split",
},
split = {
type = '"aboveleft"|"belowright"|"topleft"|"botright"',
- desc = 'Split modifier',
+ desc = "Split modifier",
},
tab = {
- type = 'boolean',
- desc = 'Open the buffer in a new tab',
+ type = "boolean",
+ desc = "Open the buffer in a new tab",
},
close = {
- type = 'boolean',
- desc = 'Close the original canola buffer once selection is made',
+ type = "boolean",
+ desc = "Close the original oil buffer once selection is made",
},
},
}
M.select_vsplit = {
- desc = 'Open the entry under the cursor in a vertical split',
+ desc = "Open the entry under the cursor in a vertical split",
deprecated = true,
callback = function()
- canola.select({ vertical = true })
+ oil.select({ vertical = true })
end,
}
M.select_split = {
- desc = 'Open the entry under the cursor in a horizontal split',
+ desc = "Open the entry under the cursor in a horizontal split",
deprecated = true,
callback = function()
- canola.select({ horizontal = true })
+ oil.select({ horizontal = true })
end,
}
M.select_tab = {
- desc = 'Open the entry under the cursor in a new tab',
+ desc = "Open the entry under the cursor in a new tab",
deprecated = true,
callback = function()
- canola.select({ tab = true })
+ oil.select({ tab = true })
end,
}
M.preview = {
- desc = 'Open the entry under the cursor in a preview window, or close the preview window if already open',
+ desc = "Open the entry under the cursor in a preview window, or close the preview window if already open",
parameters = {
vertical = {
- type = 'boolean',
- desc = 'Open the buffer in a vertical split',
+ type = "boolean",
+ desc = "Open the buffer in a vertical split",
},
horizontal = {
- type = 'boolean',
- desc = 'Open the buffer in a horizontal split',
+ type = "boolean",
+ desc = "Open the buffer in a horizontal split",
},
split = {
type = '"aboveleft"|"belowright"|"topleft"|"botright"',
- desc = 'Split modifier',
+ desc = "Split modifier",
},
},
callback = function(opts)
- local entry = canola.get_cursor_entry()
+ local entry = oil.get_cursor_entry()
if not entry then
- vim.notify('Could not find entry under cursor', vim.log.levels.ERROR)
+ vim.notify("Could not find entry under cursor", vim.log.levels.ERROR)
return
end
local winid = util.get_preview_win()
if winid then
- local cur_id = vim.w[winid].canola_entry_id
+ local cur_id = vim.w[winid].oil_entry_id
if entry.id == cur_id then
vim.api.nvim_win_close(winid, true)
if util.is_floating_win() then
- local layout = require('canola.layout')
+ local layout = require("oil.layout")
local win_opts = layout.get_fullscreen_win_opts()
vim.api.nvim_win_set_config(0, win_opts)
end
return
end
end
- canola.open_preview(opts)
+ oil.open_preview(opts)
end,
}
M.preview_scroll_down = {
- desc = 'Scroll down in the preview window',
+ desc = "Scroll down in the preview window",
callback = function()
local winid = util.get_preview_win()
if winid then
vim.api.nvim_win_call(winid, function()
vim.cmd.normal({
- args = { vim.api.nvim_replace_termcodes('', true, true, true) },
+ args = { vim.api.nvim_replace_termcodes("", true, true, true) },
bang = true,
})
end)
@@ -122,13 +122,13 @@ M.preview_scroll_down = {
}
M.preview_scroll_up = {
- desc = 'Scroll up in the preview window',
+ desc = "Scroll up in the preview window",
callback = function()
local winid = util.get_preview_win()
if winid then
vim.api.nvim_win_call(winid, function()
vim.cmd.normal({
- args = { vim.api.nvim_replace_termcodes('', true, true, true) },
+ args = { vim.api.nvim_replace_termcodes("", true, true, true) },
bang = true,
})
end)
@@ -137,60 +137,60 @@ M.preview_scroll_up = {
}
M.preview_scroll_left = {
- desc = 'Scroll left in the preview window',
+ desc = "Scroll left in the preview window",
callback = function()
local winid = util.get_preview_win()
if winid then
vim.api.nvim_win_call(winid, function()
- vim.cmd.normal({ 'zH', bang = true })
+ vim.cmd.normal({ "zH", bang = true })
end)
end
end,
}
M.preview_scroll_right = {
- desc = 'Scroll right in the preview window',
+ desc = "Scroll right in the preview window",
callback = function()
local winid = util.get_preview_win()
if winid then
vim.api.nvim_win_call(winid, function()
- vim.cmd.normal({ 'zL', bang = true })
+ vim.cmd.normal({ "zL", bang = true })
end)
end
end,
}
M.parent = {
- desc = 'Navigate to the parent path',
- callback = canola.open,
+ desc = "Navigate to the parent path",
+ callback = oil.open,
}
M.close = {
- desc = 'Close canola and restore original buffer',
+ desc = "Close oil and restore original buffer",
callback = function(opts)
opts = opts or {}
- canola.close(opts)
+ oil.close(opts)
end,
parameters = {
exit_if_last_buf = {
- type = 'boolean',
- desc = 'Exit vim if canola is closed as the last buffer',
+ type = "boolean",
+ desc = "Exit vim if oil is closed as the last buffer",
},
},
}
M.close_float = {
- desc = 'Close canola if the window is floating, otherwise do nothing',
+ desc = "Close oil if the window is floating, otherwise do nothing",
callback = function(opts)
- if vim.w.is_canola_win then
+ if vim.w.is_oil_win then
opts = opts or {}
- canola.close(opts)
+ oil.close(opts)
end
end,
parameters = {
exit_if_last_buf = {
- type = 'boolean',
- desc = 'Exit vim if canola is closed as the last buffer',
+ type = "boolean",
+ desc = "Exit vim if oil is closed as the last buffer",
},
},
}
@@ -198,97 +198,97 @@ M.close_float = {
---@param cmd string
---@param silent? boolean
local function cd(cmd, silent)
- local dir = canola.get_current_dir()
+ local dir = oil.get_current_dir()
if dir then
vim.cmd({ cmd = cmd, args = { dir } })
if not silent then
- vim.notify(string.format('CWD: %s', dir), vim.log.levels.INFO)
+ vim.notify(string.format("CWD: %s", dir), vim.log.levels.INFO)
end
else
- vim.notify('Cannot :cd; not in a directory', vim.log.levels.WARN)
+ vim.notify("Cannot :cd; not in a directory", vim.log.levels.WARN)
end
end
M.cd = {
- desc = ':cd to the current canola directory',
+ desc = ":cd to the current oil directory",
callback = function(opts)
opts = opts or {}
- local cmd = 'cd'
- if opts.scope == 'tab' then
- cmd = 'tcd'
- elseif opts.scope == 'win' then
- cmd = 'lcd'
+ local cmd = "cd"
+ if opts.scope == "tab" then
+ cmd = "tcd"
+ elseif opts.scope == "win" then
+ cmd = "lcd"
end
cd(cmd, opts.silent)
end,
parameters = {
scope = {
type = 'nil|"tab"|"win"',
- desc = 'Scope of the directory change (e.g. use |:tcd| or |:lcd|)',
+ desc = "Scope of the directory change (e.g. use |:tcd| or |:lcd|)",
},
silent = {
- type = 'boolean',
- desc = 'Do not show a message when changing directories',
+ type = "boolean",
+ desc = "Do not show a message when changing directories",
},
},
}
M.tcd = {
- desc = ':tcd to the current canola directory',
+ desc = ":tcd to the current oil directory",
deprecated = true,
callback = function()
- cd('tcd')
+ cd("tcd")
end,
}
M.open_cwd = {
- desc = "Open canola in Neovim's current working directory",
+ desc = "Open oil in Neovim's current working directory",
callback = function()
- canola.open(vim.fn.getcwd())
+ oil.open(vim.fn.getcwd())
end,
}
M.toggle_hidden = {
- desc = 'Toggle hidden files and directories',
+ desc = "Toggle hidden files and directories",
callback = function()
- require('canola.view').toggle_hidden()
+ require("oil.view").toggle_hidden()
end,
}
M.open_terminal = {
- desc = 'Open a terminal in the current directory',
+ desc = "Open a terminal in the current directory",
callback = function()
- local config = require('canola.config')
+ local config = require("oil.config")
local bufname = vim.api.nvim_buf_get_name(0)
local adapter = config.get_adapter_by_scheme(bufname)
if not adapter then
return
end
- if adapter.name == 'files' then
- local dir = canola.get_current_dir()
- assert(dir, 'Canola buffer with files adapter must have current directory')
+ if adapter.name == "files" then
+ local dir = oil.get_current_dir()
+ assert(dir, "Oil buffer with files adapter must have current directory")
local bufnr = vim.api.nvim_create_buf(false, true)
vim.api.nvim_set_current_buf(bufnr)
- if vim.fn.has('nvim-0.11') == 1 then
+ if vim.fn.has("nvim-0.11") == 1 then
vim.fn.jobstart(vim.o.shell, { cwd = dir, term = true })
else
---@diagnostic disable-next-line: deprecated
vim.fn.termopen(vim.o.shell, { cwd = dir })
end
- elseif adapter.name == 'ssh' then
+ elseif adapter.name == "ssh" then
local bufnr = vim.api.nvim_create_buf(false, true)
vim.api.nvim_set_current_buf(bufnr)
- local url = require('canola.adapters.ssh').parse_url(bufname)
- local cmd = require('canola.adapters.ssh.connection').create_ssh_command(url)
+ local url = require("oil.adapters.ssh").parse_url(bufname)
+ local cmd = require("oil.adapters.ssh.connection").create_ssh_command(url)
local term_id
- if vim.fn.has('nvim-0.11') == 1 then
+ if vim.fn.has("nvim-0.11") == 1 then
term_id = vim.fn.jobstart(cmd, { term = true })
else
---@diagnostic disable-next-line: deprecated
term_id = vim.fn.termopen(cmd)
end
if term_id then
- vim.api.nvim_chan_send(term_id, string.format('cd %s\n', url.path))
+ vim.api.nvim_chan_send(term_id, string.format("cd %s\n", url.path))
end
else
vim.notify(
@@ -304,28 +304,28 @@ M.open_terminal = {
---@return nil|string[] cmd
---@return nil|string error
local function get_open_cmd(path)
- if vim.fn.has('mac') == 1 then
- return { 'open', path }
- elseif vim.fn.has('win32') == 1 then
- if vim.fn.executable('rundll32') == 1 then
- return { 'rundll32', 'url.dll,FileProtocolHandler', path }
+ if vim.fn.has("mac") == 1 then
+ return { "open", path }
+ elseif vim.fn.has("win32") == 1 then
+ if vim.fn.executable("rundll32") == 1 then
+ return { "rundll32", "url.dll,FileProtocolHandler", path }
else
- return nil, 'rundll32 not found'
+ return nil, "rundll32 not found"
end
- elseif vim.fn.executable('explorer.exe') == 1 then
- return { 'explorer.exe', path }
- elseif vim.fn.executable('xdg-open') == 1 then
- return { 'xdg-open', path }
+ elseif vim.fn.executable("explorer.exe") == 1 then
+ return { "explorer.exe", path }
+ elseif vim.fn.executable("xdg-open") == 1 then
+ return { "xdg-open", path }
else
- return nil, 'no handler found'
+ return nil, "no handler found"
end
end
M.open_external = {
- desc = 'Open the entry under the cursor in an external program',
+ desc = "Open the entry under the cursor in an external program",
callback = function()
- local entry = canola.get_cursor_entry()
- local dir = canola.get_current_dir()
+ local entry = oil.get_cursor_entry()
+ local dir = oil.get_current_dir()
if not entry or not dir then
return
end
@@ -338,20 +338,20 @@ M.open_external = {
local cmd, err = get_open_cmd(path)
if not cmd then
- vim.notify(string.format('Could not open %s: %s', path, err), vim.log.levels.ERROR)
+ vim.notify(string.format("Could not open %s: %s", path, err), vim.log.levels.ERROR)
return
end
local jid = vim.fn.jobstart(cmd, { detach = true })
- assert(jid > 0, 'Failed to start job')
+ assert(jid > 0, "Failed to start job")
end,
}
M.refresh = {
- desc = 'Refresh current directory list',
+ desc = "Refresh current directory list",
callback = function(opts)
opts = opts or {}
if vim.bo.modified and not opts.force then
- local ok, choice = pcall(vim.fn.confirm, 'Discard changes?', 'No\nYes')
+ local ok, choice = pcall(vim.fn.confirm, "Discard changes?", "No\nYes")
if not ok or choice ~= 2 then
return
end
@@ -363,27 +363,27 @@ M.refresh = {
end,
parameters = {
force = {
- desc = 'When true, do not prompt user if they will be discarding changes',
- type = 'boolean',
+ desc = "When true, do not prompt user if they will be discarding changes",
+ type = "boolean",
},
},
}
local function open_cmdline_with_path(path)
local escaped =
- vim.api.nvim_replace_termcodes(': ' .. vim.fn.fnameescape(path) .. '', true, false, true)
- vim.api.nvim_feedkeys(escaped, 'n', false)
+ vim.api.nvim_replace_termcodes(": " .. vim.fn.fnameescape(path) .. "", true, false, true)
+ vim.api.nvim_feedkeys(escaped, "n", false)
end
M.open_cmdline = {
- desc = 'Open vim cmdline with current entry as an argument',
+ desc = "Open vim cmdline with current entry as an argument",
callback = function(opts)
- opts = vim.tbl_deep_extend('keep', opts or {}, {
+ opts = vim.tbl_deep_extend("keep", opts or {}, {
shorten_path = true,
})
- local config = require('canola.config')
- local fs = require('canola.fs')
- local entry = canola.get_cursor_entry()
+ local config = require("oil.config")
+ local fs = require("oil.fs")
+ local entry = oil.get_cursor_entry()
if not entry then
return
end
@@ -393,7 +393,7 @@ M.open_cmdline = {
return
end
local adapter = config.get_adapter_by_scheme(scheme)
- if not adapter or not path or adapter.name ~= 'files' then
+ if not adapter or not path or adapter.name ~= "files" then
return
end
local fullpath = fs.posix_to_os_path(path) .. entry.name
@@ -407,28 +407,28 @@ M.open_cmdline = {
end,
parameters = {
modify = {
- desc = 'Modify the path with |fnamemodify()| using this as the mods argument',
- type = 'string',
+ desc = "Modify the path with |fnamemodify()| using this as the mods argument",
+ type = "string",
},
shorten_path = {
- desc = 'Use relative paths when possible',
- type = 'boolean',
+ desc = "Use relative paths when possible",
+ type = "boolean",
},
},
}
M.yank_entry = {
- desc = 'Yank the filepath of the entry under the cursor to a register',
+ desc = "Yank the filepath of the entry under the cursor to a register",
callback = function(opts)
opts = opts or {}
- local entry = canola.get_cursor_entry()
- local dir = canola.get_current_dir()
+ local entry = oil.get_cursor_entry()
+ local dir = oil.get_current_dir()
if not entry or not dir then
return
end
local name = entry.name
- if entry.type == 'directory' then
- name = name .. '/'
+ if entry.type == "directory" then
+ name = name .. "/"
end
local path = dir .. name
if opts.modify then
@@ -438,18 +438,18 @@ M.yank_entry = {
end,
parameters = {
modify = {
- desc = 'Modify the path with |fnamemodify()| using this as the mods argument',
- type = 'string',
+ desc = "Modify the path with |fnamemodify()| using this as the mods argument",
+ type = "string",
},
},
}
M.copy_entry_path = {
- desc = 'Yank the filepath of the entry under the cursor to a register',
+ desc = "Yank the filepath of the entry under the cursor to a register",
deprecated = true,
callback = function()
- local entry = canola.get_cursor_entry()
- local dir = canola.get_current_dir()
+ local entry = oil.get_cursor_entry()
+ local dir = oil.get_current_dir()
if not entry or not dir then
return
end
@@ -458,10 +458,10 @@ M.copy_entry_path = {
}
M.copy_entry_filename = {
- desc = 'Yank the filename of the entry under the cursor to a register',
+ desc = "Yank the filename of the entry under the cursor to a register",
deprecated = true,
callback = function()
- local entry = canola.get_cursor_entry()
+ local entry = oil.get_cursor_entry()
if not entry then
return
end
@@ -470,31 +470,31 @@ M.copy_entry_filename = {
}
M.copy_to_system_clipboard = {
- desc = 'Copy the entry under the cursor to the system clipboard',
+ desc = "Copy the entry under the cursor to the system clipboard",
callback = function()
- require('canola.clipboard').copy_to_system_clipboard()
+ require("oil.clipboard").copy_to_system_clipboard()
end,
}
M.paste_from_system_clipboard = {
- desc = 'Paste the system clipboard into the current canola directory',
+ desc = "Paste the system clipboard into the current oil directory",
callback = function(opts)
- require('canola.clipboard').paste_from_system_clipboard(opts and opts.delete_original)
+ require("oil.clipboard").paste_from_system_clipboard(opts and opts.delete_original)
end,
parameters = {
delete_original = {
- type = 'boolean',
- desc = 'Delete the original file after copying',
+ type = "boolean",
+ desc = "Delete the original file after copying",
},
},
}
M.open_cmdline_dir = {
- desc = 'Open vim cmdline with current directory as an argument',
+ desc = "Open vim cmdline with current directory as an argument",
deprecated = true,
callback = function()
- local fs = require('canola.fs')
- local dir = canola.get_current_dir()
+ local fs = require("oil.fs")
+ local dir = oil.get_current_dir()
if dir then
open_cmdline_with_path(fs.shorten_path(dir))
end
@@ -502,30 +502,30 @@ M.open_cmdline_dir = {
}
M.change_sort = {
- desc = 'Change the sort order',
+ desc = "Change the sort order",
callback = function(opts)
opts = opts or {}
if opts.sort then
- canola.set_sort(opts.sort)
+ oil.set_sort(opts.sort)
return
end
- local sort_cols = { 'name', 'size', 'atime', 'mtime', 'ctime', 'birthtime' }
- vim.ui.select(sort_cols, { prompt = 'Sort by', kind = 'canola_sort_col' }, function(col)
+ local sort_cols = { "name", "size", "atime", "mtime", "ctime", "birthtime" }
+ vim.ui.select(sort_cols, { prompt = "Sort by", kind = "oil_sort_col" }, function(col)
if not col then
return
end
vim.ui.select(
- { 'ascending', 'descending' },
- { prompt = 'Sort order', kind = 'canola_sort_order' },
+ { "ascending", "descending" },
+ { prompt = "Sort order", kind = "oil_sort_order" },
function(order)
if not order then
return
end
- order = order == 'ascending' and 'asc' or 'desc'
- canola.set_sort({
- { 'type', 'asc' },
+ order = order == "ascending" and "asc" or "desc"
+ oil.set_sort({
+ { "type", "asc" },
{ col, order },
})
end
@@ -534,47 +534,47 @@ M.change_sort = {
end,
parameters = {
sort = {
- type = 'canola.SortSpec[]',
- desc = 'List of columns plus direction (see |canola.set_sort|) instead of interactive selection',
+ type = "oil.SortSpec[]",
+ desc = "List of columns plus direction (see |oil.set_sort|) instead of interactive selection",
},
},
}
M.toggle_trash = {
- desc = 'Jump to and from the trash for the current directory',
+ desc = "Jump to and from the trash for the current directory",
callback = function()
- local fs = require('canola.fs')
+ local fs = require("oil.fs")
local bufname = vim.api.nvim_buf_get_name(0)
local scheme, path = util.parse_url(bufname)
local bufnr = vim.api.nvim_get_current_buf()
local url
- if scheme == 'canola://' then
- url = 'canola-trash://' .. path
- elseif scheme == 'canola-trash://' then
- url = 'canola://' .. path
+ if scheme == "oil://" then
+ url = "oil-trash://" .. path
+ elseif scheme == "oil-trash://" then
+ url = "oil://" .. path
-- The non-linux trash implementations don't support per-directory trash,
-- so jump back to the stored source buffer.
if not fs.is_linux then
- local src_bufnr = vim.b.canola_trash_toggle_src
+ local src_bufnr = vim.b.oil_trash_toggle_src
if src_bufnr and vim.api.nvim_buf_is_valid(src_bufnr) then
url = vim.api.nvim_buf_get_name(src_bufnr)
end
end
else
- vim.notify('No trash found for buffer', vim.log.levels.WARN)
+ vim.notify("No trash found for buffer", vim.log.levels.WARN)
return
end
vim.cmd.edit({ args = { url } })
- vim.b.canola_trash_toggle_src = bufnr
+ vim.b.oil_trash_toggle_src = bufnr
end,
}
M.send_to_qflist = {
- desc = 'Sends files in the current canola directory to the quickfix list, replacing the previous entries.',
+ desc = "Sends files in the current oil directory to the quickfix list, replacing the previous entries.",
callback = function(opts)
- opts = vim.tbl_deep_extend('keep', opts or {}, {
- target = 'qflist',
- action = 'r',
+ opts = vim.tbl_deep_extend("keep", opts or {}, {
+ target = "qflist",
+ action = "r",
only_matching_search = false,
})
util.send_to_quickfix({
@@ -586,48 +586,48 @@ M.send_to_qflist = {
parameters = {
target = {
type = '"qflist"|"loclist"',
- desc = 'The target list to send files to',
+ desc = "The target list to send files to",
},
action = {
type = '"r"|"a"',
- desc = 'Replace or add to current quickfix list (see |setqflist-action|)',
+ desc = "Replace or add to current quickfix list (see |setqflist-action|)",
},
only_matching_search = {
- type = 'boolean',
- desc = 'Whether to only add the files that matches the last search. This option only applies when search highlighting is active',
+ type = "boolean",
+ desc = "Whether to only add the files that matches the last search. This option only applies when search highlighting is active",
},
},
}
M.add_to_qflist = {
- desc = 'Adds files in the current canola directory to the quickfix list, keeping the previous entries.',
+ desc = "Adds files in the current oil directory to the quickfix list, keeping the previous entries.",
deprecated = true,
callback = function()
util.send_to_quickfix({
- target = 'qflist',
- mode = 'a',
+ target = "qflist",
+ mode = "a",
})
end,
}
M.send_to_loclist = {
- desc = 'Sends files in the current canola directory to the location list, replacing the previous entries.',
+ desc = "Sends files in the current oil directory to the location list, replacing the previous entries.",
deprecated = true,
callback = function()
util.send_to_quickfix({
- target = 'loclist',
- mode = 'r',
+ target = "loclist",
+ mode = "r",
})
end,
}
M.add_to_loclist = {
- desc = 'Adds files in the current canola directory to the location list, keeping the previous entries.',
+ desc = "Adds files in the current oil directory to the location list, keeping the previous entries.",
deprecated = true,
callback = function()
util.send_to_quickfix({
- target = 'loclist',
- mode = 'a',
+ target = "loclist",
+ mode = "a",
})
end,
}
@@ -637,7 +637,7 @@ M.add_to_loclist = {
M._get_actions = function()
local ret = {}
for name, action in pairs(M) do
- if type(action) == 'table' and action.desc then
+ if type(action) == "table" and action.desc then
table.insert(ret, {
name = name,
desc = action.desc,
diff --git a/lua/canola/adapters/files.lua b/lua/oil/adapters/files.lua
similarity index 77%
rename from lua/canola/adapters/files.lua
rename to lua/oil/adapters/files.lua
index dff8e1a..228e263 100644
--- a/lua/canola/adapters/files.lua
+++ b/lua/oil/adapters/files.lua
@@ -1,12 +1,12 @@
-local cache = require('canola.cache')
-local columns = require('canola.columns')
-local config = require('canola.config')
-local constants = require('canola.constants')
-local fs = require('canola.fs')
-local git = require('canola.git')
-local log = require('canola.log')
-local permissions = require('canola.adapters.files.permissions')
-local util = require('canola.util')
+local cache = require("oil.cache")
+local columns = require("oil.columns")
+local config = require("oil.config")
+local constants = require("oil.constants")
+local fs = require("oil.fs")
+local git = require("oil.git")
+local log = require("oil.log")
+local permissions = require("oil.adapters.files.permissions")
+local util = require("oil.util")
local uv = vim.uv or vim.loop
local M = {}
@@ -25,7 +25,7 @@ local function read_link_data(path, cb)
assert(link)
local stat_path = link
if not fs.is_absolute(link) then
- stat_path = fs.join(vim.fn.fnamemodify(path, ':h'), link)
+ stat_path = fs.join(vim.fn.fnamemodify(path, ":h"), link)
end
uv.fs_stat(stat_path, function(stat_err, stat)
cb(nil, link, stat)
@@ -35,15 +35,15 @@ local function read_link_data(path, cb)
)
end
----@class (exact) canola.FilesAdapter: canola.Adapter
----@field to_short_os_path fun(path: string, entry_type: nil|canola.EntryType): string
+---@class (exact) oil.FilesAdapter: oil.Adapter
+---@field to_short_os_path fun(path: string, entry_type: nil|oil.EntryType): string
---@param path string
----@param entry_type nil|canola.EntryType
+---@param entry_type nil|oil.EntryType
---@return string
M.to_short_os_path = function(path, entry_type)
local shortpath = fs.shorten_path(fs.posix_to_os_path(path))
- if entry_type == 'directory' then
+ if entry_type == "directory" then
shortpath = util.addslash(shortpath, true)
end
return shortpath
@@ -61,13 +61,13 @@ file_columns.size = {
return columns.EMPTY
end
if stat.size >= 1e9 then
- return string.format('%.1fG', stat.size / 1e9)
+ return string.format("%.1fG", stat.size / 1e9)
elseif stat.size >= 1e6 then
- return string.format('%.1fM', stat.size / 1e6)
+ return string.format("%.1fM", stat.size / 1e6)
elseif stat.size >= 1e3 then
- return string.format('%.1fk', stat.size / 1e3)
+ return string.format("%.1fk", stat.size / 1e3)
else
- return string.format('%d', stat.size)
+ return string.format("%d", stat.size)
end
end,
@@ -82,7 +82,7 @@ file_columns.size = {
end,
parse = function(line, conf)
- return line:match('^(%d+%S*)%s+(.*)$')
+ return line:match("^(%d+%S*)%s+(.*)$")
end,
}
@@ -120,7 +120,7 @@ if not fs.is_windows then
local _, path = util.parse_url(action.url)
assert(path)
return string.format(
- 'CHMOD %s %s',
+ "CHMOD %s %s",
permissions.mode_to_octal_str(action.value),
M.to_short_os_path(path, action.entry_type)
)
@@ -147,10 +147,10 @@ end
local current_year
-- Make sure we run this import-time effect in the main loop (mostly for tests)
vim.schedule(function()
- current_year = vim.fn.strftime('%Y')
+ current_year = vim.fn.strftime("%Y")
end)
-for _, time_key in ipairs({ 'ctime', 'mtime', 'atime', 'birthtime' }) do
+for _, time_key in ipairs({ "ctime", "mtime", "atime", "birthtime" }) do
file_columns[time_key] = {
require_stat = true,
@@ -165,11 +165,11 @@ for _, time_key in ipairs({ 'ctime', 'mtime', 'atime', 'birthtime' }) do
if fmt then
ret = vim.fn.strftime(fmt, stat[time_key].sec)
else
- local year = vim.fn.strftime('%Y', stat[time_key].sec)
+ local year = vim.fn.strftime("%Y", stat[time_key].sec)
if year ~= current_year then
- ret = vim.fn.strftime('%b %d %Y', stat[time_key].sec)
+ ret = vim.fn.strftime("%b %d %Y", stat[time_key].sec)
else
- ret = vim.fn.strftime('%b %d %H:%M', stat[time_key].sec)
+ ret = vim.fn.strftime("%b %d %H:%M", stat[time_key].sec)
end
end
return ret
@@ -183,20 +183,20 @@ for _, time_key in ipairs({ 'ctime', 'mtime', 'atime', 'birthtime' }) do
-- and whitespace with a pattern that matches any amount of whitespace
-- e.g. "%b %d %Y" -> "%S+%s+%S+%s+%S+"
pattern = fmt
- :gsub('%%.', '%%S+')
- :gsub('%s+', '%%s+')
+ :gsub("%%.", "%%S+")
+ :gsub("%s+", "%%s+")
-- escape `()[]` because those are special characters in Lua patterns
:gsub(
- '%(',
- '%%('
+ "%(",
+ "%%("
)
- :gsub('%)', '%%)')
- :gsub('%[', '%%[')
- :gsub('%]', '%%]')
+ :gsub("%)", "%%)")
+ :gsub("%[", "%%[")
+ :gsub("%]", "%%]")
else
- pattern = '%S+%s+%d+%s+%d%d:?%d%d'
+ pattern = "%S+%s+%d+%s+%d%d:?%d%d"
end
- return line:match('^(' .. pattern .. ')%s+(.+)$')
+ return line:match("^(" .. pattern .. ")%s+(.+)$")
end,
get_sort_value = function(entry)
@@ -226,7 +226,7 @@ local function columns_require_stat(column_defs)
end
---@param name string
----@return nil|canola.ColumnDefinition
+---@return nil|oil.ColumnDefinition
M.get_column = function(name)
return file_columns[name]
end
@@ -238,17 +238,17 @@ M.normalize_url = function(url, callback)
assert(path)
if fs.is_windows then
- if path == '/' then
+ if path == "/" then
return callback(url)
else
- local is_root_drive = path:match('^/%u$')
+ local is_root_drive = path:match("^/%u$")
if is_root_drive then
- return callback(url .. '/')
+ return callback(url .. "/")
end
end
end
- local os_path = vim.fn.fnamemodify(fs.posix_to_os_path(path), ':p')
+ local os_path = vim.fn.fnamemodify(fs.posix_to_os_path(path), ":p")
uv.fs_realpath(os_path, function(err, new_os_path)
local realpath
if fs.is_windows then
@@ -264,8 +264,8 @@ M.normalize_url = function(url, callback)
vim.schedule_wrap(function(stat_err, stat)
local is_directory
if stat then
- is_directory = stat.type == 'directory'
- elseif vim.endswith(realpath, '/') or (fs.is_windows and vim.endswith(realpath, '\\')) then
+ is_directory = stat.type == "directory"
+ elseif vim.endswith(realpath, "/") or (fs.is_windows and vim.endswith(realpath, "\\")) then
is_directory = true
else
local filetype = vim.filetype.match({ filename = vim.fs.basename(realpath) })
@@ -276,7 +276,7 @@ M.normalize_url = function(url, callback)
local norm_path = util.addslash(fs.os_to_posix_path(realpath))
callback(scheme .. norm_path)
else
- callback(vim.fn.fnamemodify(realpath, ':.'))
+ callback(vim.fn.fnamemodify(realpath, ":."))
end
end)
)
@@ -284,7 +284,7 @@ M.normalize_url = function(url, callback)
end
---@param url string
----@param entry canola.Entry
+---@param entry oil.Entry
---@param cb fun(path: nil|string)
M.get_entry_path = function(url, entry, cb)
if entry.id then
@@ -292,18 +292,18 @@ M.get_entry_path = function(url, entry, cb)
local scheme, path = util.parse_url(parent_url)
M.normalize_url(scheme .. path .. entry.name, cb)
else
- if entry.type == 'directory' then
+ if entry.type == "directory" then
cb(url)
else
local _, path = util.parse_url(url)
- local os_path = vim.fn.fnamemodify(fs.posix_to_os_path(assert(path)), ':p')
+ local os_path = vim.fn.fnamemodify(fs.posix_to_os_path(assert(path)), ":p")
cb(os_path)
end
end
end
---@param parent_dir string
----@param entry canola.InternalEntry
+---@param entry oil.InternalEntry
---@param require_stat boolean
---@param cb fun(err?: string)
local function fetch_entry_metadata(parent_dir, entry, require_stat, cb)
@@ -315,16 +315,16 @@ local function fetch_entry_metadata(parent_dir, entry, require_stat, cb)
end
-- Sometimes fs_readdir entries don't have a type, so we need to stat them.
- -- See https://github.com/stevearc/canola.nvim/issues/543
+ -- See https://github.com/stevearc/oil.nvim/issues/543
if not require_stat and not entry[FIELD_TYPE] then
require_stat = true
end
-- Make sure we always get fs_stat info for links
- if entry[FIELD_TYPE] == 'link' then
+ if entry[FIELD_TYPE] == "link" then
read_link_data(entry_path, function(link_err, link, link_stat)
if link_err then
- log.warn('Error reading link data %s: %s', entry_path, link_err)
+ log.warn("Error reading link data %s: %s", entry_path, link_err)
return cb()
end
meta.link = link
@@ -336,7 +336,7 @@ local function fetch_entry_metadata(parent_dir, entry, require_stat, cb)
-- The link is broken, so let's use the stat of the link itself
uv.fs_lstat(entry_path, function(stat_err, stat)
if stat_err then
- log.warn('Error lstat link file %s: %s', entry_path, stat_err)
+ log.warn("Error lstat link file %s: %s", entry_path, stat_err)
return cb()
end
meta.stat = stat
@@ -350,7 +350,7 @@ local function fetch_entry_metadata(parent_dir, entry, require_stat, cb)
elseif require_stat then
uv.fs_stat(entry_path, function(stat_err, stat)
if stat_err then
- log.warn('Error stat file %s: %s', entry_path, stat_err)
+ log.warn("Error stat file %s: %s", entry_path, stat_err)
return cb()
end
assert(stat)
@@ -364,15 +364,15 @@ local function fetch_entry_metadata(parent_dir, entry, require_stat, cb)
end
-- On windows, sometimes the entry type from fs_readdir is "link" but the actual type is not.
--- See https://github.com/stevearc/canola.nvim/issues/535
+-- See https://github.com/stevearc/oil.nvim/issues/535
if fs.is_windows then
local old_fetch_metadata = fetch_entry_metadata
fetch_entry_metadata = function(parent_dir, entry, require_stat, cb)
- if entry[FIELD_TYPE] == 'link' then
+ if entry[FIELD_TYPE] == "link" then
local entry_path = fs.posix_to_os_path(parent_dir .. entry[FIELD_NAME])
uv.fs_lstat(entry_path, function(stat_err, stat)
if stat_err then
- log.warn('Error lstat link file %s: %s', entry_path, stat_err)
+ log.warn("Error lstat link file %s: %s", entry_path, stat_err)
return old_fetch_metadata(parent_dir, entry, require_stat, cb)
end
assert(stat)
@@ -393,22 +393,22 @@ end
---@param url string
---@param column_defs string[]
----@param cb fun(err?: string, entries?: canola.InternalEntry[], fetch_more?: fun())
+---@param cb fun(err?: string, entries?: oil.InternalEntry[], fetch_more?: fun())
local function list_windows_drives(url, column_defs, cb)
local _, path = util.parse_url(url)
assert(path)
local require_stat = columns_require_stat(column_defs)
- local stdout = ''
- local jid = vim.fn.jobstart({ 'wmic', 'logicaldisk', 'get', 'name' }, {
+ local stdout = ""
+ local jid = vim.fn.jobstart({ "wmic", "logicaldisk", "get", "name" }, {
stdout_buffered = true,
on_stdout = function(_, data)
- stdout = table.concat(data, '\n')
+ stdout = table.concat(data, "\n")
end,
on_exit = function(_, code)
if code ~= 0 then
- return cb('Error listing windows devices')
+ return cb("Error listing windows devices")
end
- local lines = vim.split(stdout, '\n', { plain = true, trimempty = true })
+ local lines = vim.split(stdout, "\n", { plain = true, trimempty = true })
-- Remove the "Name" header
table.remove(lines, 1)
local internal_entries = {}
@@ -421,12 +421,12 @@ local function list_windows_drives(url, column_defs, cb)
end)
for _, disk in ipairs(lines) do
- if disk:match('^%s*$') then
+ if disk:match("^%s*$") then
-- Skip empty line
complete_disk_cb()
else
- disk = disk:gsub(':%s*$', '')
- local cache_entry = cache.create_entry(url, disk, 'directory')
+ disk = disk:gsub(":%s*$", "")
+ local cache_entry = cache.create_entry(url, disk, "directory")
table.insert(internal_entries, cache_entry)
fetch_entry_metadata(path, cache_entry, require_stat, complete_disk_cb)
end
@@ -434,17 +434,17 @@ local function list_windows_drives(url, column_defs, cb)
end,
})
if jid <= 0 then
- cb('Could not list windows devices')
+ cb("Could not list windows devices")
end
end
---@param url string
---@param column_defs string[]
----@param cb fun(err?: string, entries?: canola.InternalEntry[], fetch_more?: fun())
+---@param cb fun(err?: string, entries?: oil.InternalEntry[], fetch_more?: fun())
M.list = function(url, column_defs, cb)
local _, path = util.parse_url(url)
assert(path)
- if fs.is_windows and path == '/' then
+ if fs.is_windows and path == "/" then
return list_windows_drives(url, column_defs, cb)
end
local dir = fs.posix_to_os_path(path)
@@ -453,7 +453,7 @@ M.list = function(url, column_defs, cb)
---@diagnostic disable-next-line: param-type-mismatch, discard-returns
uv.fs_opendir(dir, function(open_err, fd)
if open_err then
- if open_err:match('^ENOENT: no such file or directory') then
+ if open_err:match("^ENOENT: no such file or directory") 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 cb()
@@ -505,7 +505,7 @@ M.is_modifiable = function(bufnr)
local bufname = vim.api.nvim_buf_get_name(bufnr)
local _, path = util.parse_url(bufname)
assert(path)
- if fs.is_windows and path == '/' then
+ if fs.is_windows and path == "/" then
return false
end
local dir = fs.posix_to_os_path(path)
@@ -515,30 +515,30 @@ M.is_modifiable = function(bufnr)
end
-- fs_access can return nil, force boolean return
- return uv.fs_access(dir, 'W') == true
+ return uv.fs_access(dir, "W") == true
end
----@param action canola.Action
+---@param action oil.Action
---@return string
M.render_action = function(action)
- if action.type == 'create' then
+ if action.type == "create" then
local _, path = util.parse_url(action.url)
assert(path)
- local ret = string.format('CREATE %s', M.to_short_os_path(path, action.entry_type))
+ local ret = string.format("CREATE %s", M.to_short_os_path(path, action.entry_type))
if action.link then
- ret = ret .. ' -> ' .. fs.posix_to_os_path(action.link)
+ ret = ret .. " -> " .. fs.posix_to_os_path(action.link)
end
return ret
- elseif action.type == 'delete' then
+ elseif action.type == "delete" then
local _, path = util.parse_url(action.url)
assert(path)
local short_path = M.to_short_os_path(path, action.entry_type)
if config.delete_to_trash then
- return string.format(' TRASH %s', short_path)
+ return string.format(" TRASH %s", short_path)
else
- return string.format('DELETE %s', short_path)
+ return string.format("DELETE %s", short_path)
end
- elseif action.type == 'move' or action.type == 'copy' then
+ elseif action.type == "move" or action.type == "copy" then
local dest_adapter = assert(config.get_adapter_by_scheme(action.dest_url))
if dest_adapter == M then
local _, src_path = util.parse_url(action.src_url)
@@ -546,7 +546,7 @@ M.render_action = function(action)
local _, dest_path = util.parse_url(action.dest_url)
assert(dest_path)
return string.format(
- ' %s %s -> %s',
+ " %s %s -> %s",
action.type:upper(),
M.to_short_os_path(src_path, action.entry_type),
M.to_short_os_path(dest_path, action.entry_type)
@@ -560,10 +560,10 @@ M.render_action = function(action)
end
end
----@param action canola.Action
+---@param action oil.Action
---@param cb fun(err: nil|string)
M.perform_action = function(action, cb)
- if action.type == 'create' then
+ if action.type == "create" then
local _, path = util.parse_url(action.url)
assert(path)
path = fs.posix_to_os_path(path)
@@ -579,16 +579,16 @@ M.perform_action = function(action, cb)
end)
end
- if action.entry_type == 'directory' then
+ if action.entry_type == "directory" then
uv.fs_mkdir(path, config.new_dir_mode, function(err)
-- Ignore if the directory already exists
- if not err or err:match('^EEXIST:') then
+ if not err or err:match("^EEXIST:") then
cb()
else
cb(err)
end
end)
- elseif action.entry_type == 'link' and action.link then
+ elseif action.entry_type == "link" and action.link then
local flags = nil
local target = fs.posix_to_os_path(action.link)
if fs.is_windows then
@@ -600,21 +600,9 @@ M.perform_action = function(action, cb)
---@diagnostic disable-next-line: param-type-mismatch
uv.fs_symlink(target, path, flags, cb)
else
- fs.touch(
- path,
- config.new_file_mode,
- vim.schedule_wrap(function(err)
- if not err then
- vim.api.nvim_exec_autocmds(
- 'User',
- { pattern = 'CanolaFileCreated', modeline = false, data = { path = path } }
- )
- end
- cb(err)
- end)
- )
+ fs.touch(path, config.new_file_mode, cb)
end
- elseif action.type == 'delete' then
+ elseif action.type == "delete" then
local _, path = util.parse_url(action.url)
assert(path)
path = fs.posix_to_os_path(path)
@@ -631,11 +619,11 @@ M.perform_action = function(action, cb)
end
if config.delete_to_trash then
- require('canola.adapters.trash').delete_to_trash(path, cb)
+ require("oil.adapters.trash").delete_to_trash(path, cb)
else
fs.recursive_delete(action.entry_type, path, cb)
end
- elseif action.type == 'move' then
+ elseif action.type == "move" then
local dest_adapter = assert(config.get_adapter_by_scheme(action.dest_url))
if dest_adapter == M then
local _, src_path = util.parse_url(action.src_url)
@@ -653,7 +641,7 @@ M.perform_action = function(action, cb)
-- We should never hit this because we don't implement supported_cross_adapter_actions
cb("files adapter doesn't support cross-adapter move")
end
- elseif action.type == 'copy' then
+ elseif action.type == "copy" then
local dest_adapter = assert(config.get_adapter_by_scheme(action.dest_url))
if dest_adapter == M then
local _, src_path = util.parse_url(action.src_url)
@@ -668,7 +656,7 @@ M.perform_action = function(action, cb)
cb("files adapter doesn't support cross-adapter copy")
end
else
- cb(string.format('Bad action type: %s', action.type))
+ cb(string.format("Bad action type: %s", action.type))
end
end
diff --git a/lua/canola/adapters/files/permissions.lua b/lua/oil/adapters/files/permissions.lua
similarity index 72%
rename from lua/canola/adapters/files/permissions.lua
rename to lua/oil/adapters/files/permissions.lua
index 32c8488..6c306a6 100644
--- a/lua/canola/adapters/files/permissions.lua
+++ b/lua/oil/adapters/files/permissions.lua
@@ -4,7 +4,7 @@ local M = {}
---@param num integer
---@return string
local function perm_to_str(exe_modifier, num)
- local str = (bit.band(num, 4) ~= 0 and 'r' or '-') .. (bit.band(num, 2) ~= 0 and 'w' or '-')
+ local str = (bit.band(num, 4) ~= 0 and "r" or "-") .. (bit.band(num, 2) ~= 0 and "w" or "-")
if exe_modifier then
if bit.band(num, 1) ~= 0 then
return str .. exe_modifier
@@ -12,7 +12,7 @@ local function perm_to_str(exe_modifier, num)
return str .. exe_modifier:upper()
end
else
- return str .. (bit.band(num, 1) ~= 0 and 'x' or '-')
+ return str .. (bit.band(num, 1) ~= 0 and "x" or "-")
end
end
@@ -20,9 +20,9 @@ end
---@return string
M.mode_to_str = function(mode)
local extra = bit.rshift(mode, 9)
- return perm_to_str(bit.band(extra, 4) ~= 0 and 's', bit.rshift(mode, 6))
- .. perm_to_str(bit.band(extra, 2) ~= 0 and 's', bit.rshift(mode, 3))
- .. perm_to_str(bit.band(extra, 1) ~= 0 and 't', mode)
+ return perm_to_str(bit.band(extra, 4) ~= 0 and "s", bit.rshift(mode, 6))
+ .. perm_to_str(bit.band(extra, 2) ~= 0 and "s", bit.rshift(mode, 3))
+ .. perm_to_str(bit.band(extra, 1) ~= 0 and "t", mode)
end
---@param mode integer
@@ -38,25 +38,25 @@ end
---@param str string String of 3 characters
---@return nil|integer
local function str_to_mode(str)
- local r, w, x = unpack(vim.split(str, '', {}))
+ local r, w, x = unpack(vim.split(str, "", {}))
local mode = 0
- if r == 'r' then
+ if r == "r" then
mode = bit.bor(mode, 4)
- elseif r ~= '-' then
+ elseif r ~= "-" then
return nil
end
- if w == 'w' then
+ if w == "w" then
mode = bit.bor(mode, 2)
- elseif w ~= '-' then
+ elseif w ~= "-" then
return nil
end
-- t means sticky and executable
-- T means sticky, not executable
-- s means setuid/setgid and executable
-- S means setuid/setgid and not executable
- if x == 'x' or x == 't' or x == 's' then
+ if x == "x" or x == "t" or x == "s" then
mode = bit.bor(mode, 1)
- elseif x ~= '-' and x ~= 'T' and x ~= 'S' then
+ elseif x ~= "-" and x ~= "T" and x ~= "S" then
return nil
end
return mode
@@ -67,13 +67,13 @@ end
local function parse_extra_bits(perm)
perm = perm:lower()
local mode = 0
- if perm:sub(3, 3) == 's' then
+ if perm:sub(3, 3) == "s" then
mode = bit.bor(mode, 4)
end
- if perm:sub(6, 6) == 's' then
+ if perm:sub(6, 6) == "s" then
mode = bit.bor(mode, 2)
end
- if perm:sub(9, 9) == 't' then
+ if perm:sub(9, 9) == "t" then
mode = bit.bor(mode, 1)
end
return mode
@@ -83,7 +83,7 @@ end
---@return nil|integer
---@return nil|string
M.parse = function(line)
- local strval, rem = line:match('^([r%-][w%-][xsS%-][r%-][w%-][xsS%-][r%-][w%-][xtT%-])%s*(.*)$')
+ local strval, rem = line:match("^([r%-][w%-][xsS%-][r%-][w%-][xsS%-][r%-][w%-][xtT%-])%s*(.*)$")
if not strval then
return
end
diff --git a/lua/canola/adapters/s3.lua b/lua/oil/adapters/s3.lua
similarity index 65%
rename from lua/canola/adapters/s3.lua
rename to lua/oil/adapters/s3.lua
index bc3e614..b7b5400 100644
--- a/lua/canola/adapters/s3.lua
+++ b/lua/oil/adapters/s3.lua
@@ -1,78 +1,78 @@
-local config = require('canola.config')
-local constants = require('canola.constants')
-local files = require('canola.adapters.files')
-local fs = require('canola.fs')
-local loading = require('canola.loading')
-local pathutil = require('canola.pathutil')
-local s3fs = require('canola.adapters.s3.s3fs')
-local util = require('canola.util')
+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 s3fs = require("oil.adapters.s3.s3fs")
+local util = require("oil.util")
local M = {}
local FIELD_META = constants.FIELD_META
----@class (exact) canola.s3Url
+---@class (exact) oil.s3Url
---@field scheme string
---@field bucket nil|string
---@field path nil|string
----@param canola_url string
----@return canola.s3Url
-M.parse_url = function(canola_url)
- local scheme, url = util.parse_url(canola_url)
- assert(scheme and url, string.format("Malformed input url '%s'", canola_url))
+---@param oil_url string
+---@return oil.s3Url
+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 bucket, path = url:match('^([^/]+)/?(.*)$')
+ local bucket, path = url:match("^([^/]+)/?(.*)$")
ret.bucket = bucket
- ret.path = path ~= '' and path or nil
+ ret.path = path ~= "" and path or nil
if not ret.bucket and ret.path then
- error(string.format('Parsing error for s3 url: %s', canola_url))
+ error(string.format("Parsing error for s3 url: %s", oil_url))
end
- ---@cast ret canola.s3Url
+ ---@cast ret oil.s3Url
return ret
end
----@param url canola.s3Url
+---@param url oil.s3Url
---@return string
local function url_to_str(url)
local pieces = { url.scheme }
if url.bucket then
- assert(url.bucket ~= '')
+ assert(url.bucket ~= "")
table.insert(pieces, url.bucket)
- table.insert(pieces, '/')
+ table.insert(pieces, "/")
end
if url.path then
- assert(url.path ~= '')
+ assert(url.path ~= "")
table.insert(pieces, url.path)
end
- return table.concat(pieces, '')
+ return table.concat(pieces, "")
end
----@param url canola.s3Url
+---@param url oil.s3Url
---@param is_folder boolean
---@return string
local function url_to_s3(url, is_folder)
- local pieces = { 's3://' }
+ local pieces = { "s3://" }
if url.bucket then
- assert(url.bucket ~= '')
+ assert(url.bucket ~= "")
table.insert(pieces, url.bucket)
- table.insert(pieces, '/')
+ table.insert(pieces, "/")
end
if url.path then
- assert(url.path ~= '')
+ assert(url.path ~= "")
table.insert(pieces, url.path)
- if is_folder and not vim.endswith(url.path, '/') then
- table.insert(pieces, '/')
+ if is_folder and not vim.endswith(url.path, "/") then
+ table.insert(pieces, "/")
end
end
- return table.concat(pieces, '')
+ return table.concat(pieces, "")
end
----@param url canola.s3Url
+---@param url oil.s3Url
---@return boolean
local function is_bucket(url)
- assert(url.bucket and url.bucket ~= '')
+ assert(url.bucket and url.bucket ~= "")
if url.path then
- assert(url.path ~= '')
+ assert(url.path ~= "")
return false
end
return true
@@ -83,20 +83,20 @@ s3_columns.size = {
render = function(entry, conf)
local meta = entry[FIELD_META]
if not meta or not meta.size then
- return ''
+ return ""
elseif meta.size >= 1e9 then
- return string.format('%.1fG', meta.size / 1e9)
+ return string.format("%.1fG", meta.size / 1e9)
elseif meta.size >= 1e6 then
- return string.format('%.1fM', meta.size / 1e6)
+ return string.format("%.1fM", meta.size / 1e6)
elseif meta.size >= 1e3 then
- return string.format('%.1fk', meta.size / 1e3)
+ return string.format("%.1fk", meta.size / 1e3)
else
- return string.format('%d', meta.size)
+ return string.format("%d", meta.size)
end
end,
parse = function(line, conf)
- return line:match('^(%d+%S*)%s+(.*)$')
+ return line:match("^(%d+%S*)%s+(.*)$")
end,
get_sort_value = function(entry)
@@ -113,21 +113,21 @@ s3_columns.birthtime = {
render = function(entry, conf)
local meta = entry[FIELD_META]
if not meta or not meta.date then
- return ''
+ return ""
else
return meta.date
end
end,
parse = function(line, conf)
- return line:match('^(%d+%-%d+%-%d+%s%d+:%d+:%d+)%s+(.*)$')
+ return line:match("^(%d+%-%d+%-%d+%s%d+:%d+:%d+)%s+(.*)$")
end,
get_sort_value = function(entry)
local meta = entry[FIELD_META]
if meta and meta.date then
local year, month, day, hour, min, sec =
- meta.date:match('^(%d+)%-(%d+)%-(%d+)%s(%d+):(%d+):(%d+)$')
+ meta.date:match("^(%d+)%-(%d+)%-(%d+)%s(%d+):(%d+):(%d+)$")
local time =
os.time({ year = year, month = month, day = day, hour = hour, min = min, sec = sec })
return time
@@ -138,7 +138,7 @@ s3_columns.birthtime = {
}
---@param name string
----@return nil|canola.ColumnDefinition
+---@return nil|oil.ColumnDefinition
M.get_column = function(name)
return s3_columns[name]
end
@@ -148,9 +148,9 @@ end
M.get_parent = function(bufname)
local res = M.parse_url(bufname)
if res.path then
- assert(res.path ~= '')
+ assert(res.path ~= "")
local path = pathutil.parent(res.path)
- res.path = path ~= '' and path or nil
+ res.path = path ~= "" and path or nil
else
res.bucket = nil
end
@@ -166,10 +166,10 @@ end
---@param url string
---@param column_defs string[]
----@param callback fun(err?: string, entries?: canola.InternalEntry[], fetch_more?: fun())
+---@param callback fun(err?: string, entries?: oil.InternalEntry[], fetch_more?: fun())
M.list = function(url, column_defs, callback)
- if vim.fn.executable('aws') ~= 1 then
- callback('`aws` is not executable. Can you run `aws s3 ls`?')
+ if vim.fn.executable("aws") ~= 1 then
+ callback("`aws` is not executable. Can you run `aws s3 ls`?")
return
end
@@ -184,19 +184,19 @@ M.is_modifiable = function(bufnr)
return true
end
----@param action canola.Action
+---@param action oil.Action
---@return string
M.render_action = function(action)
- local is_folder = action.entry_type == 'directory'
- if action.type == 'create' then
+ local is_folder = action.entry_type == "directory"
+ if action.type == "create" then
local res = M.parse_url(action.url)
- local extra = is_bucket(res) and 'BUCKET ' or ''
- return string.format('CREATE %s%s', extra, url_to_s3(res, is_folder))
- elseif action.type == 'delete' then
+ local extra = is_bucket(res) and "BUCKET " or ""
+ return string.format("CREATE %s%s", extra, url_to_s3(res, is_folder))
+ elseif action.type == "delete" then
local res = M.parse_url(action.url)
- local extra = is_bucket(res) and 'BUCKET ' or ''
- return string.format('DELETE %s%s', extra, url_to_s3(res, is_folder))
- elseif action.type == 'move' or action.type == 'copy' then
+ local extra = is_bucket(res) and "BUCKET " or ""
+ return string.format("DELETE %s%s", extra, url_to_s3(res, is_folder))
+ 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
@@ -210,39 +210,39 @@ M.render_action = function(action)
dest = files.to_short_os_path(path, action.entry_type)
src = url_to_s3(M.parse_url(src), is_folder)
end
- return string.format(' %s %s -> %s', action.type:upper(), src, dest)
+ return string.format(" %s %s -> %s", action.type:upper(), src, dest)
else
error(string.format("Bad action type: '%s'", action.type))
end
end
----@param action canola.Action
+---@param action oil.Action
---@param cb fun(err: nil|string)
M.perform_action = function(action, cb)
- local is_folder = action.entry_type == 'directory'
- if action.type == 'create' then
+ local is_folder = action.entry_type == "directory"
+ if action.type == "create" then
local res = M.parse_url(action.url)
local bucket = is_bucket(res)
- if action.entry_type == 'directory' and bucket then
+ if action.entry_type == "directory" and bucket then
s3fs.mb(url_to_s3(res, true), cb)
- elseif action.entry_type == 'directory' or action.entry_type == 'file' then
+ elseif action.entry_type == "directory" or action.entry_type == "file" then
s3fs.touch(url_to_s3(res, is_folder), cb)
else
- cb(string.format('Bad entry type on s3 create action: %s', action.entry_type))
+ cb(string.format("Bad entry type on s3 create action: %s", action.entry_type))
end
- elseif action.type == 'delete' then
+ elseif action.type == "delete" then
local res = M.parse_url(action.url)
local bucket = is_bucket(res)
- if action.entry_type == 'directory' and bucket then
+ if action.entry_type == "directory" and bucket then
s3fs.rb(url_to_s3(res, true), cb)
- elseif action.entry_type == 'directory' or action.entry_type == 'file' then
+ elseif action.entry_type == "directory" or action.entry_type == "file" then
s3fs.rm(url_to_s3(res, is_folder), is_folder, cb)
else
- cb(string.format('Bad entry type on s3 delete action: %s', action.entry_type))
+ cb(string.format("Bad entry type on s3 delete action: %s", action.entry_type))
end
- elseif action.type == 'move' then
+ 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
@@ -250,7 +250,7 @@ M.perform_action = function(action, cb)
then
cb(
string.format(
- 'We should never attempt to move from the %s adapter to the %s adapter.',
+ "We should never attempt to move from the %s adapter to the %s adapter.",
src_adapter.name,
dest_adapter.name
)
@@ -276,7 +276,7 @@ M.perform_action = function(action, cb)
assert(dest)
s3fs.mv(src, dest, is_folder, cb)
- elseif action.type == 'copy' then
+ 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
@@ -284,7 +284,7 @@ M.perform_action = function(action, cb)
then
cb(
string.format(
- 'We should never attempt to copy from the %s adapter to the %s adapter.',
+ "We should never attempt to copy from the %s adapter to the %s adapter.",
src_adapter.name,
dest_adapter.name
)
@@ -311,11 +311,11 @@ M.perform_action = function(action, cb)
s3fs.cp(src, dest, is_folder, cb)
else
- cb(string.format('Bad action type: %s', action.type))
+ cb(string.format("Bad action type: %s", action.type))
end
end
-M.supported_cross_adapter_actions = { files = 'move' }
+M.supported_cross_adapter_actions = { files = "move" }
---@param bufnr integer
M.read_file = function(bufnr)
@@ -323,11 +323,11 @@ M.read_file = function(bufnr)
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, 'canola')
+ 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, 's3_XXXXXX'))
+ local fd, tmpfile = vim.loop.fs_mkstemp(fs.join(tmpdir, "s3_XXXXXX"))
if fd then
vim.loop.fs_close(fd)
end
@@ -336,9 +336,9 @@ M.read_file = function(bufnr)
s3fs.cp(url_to_s3(url, false), tmpfile, false, function(err)
loading.set_loading(bufnr, false)
vim.bo[bufnr].modifiable = true
- vim.cmd.doautocmd({ args = { 'BufReadPre', bufname }, mods = { silent = 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'))
+ 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()
@@ -352,7 +352,7 @@ M.read_file = function(bufnr)
if filetype then
vim.bo[bufnr].filetype = filetype
end
- vim.cmd.doautocmd({ args = { 'BufReadPost', bufname }, mods = { silent = true } })
+ vim.cmd.doautocmd({ args = { "BufReadPost", bufname }, mods = { silent = true } })
vim.api.nvim_buf_delete(tmp_bufnr, { force = true })
end)
end
@@ -361,14 +361,14 @@ end
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, 'canola')
- local fd, tmpfile = vim.loop.fs_mkstemp(fs.join(tmpdir, 's3_XXXXXXXX'))
+ 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, "s3_XXXXXXXX"))
if fd then
vim.loop.fs_close(fd)
end
- vim.cmd.doautocmd({ args = { 'BufWritePre', bufname }, mods = { silent = true } })
+ 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)
@@ -376,10 +376,10 @@ M.write_file = function(bufnr)
s3fs.cp(tmpfile, url_to_s3(url, false), false, function(err)
vim.bo[bufnr].modifiable = true
if err then
- vim.notify(string.format('Error writing file: %s', err), vim.log.levels.ERROR)
+ 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 } })
+ vim.cmd.doautocmd({ args = { "BufWritePost", bufname }, mods = { silent = true } })
end
vim.loop.fs_unlink(tmpfile)
vim.api.nvim_buf_delete(tmp_bufnr, { force = true })
diff --git a/lua/canola/adapters/s3/s3fs.lua b/lua/oil/adapters/s3/s3fs.lua
similarity index 68%
rename from lua/canola/adapters/s3/s3fs.lua
rename to lua/oil/adapters/s3/s3fs.lua
index d527166..2e16307 100644
--- a/lua/canola/adapters/s3/s3fs.lua
+++ b/lua/oil/adapters/s3/s3fs.lua
@@ -1,8 +1,8 @@
-local cache = require('canola.cache')
-local config = require('canola.config')
-local constants = require('canola.constants')
-local shell = require('canola.shell')
-local util = require('canola.util')
+local cache = require("oil.cache")
+local config = require("oil.config")
+local constants = require("oil.constants")
+local shell = require("oil.shell")
+local util = require("oil.util")
local M = {}
@@ -10,35 +10,35 @@ local FIELD_META = constants.FIELD_META
---@param line string
---@return string Name of entry
----@return canola.EntryType
+---@return oil.EntryType
---@return table Metadata for entry
local function parse_ls_line_bucket(line)
- local date, name = line:match('^(%d+%-%d+%-%d+%s%d+:%d+:%d+)%s+(.*)$')
+ local date, name = line:match("^(%d+%-%d+%-%d+%s%d+:%d+:%d+)%s+(.*)$")
if not date or not name then
error(string.format("Could not parse '%s'", line))
end
- local type = 'directory'
+ local type = "directory"
local meta = { date = date }
return name, type, meta
end
---@param line string
---@return string Name of entry
----@return canola.EntryType
+---@return oil.EntryType
---@return table Metadata for entry
local function parse_ls_line_file(line)
- local name = line:match('^%s+PRE%s+(.*)/$')
- local type = 'directory'
+ local name = line:match("^%s+PRE%s+(.*)/$")
+ local type = "directory"
local meta = {}
if name then
return name, type, meta
end
local date, size
- date, size, name = line:match('^(%d+%-%d+%-%d+%s%d+:%d+:%d+)%s+(%d+)%s+(.*)$')
+ date, size, name = line:match("^(%d+%-%d+%-%d+%s%d+:%d+:%d+)%s+(%d+)%s+(.*)$")
if not name then
error(string.format("Could not parse '%s'", line))
end
- type = 'file'
+ type = "file"
meta = { date = date, size = tonumber(size) }
return name, type, meta
end
@@ -46,15 +46,15 @@ end
---@param cmd string[] cmd and flags
---@return string[] Shell command to run
local function create_s3_command(cmd)
- local full_cmd = vim.list_extend({ 'aws', 's3' }, cmd)
+ local full_cmd = vim.list_extend({ "aws", "s3" }, cmd)
return vim.list_extend(full_cmd, config.extra_s3_args)
end
---@param url string
---@param path string
----@param callback fun(err?: string, entries?: canola.InternalEntry[], fetch_more?: fun())
+---@param callback fun(err?: string, entries?: oil.InternalEntry[], fetch_more?: fun())
function M.list_dir(url, path, callback)
- local cmd = create_s3_command({ 'ls', path, '--color=off', '--no-cli-pager' })
+ local cmd = create_s3_command({ "ls", path, "--color=off", "--no-cli-pager" })
shell.run(cmd, function(err, lines)
if err then
return callback(err)
@@ -63,13 +63,13 @@ function M.list_dir(url, path, callback)
local cache_entries = {}
local url_path, _
_, url_path = util.parse_url(url)
- local is_top_level = url_path == nil or url_path:match('/') == nil
+ local is_top_level = url_path == nil or url_path:match("/") == nil
local parse_ls_line = is_top_level and parse_ls_line_bucket or parse_ls_line_file
for _, line in ipairs(lines) do
- if line ~= '' then
+ if line ~= "" then
local name, type, meta = parse_ls_line(line)
-- in s3 '-' can be used to create an "empty folder"
- if name ~= '-' then
+ if name ~= "-" then
local cache_entry = cache.create_entry(url, name, type)
table.insert(cache_entries, cache_entry)
cache_entry[FIELD_META] = meta
@@ -85,8 +85,8 @@ end
---@param callback fun(err: nil|string)
function M.touch(path, callback)
-- here "-" means that we copy from stdin
- local cmd = create_s3_command({ 'cp', '-', path })
- shell.run(cmd, { stdin = 'null' }, callback)
+ local cmd = create_s3_command({ "cp", "-", path })
+ shell.run(cmd, { stdin = "null" }, callback)
end
--- Remove files
@@ -94,9 +94,9 @@ end
---@param is_folder boolean
---@param callback fun(err: nil|string)
function M.rm(path, is_folder, callback)
- local main_cmd = { 'rm', path }
+ local main_cmd = { "rm", path }
if is_folder then
- table.insert(main_cmd, '--recursive')
+ table.insert(main_cmd, "--recursive")
end
local cmd = create_s3_command(main_cmd)
shell.run(cmd, callback)
@@ -106,7 +106,7 @@ end
---@param bucket string
---@param callback fun(err: nil|string)
function M.rb(bucket, callback)
- local cmd = create_s3_command({ 'rb', bucket })
+ local cmd = create_s3_command({ "rb", bucket })
shell.run(cmd, callback)
end
@@ -114,7 +114,7 @@ end
---@param bucket string
---@param callback fun(err: nil|string)
function M.mb(bucket, callback)
- local cmd = create_s3_command({ 'mb', bucket })
+ local cmd = create_s3_command({ "mb", bucket })
shell.run(cmd, callback)
end
@@ -124,9 +124,9 @@ end
---@param is_folder boolean
---@param callback fun(err: nil|string)
function M.mv(src, dest, is_folder, callback)
- local main_cmd = { 'mv', src, dest }
+ local main_cmd = { "mv", src, dest }
if is_folder then
- table.insert(main_cmd, '--recursive')
+ table.insert(main_cmd, "--recursive")
end
local cmd = create_s3_command(main_cmd)
shell.run(cmd, callback)
@@ -138,9 +138,9 @@ end
---@param is_folder boolean
---@param callback fun(err: nil|string)
function M.cp(src, dest, is_folder, callback)
- local main_cmd = { 'cp', src, dest }
+ local main_cmd = { "cp", src, dest }
if is_folder then
- table.insert(main_cmd, '--recursive')
+ table.insert(main_cmd, "--recursive")
end
local cmd = create_s3_command(main_cmd)
shell.run(cmd, callback)
diff --git a/lua/canola/adapters/ssh.lua b/lua/oil/adapters/ssh.lua
similarity index 72%
rename from lua/canola/adapters/ssh.lua
rename to lua/oil/adapters/ssh.lua
index 4654b32..ae4291f 100644
--- a/lua/canola/adapters/ssh.lua
+++ b/lua/oil/adapters/ssh.lua
@@ -1,19 +1,19 @@
-local config = require('canola.config')
-local constants = require('canola.constants')
-local files = require('canola.adapters.files')
-local fs = require('canola.fs')
-local loading = require('canola.loading')
-local pathutil = require('canola.pathutil')
-local permissions = require('canola.adapters.files.permissions')
-local shell = require('canola.shell')
-local sshfs = require('canola.adapters.ssh.sshfs')
-local util = require('canola.util')
+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 sshfs = require("oil.adapters.ssh.sshfs")
+local util = require("oil.util")
local M = {}
local FIELD_NAME = constants.FIELD_NAME
local FIELD_META = constants.FIELD_META
----@class (exact) canola.sshUrl
+---@class (exact) oil.sshUrl
---@field scheme string
---@field host string
---@field user nil|string
@@ -22,75 +22,75 @@ local FIELD_META = constants.FIELD_META
---@param args string[]
local function scp(args, ...)
- local cmd = vim.list_extend({ 'scp', '-C' }, config.extra_scp_args)
+ local cmd = vim.list_extend({ "scp", "-C" }, config.extra_scp_args)
vim.list_extend(cmd, args)
shell.run(cmd, ...)
end
----@param canola_url string
----@return canola.sshUrl
-M.parse_url = function(canola_url)
- local scheme, url = util.parse_url(canola_url)
- assert(scheme and url, string.format("Malformed input url '%s'", canola_url))
+---@param oil_url string
+---@return oil.sshUrl
+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 username, rem = url:match('^([^@%s]+)@(.*)$')
+ local username, rem = url:match("^([^@%s]+)@(.*)$")
ret.user = username
url = rem or url
- local host, port, path = url:match('^([^:]+):(%d+)/(.*)$')
+ 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('^([^/]+)/(.*)$')
+ host, path = url:match("^([^/]+)/(.*)$")
ret.host = host
ret.path = path
end
if not ret.host or not ret.path then
- error(string.format('Malformed SSH url: %s', canola_url))
+ error(string.format("Malformed SSH url: %s", oil_url))
end
- ---@cast ret canola.sshUrl
+ ---@cast ret oil.sshUrl
return ret
end
----@param url canola.sshUrl
+---@param url oil.sshUrl
---@return string
local function url_to_str(url)
local pieces = { url.scheme }
if url.user then
table.insert(pieces, url.user)
- table.insert(pieces, '@')
+ table.insert(pieces, "@")
end
table.insert(pieces, url.host)
if url.port then
- table.insert(pieces, string.format(':%d', url.port))
+ table.insert(pieces, string.format(":%d", url.port))
end
- table.insert(pieces, '/')
+ table.insert(pieces, "/")
table.insert(pieces, url.path)
- return table.concat(pieces, '')
+ return table.concat(pieces, "")
end
----@param url canola.sshUrl
+---@param url oil.sshUrl
---@return string
local function url_to_scp(url)
- local pieces = { 'scp://' }
+ local pieces = { "scp://" }
if url.user then
table.insert(pieces, url.user)
- table.insert(pieces, '@')
+ table.insert(pieces, "@")
end
table.insert(pieces, url.host)
if url.port then
- table.insert(pieces, string.format(':%d', url.port))
+ table.insert(pieces, string.format(":%d", url.port))
end
- table.insert(pieces, '/')
+ table.insert(pieces, "/")
local escaped_path = util.url_escape(url.path)
table.insert(pieces, escaped_path)
- return table.concat(pieces, '')
+ return table.concat(pieces, "")
end
----@param url1 canola.sshUrl
----@param url2 canola.sshUrl
+---@param url1 oil.sshUrl
+---@param url2 oil.sshUrl
---@return boolean
local function url_hosts_equal(url1, url2)
return url1.host == url2.host and url1.port == url2.port and url1.user == url2.user
@@ -99,11 +99,11 @@ end
local _connections = {}
---@param url string
---@param allow_retry nil|boolean
----@return canola.sshFs
+---@return oil.sshFs
local function get_connection(url, allow_retry)
local res = M.parse_url(url)
res.scheme = config.adapter_to_scheme.ssh
- res.path = ''
+ res.path = ""
local key = url_to_str(res)
local conn = _connections[key]
if not conn or (allow_retry and conn:get_connection_error()) then
@@ -137,7 +137,7 @@ ssh_columns.permissions = {
end,
render_action = function(action)
- return string.format('CHMOD %s %s', permissions.mode_to_octal_str(action.value), action.url)
+ return string.format("CHMOD %s %s", permissions.mode_to_octal_str(action.value), action.url)
end,
perform_action = function(action, callback)
@@ -151,20 +151,20 @@ ssh_columns.size = {
render = function(entry, conf)
local meta = entry[FIELD_META]
if not meta or not meta.size then
- return ''
+ return ""
elseif meta.size >= 1e9 then
- return string.format('%.1fG', meta.size / 1e9)
+ return string.format("%.1fG", meta.size / 1e9)
elseif meta.size >= 1e6 then
- return string.format('%.1fM', meta.size / 1e6)
+ return string.format("%.1fM", meta.size / 1e6)
elseif meta.size >= 1e3 then
- return string.format('%.1fk', meta.size / 1e3)
+ return string.format("%.1fk", meta.size / 1e3)
else
- return string.format('%d', meta.size)
+ return string.format("%d", meta.size)
end
end,
parse = function(line, conf)
- return line:match('^(%d+%S*)%s+(.*)$')
+ return line:match("^(%d+%S*)%s+(.*)$")
end,
get_sort_value = function(entry)
@@ -178,7 +178,7 @@ ssh_columns.size = {
}
---@param name string
----@return nil|canola.ColumnDefinition
+---@return nil|oil.ColumnDefinition
M.get_column = function(name)
return ssh_columns[name]
end
@@ -206,13 +206,13 @@ M.normalize_url = function(url, callback)
local conn = get_connection(url, true)
local path = res.path
- if path == '' then
- path = '.'
+ if path == "" then
+ path = "."
end
conn:realpath(path, function(err, abspath)
if err then
- vim.notify(string.format('Error normalizing url %s: %s', url, err), vim.log.levels.WARN)
+ vim.notify(string.format("Error normalizing url %s: %s", url, err), vim.log.levels.WARN)
callback(url)
else
res.path = abspath
@@ -223,7 +223,7 @@ end
---@param url string
---@param column_defs string[]
----@param callback fun(err?: string, entries?: canola.InternalEntry[], fetch_more?: fun())
+---@param callback fun(err?: string, entries?: oil.InternalEntry[], fetch_more?: fun())
M.list = function(url, column_defs, callback)
local res = M.parse_url(url)
@@ -256,18 +256,18 @@ M.is_modifiable = function(bufnr)
return bit.band(rwx, 2) ~= 0
end
----@param action canola.Action
+---@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.type == "create" then
+ local ret = string.format("CREATE %s", action.url)
if action.link then
- ret = ret .. ' -> ' .. action.link
+ 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
+ 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
@@ -279,30 +279,30 @@ M.render_action = function(action)
assert(path)
src = files.to_short_os_path(path, action.entry_type)
end
- return string.format(' %s %s -> %s', action.type:upper(), src, dest)
+ return string.format(" %s %s -> %s", action.type:upper(), src, dest)
else
error(string.format("Bad action type: '%s'", action.type))
end
end
----@param action canola.Action
+---@param action oil.Action
---@param cb fun(err: nil|string)
M.perform_action = function(action, cb)
- if action.type == 'create' then
+ if action.type == "create" then
local res = M.parse_url(action.url)
local conn = get_connection(action.url)
- if action.entry_type == 'directory' then
+ if action.entry_type == "directory" then
conn:mkdir(res.path, cb)
- elseif action.entry_type == 'link' and action.link then
+ elseif action.entry_type == "link" and action.link then
conn:mklink(res.path, action.link, cb)
else
conn:touch(res.path, cb)
end
- elseif action.type == 'delete' then
+ elseif action.type == "delete" then
local res = M.parse_url(action.url)
local conn = get_connection(action.url)
conn:rm(res.path, cb)
- elseif action.type == 'move' then
+ 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
@@ -311,7 +311,7 @@ M.perform_action = function(action, cb)
local src_conn = get_connection(action.src_url)
local dest_conn = get_connection(action.dest_url)
if src_conn ~= dest_conn then
- scp({ '-r', url_to_scp(src_res), url_to_scp(dest_res) }, function(err)
+ scp({ "-r", url_to_scp(src_res), url_to_scp(dest_res) }, function(err)
if err then
return cb(err)
end
@@ -321,16 +321,16 @@ M.perform_action = function(action, cb)
src_conn:mv(src_res.path, dest_res.path, cb)
end
else
- cb('We should never attempt to move across adapters')
+ cb("We should never attempt to move across adapters")
end
- elseif action.type == 'copy' then
+ 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
local src_res = M.parse_url(action.src_url)
local dest_res = M.parse_url(action.dest_url)
if not url_hosts_equal(src_res, dest_res) then
- scp({ '-r', url_to_scp(src_res), url_to_scp(dest_res) }, cb)
+ scp({ "-r", url_to_scp(src_res), url_to_scp(dest_res) }, cb)
else
local src_conn = get_connection(action.src_url)
src_conn:cp(src_res.path, dest_res.path, cb)
@@ -349,14 +349,14 @@ M.perform_action = function(action, cb)
src_arg = fs.posix_to_os_path(path)
dest_arg = url_to_scp(M.parse_url(action.dest_url))
end
- scp({ '-r', src_arg, dest_arg }, cb)
+ scp({ "-r", src_arg, dest_arg }, cb)
end
else
- cb(string.format('Bad action type: %s', action.type))
+ cb(string.format("Bad action type: %s", action.type))
end
end
-M.supported_cross_adapter_actions = { files = 'copy' }
+M.supported_cross_adapter_actions = { files = "copy" }
---@param bufnr integer
M.read_file = function(bufnr)
@@ -365,11 +365,11 @@ M.read_file = function(bufnr)
local url = M.parse_url(bufname)
local scp_url = url_to_scp(url)
local basename = pathutil.basename(bufname)
- local cache_dir = vim.fn.stdpath('cache')
- assert(type(cache_dir) == 'string')
- local tmpdir = fs.join(cache_dir, 'canola')
+ 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, 'ssh_XXXXXX'))
+ local fd, tmpfile = vim.loop.fs_mkstemp(fs.join(tmpdir, "ssh_XXXXXX"))
if fd then
vim.loop.fs_close(fd)
end
@@ -378,9 +378,9 @@ M.read_file = function(bufnr)
scp({ scp_url, tmpfile }, function(err)
loading.set_loading(bufnr, false)
vim.bo[bufnr].modifiable = true
- vim.cmd.doautocmd({ args = { 'BufReadPre', bufname }, mods = { silent = 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'))
+ 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()
@@ -394,9 +394,9 @@ M.read_file = function(bufnr)
if filetype then
vim.bo[bufnr].filetype = filetype
end
- vim.cmd.doautocmd({ args = { 'BufReadPost', bufname }, mods = { silent = true } })
+ vim.cmd.doautocmd({ args = { "BufReadPost", bufname }, mods = { silent = true } })
vim.api.nvim_buf_delete(tmp_bufnr, { force = true })
- vim.keymap.set('n', 'gf', M.goto_file, { buffer = bufnr })
+ vim.keymap.set("n", "gf", M.goto_file, { buffer = bufnr })
end)
end
@@ -405,14 +405,14 @@ M.write_file = function(bufnr)
local bufname = vim.api.nvim_buf_get_name(bufnr)
local url = M.parse_url(bufname)
local scp_url = url_to_scp(url)
- local cache_dir = vim.fn.stdpath('cache')
- assert(type(cache_dir) == 'string')
- local tmpdir = fs.join(cache_dir, 'canola')
- local fd, tmpfile = vim.loop.fs_mkstemp(fs.join(tmpdir, 'ssh_XXXXXXXX'))
+ 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, "ssh_XXXXXXXX"))
if fd then
vim.loop.fs_close(fd)
end
- vim.cmd.doautocmd({ args = { 'BufWritePre', bufname }, mods = { silent = true } })
+ 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)
@@ -420,10 +420,10 @@ M.write_file = function(bufnr)
scp({ tmpfile, scp_url }, function(err)
vim.bo[bufnr].modifiable = true
if err then
- vim.notify(string.format('Error writing file: %s', err), vim.log.levels.ERROR)
+ 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 } })
+ vim.cmd.doautocmd({ args = { "BufWritePost", bufname }, mods = { silent = true } })
end
vim.loop.fs_unlink(tmpfile)
vim.api.nvim_buf_delete(tmp_bufnr, { force = true })
@@ -432,7 +432,7 @@ end
M.goto_file = function()
local url = M.parse_url(vim.api.nvim_buf_get_name(0))
- local fname = vim.fn.expand('')
+ local fname = vim.fn.expand("")
local fullpath = fname
if not fs.is_absolute(fname) then
local pardir = vim.fs.dirname(url.path)
@@ -441,7 +441,7 @@ M.goto_file = function()
url.path = vim.fs.dirname(fullpath)
local parurl = url_to_str(url)
- ---@cast M canola.Adapter
+ ---@cast M oil.Adapter
util.adapter_list_all(M, parurl, {}, function(err, entries)
if err then
vim.notify(string.format("Error finding file '%s': %s", fname, err), vim.log.levels.ERROR)
@@ -459,7 +459,7 @@ M.goto_file = function()
vim.cmd.edit({ args = { url_to_str(url) } })
return
end
- for suffix in vim.gsplit(vim.o.suffixesadd, ',', { plain = true, trimempty = true }) do
+ for suffix in vim.gsplit(vim.o.suffixesadd, ",", { plain = true, trimempty = true }) do
local suffixname = basename .. suffix
if name_map[suffixname] then
url.path = fullpath .. suffix
diff --git a/lua/canola/adapters/ssh/connection.lua b/lua/oil/adapters/ssh/connection.lua
similarity index 76%
rename from lua/canola/adapters/ssh/connection.lua
rename to lua/oil/adapters/ssh/connection.lua
index d5bcd06..6a47c07 100644
--- a/lua/canola/adapters/ssh/connection.lua
+++ b/lua/oil/adapters/ssh/connection.lua
@@ -1,22 +1,22 @@
-local config = require('canola.config')
-local layout = require('canola.layout')
-local util = require('canola.util')
+local config = require("oil.config")
+local layout = require("oil.layout")
+local util = require("oil.util")
----@class (exact) canola.sshCommand
+---@class (exact) oil.sshCommand
---@field cmd string|string[]
---@field cb fun(err?: string, output?: string[])
---@field running? boolean
----@class (exact) canola.sshConnection
----@field new fun(url: canola.sshUrl): canola.sshConnection
----@field create_ssh_command fun(url: canola.sshUrl): string[]
+---@class (exact) oil.sshConnection
+---@field new fun(url: oil.sshUrl): oil.sshConnection
+---@field create_ssh_command fun(url: oil.sshUrl): string[]
---@field meta {user?: string, groups?: string[]}
---@field connection_error nil|string
---@field connected boolean
---@field private term_bufnr integer
---@field private jid integer
---@field private term_winid nil|integer
----@field private commands canola.sshCommand[]
+---@field private commands oil.sshCommand[]
---@field private _stdout string[]
local SSHConnection = {}
@@ -24,12 +24,12 @@ local function output_extend(agg, output)
local start = #agg
if vim.tbl_isempty(agg) then
for _, line in ipairs(output) do
- line = line:gsub('\r', '')
+ line = line:gsub("\r", "")
table.insert(agg, line)
end
else
for i, v in ipairs(output) do
- v = v:gsub('\r', '')
+ v = v:gsub("\r", "")
if i == 1 then
agg[#agg] = agg[#agg] .. v
else
@@ -53,7 +53,7 @@ local function get_last_lines(bufnr, num_lines)
vim.api.nvim_buf_get_lines(bufnr, end_line - need_lines, end_line, false),
lines
)
- while not vim.tbl_isempty(lines) and lines[#lines]:match('^%s*$') do
+ while not vim.tbl_isempty(lines) and lines[#lines]:match("^%s*$") do
table.remove(lines)
end
end_line = end_line - need_lines
@@ -61,31 +61,31 @@ local function get_last_lines(bufnr, num_lines)
return lines
end
----@param url canola.sshUrl
+---@param url oil.sshUrl
---@return string[]
function SSHConnection.create_ssh_command(url)
local host = url.host
if url.user then
- host = url.user .. '@' .. host
+ host = url.user .. "@" .. host
end
local command = {
- 'ssh',
+ "ssh",
host,
}
if url.port then
- table.insert(command, '-p')
+ table.insert(command, "-p")
table.insert(command, url.port)
end
return command
end
----@param url canola.sshUrl
----@return canola.sshConnection
+---@param url oil.sshUrl
+---@return oil.sshConnection
function SSHConnection.new(url)
local command = SSHConnection.create_ssh_command(url)
vim.list_extend(command, {
- '/bin/sh',
- '-c',
+ "/bin/sh",
+ "-c",
-- HACK: For some reason in my testing if I just have "echo READY" it doesn't appear, but if I echo
-- anything prior to that, it *will* appear. The first line gets swallowed.
"echo '_make_newline_'; echo '===READY==='; exec /bin/sh",
@@ -112,7 +112,7 @@ function SSHConnection.new(url)
})
end)
self.term_id = term_id
- vim.api.nvim_chan_send(term_id, string.format('ssh %s\r\n', url.host))
+ vim.api.nvim_chan_send(term_id, string.format("ssh %s\r\n", url.host))
util.hack_around_termopen_autocmd(mode)
-- If it takes more than 2 seconds to connect, pop open the terminal
@@ -125,7 +125,7 @@ function SSHConnection.new(url)
local jid = vim.fn.jobstart(command, {
pty = true, -- This is require for interactivity
on_stdout = function(j, output)
- pcall(vim.api.nvim_chan_send, self.term_id, table.concat(output, '\r\n'))
+ pcall(vim.api.nvim_chan_send, self.term_id, table.concat(output, "\r\n"))
---@diagnostic disable-next-line: invisible
local new_i_start = output_extend(self._stdout, output)
self:_handle_output(new_i_start)
@@ -134,15 +134,15 @@ function SSHConnection.new(url)
pcall(
vim.api.nvim_chan_send,
self.term_id,
- string.format('\r\n[Process exited %d]\r\n', code)
+ string.format("\r\n[Process exited %d]\r\n", code)
)
-- Defer to allow the deferred terminal output handling to kick in first
vim.defer_fn(function()
if code == 0 then
- self:_set_connection_error('SSH connection terminated gracefully')
+ self:_set_connection_error("SSH connection terminated gracefully")
else
self:_set_connection_error(
- 'Unknown SSH error\nTo see more, run :lua require("canola.adapters.ssh").open_terminal()'
+ 'Unknown SSH error\nTo see more, run :lua require("oil.adapters.ssh").open_terminal()'
)
end
end, 20)
@@ -156,27 +156,27 @@ function SSHConnection.new(url)
else
self.jid = jid
end
- self:run('id -u', function(err, lines)
+ self:run("id -u", function(err, lines)
if err then
- vim.notify(string.format('Error fetching ssh connection user: %s', err), vim.log.levels.WARN)
+ vim.notify(string.format("Error fetching ssh connection user: %s", err), vim.log.levels.WARN)
else
assert(lines)
- self.meta.user = vim.trim(table.concat(lines, ''))
+ self.meta.user = vim.trim(table.concat(lines, ""))
end
end)
- self:run('id -G', function(err, lines)
+ self:run("id -G", function(err, lines)
if err then
vim.notify(
- string.format('Error fetching ssh connection user groups: %s', err),
+ string.format("Error fetching ssh connection user groups: %s", err),
vim.log.levels.WARN
)
else
assert(lines)
- self.meta.groups = vim.split(table.concat(lines, ''), '%s+', { trimempty = true })
+ self.meta.groups = vim.split(table.concat(lines, ""), "%s+", { trimempty = true })
end
end)
- ---@cast self canola.sshConnection
+ ---@cast self oil.sshConnection
return self
end
@@ -197,7 +197,7 @@ function SSHConnection:_handle_output(start_i)
if not self.connected then
for i = start_i, #self._stdout - 1 do
local line = self._stdout[i]
- if line == '===READY===' then
+ if line == "===READY===" then
if self.term_winid then
if vim.api.nvim_win_is_valid(self.term_winid) then
vim.api.nvim_win_close(self.term_winid, true)
@@ -215,7 +215,7 @@ function SSHConnection:_handle_output(start_i)
for i = start_i, #self._stdout - 1 do
---@type string
local line = self._stdout[i]
- if line:match('^===BEGIN===%s*$') then
+ if line:match("^===BEGIN===%s*$") then
self._stdout = util.tbl_slice(self._stdout, i + 1)
self:_handle_output(1)
return
@@ -223,15 +223,15 @@ function SSHConnection:_handle_output(start_i)
-- We can't be as strict with the matching (^$) because since we're using a pty the stdout and
-- stderr can be interleaved. If the command had an error, the stderr may interfere with a
-- clean print of the done line.
- local exit_code = line:match('===DONE%((%d+)%)===')
+ local exit_code = line:match("===DONE%((%d+)%)===")
if exit_code then
local output = util.tbl_slice(self._stdout, 1, i - 1)
local cb = self.commands[1].cb
self._stdout = util.tbl_slice(self._stdout, i + 1)
- if exit_code == '0' then
+ if exit_code == "0" then
cb(nil, output)
else
- cb(exit_code .. ': ' .. table.concat(output, '\n'), output)
+ cb(exit_code .. ": " .. table.concat(output, "\n"), output)
end
table.remove(self.commands, 1)
self:_handle_output(1)
@@ -244,17 +244,16 @@ function SSHConnection:_handle_output(start_i)
local function check_last_line()
local last_lines = get_last_lines(self.term_bufnr, 1)
local last_line = last_lines[1]
- if last_line:match('^Are you sure you want to continue connecting') then
+ if last_line:match("^Are you sure you want to continue connecting") then
self:open_terminal()
- -- selene: allow(if_same_then_else)
- elseif last_line:match('Password:%s*$') then
+ elseif last_line:match("Password:%s*$") then
self:open_terminal()
- elseif last_line:match(': Permission denied %(.+%)%.') then
- self:_set_connection_error(last_line:match(': (Permission denied %(.+%).)'))
- elseif last_line:match('^ssh: .*Connection refused%s*$') then
- self:_set_connection_error('Connection refused')
- elseif last_line:match('^Connection to .+ closed by remote host.%s*$') then
- self:_set_connection_error('Connection closed by remote host')
+ elseif last_line:match(": Permission denied %(.+%)%.") then
+ self:_set_connection_error(last_line:match(": (Permission denied %(.+%).)"))
+ elseif last_line:match("^ssh: .*Connection refused%s*$") then
+ self:_set_connection_error("Connection refused")
+ elseif last_line:match("^Connection to .+ closed by remote host.%s*$") then
+ self:_set_connection_error("Connection closed by remote host")
end
end
-- We have to defer this so the terminal buffer has time to update
@@ -274,12 +273,12 @@ function SSHConnection:open_terminal()
local row = math.floor((total_height - height) / 2)
local col = math.floor((vim.o.columns - width) / 2)
self.term_winid = vim.api.nvim_open_win(self.term_bufnr, true, {
- relative = 'editor',
+ relative = "editor",
width = width,
height = height,
row = row,
col = col,
- style = 'minimal',
+ style = "minimal",
border = config.ssh.border,
})
vim.cmd.startinsert()
diff --git a/lua/canola/adapters/ssh/sshfs.lua b/lua/oil/adapters/ssh/sshfs.lua
similarity index 65%
rename from lua/canola/adapters/ssh/sshfs.lua
rename to lua/oil/adapters/ssh/sshfs.lua
index c8602de..0dcc169 100644
--- a/lua/canola/adapters/ssh/sshfs.lua
+++ b/lua/oil/adapters/ssh/sshfs.lua
@@ -1,37 +1,37 @@
-local SSHConnection = require('canola.adapters.ssh.connection')
-local cache = require('canola.cache')
-local constants = require('canola.constants')
-local permissions = require('canola.adapters.files.permissions')
-local util = require('canola.util')
+local SSHConnection = require("oil.adapters.ssh.connection")
+local cache = require("oil.cache")
+local constants = require("oil.constants")
+local permissions = require("oil.adapters.files.permissions")
+local util = require("oil.util")
----@class (exact) canola.sshFs
----@field new fun(url: canola.sshUrl): canola.sshFs
----@field conn canola.sshConnection
+---@class (exact) oil.sshFs
+---@field new fun(url: oil.sshUrl): oil.sshFs
+---@field conn oil.sshConnection
local SSHFS = {}
local FIELD_TYPE = constants.FIELD_TYPE
local FIELD_META = constants.FIELD_META
local typechar_map = {
- l = 'link',
- d = 'directory',
- p = 'fifo',
- s = 'socket',
- ['-'] = 'file',
- c = 'file', -- character special file
- b = 'file', -- block special file
+ 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 canola.EntryType
+---@return oil.EntryType
---@return table Metadata for entry
local function parse_ls_line(line)
local typechar, perms, refcount, user, group, rem =
- line:match('^(.)(%S+)%s+(%d+)%s+(%d+)%s+(%d+)%s+(.*)$')
+ line:match("^(.)(%S+)%s+(%d+)%s+(%d+)%s+(%d+)%s+(.*)$")
if not typechar then
error(string.format("Could not parse '%s'", line))
end
- local type = typechar_map[typechar] or 'file'
+ local type = typechar_map[typechar] or "file"
local meta = {
user = user,
@@ -40,26 +40,26 @@ local function parse_ls_line(line)
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+(.*)')
+ 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+(.*)")
if name == nil then
major, minor, date, name =
- rem:match('^(%d+)%s*,%s*(%d+)%s+(%d+%-%d+%-%d+%s+%d%d:?%d%d)%s+(.*)')
+ rem:match("^(%d+)%s*,%s*(%d+)%s+(%d+%-%d+%-%d+%s+%d%d:?%d%d)%s+(.*)")
end
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+(.*)')
+ size, date, name = rem:match("^(%d+)%s+(%S+%s+%d+%s+%d%d:?%d%d)%s+(.*)")
if name == nil then
- size, date, name = rem:match('^(%d+)%s+(%d+%-%d+%-%d+%s+%d%d:?%d%d)%s+(.*)')
+ size, date, name = rem:match("^(%d+)%s+(%d+%-%d+%-%d+%s+%d%d:?%d%d)%s+(.*)")
end
meta.size = tonumber(size)
end
meta.iso_modified_date = date
- if type == 'link' then
+ if type == "link" then
local link
- name, link = unpack(vim.split(name, ' -> ', { plain = true }))
- if vim.endswith(link, '/') then
+ name, link = unpack(vim.split(name, " -> ", { plain = true }))
+ if vim.endswith(link, "/") then
link = link:sub(1, #link - 1)
end
meta.link = link
@@ -74,10 +74,10 @@ local function shellescape(str)
return "'" .. str:gsub("'", "'\\''") .. "'"
end
----@param url canola.sshUrl
----@return canola.sshFs
+---@param url oil.sshUrl
+---@return oil.sshFs
function SSHFS.new(url)
- ---@type canola.sshFs
+ ---@type oil.sshFs
return setmetatable({
conn = SSHConnection.new(url),
}, {
@@ -94,7 +94,7 @@ end
---@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, shellescape(path)), callback)
+ self.conn:run(string.format("chmod %s %s", octal, shellescape(path)), callback)
end
function SSHFS:open_terminal()
@@ -114,24 +114,24 @@ function SSHFS:realpath(path, callback)
return callback(err)
end
assert(lines)
- local abspath = table.concat(lines, '')
+ 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
+ if vim.endswith(abspath, ".") then
abspath = abspath:sub(1, #abspath - 1)
end
self.conn:run(
- string.format('LC_ALL=C ls -land --color=never %s', shellescape(abspath)),
+ string.format("LC_ALL=C ls -land --color=never %s", shellescape(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'
+ type = "directory"
else
assert(ls_lines)
local _
_, type = parse_ls_line(ls_lines[1])
end
- if type == 'directory' then
+ if type == "directory" then
abspath = util.addslash(abspath)
end
callback(nil, abspath)
@@ -144,15 +144,15 @@ local dir_meta = {}
---@param url string
---@param path string
----@param callback fun(err?: string, entries?: canola.InternalEntry[], fetch_more?: fun())
+---@param callback fun(err?: string, entries?: oil.InternalEntry[], fetch_more?: fun())
function SSHFS:list_dir(url, path, callback)
- local path_postfix = ''
- if path ~= '' then
- path_postfix = string.format(' %s', shellescape(path))
+ local path_postfix = ""
+ if path ~= "" then
+ path_postfix = string.format(" %s", shellescape(path))
end
- self.conn:run('LC_ALL=C ls -lan --color=never' .. path_postfix, function(err, lines)
+ self.conn:run("LC_ALL=C ls -lan --color=never" .. path_postfix, function(err, lines)
if err then
- if err:match('No such file or directory%s*$') 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()
@@ -165,12 +165,12 @@ function SSHFS:list_dir(url, path, callback)
local entries = {}
local cache_entries = {}
for _, line in ipairs(lines) do
- if line ~= '' and not line:match('^total') then
+ if line ~= "" and not line:match("^total") then
local name, type, meta = parse_ls_line(line)
- if name == '.' then
+ if name == "." then
dir_meta[url] = meta
- elseif name ~= '..' then
- if type == 'link' then
+ elseif name ~= ".." then
+ if type == "link" then
any_links = true
end
local cache_entry = cache.create_entry(url, name, type)
@@ -184,19 +184,19 @@ function SSHFS:list_dir(url, path, callback)
-- 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(
- 'LC_ALL=C ls -naLl --color=never' .. path_postfix .. ' 2> /dev/null',
+ "LC_ALL=C ls -naLl --color=never" .. path_postfix .. " 2> /dev/null",
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
+ if link_err and not link_err:match("^1:") then
return callback(link_err)
end
assert(link_lines)
for _, line in ipairs(link_lines) do
- if line ~= '' and not line:match('^total') then
+ 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
+ if ok and name ~= "." and name ~= ".." then
local cache_entry = entries[name]
- if cache_entry[FIELD_TYPE] == 'link' then
+ if cache_entry[FIELD_TYPE] == "link" then
cache_entry[FIELD_META].link_stat = {
type = type,
size = meta.size,
@@ -217,40 +217,40 @@ end
---@param path string
---@param callback fun(err: nil|string)
function SSHFS:mkdir(path, callback)
- self.conn:run(string.format('mkdir -p %s', shellescape(path)), callback)
+ self.conn:run(string.format("mkdir -p %s", shellescape(path)), callback)
end
---@param path string
---@param callback fun(err: nil|string)
function SSHFS:touch(path, callback)
- self.conn:run(string.format('touch %s', shellescape(path)), callback)
+ self.conn:run(string.format("touch %s", shellescape(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', shellescape(link), shellescape(path)), callback)
+ self.conn:run(string.format("ln -s %s %s", shellescape(link), shellescape(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', shellescape(path)), callback)
+ self.conn:run(string.format("rm -rf %s", shellescape(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', shellescape(src), shellescape(dest)), callback)
+ self.conn:run(string.format("mv %s %s", shellescape(src), shellescape(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', shellescape(src), shellescape(dest)), callback)
+ self.conn:run(string.format("cp -r %s %s", shellescape(src), shellescape(dest)), callback)
end
function SSHFS:get_dir_meta(url)
diff --git a/lua/canola/adapters/test.lua b/lua/oil/adapters/test.lua
similarity index 65%
rename from lua/canola/adapters/test.lua
rename to lua/oil/adapters/test.lua
index bcc42ed..c4176ef 100644
--- a/lua/canola/adapters/test.lua
+++ b/lua/oil/adapters/test.lua
@@ -1,5 +1,5 @@
-local cache = require('canola.cache')
-local util = require('canola.util')
+local cache = require("oil.cache")
+local util = require("oil.util")
local M = {}
---@param url string
@@ -12,7 +12,7 @@ local dir_listing = {}
---@param url string
---@param column_defs string[]
----@param cb fun(err?: string, entries?: canola.InternalEntry[], fetch_more?: fun())
+---@param cb fun(err?: string, entries?: oil.InternalEntry[], fetch_more?: fun())
M.list = function(url, column_defs, cb)
local _, path = util.parse_url(url)
local entries = dir_listing[path] or {}
@@ -29,32 +29,32 @@ M.test_clear = function()
end
---@param path string
----@param entry_type canola.EntryType
----@return canola.InternalEntry
+---@param entry_type oil.EntryType
+---@return oil.InternalEntry
M.test_set = function(path, entry_type)
- if path == '/' then
+ if path == "/" then
return {}
end
- local parent = vim.fn.fnamemodify(path, ':h')
+ local parent = vim.fn.fnamemodify(path, ":h")
if parent ~= path then
- M.test_set(parent, 'directory')
+ M.test_set(parent, "directory")
end
parent = util.addslash(parent)
if not dir_listing[parent] then
dir_listing[parent] = {}
end
- local name = vim.fn.fnamemodify(path, ':t')
+ local name = vim.fn.fnamemodify(path, ":t")
local entry = {
name = name,
entry_type = entry_type,
}
table.insert(dir_listing[parent], entry)
- local parent_url = 'canola-test://' .. parent
+ local parent_url = "oil-test://" .. parent
return cache.create_and_store_entry(parent_url, entry.name, entry.entry_type)
end
---@param name string
----@return nil|canola.ColumnDefinition
+---@return nil|oil.ColumnDefinition
M.get_column = function(name)
return nil
end
@@ -65,19 +65,19 @@ M.is_modifiable = function(bufnr)
return true
end
----@param action canola.Action
+---@param action oil.Action
---@return string
M.render_action = function(action)
- if action.type == 'create' or action.type == 'delete' then
- return string.format('%s %s', action.type:upper(), action.url)
- elseif action.type == 'move' or action.type == 'copy' then
- return string.format(' %s %s -> %s', action.type:upper(), action.src_url, action.dest_url)
+ if action.type == "create" or action.type == "delete" then
+ return string.format("%s %s", action.type:upper(), action.url)
+ elseif action.type == "move" or action.type == "copy" then
+ return string.format(" %s %s -> %s", action.type:upper(), action.src_url, action.dest_url)
else
- error('Bad action type')
+ error("Bad action type")
end
end
----@param action canola.Action
+---@param action oil.Action
---@param cb fun(err: nil|string)
M.perform_action = function(action, cb)
cb()
diff --git a/lua/oil/adapters/trash.lua b/lua/oil/adapters/trash.lua
new file mode 100644
index 0000000..b007074
--- /dev/null
+++ b/lua/oil/adapters/trash.lua
@@ -0,0 +1,9 @@
+local fs = require("oil.fs")
+
+if fs.is_mac then
+ return require("oil.adapters.trash.mac")
+elseif fs.is_windows then
+ return require("oil.adapters.trash.windows")
+else
+ return require("oil.adapters.trash.freedesktop")
+end
diff --git a/lua/canola/adapters/trash/freedesktop.lua b/lua/oil/adapters/trash/freedesktop.lua
similarity index 74%
rename from lua/canola/adapters/trash/freedesktop.lua
rename to lua/oil/adapters/trash/freedesktop.lua
index 65bf090..18b7e4c 100644
--- a/lua/canola/adapters/trash/freedesktop.lua
+++ b/lua/oil/adapters/trash/freedesktop.lua
@@ -1,11 +1,11 @@
-- Based on the FreeDesktop.org trash specification
-- https://specifications.freedesktop.org/trash/1.0/
-local cache = require('canola.cache')
-local config = require('canola.config')
-local constants = require('canola.constants')
-local files = require('canola.adapters.files')
-local fs = require('canola.fs')
-local util = require('canola.util')
+local cache = require("oil.cache")
+local config = require("oil.config")
+local constants = require("oil.constants")
+local files = require("oil.adapters.files")
+local fs = require("oil.fs")
+local util = require("oil.util")
local uv = vim.uv or vim.loop
local FIELD_META = constants.FIELD_META
@@ -14,8 +14,8 @@ local M = {}
local function ensure_trash_dir(path)
local mode = 448 -- 0700
- fs.mkdirp(fs.join(path, 'info'), mode)
- fs.mkdirp(fs.join(path, 'files'), mode)
+ fs.mkdirp(fs.join(path, "info"), mode)
+ fs.mkdirp(fs.join(path, "files"), mode)
end
---Gets the location of the home trash dir, creating it if necessary
@@ -23,9 +23,9 @@ end
local function get_home_trash_dir()
local xdg_home = vim.env.XDG_DATA_HOME
if not xdg_home then
- xdg_home = fs.join(assert(uv.os_homedir()), '.local', 'share')
+ xdg_home = fs.join(assert(uv.os_homedir()), ".local", "share")
end
- local trash_dir = fs.join(xdg_home, 'Trash')
+ local trash_dir = fs.join(xdg_home, "Trash")
ensure_trash_dir(trash_dir)
return trash_dir
end
@@ -43,13 +43,13 @@ end
local function get_top_trash_dirs(path)
local dirs = {}
local dev = (uv.fs_lstat(path) or {}).dev
- local top_trash_dirs = vim.fs.find('.Trash', { upward = true, path = path, limit = math.huge })
+ local top_trash_dirs = vim.fs.find(".Trash", { upward = true, path = path, limit = math.huge })
for _, top_trash_dir in ipairs(top_trash_dirs) do
local stat = uv.fs_lstat(top_trash_dir)
if stat and not dev then
dev = stat.dev
end
- if stat and stat.dev == dev and stat.type == 'directory' and is_sticky(stat.mode) then
+ if stat and stat.dev == dev and stat.type == "directory" and is_sticky(stat.mode) then
local trash_dir = fs.join(top_trash_dir, tostring(uv.getuid()))
ensure_trash_dir(trash_dir)
table.insert(dirs, trash_dir)
@@ -58,7 +58,7 @@ local function get_top_trash_dirs(path)
-- Also search for the .Trash-$uid
top_trash_dirs = vim.fs.find(
- string.format('.Trash-%d', uv.getuid()),
+ string.format(".Trash-%d", uv.getuid()),
{ upward = true, path = path, limit = math.huge }
)
for _, top_trash_dir in ipairs(top_trash_dirs) do
@@ -91,14 +91,14 @@ local function get_write_trash_dir(path)
return top_trash_dirs[1]
end
- local parent = vim.fn.fnamemodify(path, ':h')
- local next_parent = vim.fn.fnamemodify(parent, ':h')
+ local parent = vim.fn.fnamemodify(path, ":h")
+ local next_parent = vim.fn.fnamemodify(parent, ":h")
while parent ~= next_parent and uv.fs_lstat(next_parent).dev == dev do
parent = next_parent
- next_parent = vim.fn.fnamemodify(parent, ':h')
+ next_parent = vim.fn.fnamemodify(parent, ":h")
end
- local top_trash = fs.join(parent, string.format('.Trash-%d', uv.getuid()))
+ local top_trash = fs.join(parent, string.format(".Trash-%d", uv.getuid()))
ensure_trash_dir(top_trash)
return top_trash
end
@@ -116,7 +116,7 @@ end
M.normalize_url = function(url, callback)
local scheme, path = util.parse_url(url)
assert(path)
- local os_path = vim.fn.fnamemodify(fs.posix_to_os_path(path), ':p')
+ local os_path = vim.fn.fnamemodify(fs.posix_to_os_path(path), ":p")
uv.fs_realpath(
os_path,
vim.schedule_wrap(function(err, new_os_path)
@@ -127,12 +127,12 @@ M.normalize_url = function(url, callback)
end
---@param url string
----@param entry canola.Entry
+---@param entry oil.Entry
---@param cb fun(path: string)
M.get_entry_path = function(url, entry, cb)
local internal_entry = assert(cache.get_entry_by_id(entry.id))
local meta = assert(internal_entry[FIELD_META])
- ---@type canola.TrashInfo
+ ---@type oil.TrashInfo
local trash_info = meta.trash_info
if not trash_info then
-- This is a subpath in the trash
@@ -140,13 +140,13 @@ M.get_entry_path = function(url, entry, cb)
return
end
local path = fs.os_to_posix_path(trash_info.trash_file)
- if meta.stat.type == 'directory' then
+ if meta.stat.type == "directory" then
path = util.addslash(path)
end
- cb('canola://' .. path)
+ cb("oil://" .. path)
end
----@class canola.TrashInfo
+---@class oil.TrashInfo
---@field trash_file string
---@field info_file string
---@field original_path string
@@ -154,12 +154,12 @@ end
---@field stat uv.aliases.fs_stat_table
---@param info_file string
----@param cb fun(err?: string, info?: canola.TrashInfo)
+---@param cb fun(err?: string, info?: oil.TrashInfo)
local function read_trash_info(info_file, cb)
- if not vim.endswith(info_file, '.trashinfo') then
- return cb('File is not .trashinfo')
+ if not vim.endswith(info_file, ".trashinfo") then
+ return cb("File is not .trashinfo")
end
- uv.fs_open(info_file, 'r', 448, function(err, fd)
+ uv.fs_open(info_file, "r", 448, function(err, fd)
if err then
return cb(err)
end
@@ -182,35 +182,35 @@ local function read_trash_info(info_file, cb)
local trash_info = {
info_file = info_file,
}
- local lines = vim.split(content, '\r?\n')
- if lines[1] ~= '[Trash Info]' then
- return cb('File missing [Trash Info] header')
+ local lines = vim.split(content, "\r?\n")
+ if lines[1] ~= "[Trash Info]" then
+ return cb("File missing [Trash Info] header")
end
- local trash_base = vim.fn.fnamemodify(info_file, ':h:h')
+ local trash_base = vim.fn.fnamemodify(info_file, ":h:h")
for _, line in ipairs(lines) do
- local key, value = unpack(vim.split(line, '=', { plain = true, trimempty = true }))
- if key == 'Path' and not trash_info.original_path then
- if not vim.startswith(value, '/') then
+ local key, value = unpack(vim.split(line, "=", { plain = true, trimempty = true }))
+ if key == "Path" and not trash_info.original_path then
+ if not vim.startswith(value, "/") then
value = fs.join(trash_base, value)
end
trash_info.original_path = value
- elseif key == 'DeletionDate' and not trash_info.deletion_date then
- trash_info.deletion_date = vim.fn.strptime('%Y-%m-%dT%H:%M:%S', value)
+ elseif key == "DeletionDate" and not trash_info.deletion_date then
+ trash_info.deletion_date = vim.fn.strptime("%Y-%m-%dT%H:%M:%S", value)
end
end
if not trash_info.original_path or not trash_info.deletion_date then
- return cb('File missing required fields')
+ return cb("File missing required fields")
end
- local basename = vim.fn.fnamemodify(info_file, ':t:r')
- trash_info.trash_file = fs.join(trash_base, 'files', basename)
+ local basename = vim.fn.fnamemodify(info_file, ":t:r")
+ trash_info.trash_file = fs.join(trash_base, "files", basename)
uv.fs_lstat(trash_info.trash_file, function(trash_stat_err, trash_stat)
if trash_stat_err then
- cb('.trashinfo file points to non-existant file')
+ cb(".trashinfo file points to non-existant file")
else
trash_info.stat = trash_stat
- ---@cast trash_info canola.TrashInfo
+ ---@cast trash_info oil.TrashInfo
cb(nil, trash_info)
end
end)
@@ -222,7 +222,7 @@ end
---@param url string
---@param column_defs string[]
----@param cb fun(err?: string, entries?: canola.InternalEntry[], fetch_more?: fun())
+---@param cb fun(err?: string, entries?: oil.InternalEntry[], fetch_more?: fun())
M.list = function(url, column_defs, cb)
cb = vim.schedule_wrap(cb)
local _, path = util.parse_url(url)
@@ -244,14 +244,14 @@ M.list = function(url, column_defs, cb)
-- The first trash dir is a special case; it is in the home directory and we should only show
-- all entries if we are in the top root path "/"
if trash_idx == 1 then
- show_all_files = path == '/'
+ show_all_files = path == "/"
end
- local info_dir = fs.join(trash_dir, 'info')
+ local info_dir = fs.join(trash_dir, "info")
---@diagnostic disable-next-line: param-type-mismatch, discard-returns
uv.fs_opendir(info_dir, function(open_err, fd)
if open_err then
- if open_err:match('^ENOENT: no such file or directory') then
+ if open_err:match("^ENOENT: no such file or directory") 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 read_next_trash_dir()
@@ -286,12 +286,12 @@ M.list = function(url, column_defs, cb)
-- files.
poll()
else
- local parent = util.addslash(vim.fn.fnamemodify(info.original_path, ':h'))
+ local parent = util.addslash(vim.fn.fnamemodify(info.original_path, ":h"))
if path == parent or show_all_files then
- local name = vim.fn.fnamemodify(info.trash_file, ':t')
+ local name = vim.fn.fnamemodify(info.trash_file, ":t")
---@diagnostic disable-next-line: undefined-field
local cache_entry = cache.create_entry(url, name, info.stat.type)
- local display_name = vim.fn.fnamemodify(info.original_path, ':t')
+ local display_name = vim.fn.fnamemodify(info.original_path, ":t")
cache_entry[FIELD_META] = {
stat = info.stat,
trash_info = info,
@@ -302,12 +302,12 @@ M.list = function(url, column_defs, cb)
if path ~= parent and (show_all_files or fs.is_subpath(path, parent)) then
local name = parent:sub(path:len() + 1)
local next_par = vim.fs.dirname(name)
- while next_par ~= '.' do
+ while next_par ~= "." do
name = next_par
next_par = vim.fs.dirname(name)
end
---@diagnostic disable-next-line: undefined-field
- local cache_entry = cache.create_entry(url, name, 'directory')
+ local cache_entry = cache.create_entry(url, name, "directory")
cache_entry[FIELD_META] = {
stat = info.stat,
@@ -348,7 +348,7 @@ local file_columns = {}
local current_year
-- Make sure we run this import-time effect in the main loop (mostly for tests)
vim.schedule(function()
- current_year = vim.fn.strftime('%Y')
+ current_year = vim.fn.strftime("%Y")
end)
file_columns.mtime = {
@@ -357,7 +357,7 @@ file_columns.mtime = {
if not meta then
return nil
end
- ---@type canola.TrashInfo
+ ---@type oil.TrashInfo
local trash_info = meta.trash_info
local time = trash_info and trash_info.deletion_date or meta.stat and meta.stat.mtime.sec
if not time then
@@ -368,11 +368,11 @@ file_columns.mtime = {
if fmt then
ret = vim.fn.strftime(fmt, time)
else
- local year = vim.fn.strftime('%Y', time)
+ local year = vim.fn.strftime("%Y", time)
if year ~= current_year then
- ret = vim.fn.strftime('%b %d %Y', time)
+ ret = vim.fn.strftime("%b %d %Y", time)
else
- ret = vim.fn.strftime('%b %d %H:%M', time)
+ ret = vim.fn.strftime("%b %d %H:%M", time)
end
end
return ret
@@ -380,7 +380,7 @@ file_columns.mtime = {
get_sort_value = function(entry)
local meta = entry[FIELD_META]
- ---@type nil|canola.TrashInfo
+ ---@type nil|oil.TrashInfo
local trash_info = meta and meta.trash_info
if trash_info then
return trash_info.deletion_date
@@ -393,105 +393,104 @@ file_columns.mtime = {
local fmt = conf and conf.format
local pattern
if fmt then
- pattern = fmt:gsub('%%.', '%%S+')
+ pattern = fmt:gsub("%%.", "%%S+")
else
- pattern = '%S+%s+%d+%s+%d%d:?%d%d'
+ pattern = "%S+%s+%d+%s+%d%d:?%d%d"
end
- return line:match('^(' .. pattern .. ')%s+(.+)$')
+ return line:match("^(" .. pattern .. ")%s+(.+)$")
end,
}
---@param name string
----@return nil|canola.ColumnDefinition
+---@return nil|oil.ColumnDefinition
M.get_column = function(name)
return file_columns[name]
end
-M.supported_cross_adapter_actions = { files = 'move' }
+M.supported_cross_adapter_actions = { files = "move" }
----@param action canola.Action
+---@param action oil.Action
---@return boolean
M.filter_action = function(action)
- if action.type == 'create' then
+ if action.type == "create" then
return false
- elseif action.type == 'delete' then
+ elseif action.type == "delete" then
local entry = assert(cache.get_entry_by_url(action.url))
local meta = entry[FIELD_META]
return meta ~= nil and meta.trash_info ~= nil
- elseif action.type == 'move' then
+ 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))
- return src_adapter.name == 'files' or dest_adapter.name == 'files'
- -- selene: allow(if_same_then_else)
- elseif action.type == 'copy' then
+ return src_adapter.name == "files" or dest_adapter.name == "files"
+ 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))
- return src_adapter.name == 'files' or dest_adapter.name == 'files'
+ return src_adapter.name == "files" or dest_adapter.name == "files"
else
error(string.format("Bad action type '%s'", action.type))
end
end
----@param err canola.ParseError
+---@param err oil.ParseError
---@return boolean
M.filter_error = function(err)
- if err.message == 'Duplicate filename' then
+ if err.message == "Duplicate filename" then
return false
end
return true
end
----@param action canola.Action
+---@param action oil.Action
---@return string
M.render_action = function(action)
- if action.type == 'delete' then
+ if action.type == "delete" then
local entry = assert(cache.get_entry_by_url(action.url))
local meta = entry[FIELD_META]
- ---@type canola.TrashInfo
+ ---@type oil.TrashInfo
local trash_info = assert(meta).trash_info
local short_path = fs.shorten_path(trash_info.original_path)
- return string.format(' PURGE %s', short_path)
- elseif action.type == 'move' then
+ return string.format(" PURGE %s", short_path)
+ 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.name == 'files' then
+ if src_adapter.name == "files" then
local _, path = util.parse_url(action.src_url)
assert(path)
local short_path = files.to_short_os_path(path, action.entry_type)
- return string.format(' TRASH %s', short_path)
- elseif dest_adapter.name == 'files' then
+ return string.format(" TRASH %s", short_path)
+ elseif dest_adapter.name == "files" then
local _, path = util.parse_url(action.dest_url)
assert(path)
local short_path = files.to_short_os_path(path, action.entry_type)
- return string.format('RESTORE %s', short_path)
+ return string.format("RESTORE %s", short_path)
else
- error('Must be moving files into or out of trash')
+ error("Must be moving files into or out of trash")
end
- elseif action.type == 'copy' then
+ 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.name == 'files' then
+ if src_adapter.name == "files" then
local _, path = util.parse_url(action.src_url)
assert(path)
local short_path = files.to_short_os_path(path, action.entry_type)
- return string.format(' COPY %s -> TRASH', short_path)
- elseif dest_adapter.name == 'files' then
+ return string.format(" COPY %s -> TRASH", short_path)
+ elseif dest_adapter.name == "files" then
local _, path = util.parse_url(action.dest_url)
assert(path)
local short_path = files.to_short_os_path(path, action.entry_type)
- return string.format('RESTORE %s', short_path)
+ return string.format("RESTORE %s", short_path)
else
- error('Must be copying files into or out of trash')
+ error("Must be copying files into or out of trash")
end
else
error(string.format("Bad action type '%s'", action.type))
end
end
----@param trash_info canola.TrashInfo
+---@param trash_info oil.TrashInfo
---@param cb fun(err?: string)
local function purge(trash_info, cb)
- fs.recursive_delete('file', trash_info.info_file, function(err)
+ fs.recursive_delete("file", trash_info.info_file, function(err)
if err then
return cb(err)
end
@@ -506,15 +505,15 @@ end
local function write_info_file(path, info_path, cb)
uv.fs_open(
info_path,
- 'w',
+ "w",
448,
vim.schedule_wrap(function(err, fd)
if err then
return cb(err)
end
assert(fd)
- local deletion_date = vim.fn.strftime('%Y-%m-%dT%H:%M:%S')
- local contents = string.format('[Trash Info]\nPath=%s\nDeletionDate=%s', path, deletion_date)
+ local deletion_date = vim.fn.strftime("%Y-%m-%dT%H:%M:%S")
+ local contents = string.format("[Trash Info]\nPath=%s\nDeletionDate=%s", path, deletion_date)
uv.fs_write(fd, contents, function(write_err)
uv.fs_close(fd, function(close_err)
cb(write_err or close_err)
@@ -525,14 +524,14 @@ local function write_info_file(path, info_path, cb)
end
---@param path string
----@param cb fun(err?: string, trash_info?: canola.TrashInfo)
+---@param cb fun(err?: string, trash_info?: oil.TrashInfo)
local function create_trash_info(path, cb)
local trash_dir = get_write_trash_dir(path)
local basename = vim.fs.basename(path)
local now = os.time()
- local name = string.format('%s-%d.%d', basename, now, math.random(100000, 999999))
- local dest_path = fs.join(trash_dir, 'files', name)
- local dest_info = fs.join(trash_dir, 'info', name .. '.trashinfo')
+ local name = string.format("%s-%d.%d", basename, now, math.random(100000, 999999))
+ local dest_path = fs.join(trash_dir, "files", name)
+ local dest_info = fs.join(trash_dir, "info", name .. ".trashinfo")
uv.fs_lstat(path, function(err, stat)
if err then
return cb(err)
@@ -542,7 +541,7 @@ local function create_trash_info(path, cb)
if info_err then
return cb(info_err)
end
- ---@type canola.TrashInfo
+ ---@type oil.TrashInfo
local trash_info = {
original_path = path,
trash_file = dest_path,
@@ -555,28 +554,28 @@ local function create_trash_info(path, cb)
end)
end
----@param action canola.Action
+---@param action oil.Action
---@param cb fun(err: nil|string)
M.perform_action = function(action, cb)
- if action.type == 'delete' then
+ if action.type == "delete" then
local entry = assert(cache.get_entry_by_url(action.url))
local meta = entry[FIELD_META]
- ---@type canola.TrashInfo
+ ---@type oil.TrashInfo
local trash_info = assert(meta).trash_info
purge(trash_info, cb)
- elseif action.type == 'move' then
+ 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.name == 'files' then
+ if src_adapter.name == "files" then
local _, path = util.parse_url(action.src_url)
M.delete_to_trash(assert(path), cb)
- elseif dest_adapter.name == 'files' then
+ elseif dest_adapter.name == "files" then
-- Restore
local _, dest_path = util.parse_url(action.dest_url)
assert(dest_path)
local entry = assert(cache.get_entry_by_url(action.src_url))
local meta = entry[FIELD_META]
- ---@type canola.TrashInfo
+ ---@type oil.TrashInfo
local trash_info = assert(meta).trash_info
fs.recursive_move(action.entry_type, trash_info.trash_file, dest_path, function(err)
if err then
@@ -585,36 +584,36 @@ M.perform_action = function(action, cb)
uv.fs_unlink(trash_info.info_file, cb)
end)
else
- error('Must be moving files into or out of trash')
+ error("Must be moving files into or out of trash")
end
- elseif action.type == 'copy' then
+ 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.name == 'files' then
+ if src_adapter.name == "files" then
local _, path = util.parse_url(action.src_url)
assert(path)
create_trash_info(path, function(err, trash_info)
if err then
cb(err)
else
- local stat_type = trash_info.stat.type or 'unknown'
+ local stat_type = trash_info.stat.type or "unknown"
fs.recursive_copy(stat_type, path, trash_info.trash_file, vim.schedule_wrap(cb))
end
end)
- elseif dest_adapter.name == 'files' then
+ elseif dest_adapter.name == "files" then
-- Restore
local _, dest_path = util.parse_url(action.dest_url)
assert(dest_path)
local entry = assert(cache.get_entry_by_url(action.src_url))
local meta = entry[FIELD_META]
- ---@type canola.TrashInfo
+ ---@type oil.TrashInfo
local trash_info = assert(meta).trash_info
fs.recursive_copy(action.entry_type, trash_info.trash_file, dest_path, cb)
else
- error('Must be moving files into or out of trash')
+ error("Must be moving files into or out of trash")
end
else
- cb(string.format('Bad action type: %s', action.type))
+ cb(string.format("Bad action type: %s", action.type))
end
end
@@ -625,7 +624,7 @@ M.delete_to_trash = function(path, cb)
if err then
cb(err)
else
- local stat_type = trash_info.stat.type or 'unknown'
+ local stat_type = trash_info.stat.type or "unknown"
fs.recursive_move(stat_type, path, trash_info.trash_file, vim.schedule_wrap(cb))
end
end)
diff --git a/lua/canola/adapters/trash/mac.lua b/lua/oil/adapters/trash/mac.lua
similarity index 74%
rename from lua/canola/adapters/trash/mac.lua
rename to lua/oil/adapters/trash/mac.lua
index 3bf35ed..54d68a3 100644
--- a/lua/canola/adapters/trash/mac.lua
+++ b/lua/oil/adapters/trash/mac.lua
@@ -1,8 +1,8 @@
-local cache = require('canola.cache')
-local config = require('canola.config')
-local files = require('canola.adapters.files')
-local fs = require('canola.fs')
-local util = require('canola.util')
+local cache = require("oil.cache")
+local config = require("oil.config")
+local files = require("oil.adapters.files")
+local fs = require("oil.fs")
+local util = require("oil.util")
local uv = vim.uv or vim.loop
@@ -15,7 +15,7 @@ end
---Gets the location of the home trash dir, creating it if necessary
---@return string
local function get_trash_dir()
- local trash_dir = fs.join(assert(uv.os_homedir()), '.Trash')
+ local trash_dir = fs.join(assert(uv.os_homedir()), ".Trash")
touch_dir(trash_dir)
return trash_dir
end
@@ -25,24 +25,24 @@ end
M.normalize_url = function(url, callback)
local scheme, path = util.parse_url(url)
assert(path)
- callback(scheme .. '/')
+ callback(scheme .. "/")
end
---@param url string
----@param entry canola.Entry
+---@param entry oil.Entry
---@param cb fun(path: string)
M.get_entry_path = function(url, entry, cb)
local trash_dir = get_trash_dir()
local path = fs.join(trash_dir, entry.name)
- if entry.type == 'directory' then
- path = 'canola://' .. path
+ if entry.type == "directory" then
+ path = "oil://" .. path
end
cb(path)
end
---@param url string
---@param column_defs string[]
----@param cb fun(err?: string, entries?: canola.InternalEntry[], fetch_more?: fun())
+---@param cb fun(err?: string, entries?: oil.InternalEntry[], fetch_more?: fun())
M.list = function(url, column_defs, cb)
cb = vim.schedule_wrap(cb)
local _, path = util.parse_url(url)
@@ -51,7 +51,7 @@ M.list = function(url, column_defs, cb)
---@diagnostic disable-next-line: param-type-mismatch, discard-returns
uv.fs_opendir(trash_dir, function(open_err, fd)
if open_err then
- if open_err:match('^ENOENT: no such file or directory') then
+ if open_err:match("^ENOENT: no such file or directory") 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 cb()
@@ -106,61 +106,61 @@ M.is_modifiable = function(bufnr)
end
---@param name string
----@return nil|canola.ColumnDefinition
+---@return nil|oil.ColumnDefinition
M.get_column = function(name)
return nil
end
-M.supported_cross_adapter_actions = { files = 'move' }
+M.supported_cross_adapter_actions = { files = "move" }
----@param action canola.Action
+---@param action oil.Action
---@return string
M.render_action = function(action)
- if action.type == 'create' then
- return string.format('CREATE %s', action.url)
- elseif action.type == 'delete' then
- return string.format(' PURGE %s', action.url)
- elseif action.type == 'move' then
+ if action.type == "create" then
+ return string.format("CREATE %s", action.url)
+ elseif action.type == "delete" then
+ return string.format(" PURGE %s", action.url)
+ 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.name == 'files' then
+ if src_adapter.name == "files" then
local _, path = util.parse_url(action.src_url)
assert(path)
local short_path = files.to_short_os_path(path, action.entry_type)
- return string.format(' TRASH %s', short_path)
- elseif dest_adapter.name == 'files' then
+ return string.format(" TRASH %s", short_path)
+ elseif dest_adapter.name == "files" then
local _, path = util.parse_url(action.dest_url)
assert(path)
local short_path = files.to_short_os_path(path, action.entry_type)
- return string.format('RESTORE %s', short_path)
+ return string.format("RESTORE %s", short_path)
else
- return string.format(' %s %s -> %s', action.type:upper(), action.src_url, action.dest_url)
+ return string.format(" %s %s -> %s", action.type:upper(), action.src_url, action.dest_url)
end
- elseif action.type == 'copy' then
- return string.format(' %s %s -> %s', action.type:upper(), action.src_url, action.dest_url)
+ elseif action.type == "copy" then
+ return string.format(" %s %s -> %s", action.type:upper(), action.src_url, action.dest_url)
else
- error('Bad action type')
+ error("Bad action type")
end
end
----@param action canola.Action
+---@param action oil.Action
---@param cb fun(err: nil|string)
M.perform_action = function(action, cb)
local trash_dir = get_trash_dir()
- if action.type == 'create' then
+ if action.type == "create" then
local _, path = util.parse_url(action.url)
assert(path)
path = trash_dir .. path
- if action.entry_type == 'directory' then
+ if action.entry_type == "directory" then
uv.fs_mkdir(path, 493, function(err)
-- Ignore if the directory already exists
- if not err or err:match('^EEXIST:') then
+ if not err or err:match("^EEXIST:") then
cb()
else
cb(err)
end
end) -- 0755
- elseif action.entry_type == 'link' and action.link then
+ elseif action.entry_type == "link" and action.link then
local flags = nil
local target = fs.posix_to_os_path(action.link)
---@diagnostic disable-next-line: param-type-mismatch
@@ -168,33 +168,33 @@ M.perform_action = function(action, cb)
else
fs.touch(path, config.new_file_mode, cb)
end
- elseif action.type == 'delete' then
+ elseif action.type == "delete" then
local _, path = util.parse_url(action.url)
assert(path)
local fullpath = trash_dir .. path
fs.recursive_delete(action.entry_type, fullpath, cb)
- elseif action.type == 'move' or action.type == 'copy' then
+ elseif action.type == "move" or 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))
local _, src_path = util.parse_url(action.src_url)
local _, dest_path = util.parse_url(action.dest_url)
assert(src_path and dest_path)
- if src_adapter.name == 'files' then
+ if src_adapter.name == "files" then
dest_path = trash_dir .. dest_path
- elseif dest_adapter.name == 'files' then
+ elseif dest_adapter.name == "files" then
src_path = trash_dir .. src_path
else
dest_path = trash_dir .. dest_path
src_path = trash_dir .. src_path
end
- if action.type == 'move' then
+ if action.type == "move" then
fs.recursive_move(action.entry_type, src_path, dest_path, cb)
else
fs.recursive_copy(action.entry_type, src_path, dest_path, cb)
end
else
- cb(string.format('Bad action type: %s', action.type))
+ cb(string.format("Bad action type: %s", action.type))
end
end
@@ -212,8 +212,8 @@ M.delete_to_trash = function(path, cb)
end
assert(src_stat)
if uv.fs_lstat(dest) then
- local date_str = vim.fn.strftime(' %Y-%m-%dT%H:%M:%S')
- local name_pieces = vim.split(basename, '.', { plain = true })
+ local date_str = vim.fn.strftime(" %Y-%m-%dT%H:%M:%S")
+ local name_pieces = vim.split(basename, ".", { plain = true })
if #name_pieces > 1 then
table.insert(name_pieces, #name_pieces - 1, date_str)
basename = table.concat(name_pieces)
diff --git a/lua/canola/adapters/trash/windows.lua b/lua/oil/adapters/trash/windows.lua
similarity index 71%
rename from lua/canola/adapters/trash/windows.lua
rename to lua/oil/adapters/trash/windows.lua
index b0b2dcf..f7634e1 100644
--- a/lua/canola/adapters/trash/windows.lua
+++ b/lua/oil/adapters/trash/windows.lua
@@ -1,11 +1,11 @@
-local util = require('canola.util')
+local util = require("oil.util")
local uv = vim.uv or vim.loop
-local cache = require('canola.cache')
-local config = require('canola.config')
-local constants = require('canola.constants')
-local files = require('canola.adapters.files')
-local fs = require('canola.fs')
-local powershell_trash = require('canola.adapters.trash.windows.powershell-trash')
+local cache = require("oil.cache")
+local config = require("oil.config")
+local constants = require("oil.constants")
+local files = require("oil.adapters.files")
+local fs = require("oil.fs")
+local powershell_trash = require("oil.adapters.trash.windows.powershell-trash")
local FIELD_META = constants.FIELD_META
local FIELD_TYPE = constants.FIELD_TYPE
@@ -15,28 +15,28 @@ local M = {}
---@return string
local function get_trash_dir()
local cwd = assert(vim.fn.getcwd())
- local trash_dir = cwd:sub(1, 3) .. '$Recycle.Bin'
+ local trash_dir = cwd:sub(1, 3) .. "$Recycle.Bin"
if vim.fn.isdirectory(trash_dir) == 1 then
return trash_dir
end
- trash_dir = 'C:\\$Recycle.Bin'
+ trash_dir = "C:\\$Recycle.Bin"
if vim.fn.isdirectory(trash_dir) == 1 then
return trash_dir
end
- error('No trash found')
+ error("No trash found")
end
---@param path string
---@return string
local win_addslash = function(path)
- if not vim.endswith(path, '\\') then
- return path .. '\\'
+ if not vim.endswith(path, "\\") then
+ return path .. "\\"
else
return path
end
end
----@class canola.WindowsTrashInfo
+---@class oil.WindowsTrashInfo
---@field trash_file string
---@field original_path string
---@field deletion_date integer
@@ -44,7 +44,7 @@ end
---@param url string
---@param column_defs string[]
----@param cb fun(err?: string, entries?: canola.InternalEntry[], fetch_more?: fun())
+---@param cb fun(err?: string, entries?: oil.InternalEntry[], fetch_more?: fun())
M.list = function(url, column_defs, cb)
local _, path = util.parse_url(url)
path = fs.posix_to_os_path(assert(path))
@@ -61,7 +61,7 @@ M.list = function(url, column_defs, cb)
local raw_displayed_entries = vim.tbl_filter(
---@param entry {IsFolder: boolean, DeletionDate: integer, Name: string, Path: string, OriginalPath: string}
function(entry)
- local parent = win_addslash(assert(vim.fn.fnamemodify(entry.OriginalPath, ':h')))
+ local parent = win_addslash(assert(vim.fn.fnamemodify(entry.OriginalPath, ":h")))
local is_in_path = path == parent
local is_subpath = fs.is_subpath(path, parent)
return is_in_path or is_subpath or show_all_files
@@ -70,33 +70,33 @@ M.list = function(url, column_defs, cb)
)
local displayed_entries = vim.tbl_map(
---@param entry {IsFolder: boolean, DeletionDate: integer, Name: string, Path: string, OriginalPath: string}
- ---@return {[1]:nil, [2]:string, [3]:string, [4]:{stat: uv_fs_t, trash_info: canola.WindowsTrashInfo, display_name: string}}
+ ---@return {[1]:nil, [2]:string, [3]:string, [4]:{stat: uv_fs_t, trash_info: oil.WindowsTrashInfo, display_name: string}}
function(entry)
- local parent = win_addslash(assert(vim.fn.fnamemodify(entry.OriginalPath, ':h')))
+ local parent = win_addslash(assert(vim.fn.fnamemodify(entry.OriginalPath, ":h")))
- --- @type canola.InternalEntry
+ --- @type oil.InternalEntry
local cache_entry
if path == parent or show_all_files then
- local deleted_file_tail = assert(vim.fn.fnamemodify(entry.Path, ':t'))
- local deleted_file_head = assert(vim.fn.fnamemodify(entry.Path, ':h'))
+ local deleted_file_tail = assert(vim.fn.fnamemodify(entry.Path, ":t"))
+ local deleted_file_head = assert(vim.fn.fnamemodify(entry.Path, ":h"))
local info_file_head = deleted_file_head
--- @type string?
local info_file
cache_entry =
- cache.create_entry(url, deleted_file_tail, entry.IsFolder and 'directory' or 'file')
+ cache.create_entry(url, deleted_file_tail, entry.IsFolder and "directory" or "file")
-- info_file on windows has the following format: $I<6 char hash>.
-- the hash is the same for the deleted file and the info file
-- so, we take the hash (and extension) from the deleted file
--
-- see https://superuser.com/questions/368890/how-does-the-recycle-bin-in-windows-work/1736690#1736690
- local info_file_tail = deleted_file_tail:match('^%$R(.*)$') --[[@as string?]]
+ local info_file_tail = deleted_file_tail:match("^%$R(.*)$") --[[@as string?]]
if info_file_tail then
- info_file_tail = '$I' .. info_file_tail
- info_file = info_file_head .. '\\' .. info_file_tail
+ info_file_tail = "$I" .. info_file_tail
+ info_file = info_file_head .. "\\" .. info_file_tail
end
cache_entry[FIELD_META] = {
stat = nil,
- ---@type canola.WindowsTrashInfo
+ ---@type oil.WindowsTrashInfo
trash_info = {
trash_file = entry.Path,
original_path = entry.OriginalPath,
@@ -109,10 +109,10 @@ M.list = function(url, column_defs, cb)
if path ~= parent and (show_all_files or fs.is_subpath(path, parent)) then
local name = parent:sub(path:len() + 1)
local next_par = vim.fs.dirname(name)
- while next_par ~= '.' do
+ while next_par ~= "." do
name = next_par
next_par = vim.fs.dirname(name)
- cache_entry = cache.create_entry(url, name, 'directory')
+ cache_entry = cache.create_entry(url, name, "directory")
cache_entry[FIELD_META] = {}
end
@@ -132,7 +132,7 @@ end
local current_year
-- Make sure we run this import-time effect in the main loop (mostly for tests)
vim.schedule(function()
- current_year = vim.fn.strftime('%Y')
+ current_year = vim.fn.strftime("%Y")
end)
local file_columns = {}
@@ -142,7 +142,7 @@ file_columns.mtime = {
if not meta then
return nil
end
- ---@type canola.WindowsTrashInfo
+ ---@type oil.WindowsTrashInfo
local trash_info = meta.trash_info
local time = trash_info and trash_info.deletion_date
if not time then
@@ -153,11 +153,11 @@ file_columns.mtime = {
if fmt then
ret = vim.fn.strftime(fmt, time)
else
- local year = vim.fn.strftime('%Y', time)
+ local year = vim.fn.strftime("%Y", time)
if year ~= current_year then
- ret = vim.fn.strftime('%b %d %Y', time)
+ ret = vim.fn.strftime("%b %d %Y", time)
else
- ret = vim.fn.strftime('%b %d %H:%M', time)
+ ret = vim.fn.strftime("%b %d %H:%M", time)
end
end
return ret
@@ -165,7 +165,7 @@ file_columns.mtime = {
get_sort_value = function(entry)
local meta = entry[FIELD_META]
- ---@type nil|canola.WindowsTrashInfo
+ ---@type nil|oil.WindowsTrashInfo
local trash_info = meta and meta.trash_info
if trash_info and trash_info.deletion_date then
return trash_info.deletion_date
@@ -178,38 +178,37 @@ file_columns.mtime = {
local fmt = conf and conf.format
local pattern
if fmt then
- pattern = fmt:gsub('%%.', '%%S+')
+ pattern = fmt:gsub("%%.", "%%S+")
else
- pattern = '%S+%s+%d+%s+%d%d:?%d%d'
+ pattern = "%S+%s+%d+%s+%d%d:?%d%d"
end
- return line:match('^(' .. pattern .. ')%s+(.+)$')
+ return line:match("^(" .. pattern .. ")%s+(.+)$")
end,
}
---@param name string
----@return nil|canola.ColumnDefinition
+---@return nil|oil.ColumnDefinition
M.get_column = function(name)
return file_columns[name]
end
----@param action canola.Action
+---@param action oil.Action
---@return boolean
M.filter_action = function(action)
- if action.type == 'create' then
+ if action.type == "create" then
return false
- elseif action.type == 'delete' then
+ elseif action.type == "delete" then
local entry = assert(cache.get_entry_by_url(action.url))
local meta = entry[FIELD_META]
return meta ~= nil and meta.trash_info ~= nil
- elseif action.type == 'move' then
+ 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))
- return src_adapter.name == 'files' or dest_adapter.name == 'files'
- -- selene: allow(if_same_then_else)
- elseif action.type == 'copy' then
+ return src_adapter.name == "files" or dest_adapter.name == "files"
+ 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))
- return src_adapter.name == 'files' or dest_adapter.name == 'files'
+ return src_adapter.name == "files" or dest_adapter.name == "files"
else
error(string.format("Bad action type '%s'", action.type))
end
@@ -220,7 +219,7 @@ end
M.normalize_url = function(url, callback)
local scheme, path = util.parse_url(url)
assert(path)
- local os_path = vim.fn.fnamemodify(fs.posix_to_os_path(path), ':p')
+ local os_path = vim.fn.fnamemodify(fs.posix_to_os_path(path), ":p")
assert(os_path)
uv.fs_realpath(
os_path,
@@ -232,11 +231,11 @@ M.normalize_url = function(url, callback)
end
---@param url string
----@param entry canola.Entry
+---@param entry oil.Entry
---@param cb fun(path: string)
M.get_entry_path = function(url, entry, cb)
local internal_entry = assert(cache.get_entry_by_id(entry.id))
- local meta = internal_entry[FIELD_META] --[[@as {stat: uv_fs_t, trash_info: canola.WindowsTrashInfo, display_name: string}]]
+ local meta = internal_entry[FIELD_META] --[[@as {stat: uv_fs_t, trash_info: oil.WindowsTrashInfo, display_name: string}]]
local trash_info = meta and meta.trash_info
if not trash_info then
-- This is a subpath in the trash
@@ -245,84 +244,84 @@ M.get_entry_path = function(url, entry, cb)
end
local path = fs.os_to_posix_path(trash_info.trash_file)
- if entry.type == 'directory' then
+ if entry.type == "directory" then
path = win_addslash(path)
end
- cb('canola://' .. path)
+ cb("oil://" .. path)
end
----@param err canola.ParseError
+---@param err oil.ParseError
---@return boolean
M.filter_error = function(err)
- if err.message == 'Duplicate filename' then
+ if err.message == "Duplicate filename" then
return false
end
return true
end
----@param action canola.Action
+---@param action oil.Action
---@return string
M.render_action = function(action)
- if action.type == 'delete' then
+ if action.type == "delete" then
local entry = assert(cache.get_entry_by_url(action.url))
local meta = entry[FIELD_META]
- ---@type canola.WindowsTrashInfo
+ ---@type oil.WindowsTrashInfo
local trash_info = assert(meta).trash_info
local short_path = fs.shorten_path(trash_info.original_path)
- return string.format(' PURGE %s', short_path)
- elseif action.type == 'move' then
+ return string.format(" PURGE %s", short_path)
+ 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.name == 'files' then
+ if src_adapter.name == "files" then
local _, path = util.parse_url(action.src_url)
assert(path)
local short_path = files.to_short_os_path(path, action.entry_type)
- return string.format(' TRASH %s', short_path)
- elseif dest_adapter.name == 'files' then
+ return string.format(" TRASH %s", short_path)
+ elseif dest_adapter.name == "files" then
local _, path = util.parse_url(action.dest_url)
assert(path)
local short_path = files.to_short_os_path(path, action.entry_type)
- return string.format('RESTORE %s', short_path)
+ return string.format("RESTORE %s", short_path)
else
- error('Must be moving files into or out of trash')
+ error("Must be moving files into or out of trash")
end
- elseif action.type == 'copy' then
+ 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.name == 'files' then
+ if src_adapter.name == "files" then
local _, path = util.parse_url(action.src_url)
assert(path)
local short_path = files.to_short_os_path(path, action.entry_type)
- return string.format(' COPY %s -> TRASH', short_path)
- elseif dest_adapter.name == 'files' then
+ return string.format(" COPY %s -> TRASH", short_path)
+ elseif dest_adapter.name == "files" then
local _, path = util.parse_url(action.dest_url)
assert(path)
local short_path = files.to_short_os_path(path, action.entry_type)
- return string.format('RESTORE %s', short_path)
+ return string.format("RESTORE %s", short_path)
else
- error('Must be copying files into or out of trash')
+ error("Must be copying files into or out of trash")
end
else
error(string.format("Bad action type '%s'", action.type))
end
end
----@param trash_info canola.WindowsTrashInfo
----@param cb fun(err?: string, raw_entries: canola.WindowsRawEntry[]?)
+---@param trash_info oil.WindowsTrashInfo
+---@param cb fun(err?: string, raw_entries: oil.WindowsRawEntry[]?)
local purge = function(trash_info, cb)
- fs.recursive_delete('file', trash_info.info_file, function(err)
+ fs.recursive_delete("file", trash_info.info_file, function(err)
if err then
return cb(err)
end
- fs.recursive_delete('file', trash_info.trash_file, cb)
+ fs.recursive_delete("file", trash_info.trash_file, cb)
end)
end
---@param path string
---@param type string
----@param cb fun(err?: string, trash_info?: canola.TrashInfo)
+---@param cb fun(err?: string, trash_info?: oil.TrashInfo)
local function create_trash_info_and_copy(path, type, cb)
- local temp_path = path .. 'temp'
+ local temp_path = path .. "temp"
-- create a temporary copy on the same location
fs.recursive_copy(
type,
@@ -344,28 +343,28 @@ local function create_trash_info_and_copy(path, type, cb)
)
end
----@param action canola.Action
+---@param action oil.Action
---@param cb fun(err: nil|string)
M.perform_action = function(action, cb)
- if action.type == 'delete' then
+ if action.type == "delete" then
local entry = assert(cache.get_entry_by_url(action.url))
- local meta = entry[FIELD_META] --[[@as {stat: uv_fs_t, trash_info: canola.WindowsTrashInfo, display_name: string}]]
+ local meta = entry[FIELD_META] --[[@as {stat: uv_fs_t, trash_info: oil.WindowsTrashInfo, display_name: string}]]
local trash_info = meta and meta.trash_info
purge(trash_info, cb)
- elseif action.type == 'move' then
+ 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.name == 'files' then
+ if src_adapter.name == "files" then
local _, path = util.parse_url(action.src_url)
M.delete_to_trash(assert(path), cb)
- elseif dest_adapter.name == 'files' then
+ elseif dest_adapter.name == "files" then
-- Restore
local _, dest_path = util.parse_url(action.dest_url)
assert(dest_path)
dest_path = fs.posix_to_os_path(dest_path)
local entry = assert(cache.get_entry_by_url(action.src_url))
- local meta = entry[FIELD_META] --[[@as {stat: uv_fs_t, trash_info: canola.WindowsTrashInfo, display_name: string}]]
+ local meta = entry[FIELD_META] --[[@as {stat: uv_fs_t, trash_info: oil.WindowsTrashInfo, display_name: string}]]
local trash_info = meta and meta.trash_info
fs.recursive_move(action.entry_type, trash_info.trash_file, dest_path, function(err)
if err then
@@ -374,33 +373,33 @@ M.perform_action = function(action, cb)
uv.fs_unlink(trash_info.info_file, cb)
end)
end
- elseif action.type == 'copy' then
+ 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.name == 'files' then
+ if src_adapter.name == "files" then
local _, path = util.parse_url(action.src_url)
assert(path)
path = fs.posix_to_os_path(path)
local entry = assert(cache.get_entry_by_url(action.src_url))
create_trash_info_and_copy(path, entry[FIELD_TYPE], cb)
- elseif dest_adapter.name == 'files' then
+ elseif dest_adapter.name == "files" then
-- Restore
local _, dest_path = util.parse_url(action.dest_url)
assert(dest_path)
dest_path = fs.posix_to_os_path(dest_path)
local entry = assert(cache.get_entry_by_url(action.src_url))
- local meta = entry[FIELD_META] --[[@as {stat: uv_fs_t, trash_info: canola.WindowsTrashInfo, display_name: string}]]
+ local meta = entry[FIELD_META] --[[@as {stat: uv_fs_t, trash_info: oil.WindowsTrashInfo, display_name: string}]]
local trash_info = meta and meta.trash_info
fs.recursive_copy(action.entry_type, trash_info.trash_file, dest_path, cb)
else
- error('Must be moving files into or out of trash')
+ error("Must be moving files into or out of trash")
end
else
- cb(string.format('Bad action type: %s', action.type))
+ cb(string.format("Bad action type: %s", action.type))
end
end
-M.supported_cross_adapter_actions = { files = 'move' }
+M.supported_cross_adapter_actions = { files = "move" }
---@param path string
---@param cb fun(err?: string)
diff --git a/lua/canola/adapters/trash/windows/powershell-connection.lua b/lua/oil/adapters/trash/windows/powershell-connection.lua
similarity index 85%
rename from lua/canola/adapters/trash/windows/powershell-connection.lua
rename to lua/oil/adapters/trash/windows/powershell-connection.lua
index d97fa4f..332defb 100644
--- a/lua/canola/adapters/trash/windows/powershell-connection.lua
+++ b/lua/oil/adapters/trash/windows/powershell-connection.lua
@@ -1,18 +1,18 @@
----@class (exact) canola.PowershellCommand
+---@class (exact) oil.PowershellCommand
---@field cmd string
---@field cb fun(err?: string, output?: string)
---@field running? boolean
----@class canola.PowershellConnection
+---@class oil.PowershellConnection
---@field private jid integer
---@field private execution_error? string
----@field private commands canola.PowershellCommand[]
+---@field private commands oil.PowershellCommand[]
---@field private stdout string[]
---@field private is_reading_data boolean
local PowershellConnection = {}
---@param init_command? string
----@return canola.PowershellConnection
+---@return oil.PowershellConnection
function PowershellConnection.new(init_command)
local self = setmetatable({
commands = {},
@@ -22,7 +22,7 @@ function PowershellConnection.new(init_command)
self:_init(init_command)
- ---@type canola.PowershellConnection
+ ---@type oil.PowershellConnection
return self
end
@@ -41,23 +41,23 @@ function PowershellConnection:_init(init_command)
-- 65001 is the UTF-8 codepage
-- powershell needs to be launched with the UTF-8 codepage to use it for both stdin and stdout
local jid = vim.fn.jobstart({
- 'cmd',
- '/c',
+ "cmd",
+ "/c",
'"chcp 65001 && powershell -NoProfile -NoLogo -ExecutionPolicy Bypass -NoExit -Command -"',
}, {
---@param data string[]
on_stdout = function(_, data)
for _, fragment in ipairs(data) do
- if fragment:find('===DONE%((%a+)%)===') then
+ if fragment:find("===DONE%((%a+)%)===") then
self.is_reading_data = false
- local output = table.concat(self.stdout, '')
+ local output = table.concat(self.stdout, "")
local cb = self.commands[1].cb
table.remove(self.commands, 1)
- local success = fragment:match('===DONE%((%a+)%)===')
- if success == 'True' then
+ local success = fragment:match("===DONE%((%a+)%)===")
+ if success == "True" then
cb(nil, output)
- elseif success == 'False' then
- cb(success .. ': ' .. output, output)
+ elseif success == "False" then
+ cb(success .. ": " .. output, output)
end
self.stdout = {}
self:_consume()
diff --git a/lua/canola/adapters/trash/windows/powershell-trash.lua b/lua/oil/adapters/trash/windows/powershell-trash.lua
similarity index 88%
rename from lua/canola/adapters/trash/windows/powershell-trash.lua
rename to lua/oil/adapters/trash/windows/powershell-trash.lua
index 55ff69a..d050bb0 100644
--- a/lua/canola/adapters/trash/windows/powershell-trash.lua
+++ b/lua/oil/adapters/trash/windows/powershell-trash.lua
@@ -1,7 +1,7 @@
-- A wrapper around trash operations using windows powershell
-local Powershell = require('canola.adapters.trash.windows.powershell-connection')
+local Powershell = require("oil.adapters.trash.windows.powershell-connection")
----@class canola.WindowsRawEntry
+---@class oil.WindowsRawEntry
---@field IsFolder boolean
---@field DeletionDate integer
---@field Name string
@@ -30,10 +30,10 @@ $data = @(foreach ($i in $folder.items())
ConvertTo-Json $data -Compress
]]
----@type nil|canola.PowershellConnection
+---@type nil|oil.PowershellConnection
local list_entries_powershell
----@param cb fun(err?: string, raw_entries?: canola.WindowsRawEntry[])
+---@param cb fun(err?: string, raw_entries?: oil.WindowsRawEntry[])
M.list_raw_entries = function(cb)
if not list_entries_powershell then
list_entries_powershell = Powershell.new(list_entries_init)
@@ -63,7 +63,7 @@ $path = Get-Item '%s'
$folder.ParseName($path.FullName).InvokeVerb('delete')
]]
----@type nil|canola.PowershellConnection
+---@type nil|oil.PowershellConnection
local delete_to_trash_powershell
---@param path string
diff --git a/lua/canola/cache.lua b/lua/oil/cache.lua
similarity index 77%
rename from lua/canola/cache.lua
rename to lua/oil/cache.lua
index 20160c7..ef5597c 100644
--- a/lua/canola/cache.lua
+++ b/lua/oil/cache.lua
@@ -1,5 +1,5 @@
-local constants = require('canola.constants')
-local util = require('canola.util')
+local constants = require("oil.constants")
+local util = require("oil.util")
local M = {}
local FIELD_ID = constants.FIELD_ID
@@ -8,11 +8,11 @@ local FIELD_META = constants.FIELD_META
local next_id = 1
--- Map>
----@type table>
+-- Map>
+---@type table>
local url_directory = {}
----@type table
+---@type table
local entries_by_id = {}
---@type table
@@ -28,7 +28,7 @@ local _cached_id_fmt
M.format_id = function(id)
if not _cached_id_fmt then
local id_str_length = math.max(3, 1 + math.floor(math.log10(next_id)))
- _cached_id_fmt = '/%0' .. string.format('%d', id_str_length) .. 'd'
+ _cached_id_fmt = "/%0" .. string.format("%d", id_str_length) .. "d"
end
return _cached_id_fmt:format(id)
end
@@ -42,8 +42,8 @@ end
---@param parent_url string
---@param name string
----@param type canola.EntryType
----@return canola.InternalEntry
+---@param type oil.EntryType
+---@return oil.InternalEntry
M.create_entry = function(parent_url, name, type)
parent_url = util.addslash(parent_url)
local parent = tmp_url_directory[parent_url] or url_directory[parent_url]
@@ -58,7 +58,7 @@ M.create_entry = function(parent_url, name, type)
end
---@param parent_url string
----@param entry canola.InternalEntry
+---@param entry oil.InternalEntry
M.store_entry = function(parent_url, entry)
parent_url = util.addslash(parent_url)
local parent = url_directory[parent_url]
@@ -85,8 +85,8 @@ end
---@param parent_url string
---@param name string
----@param type canola.EntryType
----@return canola.InternalEntry
+---@param type oil.EntryType
+---@return oil.InternalEntry
M.create_and_store_entry = function(parent_url, name, type)
local entry = M.create_entry(parent_url, name, type)
M.store_entry(parent_url, entry)
@@ -115,18 +115,18 @@ M.end_update_url = function(parent_url)
end
---@param id integer
----@return nil|canola.InternalEntry
+---@return nil|oil.InternalEntry
M.get_entry_by_id = function(id)
return entries_by_id[id]
end
---@param url string
----@return nil|canola.InternalEntry
+---@return nil|oil.InternalEntry
M.get_entry_by_url = function(url)
local scheme, path = util.parse_url(url)
assert(path)
- local parent_url = scheme .. vim.fn.fnamemodify(path, ':h')
- local basename = vim.fn.fnamemodify(path, ':t')
+ local parent_url = scheme .. vim.fn.fnamemodify(path, ":h")
+ local basename = vim.fn.fnamemodify(path, ":t")
return M.list_url(parent_url)[basename]
end
@@ -135,46 +135,46 @@ end
M.get_parent_url = function(id)
local url = parent_url_by_id[id]
if not url then
- error(string.format('Entry %d missing parent url', id))
+ error(string.format("Entry %d missing parent url", id))
end
return url
end
---@param url string
----@return table
+---@return table
M.list_url = function(url)
url = util.addslash(url)
return url_directory[url] or {}
end
----@param action canola.Action
+---@param action oil.Action
M.perform_action = function(action)
- if action.type == 'create' then
+ if action.type == "create" then
local scheme, path = util.parse_url(action.url)
assert(path)
- local parent_url = util.addslash(scheme .. vim.fn.fnamemodify(path, ':h'))
- local name = vim.fn.fnamemodify(path, ':t')
+ local parent_url = util.addslash(scheme .. vim.fn.fnamemodify(path, ":h"))
+ local name = vim.fn.fnamemodify(path, ":t")
M.create_and_store_entry(parent_url, name, action.entry_type)
- elseif action.type == 'delete' then
+ elseif action.type == "delete" then
local scheme, path = util.parse_url(action.url)
assert(path)
- local parent_url = util.addslash(scheme .. vim.fn.fnamemodify(path, ':h'))
- local name = vim.fn.fnamemodify(path, ':t')
+ local parent_url = util.addslash(scheme .. vim.fn.fnamemodify(path, ":h"))
+ local name = vim.fn.fnamemodify(path, ":t")
local entry = url_directory[parent_url][name]
url_directory[parent_url][name] = nil
entries_by_id[entry[FIELD_ID]] = nil
parent_url_by_id[entry[FIELD_ID]] = nil
- elseif action.type == 'move' then
+ elseif action.type == "move" then
local src_scheme, src_path = util.parse_url(action.src_url)
assert(src_path)
- local src_parent_url = util.addslash(src_scheme .. vim.fn.fnamemodify(src_path, ':h'))
- local src_name = vim.fn.fnamemodify(src_path, ':t')
+ local src_parent_url = util.addslash(src_scheme .. vim.fn.fnamemodify(src_path, ":h"))
+ local src_name = vim.fn.fnamemodify(src_path, ":t")
local entry = url_directory[src_parent_url][src_name]
local dest_scheme, dest_path = util.parse_url(action.dest_url)
assert(dest_path)
- local dest_parent_url = util.addslash(dest_scheme .. vim.fn.fnamemodify(dest_path, ':h'))
- local dest_name = vim.fn.fnamemodify(dest_path, ':t')
+ local dest_parent_url = util.addslash(dest_scheme .. vim.fn.fnamemodify(dest_path, ":h"))
+ local dest_name = vim.fn.fnamemodify(dest_path, ":t")
url_directory[src_parent_url][src_name] = nil
local dest_parent = url_directory[dest_parent_url]
@@ -188,14 +188,13 @@ M.perform_action = function(action)
parent_url_by_id[entry[FIELD_ID]] = dest_parent_url
entry[FIELD_NAME] = dest_name
util.update_moved_buffers(action.entry_type, action.src_url, action.dest_url)
- elseif action.type == 'copy' then
+ elseif action.type == "copy" then
local scheme, path = util.parse_url(action.dest_url)
assert(path)
- local parent_url = util.addslash(scheme .. vim.fn.fnamemodify(path, ':h'))
- local name = vim.fn.fnamemodify(path, ':t')
+ local parent_url = util.addslash(scheme .. vim.fn.fnamemodify(path, ":h"))
+ local name = vim.fn.fnamemodify(path, ":t")
M.create_and_store_entry(parent_url, name, action.entry_type)
- -- selene: allow(empty_if)
- elseif action.type == 'change' then
+ elseif action.type == "change" then
-- Cache doesn't need to update
else
---@diagnostic disable-next-line: undefined-field
diff --git a/lua/canola/clipboard.lua b/lua/oil/clipboard.lua
similarity index 67%
rename from lua/canola/clipboard.lua
rename to lua/oil/clipboard.lua
index a5bad24..04498f5 100644
--- a/lua/canola/clipboard.lua
+++ b/lua/oil/clipboard.lua
@@ -1,11 +1,11 @@
-local cache = require('canola.cache')
-local canola = require('canola')
-local columns = require('canola.columns')
-local config = require('canola.config')
-local fs = require('canola.fs')
-local parser = require('canola.mutator.parser')
-local util = require('canola.util')
-local view = require('canola.view')
+local cache = require("oil.cache")
+local columns = require("oil.columns")
+local config = require("oil.config")
+local fs = require("oil.fs")
+local oil = require("oil")
+local parser = require("oil.mutator.parser")
+local util = require("oil.util")
+local view = require("oil.view")
local M = {}
@@ -16,10 +16,10 @@ local function get_linux_session_type()
return
end
xdg_session_type = xdg_session_type:lower()
- if xdg_session_type:find('x11') then
- return 'x11'
- elseif xdg_session_type:find('wayland') then
- return 'wayland'
+ if xdg_session_type:find("x11") then
+ return "x11"
+ elseif xdg_session_type:find("wayland") then
+ return "wayland"
else
return nil
end
@@ -29,15 +29,15 @@ end
local function is_linux_desktop_gnome()
local cur_desktop = vim.env.XDG_CURRENT_DESKTOP
local session_desktop = vim.env.XDG_SESSION_DESKTOP
- local idx = session_desktop and session_desktop:lower():find('gnome')
- or cur_desktop and cur_desktop:lower():find('gnome')
- return idx ~= nil or cur_desktop == 'X-Cinnamon' or cur_desktop == 'XFCE'
+ local idx = session_desktop and session_desktop:lower():find("gnome")
+ or cur_desktop and cur_desktop:lower():find("gnome")
+ return idx ~= nil or cur_desktop == "X-Cinnamon" or cur_desktop == "XFCE"
end
---@param winid integer
----@param entry canola.InternalEntry
----@param column_defs canola.ColumnSpec[]
----@param adapter canola.Adapter
+---@param entry oil.InternalEntry
+---@param column_defs oil.ColumnSpec[]
+---@param adapter oil.Adapter
---@param bufnr integer
local function write_pasted(winid, entry, column_defs, adapter, bufnr)
local col_width = {}
@@ -52,10 +52,10 @@ local function write_pasted(winid, entry, column_defs, adapter, bufnr)
end
---@param parent_url string
----@param entry canola.InternalEntry
+---@param entry oil.InternalEntry
local function remove_entry_from_parent_buffer(parent_url, entry)
local bufnr = vim.fn.bufadd(parent_url)
- assert(vim.api.nvim_buf_is_loaded(bufnr), 'Expected parent buffer to be loaded during paste')
+ assert(vim.api.nvim_buf_is_loaded(bufnr), "Expected parent buffer to be loaded during paste")
local adapter = assert(util.get_adapter(bufnr))
local column_defs = columns.get_supported_columns(adapter)
local lines = vim.api.nvim_buf_get_lines(bufnr, 0, -1, false)
@@ -77,7 +77,7 @@ end
---@param delete_original? boolean
local function paste_paths(paths, delete_original)
local bufnr = vim.api.nvim_get_current_buf()
- local scheme = 'canola://'
+ local scheme = "oil://"
local adapter = assert(config.get_adapter_by_scheme(scheme))
local column_defs = columns.get_supported_columns(scheme)
local winid = vim.api.nvim_get_current_win()
@@ -88,7 +88,7 @@ local function paste_paths(paths, delete_original)
-- Handle as many paths synchronously as possible
for _, path in ipairs(paths) do
-- Trim the trailing slash off directories
- if vim.endswith(path, '/') then
+ if vim.endswith(path, "/") then
path = path:sub(1, -2)
end
@@ -114,7 +114,7 @@ local function paste_paths(paths, delete_original)
local cursor = vim.api.nvim_win_get_cursor(winid)
local complete_loading = util.cb_collect(#vim.tbl_keys(parent_urls), function(err)
if err then
- vim.notify(string.format('Error loading parent directory: %s', err), vim.log.levels.ERROR)
+ vim.notify(string.format("Error loading parent directory: %s", err), vim.log.levels.ERROR)
else
-- Something in this process moves the cursor to the top of the window, so have to restore it
vim.api.nvim_win_set_cursor(winid, cursor)
@@ -140,7 +140,7 @@ local function paste_paths(paths, delete_original)
for parent_url, _ in pairs(parent_urls) do
local new_bufnr = vim.api.nvim_create_buf(false, false)
vim.api.nvim_buf_set_name(new_bufnr, parent_url)
- canola.load_canola_buffer(new_bufnr)
+ oil.load_oil_buffer(new_bufnr)
util.run_after_load(new_bufnr, complete_loading)
end
end
@@ -149,8 +149,8 @@ end
---@return integer end
local function range_from_selection()
-- [bufnum, lnum, col, off]; both row and column 1-indexed
- local start = vim.fn.getpos('v')
- local end_ = vim.fn.getpos('.')
+ local start = vim.fn.getpos("v")
+ local end_ = vim.fn.getpos(".")
local start_row = start[2]
local end_row = end_[2]
@@ -162,38 +162,38 @@ local function range_from_selection()
end
M.copy_to_system_clipboard = function()
- local dir = canola.get_current_dir()
+ local dir = oil.get_current_dir()
if not dir then
- vim.notify('System clipboard only works for local files', vim.log.levels.ERROR)
+ vim.notify("System clipboard only works for local files", vim.log.levels.ERROR)
return
end
local entries = {}
local mode = vim.api.nvim_get_mode().mode
- if mode == 'v' or mode == 'V' then
+ if mode == "v" or mode == "V" then
if fs.is_mac then
vim.notify(
- 'Copying multiple paths to clipboard is not supported on mac',
+ "Copying multiple paths to clipboard is not supported on mac",
vim.log.levels.ERROR
)
return
end
local start_row, end_row = range_from_selection()
for i = start_row, end_row do
- table.insert(entries, canola.get_entry_on_line(0, i))
+ table.insert(entries, oil.get_entry_on_line(0, i))
end
-- leave visual mode
- vim.api.nvim_feedkeys(vim.api.nvim_replace_termcodes('', true, false, true), 'n', true)
+ vim.api.nvim_feedkeys(vim.api.nvim_replace_termcodes("", true, false, true), "n", true)
else
- table.insert(entries, canola.get_cursor_entry())
+ table.insert(entries, oil.get_cursor_entry())
end
-- This removes holes in the list-like table
entries = vim.tbl_values(entries)
if #entries == 0 then
- vim.notify('Could not find local file under cursor', vim.log.levels.WARN)
+ vim.notify("Could not find local file under cursor", vim.log.levels.WARN)
return
end
local paths = {}
@@ -204,38 +204,38 @@ M.copy_to_system_clipboard = function()
local stdin
if fs.is_mac then
cmd = {
- 'osascript',
- '-e',
- 'on run args',
- '-e',
- 'set the clipboard to POSIX file (first item of args)',
- '-e',
- 'end run',
+ "osascript",
+ "-e",
+ "on run args",
+ "-e",
+ "set the clipboard to POSIX file (first item of args)",
+ "-e",
+ "end run",
paths[1],
}
elseif fs.is_linux then
local xdg_session_type = get_linux_session_type()
- if xdg_session_type == 'x11' then
- vim.list_extend(cmd, { 'xclip', '-i', '-selection', 'clipboard' })
- elseif xdg_session_type == 'wayland' then
- table.insert(cmd, 'wl-copy')
+ if xdg_session_type == "x11" then
+ vim.list_extend(cmd, { "xclip", "-i", "-selection", "clipboard" })
+ elseif xdg_session_type == "wayland" then
+ table.insert(cmd, "wl-copy")
else
- vim.notify('System clipboard not supported, check $XDG_SESSION_TYPE', vim.log.levels.ERROR)
+ vim.notify("System clipboard not supported, check $XDG_SESSION_TYPE", vim.log.levels.ERROR)
return
end
local urls = {}
for _, path in ipairs(paths) do
- table.insert(urls, 'file://' .. path)
+ table.insert(urls, "file://" .. path)
end
if is_linux_desktop_gnome() then
- stdin = string.format('copy\n%s\0', table.concat(urls, '\n'))
- vim.list_extend(cmd, { '-t', 'x-special/gnome-copied-files' })
+ stdin = string.format("copy\n%s\0", table.concat(urls, "\n"))
+ vim.list_extend(cmd, { "-t", "x-special/gnome-copied-files" })
else
- stdin = table.concat(urls, '\n') .. '\n'
- vim.list_extend(cmd, { '-t', 'text/uri-list' })
+ stdin = table.concat(urls, "\n") .. "\n"
+ vim.list_extend(cmd, { "-t", "text/uri-list" })
end
else
- vim.notify('System clipboard not supported on Windows', vim.log.levels.ERROR)
+ vim.notify("System clipboard not supported on Windows", vim.log.levels.ERROR)
return
end
@@ -243,11 +243,11 @@ M.copy_to_system_clipboard = function()
vim.notify(string.format("Could not find executable '%s'", cmd[1]), vim.log.levels.ERROR)
return
end
- local stderr = ''
+ local stderr = ""
local jid = vim.fn.jobstart(cmd, {
stderr_buffered = true,
on_stderr = function(_, data)
- stderr = table.concat(data, '\n')
+ stderr = table.concat(data, "\n")
end,
on_exit = function(j, exit_code)
if exit_code ~= 0 then
@@ -259,15 +259,15 @@ M.copy_to_system_clipboard = function()
if #paths == 1 then
vim.notify(string.format("Copied '%s' to system clipboard", paths[1]))
else
- vim.notify(string.format('Copied %d files to system clipboard', #paths))
+ vim.notify(string.format("Copied %d files to system clipboard", #paths))
end
end
end,
})
- assert(jid > 0, 'Failed to start job')
+ assert(jid > 0, "Failed to start job")
if stdin then
vim.api.nvim_chan_send(jid, stdin)
- vim.fn.chanclose(jid, 'stdin')
+ vim.fn.chanclose(jid, "stdin")
end
end
@@ -276,7 +276,7 @@ end
local function handle_paste_output_mac(lines)
local ret = {}
for _, line in ipairs(lines) do
- if not line:match('^%s*$') then
+ if not line:match("^%s*$") then
table.insert(ret, line)
end
end
@@ -288,7 +288,7 @@ end
local function handle_paste_output_linux(lines)
local ret = {}
for _, line in ipairs(lines) do
- local path = line:match('^file://(.+)$')
+ local path = line:match("^file://(.+)$")
if path then
table.insert(ret, util.url_unescape(path))
end
@@ -298,7 +298,7 @@ end
---@param delete_original? boolean Delete the source file after pasting
M.paste_from_system_clipboard = function(delete_original)
- local dir = canola.get_current_dir()
+ local dir = oil.get_current_dir()
if not dir then
return
end
@@ -306,37 +306,37 @@ M.paste_from_system_clipboard = function(delete_original)
local handle_paste_output
if fs.is_mac then
cmd = {
- 'osascript',
- '-e',
- 'on run',
- '-e',
- 'POSIX path of (the clipboard as «class furl»)',
- '-e',
- 'end run',
+ "osascript",
+ "-e",
+ "on run",
+ "-e",
+ "POSIX path of (the clipboard as «class furl»)",
+ "-e",
+ "end run",
}
handle_paste_output = handle_paste_output_mac
elseif fs.is_linux then
local xdg_session_type = get_linux_session_type()
- if xdg_session_type == 'x11' then
- vim.list_extend(cmd, { 'xclip', '-o', '-selection', 'clipboard' })
- elseif xdg_session_type == 'wayland' then
- table.insert(cmd, 'wl-paste')
+ if xdg_session_type == "x11" then
+ vim.list_extend(cmd, { "xclip", "-o", "-selection", "clipboard" })
+ elseif xdg_session_type == "wayland" then
+ table.insert(cmd, "wl-paste")
else
- vim.notify('System clipboard not supported, check $XDG_SESSION_TYPE', vim.log.levels.ERROR)
+ vim.notify("System clipboard not supported, check $XDG_SESSION_TYPE", vim.log.levels.ERROR)
return
end
if is_linux_desktop_gnome() then
- vim.list_extend(cmd, { '-t', 'x-special/gnome-copied-files' })
+ vim.list_extend(cmd, { "-t", "x-special/gnome-copied-files" })
else
- vim.list_extend(cmd, { '-t', 'text/uri-list' })
+ vim.list_extend(cmd, { "-t", "text/uri-list" })
end
handle_paste_output = handle_paste_output_linux
else
- vim.notify('System clipboard not supported on Windows', vim.log.levels.ERROR)
+ vim.notify("System clipboard not supported on Windows", vim.log.levels.ERROR)
return
end
local paths
- local stderr = ''
+ local stderr = ""
if vim.fn.executable(cmd[1]) == 0 then
vim.notify(string.format("Could not find executable '%s'", cmd[1]), vim.log.levels.ERROR)
return
@@ -345,26 +345,26 @@ M.paste_from_system_clipboard = function(delete_original)
stdout_buffered = true,
stderr_buffered = true,
on_stdout = function(j, data)
- local lines = vim.split(table.concat(data, '\n'), '\r?\n')
+ local lines = vim.split(table.concat(data, "\n"), "\r?\n")
paths = handle_paste_output(lines)
end,
on_stderr = function(_, data)
- stderr = table.concat(data, '\n')
+ stderr = table.concat(data, "\n")
end,
on_exit = function(j, exit_code)
if exit_code ~= 0 or not paths then
vim.notify(
- string.format('Error pasting from system clipboard: %s', stderr),
+ string.format("Error pasting from system clipboard: %s", stderr),
vim.log.levels.ERROR
)
elseif #paths == 0 then
- vim.notify('No valid files found in system clipboard', vim.log.levels.WARN)
+ vim.notify("No valid files found in system clipboard", vim.log.levels.WARN)
else
paste_paths(paths, delete_original)
end
end,
})
- assert(jid > 0, 'Failed to start job')
+ assert(jid > 0, "Failed to start job")
end
return M
diff --git a/lua/canola/columns.lua b/lua/oil/columns.lua
similarity index 65%
rename from lua/canola/columns.lua
rename to lua/oil/columns.lua
index f616240..6d76674 100644
--- a/lua/canola/columns.lua
+++ b/lua/oil/columns.lua
@@ -1,6 +1,6 @@
-local config = require('canola.config')
-local constants = require('canola.constants')
-local util = require('canola.util')
+local config = require("oil.config")
+local constants = require("oil.constants")
+local util = require("oil.util")
local M = {}
local FIELD_NAME = constants.FIELD_NAME
@@ -9,36 +9,36 @@ local FIELD_META = constants.FIELD_META
local all_columns = {}
----@alias canola.ColumnSpec string|{[1]: string, [string]: any}
+---@alias oil.ColumnSpec string|{[1]: string, [string]: any}
----@class (exact) canola.ColumnDefinition
----@field render fun(entry: canola.InternalEntry, conf: nil|table, bufnr: integer): nil|canola.TextChunk
+---@class (exact) oil.ColumnDefinition
+---@field render fun(entry: oil.InternalEntry, conf: nil|table, bufnr: integer): nil|oil.TextChunk
---@field parse fun(line: string, conf: nil|table): nil|string, nil|string
----@field compare? fun(entry: canola.InternalEntry, parsed_value: any): boolean
----@field render_action? fun(action: canola.ChangeAction): string
----@field perform_action? fun(action: canola.ChangeAction, callback: fun(err: nil|string))
----@field get_sort_value? fun(entry: canola.InternalEntry): number|string
----@field create_sort_value_factory? fun(num_entries: integer): fun(entry: canola.InternalEntry): number|string
+---@field compare? fun(entry: oil.InternalEntry, parsed_value: any): boolean
+---@field render_action? fun(action: oil.ChangeAction): string
+---@field perform_action? fun(action: oil.ChangeAction, callback: fun(err: nil|string))
+---@field get_sort_value? fun(entry: oil.InternalEntry): number|string
+---@field create_sort_value_factory? fun(num_entries: integer): fun(entry: oil.InternalEntry): number|string
---@param name string
----@param column canola.ColumnDefinition
+---@param column oil.ColumnDefinition
M.register = function(name, column)
all_columns[name] = column
end
----@param adapter canola.Adapter
----@param defn canola.ColumnSpec
----@return nil|canola.ColumnDefinition
+---@param adapter oil.Adapter
+---@param defn oil.ColumnSpec
+---@return nil|oil.ColumnDefinition
M.get_column = function(adapter, defn)
local name = util.split_config(defn)
return all_columns[name] or adapter.get_column(name)
end
----@param adapter_or_scheme string|canola.Adapter
----@return canola.ColumnSpec[]
+---@param adapter_or_scheme string|oil.Adapter
+---@return oil.ColumnSpec[]
M.get_supported_columns = function(adapter_or_scheme)
local adapter
- if type(adapter_or_scheme) == 'string' then
+ if type(adapter_or_scheme) == "string" then
adapter = config.get_adapter_by_scheme(adapter_or_scheme)
else
adapter = adapter_or_scheme
@@ -53,15 +53,15 @@ M.get_supported_columns = function(adapter_or_scheme)
return ret
end
-local EMPTY = { '-', 'CanolaEmpty' }
+local EMPTY = { "-", "OilEmpty" }
M.EMPTY = EMPTY
----@param adapter canola.Adapter
----@param col_def canola.ColumnSpec
----@param entry canola.InternalEntry
+---@param adapter oil.Adapter
+---@param col_def oil.ColumnSpec
+---@param entry oil.InternalEntry
---@param bufnr integer
----@return canola.TextChunk
+---@return oil.TextChunk
M.render_col = function(adapter, col_def, entry, bufnr)
local name, conf = util.split_config(col_def)
local column = M.get_column(adapter, name)
@@ -71,17 +71,17 @@ M.render_col = function(adapter, col_def, entry, bufnr)
end
local chunk = column.render(entry, conf, bufnr)
- if type(chunk) == 'table' then
- if chunk[1]:match('^%s*$') then
+ if type(chunk) == "table" then
+ if chunk[1]:match("^%s*$") then
return EMPTY
end
else
- if not chunk or chunk:match('^%s*$') then
+ if not chunk or chunk:match("^%s*$") then
return EMPTY
end
if conf and conf.highlight then
local highlight = conf.highlight
- if type(highlight) == 'function' then
+ if type(highlight) == "function" then
highlight = conf.highlight(chunk)
end
return { chunk, highlight }
@@ -90,27 +90,27 @@ M.render_col = function(adapter, col_def, entry, bufnr)
return chunk
end
----@param adapter canola.Adapter
+---@param adapter oil.Adapter
---@param line string
----@param col_def canola.ColumnSpec
+---@param col_def oil.ColumnSpec
---@return nil|string
---@return nil|string
M.parse_col = function(adapter, line, col_def)
local name, conf = util.split_config(col_def)
-- If rendering failed, there will just be a "-"
- local empty_col, rem = line:match('^%s*(-%s+)(.*)$')
+ local empty_col, rem = line:match("^%s*(-%s+)(.*)$")
if empty_col then
return nil, rem
end
local column = M.get_column(adapter, name)
if column then
- return column.parse(line:gsub('^%s+', ''), conf)
+ return column.parse(line:gsub("^%s+", ""), conf)
end
end
----@param adapter canola.Adapter
+---@param adapter oil.Adapter
---@param col_name string
----@param entry canola.InternalEntry
+---@param entry oil.InternalEntry
---@param parsed_value any
---@return boolean
M.compare = function(adapter, col_name, entry, parsed_value)
@@ -122,29 +122,29 @@ M.compare = function(adapter, col_name, entry, parsed_value)
end
end
----@param adapter canola.Adapter
----@param action canola.ChangeAction
+---@param adapter oil.Adapter
+---@param action oil.ChangeAction
---@return string
M.render_change_action = function(adapter, action)
local column = M.get_column(adapter, action.column)
if not column then
- error(string.format('Received change action for nonexistant column %s', action.column))
+ error(string.format("Received change action for nonexistant column %s", action.column))
end
if column.render_action then
return column.render_action(action)
else
- return string.format('CHANGE %s %s = %s', action.url, action.column, action.value)
+ return string.format("CHANGE %s %s = %s", action.url, action.column, action.value)
end
end
----@param adapter canola.Adapter
----@param action canola.ChangeAction
+---@param adapter oil.Adapter
+---@param action oil.ChangeAction
---@param callback fun(err: nil|string)
M.perform_change_action = function(adapter, action, callback)
local column = M.get_column(adapter, action.column)
if not column then
return callback(
- string.format('Received change action for nonexistant column %s', action.column)
+ string.format("Received change action for nonexistant column %s", action.column)
)
end
column.perform_action(action, callback)
@@ -152,12 +152,12 @@ end
local icon_provider = util.get_icon_provider()
if icon_provider then
- M.register('icon', {
+ M.register("icon", {
render = function(entry, conf, bufnr)
local field_type = entry[FIELD_TYPE]
local name = entry[FIELD_NAME]
local meta = entry[FIELD_META]
- if field_type == 'link' and meta then
+ if field_type == "link" and meta then
if meta.link then
name = meta.link
end
@@ -170,11 +170,11 @@ if icon_provider then
end
local ft = nil
- if conf and conf.use_slow_filetype_detection and field_type == 'file' then
+ if conf and conf.use_slow_filetype_detection and field_type == "file" then
local bufname = vim.api.nvim_buf_get_name(bufnr)
local _, path = util.parse_url(bufname)
if path then
- local lines = vim.fn.readfile(path .. name, '', 16)
+ local lines = vim.fn.readfile(path .. name, "", 16)
if lines and #lines > 0 then
ft = vim.filetype.match({ filename = name, contents = lines })
end
@@ -183,10 +183,10 @@ if icon_provider then
local icon, hl = icon_provider(field_type, name, conf, ft)
if not conf or conf.add_padding ~= false then
- icon = icon .. ' '
+ icon = icon .. " "
end
if conf and conf.highlight then
- if type(conf.highlight) == 'function' then
+ if type(conf.highlight) == "function" then
hl = conf.highlight(icon)
else
hl = conf.highlight
@@ -196,29 +196,29 @@ if icon_provider then
end,
parse = function(line, conf)
- return line:match('^(%S+)%s+(.*)$')
+ return line:match("^(%S+)%s+(.*)$")
end,
})
end
local default_type_icons = {
- directory = 'dir',
- socket = 'sock',
+ directory = "dir",
+ socket = "sock",
}
----@param entry canola.InternalEntry
+---@param entry oil.InternalEntry
---@return boolean
local function is_entry_directory(entry)
local type = entry[FIELD_TYPE]
- if type == 'directory' then
+ if type == "directory" then
return true
- elseif type == 'link' then
+ elseif type == "link" then
local meta = entry[FIELD_META]
- return (meta and meta.link_stat and meta.link_stat.type == 'directory') == true
+ return (meta and meta.link_stat and meta.link_stat.type == "directory") == true
else
return false
end
end
-M.register('type', {
+M.register("type", {
render = function(entry, conf)
local entry_type = entry[FIELD_TYPE]
if conf and conf.icons then
@@ -229,7 +229,7 @@ M.register('type', {
end,
parse = function(line, conf)
- return line:match('^(%S+)%s+(.*)$')
+ return line:match("^(%S+)%s+(.*)$")
end,
get_sort_value = function(entry)
@@ -242,22 +242,22 @@ M.register('type', {
})
local function adjust_number(int)
- return string.format('%03d%s', #int, int)
+ return string.format("%03d%s", #int, int)
end
-M.register('name', {
+M.register("name", {
render = function(entry, conf)
- error('Do not use the name column. It is for sorting only')
+ error("Do not use the name column. It is for sorting only")
end,
parse = function(line, conf)
- error('Do not use the name column. It is for sorting only')
+ error("Do not use the name column. It is for sorting only")
end,
create_sort_value_factory = function(num_entries)
if
config.view_options.natural_order == false
- or (config.view_options.natural_order == 'fast' and num_entries > 5000)
+ or (config.view_options.natural_order == "fast" and num_entries > 5000)
then
if config.view_options.case_insensitive then
return function(entry)
@@ -272,7 +272,7 @@ M.register('name', {
local memo = {}
return function(entry)
if memo[entry] == nil then
- local name = entry[FIELD_NAME]:gsub('0*(%d+)', adjust_number)
+ local name = entry[FIELD_NAME]:gsub("0*(%d+)", adjust_number)
if config.view_options.case_insensitive then
name = name:lower()
end
diff --git a/lua/canola/config.lua b/lua/oil/config.lua
similarity index 59%
rename from lua/canola/config.lua
rename to lua/oil/config.lua
index 25e8876..3734bc0 100644
--- a/lua/canola/config.lua
+++ b/lua/oil/config.lua
@@ -1,45 +1,41 @@
local default_config = {
- -- Canola will take over directory buffers (e.g. `vim .` or `:e src/`)
+ -- Oil will take over directory buffers (e.g. `vim .` or `:e src/`)
-- Set to false if you want some other plugin (e.g. netrw) to open when you edit directories.
default_file_explorer = true,
-- Id is automatically added at the beginning, and name at the end
- -- See :help canola-columns
+ -- See :help oil-columns
columns = {
- 'icon',
+ "icon",
-- "permissions",
-- "size",
-- "mtime",
},
- -- Buffer-local options to use for canola buffers
+ -- Buffer-local options to use for oil buffers
buf_options = {
buflisted = false,
- bufhidden = 'hide',
+ bufhidden = "hide",
},
- -- Window-local options to use for canola buffers
+ -- Window-local options to use for oil buffers
win_options = {
wrap = false,
- signcolumn = 'no',
+ signcolumn = "no",
cursorcolumn = false,
- foldcolumn = '0',
+ foldcolumn = "0",
spell = false,
list = false,
conceallevel = 3,
- concealcursor = 'nvic',
+ concealcursor = "nvic",
},
- -- Send deleted files to the trash instead of permanently deleting them (:help canola-trash)
+ -- Send deleted files to the trash instead of permanently deleting them (:help oil-trash)
delete_to_trash = false,
- -- Wipe open buffers for files deleted via canola (:help canola.cleanup_buffers_on_delete)
- cleanup_buffers_on_delete = false,
- -- Skip the confirmation popup for simple operations (:help canola.skip_confirm_for_simple_edits)
+ -- Skip the confirmation popup for simple operations (:help oil.skip_confirm_for_simple_edits)
skip_confirm_for_simple_edits = false,
- skip_confirm_for_delete = false,
-- Selecting a new/moved/renamed file or directory will prompt you to save changes first
-- (:help prompt_save_on_select_new_entry)
prompt_save_on_select_new_entry = true,
- auto_save_on_select_new_entry = false,
- -- Canola will automatically delete hidden buffers after this delay
+ -- Oil will automatically delete hidden buffers after this delay
-- You can set the delay to false to disable cleanup entirely
- -- Note that the cleanup process only starts when none of the canola buffers are currently displayed
+ -- Note that the cleanup process only starts when none of the oil buffers are currently displayed
cleanup_delay_ms = 2000,
lsp_file_methods = {
-- Enable or disable LSP file operations
@@ -50,44 +46,43 @@ local default_config = {
-- Set to "unmodified" to only save unmodified buffers
autosave_changes = false,
},
- -- Constrain the cursor to the editable parts of the canola buffer
+ -- Constrain the cursor to the editable parts of the oil buffer
-- Set to `false` to disable, or "name" to keep it on the file names
- constrain_cursor = 'editable',
- -- Set to true to watch the filesystem for changes and reload canola
+ constrain_cursor = "editable",
+ -- Set to true to watch the filesystem for changes and reload oil
watch_for_changes = false,
- -- Keymaps in canola buffer. Can be any value that `vim.keymap.set` accepts OR a table of keymap
+ -- Keymaps in oil buffer. Can be any value that `vim.keymap.set` accepts OR a table of keymap
-- options with a `callback` (e.g. { callback = function() ... end, desc = "", mode = "n" })
-- Additionally, if it is a string that matches "actions.",
- -- it will use the mapping at require("canola.actions").
+ -- it will use the mapping at require("oil.actions").
-- Set to `false` to remove a keymap
- -- See :help canola-actions for a list of all available actions
+ -- See :help oil-actions for a list of all available actions
keymaps = {
- ['g?'] = { 'actions.show_help', mode = 'n' },
- [''] = 'actions.select',
- [''] = { 'actions.select', opts = { vertical = true } },
- [''] = { 'actions.select', opts = { horizontal = true } },
- [''] = { 'actions.select', opts = { tab = true } },
- [''] = 'actions.preview',
- [''] = { 'actions.close', mode = 'n' },
- [''] = 'actions.refresh',
- ['-'] = { 'actions.parent', mode = 'n' },
- ['_'] = { 'actions.open_cwd', mode = 'n' },
- ['`'] = { 'actions.cd', mode = 'n' },
- ['g~'] = { 'actions.cd', opts = { scope = 'tab' }, mode = 'n' },
- ['gs'] = { 'actions.change_sort', mode = 'n' },
- ['gx'] = 'actions.open_external',
- ['g.'] = { 'actions.toggle_hidden', mode = 'n' },
- ['g\\'] = { 'actions.toggle_trash', mode = 'n' },
+ ["g?"] = { "actions.show_help", mode = "n" },
+ [""] = "actions.select",
+ [""] = { "actions.select", opts = { vertical = true } },
+ [""] = { "actions.select", opts = { horizontal = true } },
+ [""] = { "actions.select", opts = { tab = true } },
+ [""] = "actions.preview",
+ [""] = { "actions.close", mode = "n" },
+ [""] = "actions.refresh",
+ ["-"] = { "actions.parent", mode = "n" },
+ ["_"] = { "actions.open_cwd", mode = "n" },
+ ["`"] = { "actions.cd", mode = "n" },
+ ["g~"] = { "actions.cd", opts = { scope = "tab" }, mode = "n" },
+ ["gs"] = { "actions.change_sort", mode = "n" },
+ ["gx"] = "actions.open_external",
+ ["g."] = { "actions.toggle_hidden", mode = "n" },
+ ["g\\"] = { "actions.toggle_trash", mode = "n" },
},
-- Set to false to disable all of the above keymaps
use_default_keymaps = true,
view_options = {
-- Show files and directories that start with "."
show_hidden = false,
- show_hidden_when_empty = false,
-- This function defines what is considered a "hidden" file
is_hidden_file = function(name, bufnr)
- local m = name:match('^%.')
+ local m = name:match("^%.")
return m ~= nil
end,
-- This function defines what will never be shown, even when `show_hidden` is set
@@ -96,14 +91,14 @@ local default_config = {
end,
-- Sort file names with numbers in a more intuitive order for humans.
-- Can be "fast", true, or false. "fast" will turn it off for large directories.
- natural_order = 'fast',
+ natural_order = "fast",
-- Sort file and directory names case insensitive
case_insensitive = false,
sort = {
-- sort order can be "asc" or "desc"
- -- see :help canola-columns to see which columns are sortable
- { 'type', 'asc' },
- { 'name', 'asc' },
+ -- see :help oil-columns to see which columns are sortable
+ { "type", "asc" },
+ { "name", "asc" },
},
-- Customize the highlight group for the file name
highlight_filename = function(entry, is_hidden, is_link_target, is_link_orphan)
@@ -129,7 +124,7 @@ local default_config = {
return false
end,
},
- -- Configuration for the floating window in canola.open_float
+ -- Configuration for the floating window in oil.open_float
float = {
-- Padding around the floating window
padding = 2,
@@ -140,10 +135,10 @@ local default_config = {
win_options = {
winblend = 0,
},
- -- optionally override the canola buffers window title with custom function: fun(winid: integer): string
+ -- optionally override the oil buffers window title with custom function: fun(winid: integer): string
get_win_title = nil,
-- preview_split: Split direction: "auto", "left", "right", "above", "below".
- preview_split = 'auto',
+ preview_split = "auto",
-- This is the config that will be passed to nvim_open_win.
-- Change values here to customize the layout
override = function(conf)
@@ -155,12 +150,11 @@ local default_config = {
-- Whether the preview window is automatically updated when the cursor is moved
update_on_cursor_moved = true,
-- How to open the preview window "load"|"scratch"|"fast_scratch"
- preview_method = 'fast_scratch',
+ preview_method = "fast_scratch",
-- A function that returns true to disable preview on a file e.g. to avoid lag
disable_preview = function(filename)
return false
end,
- max_file_size = 10,
-- Window-local options to use for preview window buffers
win_options = {},
},
@@ -196,7 +190,7 @@ local default_config = {
min_height = { 5, 0.1 },
height = nil,
border = nil,
- minimized_border = 'none',
+ minimized_border = "none",
win_options = {
winblend = 0,
},
@@ -215,187 +209,177 @@ local default_config = {
-- write their own adapters, and so there's no real reason to edit these config options. For that
-- reason, I'm taking them out of the section above so they won't show up in the autogen docs.
--- not "canola-s3://" on older neovim versions, since it doesn't open buffers correctly with a number
+-- not "oil-s3://" on older neovim versions, since it doesn't open buffers correctly with a number
-- in the name
-local canola_s3_string = vim.fn.has('nvim-0.12') == 1 and 'canola-s3://' or 'canola-sss://'
+local oil_s3_string = vim.fn.has("nvim-0.12") == 1 and "oil-s3://" or "oil-sss://"
default_config.adapters = {
- ['canola://'] = 'files',
- ['canola-ssh://'] = 'ssh',
- [canola_s3_string] = 's3',
- ['canola-trash://'] = 'trash',
+ ["oil://"] = "files",
+ ["oil-ssh://"] = "ssh",
+ [oil_s3_string] = "s3",
+ ["oil-trash://"] = "trash",
}
default_config.adapter_aliases = {}
-- We want the function in the default config for documentation generation, but if we nil it out
-- here we can get some performance wins
default_config.view_options.highlight_filename = nil
----@class canola.Config
+---@class oil.Config
---@field adapters table Hidden from SetupOpts
---@field adapter_aliases table Hidden from SetupOpts
---@field silence_scp_warning? boolean Undocumented option
---@field default_file_explorer boolean
----@field columns canola.ColumnSpec[]
+---@field columns oil.ColumnSpec[]
---@field buf_options table
---@field win_options table
---@field delete_to_trash boolean
----@field cleanup_buffers_on_delete boolean
---@field skip_confirm_for_simple_edits boolean
----@field skip_confirm_for_delete boolean
---@field prompt_save_on_select_new_entry boolean
----@field auto_save_on_select_new_entry boolean
---@field cleanup_delay_ms integer
----@field lsp_file_methods canola.LspFileMethods
+---@field lsp_file_methods oil.LspFileMethods
---@field constrain_cursor false|"name"|"editable"
---@field watch_for_changes boolean
---@field keymaps table
---@field use_default_keymaps boolean
----@field view_options canola.ViewOptions
+---@field view_options oil.ViewOptions
---@field new_file_mode integer
---@field new_dir_mode integer
---@field extra_scp_args string[]
---@field extra_s3_args string[]
----@field git canola.GitOptions
----@field float canola.FloatWindowConfig
----@field preview_win canola.PreviewWindowConfig
----@field confirmation canola.ConfirmationWindowConfig
----@field progress canola.ProgressWindowConfig
----@field ssh canola.SimpleWindowConfig
----@field keymaps_help canola.SimpleWindowConfig
+---@field git oil.GitOptions
+---@field float oil.FloatWindowConfig
+---@field preview_win oil.PreviewWindowConfig
+---@field confirmation oil.ConfirmationWindowConfig
+---@field progress oil.ProgressWindowConfig
+---@field ssh oil.SimpleWindowConfig
+---@field keymaps_help oil.SimpleWindowConfig
local M = {}
-- For backwards compatibility
----@alias canola.setupOpts canola.SetupOpts
+---@alias oil.setupOpts oil.SetupOpts
----@class (exact) canola.SetupOpts
----@field default_file_explorer? boolean Canola will take over directory buffers (e.g. `vim .` or `:e src/`). Set to false if you still want to use netrw.
----@field columns? canola.ColumnSpec[] The columns to display. See :help canola-columns.
----@field buf_options? table Buffer-local options to use for canola buffers
----@field win_options? table Window-local options to use for canola buffers
----@field delete_to_trash? boolean Send deleted files to the trash instead of permanently deleting them (:help canola-trash).
----@field cleanup_buffers_on_delete? boolean Wipe open buffers for files deleted via canola (:help canola.cleanup_buffers_on_delete).
----@field skip_confirm_for_simple_edits? boolean Skip the confirmation popup for simple operations (:help canola.skip_confirm_for_simple_edits).
----@field skip_confirm_for_delete? boolean Skip the confirmation popup when all pending actions are deletes (:help canola.skip_confirm_for_delete).
+---@class (exact) oil.SetupOpts
+---@field default_file_explorer? boolean Oil will take over directory buffers (e.g. `vim .` or `:e src/`). Set to false if you still want to use netrw.
+---@field columns? oil.ColumnSpec[] The columns to display. See :help oil-columns.
+---@field buf_options? table Buffer-local options to use for oil buffers
+---@field win_options? table Window-local options to use for oil buffers
+---@field delete_to_trash? boolean Send deleted files to the trash instead of permanently deleting them (:help oil-trash).
+---@field skip_confirm_for_simple_edits? boolean Skip the confirmation popup for simple operations (:help oil.skip_confirm_for_simple_edits).
---@field prompt_save_on_select_new_entry? boolean Selecting a new/moved/renamed file or directory will prompt you to save changes first (:help prompt_save_on_select_new_entry).
----@field auto_save_on_select_new_entry? boolean Automatically save changes when selecting a new/moved/renamed entry, instead of prompting (:help canola.auto_save_on_select_new_entry).
----@field cleanup_delay_ms? integer Canola will automatically delete hidden buffers after this delay. You can set the delay to false to disable cleanup entirely. Note that the cleanup process only starts when none of the canola buffers are currently displayed.
----@field lsp_file_methods? canola.SetupLspFileMethods Configure LSP file operation integration.
----@field constrain_cursor? false|"name"|"editable" Constrain the cursor to the editable parts of the canola buffer. Set to `false` to disable, or "name" to keep it on the file names.
----@field watch_for_changes? boolean Set to true to watch the filesystem for changes and reload canola.
+---@field cleanup_delay_ms? integer Oil will automatically delete hidden buffers after this delay. You can set the delay to false to disable cleanup entirely. Note that the cleanup process only starts when none of the oil buffers are currently displayed.
+---@field lsp_file_methods? oil.SetupLspFileMethods Configure LSP file operation integration.
+---@field constrain_cursor? false|"name"|"editable" Constrain the cursor to the editable parts of the oil buffer. Set to `false` to disable, or "name" to keep it on the file names.
+---@field watch_for_changes? boolean Set to true to watch the filesystem for changes and reload oil.
---@field keymaps? table
---@field use_default_keymaps? boolean Set to false to disable all of the above keymaps
----@field view_options? canola.SetupViewOptions Configure which files are shown and how they are shown.
+---@field view_options? oil.SetupViewOptions Configure which files are shown and how they are shown.
---@field new_file_mode? integer Permission mode for new files in decimal (default 420 = 0644)
---@field new_dir_mode? integer Permission mode for new directories in decimal (default 493 = 0755)
---@field extra_scp_args? string[] Extra arguments to pass to SCP when moving/copying files over SSH
---@field extra_s3_args? string[] Extra arguments to pass to aws s3 when moving/copying files using aws s3
----@field git? canola.SetupGitOptions EXPERIMENTAL support for performing file operations with git
----@field float? canola.SetupFloatWindowConfig Configuration for the floating window in canola.open_float
----@field preview_win? canola.SetupPreviewWindowConfig Configuration for the file preview window
----@field confirmation? canola.SetupConfirmationWindowConfig Configuration for the floating action confirmation window
----@field progress? canola.SetupProgressWindowConfig Configuration for the floating progress window
----@field ssh? canola.SetupSimpleWindowConfig Configuration for the floating SSH window
----@field keymaps_help? canola.SetupSimpleWindowConfig Configuration for the floating keymaps help window
+---@field git? oil.SetupGitOptions EXPERIMENTAL support for performing file operations with git
+---@field float? oil.SetupFloatWindowConfig Configuration for the floating window in oil.open_float
+---@field preview_win? oil.SetupPreviewWindowConfig Configuration for the file preview window
+---@field confirmation? oil.SetupConfirmationWindowConfig Configuration for the floating action confirmation window
+---@field progress? oil.SetupProgressWindowConfig Configuration for the floating progress window
+---@field ssh? oil.SetupSimpleWindowConfig Configuration for the floating SSH window
+---@field keymaps_help? oil.SetupSimpleWindowConfig Configuration for the floating keymaps help window
----@class (exact) canola.LspFileMethods
+---@class (exact) oil.LspFileMethods
---@field enabled boolean
---@field timeout_ms integer
---@field autosave_changes boolean|"unmodified" Set to true to autosave buffers that are updated with LSP willRenameFiles. Set to "unmodified" to only save unmodified buffers.
----@class (exact) canola.SetupLspFileMethods
+---@class (exact) oil.SetupLspFileMethods
---@field enabled? boolean Enable or disable LSP file operations
---@field timeout_ms? integer Time to wait for LSP file operations to complete before skipping.
---@field autosave_changes? boolean|"unmodified" Set to true to autosave buffers that are updated with LSP willRenameFiles. Set to "unmodified" to only save unmodified buffers.
----@class (exact) canola.ViewOptions
+---@class (exact) oil.ViewOptions
---@field show_hidden boolean
----@field show_hidden_when_empty boolean
----@field is_hidden_file fun(name: string, bufnr: integer, entry: canola.Entry): boolean
----@field is_always_hidden fun(name: string, bufnr: integer, entry: canola.Entry): boolean
+---@field is_hidden_file fun(name: string, bufnr: integer, entry: oil.Entry): boolean
+---@field is_always_hidden fun(name: string, bufnr: integer, entry: oil.Entry): boolean
---@field natural_order boolean|"fast"
---@field case_insensitive boolean
----@field sort canola.SortSpec[]
----@field highlight_filename? fun(entry: canola.Entry, is_hidden: boolean, is_link_target: boolean, is_link_orphan: boolean, bufnr: integer): string|nil
+---@field sort oil.SortSpec[]
+---@field highlight_filename? fun(entry: oil.Entry, is_hidden: boolean, is_link_target: boolean, is_link_orphan: boolean, bufnr: integer): string|nil
----@class (exact) canola.SetupViewOptions
+---@class (exact) oil.SetupViewOptions
---@field show_hidden? boolean Show files and directories that start with "."
----@field show_hidden_when_empty? boolean When true and the directory has no visible entries, show hidden entries instead of an empty listing (:help canola.show_hidden_when_empty).
---@field is_hidden_file? fun(name: string, bufnr: integer): boolean This function defines what is considered a "hidden" file
---@field is_always_hidden? fun(name: string, bufnr: integer): boolean This function defines what will never be shown, even when `show_hidden` is set
---@field natural_order? boolean|"fast" Sort file names with numbers in a more intuitive order for humans. Can be slow for large directories.
---@field case_insensitive? boolean Sort file and directory names case insensitive
----@field sort? canola.SortSpec[] Sort order for the file list
----@field highlight_filename? fun(entry: canola.Entry, is_hidden: boolean, is_link_target: boolean, is_link_orphan: boolean): string|nil Customize the highlight group for the file name
+---@field sort? oil.SortSpec[] Sort order for the file list
+---@field highlight_filename? fun(entry: oil.Entry, is_hidden: boolean, is_link_target: boolean, is_link_orphan: boolean): string|nil Customize the highlight group for the file name
----@class (exact) canola.SortSpec
+---@class (exact) oil.SortSpec
---@field [1] string
---@field [2] "asc"|"desc"
----@class (exact) canola.GitOptions
+---@class (exact) oil.GitOptions
---@field add fun(path: string): boolean
---@field mv fun(src_path: string, dest_path: string): boolean
---@field rm fun(path: string): boolean
----@class (exact) canola.SetupGitOptions
+---@class (exact) oil.SetupGitOptions
---@field add? fun(path: string): boolean Return true to automatically git add a new file
---@field mv? fun(src_path: string, dest_path: string): boolean Return true to automatically git mv a moved file
---@field rm? fun(path: string): boolean Return true to automatically git rm a deleted file
----@class (exact) canola.WindowDimensionDualConstraint
+---@class (exact) oil.WindowDimensionDualConstraint
---@field [1] number
---@field [2] number
----@alias canola.WindowDimension number|canola.WindowDimensionDualConstraint
+---@alias oil.WindowDimension number|oil.WindowDimensionDualConstraint
----@class (exact) canola.WindowConfig
----@field max_width canola.WindowDimension
----@field min_width canola.WindowDimension
+---@class (exact) oil.WindowConfig
+---@field max_width oil.WindowDimension
+---@field min_width oil.WindowDimension
---@field width? number
----@field max_height canola.WindowDimension
----@field min_height canola.WindowDimension
+---@field max_height oil.WindowDimension
+---@field min_height oil.WindowDimension
---@field height? number
---@field border string|string[]
---@field win_options table
----@class (exact) canola.SetupWindowConfig
----@field max_width? canola.WindowDimension Width dimensions can be integers or a float between 0 and 1 (e.g. 0.4 for 40%). Can be a single value or a list of mixed integer/float types. max_width = {100, 0.8} means "the lesser of 100 columns or 80% of total"
----@field min_width? canola.WindowDimension Width dimensions can be integers or a float between 0 and 1 (e.g. 0.4 for 40%). Can be a single value or a list of mixed integer/float types. min_width = {40, 0.4} means "the greater of 40 columns or 40% of total"
+---@class (exact) oil.SetupWindowConfig
+---@field max_width? oil.WindowDimension Width dimensions can be integers or a float between 0 and 1 (e.g. 0.4 for 40%). Can be a single value or a list of mixed integer/float types. max_width = {100, 0.8} means "the lesser of 100 columns or 80% of total"
+---@field min_width? oil.WindowDimension Width dimensions can be integers or a float between 0 and 1 (e.g. 0.4 for 40%). Can be a single value or a list of mixed integer/float types. min_width = {40, 0.4} means "the greater of 40 columns or 40% of total"
---@field width? number Define an integer/float for the exact width of the preview window
----@field max_height? canola.WindowDimension Height dimensions can be integers or a float between 0 and 1 (e.g. 0.4 for 40%). Can be a single value or a list of mixed integer/float types. max_height = {80, 0.9} means "the lesser of 80 columns or 90% of total"
----@field min_height? canola.WindowDimension Height dimensions can be integers or a float between 0 and 1 (e.g. 0.4 for 40%). Can be a single value or a list of mixed integer/float types. min_height = {5, 0.1} means "the greater of 5 columns or 10% of total"
+---@field max_height? oil.WindowDimension Height dimensions can be integers or a float between 0 and 1 (e.g. 0.4 for 40%). Can be a single value or a list of mixed integer/float types. max_height = {80, 0.9} means "the lesser of 80 columns or 90% of total"
+---@field min_height? oil.WindowDimension Height dimensions can be integers or a float between 0 and 1 (e.g. 0.4 for 40%). Can be a single value or a list of mixed integer/float types. min_height = {5, 0.1} means "the greater of 5 columns or 10% of total"
---@field height? number Define an integer/float for the exact height of the preview window
---@field border? string|string[] Window border
---@field win_options? table
----@alias canola.PreviewMethod
+---@alias oil.PreviewMethod
---| '"load"' # Load the previewed file into a buffer
---| '"scratch"' # Put the text into a scratch buffer to avoid LSP attaching
---| '"fast_scratch"' # Put only the visible text into a scratch buffer
----@class (exact) canola.PreviewWindowConfig
+---@class (exact) oil.PreviewWindowConfig
---@field update_on_cursor_moved boolean
----@field preview_method canola.PreviewMethod
+---@field preview_method oil.PreviewMethod
---@field disable_preview fun(filename: string): boolean
----@field max_file_size number Maximum file size (in MB) to preview. Files larger than this will show a placeholder.
---@field win_options table
----@class (exact) canola.ConfirmationWindowConfig : canola.WindowConfig
+---@class (exact) oil.ConfirmationWindowConfig : oil.WindowConfig
----@class (exact) canola.SetupPreviewWindowConfig
+---@class (exact) oil.SetupPreviewWindowConfig
---@field update_on_cursor_moved? boolean Whether the preview window is automatically updated when the cursor is moved
---@field disable_preview? fun(filename: string): boolean A function that returns true to disable preview on a file e.g. to avoid lag
----@field max_file_size? number Maximum file size in MB to show in preview. Files exceeding this will not be loaded (:help canola.preview_win). Set to nil to disable the limit.
----@field preview_method? canola.PreviewMethod How to open the preview window
+---@field preview_method? oil.PreviewMethod How to open the preview window
---@field win_options? table Window-local options to use for preview window buffers
----@class (exact) canola.SetupConfirmationWindowConfig : canola.SetupWindowConfig
+---@class (exact) oil.SetupConfirmationWindowConfig : oil.SetupWindowConfig
----@class (exact) canola.ProgressWindowConfig : canola.WindowConfig
+---@class (exact) oil.ProgressWindowConfig : oil.WindowConfig
---@field minimized_border string|string[]
----@class (exact) canola.SetupProgressWindowConfig : canola.SetupWindowConfig
+---@class (exact) oil.SetupProgressWindowConfig : oil.SetupWindowConfig
---@field minimized_border? string|string[] The border for the minimized progress window
----@class (exact) canola.FloatWindowConfig
+---@class (exact) oil.FloatWindowConfig
---@field padding integer
---@field max_width integer
---@field max_height integer
@@ -405,7 +389,7 @@ local M = {}
---@field preview_split "auto"|"left"|"right"|"above"|"below"
---@field override fun(conf: table): table
----@class (exact) canola.SetupFloatWindowConfig
+---@class (exact) oil.SetupFloatWindowConfig
---@field padding? integer
---@field max_width? integer
---@field max_height? integer
@@ -415,16 +399,16 @@ local M = {}
---@field preview_split? "auto"|"left"|"right"|"above"|"below" Direction that the preview command will split the window
---@field override? fun(conf: table): table
----@class (exact) canola.SimpleWindowConfig
+---@class (exact) oil.SimpleWindowConfig
---@field border string|string[]
----@class (exact) canola.SetupSimpleWindowConfig
+---@class (exact) oil.SetupSimpleWindowConfig
---@field border? string|string[] Window border
M.setup = function(opts)
- opts = opts or vim.g.canola or {}
+ opts = opts or vim.g.oil or {}
- local new_conf = vim.tbl_deep_extend('keep', opts, default_config)
+ local new_conf = vim.tbl_deep_extend("keep", opts, default_config)
if not new_conf.use_default_keymaps then
new_conf.keymaps = opts.keymaps or {}
elseif opts.keymaps then
@@ -445,19 +429,19 @@ M.setup = function(opts)
end
-- Backwards compatibility for old versions that don't support winborder
- if vim.fn.has('nvim-0.11') == 0 then
- new_conf = vim.tbl_deep_extend('keep', new_conf, {
- float = { border = 'rounded' },
- confirmation = { border = 'rounded' },
- progress = { border = 'rounded' },
- ssh = { border = 'rounded' },
- keymaps_help = { border = 'rounded' },
+ if vim.fn.has("nvim-0.11") == 0 then
+ new_conf = vim.tbl_deep_extend("keep", new_conf, {
+ float = { border = "rounded" },
+ confirmation = { border = "rounded" },
+ progress = { border = "rounded" },
+ ssh = { border = "rounded" },
+ keymaps_help = { border = "rounded" },
})
end
-- Backwards compatibility. We renamed the 'preview' window config to be called 'confirmation'.
if opts.preview and not opts.confirmation then
- new_conf.confirmation = vim.tbl_deep_extend('keep', opts.preview, default_config.confirmation)
+ new_conf.confirmation = vim.tbl_deep_extend("keep", opts.preview, default_config.confirmation)
end
-- Backwards compatibility. We renamed the 'preview' config to 'preview_win'
if opts.preview and opts.preview.update_on_cursor_moved ~= nil then
@@ -468,7 +452,7 @@ M.setup = function(opts)
new_conf.lsp_file_methods.autosave_changes = new_conf.lsp_rename_autosave
new_conf.lsp_rename_autosave = nil
vim.notify_once(
- 'canola config value lsp_rename_autosave has moved to lsp_file_methods.autosave_changes.\nCompatibility will be removed on 2024-09-01.',
+ "oil config value lsp_rename_autosave has moved to lsp_file_methods.autosave_changes.\nCompatibility will be removed on 2024-09-01.",
vim.log.levels.WARN
)
end
@@ -490,15 +474,15 @@ M.setup = function(opts)
end
---@param scheme nil|string
----@return nil|canola.Adapter
+---@return nil|oil.Adapter
M.get_adapter_by_scheme = function(scheme)
if not scheme then
return nil
end
- if not vim.endswith(scheme, '://') then
- local pieces = vim.split(scheme, '://', { plain = true })
+ if not vim.endswith(scheme, "://") then
+ local pieces = vim.split(scheme, "://", { plain = true })
if #pieces <= 2 then
- scheme = pieces[1] .. '://'
+ scheme = pieces[1] .. "://"
else
error(string.format("Malformed url: '%s'", scheme))
end
@@ -510,7 +494,7 @@ M.get_adapter_by_scheme = function(scheme)
return nil
end
local ok
- ok, adapter = pcall(require, string.format('canola.adapters.%s', name))
+ ok, adapter = pcall(require, string.format("oil.adapters.%s", name))
if ok then
adapter.name = name
M._adapter_by_scheme[scheme] = adapter
diff --git a/lua/canola/constants.lua b/lua/oil/constants.lua
similarity index 63%
rename from lua/canola/constants.lua
rename to lua/oil/constants.lua
index 9427837..3f5a38a 100644
--- a/lua/canola/constants.lua
+++ b/lua/oil/constants.lua
@@ -2,9 +2,9 @@ local M = {}
---Store entries as a list-like table for maximum space efficiency and retrieval speed.
---We use the constants below to index into the table.
----@alias canola.InternalEntry {[1]: integer, [2]: string, [3]: canola.EntryType, [4]: nil|table}
+---@alias oil.InternalEntry {[1]: integer, [2]: string, [3]: oil.EntryType, [4]: nil|table}
--- Indexes into canola.InternalEntry
+-- Indexes into oil.InternalEntry
M.FIELD_ID = 1
M.FIELD_NAME = 2
M.FIELD_TYPE = 3
diff --git a/lua/canola/fs.lua b/lua/oil/fs.lua
similarity index 83%
rename from lua/canola/fs.lua
rename to lua/oil/fs.lua
index e7daa77..80fb6d4 100644
--- a/lua/canola/fs.lua
+++ b/lua/oil/fs.lua
@@ -1,17 +1,17 @@
-local log = require('canola.log')
+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_windows = uv.os_uname().version:match("Windows")
-M.is_mac = uv.os_uname().sysname == 'Darwin'
+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 '/'
+M.sep = M.is_windows and "\\" or "/"
---@param ... string
M.join = function(...)
@@ -23,15 +23,15 @@ end
---@return boolean
M.is_absolute = function(dir)
if M.is_windows then
- return dir:match('^%a:\\')
+ return dir:match("^%a:\\")
else
- return vim.startswith(dir, '/')
+ return vim.startswith(dir, "/")
end
end
M.abspath = function(path)
if not M.is_absolute(path) then
- path = vim.fn.fnamemodify(path, ':p')
+ path = vim.fn.fnamemodify(path, ":p")
end
return path
end
@@ -40,11 +40,11 @@ end
---@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
+ if type(mode) == "function" then
cb = mode
mode = 420
end
- uv.fs_open(path, 'a', mode or 420, function(err, fd)
+ uv.fs_open(path, "a", mode or 420, function(err, fd)
if err then
cb(err)
else
@@ -59,12 +59,12 @@ end
---@param candidate string
---@return boolean
M.is_subpath = function(root, candidate)
- if candidate == '' then
+ if candidate == "" then
return false
end
root = vim.fs.normalize(M.abspath(root))
-- Trim trailing "/" from the root
- if root:find('/', -1) then
+ if root:find("/", -1) then
root = root:sub(1, -2)
end
candidate = vim.fs.normalize(M.abspath(candidate))
@@ -80,8 +80,8 @@ M.is_subpath = function(root, candidate)
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()
+ 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
@@ -90,15 +90,15 @@ end
---@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 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('/', '\\'))
+ return string.format("%s:%s", drive, rem:gsub("/", "\\"))
else
- local newpath = path:gsub('/', '\\')
+ local newpath = path:gsub("/", "\\")
return newpath
end
else
@@ -111,10 +111,10 @@ end
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('\\', '/'))
+ local drive, rem = path:match("^([^:]+):\\(.*)$")
+ return string.format("/%s/%s", drive:upper(), rem:gsub("\\", "/"))
else
- local newpath = path:gsub('\\', '/')
+ local newpath = path:gsub("\\", "/")
return newpath
end
else
@@ -135,16 +135,16 @@ M.shorten_path = function(path, relative_to)
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
+ 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 = '.'
+ if relpath == "" then
+ relpath = "."
end
end
if M.is_subpath(home_dir, path) then
- local homepath = '~' .. path:sub(home_dir:len() + 1)
+ local homepath = "~" .. path:sub(home_dir:len() + 1)
if not relpath or homepath:len() < relpath:len() then
return homepath
end
@@ -156,13 +156,13 @@ end
---@param mode? integer
M.mkdirp = function(dir, mode)
mode = mode or 493
- local mod = ''
+ local mod = ""
local path = dir
while vim.fn.isdirectory(path) == 0 do
- mod = mod .. ':h'
+ mod = mod .. ":h"
path = vim.fn.fnamemodify(dir, mod)
end
- while mod ~= '' do
+ while mod ~= "" do
mod = mod:sub(3)
path = vim.fn.fnamemodify(dir, mod)
uv.fs_mkdir(path, mode)
@@ -170,7 +170,7 @@ M.mkdirp = function(dir, mode)
end
---@param dir string
----@param cb fun(err: nil|string, entries: nil|{type: canola.EntryType, name: 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)
@@ -205,11 +205,11 @@ M.listdir = function(dir, cb)
end, 10000)
end
----@param entry_type canola.EntryType
+---@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
+ if entry_type ~= "directory" then
return uv.fs_unlink(path, cb)
end
---@diagnostic disable-next-line: param-type-mismatch, discard-returns
@@ -271,13 +271,13 @@ local move_undofile = vim.schedule_wrap(function(src_path, dest_path, copy)
if copy then
uv.fs_copyfile(src_path, dest_path, function(err)
if err then
- log.warn('Error copying undofile %s: %s', undofile, err)
+ 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)
+ log.warn("Error moving undofile %s: %s", undofile, err)
end
end)
end
@@ -285,12 +285,12 @@ local move_undofile = vim.schedule_wrap(function(src_path, dest_path, copy)
)
end)
----@param entry_type canola.EntryType
+---@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
+ if entry_type == "link" then
uv.fs_readlink(src_path, function(link_err, link)
if link_err then
return cb(link_err)
@@ -300,7 +300,7 @@ M.recursive_copy = function(entry_type, src_path, dest_path, cb)
end)
return
end
- if entry_type ~= 'directory' then
+ if entry_type ~= "directory" then
uv.fs_copyfile(src_path, dest_path, { excl = true }, cb)
move_undofile(src_path, dest_path, true)
return
@@ -357,7 +357,7 @@ M.recursive_copy = function(entry_type, src_path, dest_path, cb)
end)
end
----@param entry_type canola.EntryType
+---@param entry_type oil.EntryType
---@param src_path string
---@param dest_path string
---@param cb fun(err: nil|string)
@@ -374,7 +374,7 @@ M.recursive_move = function(entry_type, src_path, dest_path, cb)
end
end)
else
- if entry_type ~= 'directory' then
+ if entry_type ~= "directory" then
move_undofile(src_path, dest_path, false)
end
cb()
diff --git a/lua/canola/git.lua b/lua/oil/git.lua
similarity index 72%
rename from lua/canola/git.lua
rename to lua/oil/git.lua
index 747c123..ec3b84b 100644
--- a/lua/canola/git.lua
+++ b/lua/oil/git.lua
@@ -1,12 +1,12 @@
-- integration with git operations
-local fs = require('canola.fs')
+local fs = require("oil.fs")
local M = {}
---@param path string
---@return string|nil
M.get_root = function(path)
- local git_dir = vim.fs.find('.git', { upward = true, path = path })[1]
+ local git_dir = vim.fs.find(".git", { upward = true, path = path })[1]
if git_dir then
return vim.fs.dirname(git_dir)
else
@@ -22,16 +22,16 @@ M.add = function(path, cb)
return cb()
end
- local stderr = ''
- local jid = vim.fn.jobstart({ 'git', 'add', path }, {
+ local stderr = ""
+ local jid = vim.fn.jobstart({ "git", "add", path }, {
cwd = root,
stderr_buffered = true,
on_stderr = function(_, data)
- stderr = table.concat(data, '\n')
+ stderr = table.concat(data, "\n")
end,
on_exit = function(_, code)
if code ~= 0 then
- cb('Error in git add: ' .. stderr)
+ cb("Error in git add: " .. stderr)
else
cb()
end
@@ -50,12 +50,12 @@ M.rm = function(path, cb)
return cb()
end
- local stderr = ''
- local jid = vim.fn.jobstart({ 'git', 'rm', '-r', path }, {
+ local stderr = ""
+ local jid = vim.fn.jobstart({ "git", "rm", "-r", path }, {
cwd = root,
stderr_buffered = true,
on_stderr = function(_, data)
- stderr = table.concat(data, '\n')
+ stderr = table.concat(data, "\n")
end,
on_exit = function(_, code)
if code ~= 0 then
@@ -63,7 +63,7 @@ M.rm = function(path, cb)
if stderr:match("^fatal: pathspec '.*' did not match any files$") then
cb()
else
- cb('Error in git rm: ' .. stderr)
+ cb("Error in git rm: " .. stderr)
end
else
cb()
@@ -75,7 +75,7 @@ M.rm = function(path, cb)
end
end
----@param entry_type canola.EntryType
+---@param entry_type oil.EntryType
---@param src_path string
---@param dest_path string
---@param cb fun(err: nil|string)
@@ -86,23 +86,23 @@ M.mv = function(entry_type, src_path, dest_path, cb)
return
end
- local stderr = ''
- local jid = vim.fn.jobstart({ 'git', 'mv', src_path, dest_path }, {
+ local stderr = ""
+ local jid = vim.fn.jobstart({ "git", "mv", src_path, dest_path }, {
cwd = src_git,
stderr_buffered = true,
on_stderr = function(_, data)
- stderr = table.concat(data, '\n')
+ stderr = table.concat(data, "\n")
end,
on_exit = function(_, code)
if code ~= 0 then
stderr = vim.trim(stderr)
if
- stderr:match('^fatal: not under version control')
- or stderr:match('^fatal: source directory is empty')
+ stderr:match("^fatal: not under version control")
+ or stderr:match("^fatal: source directory is empty")
then
fs.recursive_move(entry_type, src_path, dest_path, cb)
else
- cb('Error in git mv: ' .. stderr)
+ cb("Error in git mv: " .. stderr)
end
else
cb()
diff --git a/lua/canola/init.lua b/lua/oil/init.lua
similarity index 52%
rename from lua/canola/init.lua
rename to lua/oil/init.lua
index 18d9896..0329afd 100644
--- a/lua/canola/init.lua
+++ b/lua/oil/init.lua
@@ -1,44 +1,44 @@
local M = {}
----@class (exact) canola.Entry
+---@class (exact) oil.Entry
---@field name string
----@field type canola.EntryType
+---@field type oil.EntryType
---@field id nil|integer Will be nil if it hasn't been persisted to disk yet
---@field parsed_name nil|string
---@field meta nil|table
----@alias canola.EntryType uv.aliases.fs_types
----@alias canola.HlRange { [1]: string, [2]: integer, [3]: integer } A tuple of highlight group name, col_start, col_end
----@alias canola.HlTuple { [1]: string, [2]: string } A tuple of text, highlight group
----@alias canola.HlRangeTuple { [1]: string, [2]: canola.HlRange[] } A tuple of text, internal highlights
----@alias canola.TextChunk string|canola.HlTuple|canola.HlRangeTuple
----@alias canola.CrossAdapterAction "copy"|"move"
+---@alias oil.EntryType uv.aliases.fs_types
+---@alias oil.HlRange { [1]: string, [2]: integer, [3]: integer } A tuple of highlight group name, col_start, col_end
+---@alias oil.HlTuple { [1]: string, [2]: string } A tuple of text, highlight group
+---@alias oil.HlRangeTuple { [1]: string, [2]: oil.HlRange[] } A tuple of text, internal highlights
+---@alias oil.TextChunk string|oil.HlTuple|oil.HlRangeTuple
+---@alias oil.CrossAdapterAction "copy"|"move"
----@class (exact) canola.Adapter
+---@class (exact) oil.Adapter
---@field name string The unique name of the adapter (this will be set automatically)
----@field list fun(path: string, column_defs: string[], cb: fun(err?: string, entries?: canola.InternalEntry[], fetch_more?: fun())) Async function to list a directory.
+---@field list fun(path: string, column_defs: string[], cb: fun(err?: string, entries?: oil.InternalEntry[], fetch_more?: fun())) Async function to list a directory.
---@field is_modifiable fun(bufnr: integer): boolean Return true if this directory is modifiable (allows for directories with read-only permissions).
----@field get_column fun(name: string): nil|canola.ColumnDefinition If the adapter has any adapter-specific columns, return them when fetched by name.
+---@field get_column fun(name: string): nil|oil.ColumnDefinition If the adapter has any adapter-specific columns, return them when fetched by name.
---@field get_parent? fun(bufname: string): string Get the parent url of the given buffer
----@field normalize_url fun(url: string, callback: fun(url: string)) Before canola opens a url it will be normalized. This allows for link following, path normalizing, and converting an canola file url to the actual path of a file.
----@field get_entry_path? fun(url: string, entry: canola.Entry, callback: fun(path: string)) Similar to normalize_url, but used when selecting an entry
----@field render_action? fun(action: canola.Action): string Render a mutation action for display in the preview window. Only needed if adapter is modifiable.
----@field perform_action? fun(action: canola.Action, cb: fun(err: nil|string)) Perform a mutation action. Only needed if adapter is modifiable.
+---@field normalize_url fun(url: string, callback: fun(url: string)) Before oil opens a url it will be normalized. This allows for link following, path normalizing, and converting an oil file url to the actual path of a file.
+---@field get_entry_path? fun(url: string, entry: oil.Entry, callback: fun(path: string)) Similar to normalize_url, but used when selecting an entry
+---@field render_action? fun(action: oil.Action): string Render a mutation action for display in the preview window. Only needed if adapter is modifiable.
+---@field perform_action? fun(action: oil.Action, cb: fun(err: nil|string)) Perform a mutation action. Only needed if adapter is modifiable.
---@field read_file? fun(bufnr: integer) Used for adapters that deal with remote/virtual files. Read the contents of the file into a buffer.
---@field write_file? fun(bufnr: integer) Used for adapters that deal with remote/virtual files. Write the contents of a buffer to the destination.
----@field supported_cross_adapter_actions? table Mapping of adapter name to enum for all other adapters that can be used as a src or dest for move/copy actions.
----@field filter_action? fun(action: canola.Action): boolean When present, filter out actions as they are created
----@field filter_error? fun(action: canola.ParseError): boolean When present, filter out errors from parsing a buffer
+---@field supported_cross_adapter_actions? table Mapping of adapter name to enum for all other adapters that can be used as a src or dest for move/copy actions.
+---@field filter_action? fun(action: oil.Action): boolean When present, filter out actions as they are created
+---@field filter_error? fun(action: oil.ParseError): boolean When present, filter out errors from parsing a buffer
---Get the entry on a specific line (1-indexed)
---@param bufnr integer
---@param lnum integer
----@return nil|canola.Entry
+---@return nil|oil.Entry
M.get_entry_on_line = function(bufnr, lnum)
- local columns = require('canola.columns')
- local parser = require('canola.mutator.parser')
- local util = require('canola.util')
- if vim.bo[bufnr].filetype ~= 'canola' then
+ local columns = require("oil.columns")
+ local parser = require("oil.mutator.parser")
+ local util = require("oil.util")
+ if vim.bo[bufnr].filetype ~= "oil" then
return nil
end
local adapter = util.get_adapter(bufnr)
@@ -69,13 +69,13 @@ M.get_entry_on_line = function(bufnr, lnum)
-- This is a NEW entry that hasn't been saved yet
local name = vim.trim(line)
local entry_type
- if vim.endswith(name, '/') then
+ if vim.endswith(name, "/") then
name = name:sub(1, name:len() - 1)
- entry_type = 'directory'
+ entry_type = "directory"
else
- entry_type = 'file'
+ entry_type = "file"
end
- if name == '' then
+ if name == "" then
return nil
else
return {
@@ -87,22 +87,22 @@ M.get_entry_on_line = function(bufnr, lnum)
end
---Get the entry currently under the cursor
----@return nil|canola.Entry
+---@return nil|oil.Entry
M.get_cursor_entry = function()
local lnum = vim.api.nvim_win_get_cursor(0)[1]
return M.get_entry_on_line(0, lnum)
end
----Discard all changes made to canola buffers
+---Discard all changes made to oil buffers
M.discard_all_changes = function()
- local view = require('canola.view')
+ local view = require("oil.view")
for _, bufnr in ipairs(view.get_all_buffers()) do
if vim.bo[bufnr].modified then
view.render_buffer_async(bufnr, {}, function(err)
if err then
vim.notify(
string.format(
- 'Error rendering canola buffer %s: %s',
+ "Error rendering oil buffer %s: %s",
vim.api.nvim_buf_get_name(bufnr),
err
),
@@ -114,60 +114,60 @@ M.discard_all_changes = function()
end
end
----Change the display columns for canola
----@param cols canola.ColumnSpec[]
+---Change the display columns for oil
+---@param cols oil.ColumnSpec[]
M.set_columns = function(cols)
- require('canola.view').set_columns(cols)
+ require("oil.view").set_columns(cols)
end
----Change the sort order for canola
----@param sort canola.SortSpec[] List of columns plus direction. See :help canola-columns to see which ones are sortable.
+---Change the sort order for oil
+---@param sort oil.SortSpec[] List of columns plus direction. See :help oil-columns to see which ones are sortable.
---@example
---- require("canola").set_sort({ { "type", "asc" }, { "size", "desc" } })
+--- require("oil").set_sort({ { "type", "asc" }, { "size", "desc" } })
M.set_sort = function(sort)
- require('canola.view').set_sort(sort)
+ require("oil.view").set_sort(sort)
end
----Change how canola determines if the file is hidden
----@param is_hidden_file fun(filename: string, bufnr: integer, entry: canola.Entry): boolean Return true if the file/dir should be hidden
+---Change how oil determines if the file is hidden
+---@param is_hidden_file fun(filename: string, bufnr: integer, entry: oil.Entry): boolean Return true if the file/dir should be hidden
M.set_is_hidden_file = function(is_hidden_file)
- require('canola.view').set_is_hidden_file(is_hidden_file)
+ require("oil.view").set_is_hidden_file(is_hidden_file)
end
---Toggle hidden files and directories
M.toggle_hidden = function()
- require('canola.view').toggle_hidden()
+ require("oil.view").toggle_hidden()
end
---Get the current directory
---@param bufnr? integer
---@return nil|string
M.get_current_dir = function(bufnr)
- local config = require('canola.config')
- local fs = require('canola.fs')
- local util = require('canola.util')
+ local config = require("oil.config")
+ local fs = require("oil.fs")
+ local util = require("oil.util")
local buf_name = vim.api.nvim_buf_get_name(bufnr or 0)
local scheme, path = util.parse_url(buf_name)
- if config.adapters[scheme] == 'files' then
+ if config.adapters[scheme] == "files" then
assert(path)
return fs.posix_to_os_path(path)
end
end
----Get the canola url for a given directory
+---Get the oil url for a given directory
---@private
---@param dir nil|string When nil, use the cwd
----@param use_canola_parent nil|boolean If in an canola buffer, return the parent (default true)
+---@param use_oil_parent nil|boolean If in an oil buffer, return the parent (default true)
---@return string The parent url
---@return nil|string The basename (if present) of the file/dir we were just in
-M.get_url_for_path = function(dir, use_canola_parent)
- if use_canola_parent == nil then
- use_canola_parent = true
+M.get_url_for_path = function(dir, use_oil_parent)
+ if use_oil_parent == nil then
+ use_oil_parent = true
end
- local config = require('canola.config')
- local fs = require('canola.fs')
- local util = require('canola.util')
- if vim.bo.filetype == 'netrw' and not dir then
+ local config = require("oil.config")
+ local fs = require("oil.fs")
+ local util = require("oil.util")
+ if vim.bo.filetype == "netrw" and not dir then
dir = vim.b.netrw_curdir
end
if dir then
@@ -175,42 +175,42 @@ M.get_url_for_path = function(dir, use_canola_parent)
if scheme then
return dir
end
- local abspath = vim.fn.fnamemodify(dir, ':p')
+ local abspath = vim.fn.fnamemodify(dir, ":p")
local path = fs.os_to_posix_path(abspath)
return config.adapter_to_scheme.files .. path
else
local bufname = vim.api.nvim_buf_get_name(0)
- return M.get_buffer_parent_url(bufname, use_canola_parent)
+ return M.get_buffer_parent_url(bufname, use_oil_parent)
end
end
---@private
---@param bufname string
----@param use_canola_parent boolean If in an canola buffer, return the parent
+---@param use_oil_parent boolean If in an oil buffer, return the parent
---@return string
---@return nil|string
-M.get_buffer_parent_url = function(bufname, use_canola_parent)
- local config = require('canola.config')
- local fs = require('canola.fs')
- local pathutil = require('canola.pathutil')
- local util = require('canola.util')
+M.get_buffer_parent_url = function(bufname, use_oil_parent)
+ local config = require("oil.config")
+ local fs = require("oil.fs")
+ local pathutil = require("oil.pathutil")
+ local util = require("oil.util")
local scheme, path = util.parse_url(bufname)
if not scheme then
local parent, basename
scheme = config.adapter_to_scheme.files
- if bufname == '' then
+ if bufname == "" then
parent = fs.os_to_posix_path(vim.fn.getcwd())
else
- parent = fs.os_to_posix_path(vim.fn.fnamemodify(bufname, ':p:h'))
- basename = vim.fn.fnamemodify(bufname, ':t')
+ parent = fs.os_to_posix_path(vim.fn.fnamemodify(bufname, ":p:h"))
+ basename = vim.fn.fnamemodify(bufname, ":t")
end
local parent_url = util.addslash(scheme .. parent)
return parent_url, basename
else
assert(path)
- if scheme == 'term://' then
+ if scheme == "term://" then
---@type string
- path = vim.fn.expand(path:match('^(.*)//')) ---@diagnostic disable-line: assign-type-mismatch
+ path = vim.fn.expand(path:match("^(.*)//")) ---@diagnostic disable-line: assign-type-mismatch
return config.adapter_to_scheme.files .. util.addslash(path)
end
@@ -219,7 +219,7 @@ M.get_buffer_parent_url = function(bufname, use_canola_parent)
return vim.fn.getcwd()
end
- if not use_canola_parent then
+ if not use_oil_parent then
return bufname
end
local adapter = assert(config.get_adapter_by_scheme(scheme))
@@ -239,19 +239,19 @@ M.get_buffer_parent_url = function(bufname, use_canola_parent)
end
end
----@class (exact) canola.OpenOpts
----@field preview? canola.OpenPreviewOpts When present, open the preview window after opening canola
+---@class (exact) oil.OpenOpts
+---@field preview? oil.OpenPreviewOpts When present, open the preview window after opening oil
----Open canola browser in a floating window
+---Open oil browser in a floating window
---@param dir? string When nil, open the parent of the current buffer, or the cwd if current buffer is not a file
----@param opts? canola.OpenOpts
----@param cb? fun() Called after the canola buffer is ready
+---@param opts? oil.OpenOpts
+---@param cb? fun() Called after the oil buffer is ready
M.open_float = function(dir, opts, cb)
opts = opts or {}
- local config = require('canola.config')
- local layout = require('canola.layout')
- local util = require('canola.util')
- local view = require('canola.view')
+ local config = require("oil.config")
+ local layout = require("oil.layout")
+ local util = require("oil.util")
+ local view = require("oil.view")
local parent_url, basename = M.get_url_for_path(dir)
if basename then
@@ -259,24 +259,24 @@ M.open_float = function(dir, opts, cb)
end
local bufnr = vim.api.nvim_create_buf(false, true)
- vim.bo[bufnr].bufhidden = 'wipe'
+ vim.bo[bufnr].bufhidden = "wipe"
local win_opts = layout.get_fullscreen_win_opts()
local original_winid = vim.api.nvim_get_current_win()
local winid = vim.api.nvim_open_win(bufnr, true, win_opts)
- vim.w[winid].is_canola_win = true
- vim.w[winid].canola_original_win = original_winid
+ vim.w[winid].is_oil_win = true
+ vim.w[winid].oil_original_win = original_winid
for k, v in pairs(config.float.win_options) do
- vim.api.nvim_set_option_value(k, v, { scope = 'local', win = winid })
+ vim.api.nvim_set_option_value(k, v, { scope = "local", win = winid })
end
local autocmds = {}
table.insert(
autocmds,
- vim.api.nvim_create_autocmd('WinLeave', {
- desc = 'Close floating canola window',
- group = 'Canola',
+ vim.api.nvim_create_autocmd("WinLeave", {
+ desc = "Close floating oil window",
+ group = "Oil",
callback = vim.schedule_wrap(function()
- if util.is_floating_win() or vim.fn.win_gettype() == 'command' then
+ if util.is_floating_win() or vim.fn.win_gettype() == "command" then
return
end
if vim.api.nvim_win_is_valid(winid) then
@@ -293,30 +293,29 @@ M.open_float = function(dir, opts, cb)
table.insert(
autocmds,
- vim.api.nvim_create_autocmd('BufWinEnter', {
- desc = 'Reset local canola window options when buffer changes',
- pattern = '*',
+ vim.api.nvim_create_autocmd("BufWinEnter", {
+ desc = "Reset local oil window options when buffer changes",
+ pattern = "*",
callback = function(params)
local winbuf = params.buf
if not vim.api.nvim_win_is_valid(winid) or vim.api.nvim_win_get_buf(winid) ~= winbuf then
return
end
for k, v in pairs(config.float.win_options) do
- vim.api.nvim_set_option_value(k, v, { scope = 'local', win = winid })
+ vim.api.nvim_set_option_value(k, v, { scope = "local", win = winid })
end
- if config.float.border ~= nil and config.float.border ~= 'none' then
+ -- Update the floating window title
+ if vim.fn.has("nvim-0.9") == 1 and config.float.border ~= "none" then
local cur_win_opts = vim.api.nvim_win_get_config(winid)
vim.api.nvim_win_set_config(winid, {
- relative = 'editor',
+ relative = "editor",
row = cur_win_opts.row,
col = cur_win_opts.col,
width = cur_win_opts.width,
height = cur_win_opts.height,
title = util.get_title(winid),
})
- else
- util.add_title_to_win(winid)
end
end,
})
@@ -325,7 +324,7 @@ M.open_float = function(dir, opts, cb)
vim.cmd.edit({ args = { util.escape_filename(parent_url) }, mods = { keepalt = true } })
-- :edit will set buflisted = true, but we may not want that
if config.buf_options.buflisted ~= nil then
- vim.api.nvim_set_option_value('buflisted', config.buf_options.buflisted, { buf = 0 })
+ vim.api.nvim_set_option_value("buflisted", config.buf_options.buflisted, { buf = 0 })
end
util.run_after_load(0, function()
@@ -336,17 +335,17 @@ M.open_float = function(dir, opts, cb)
end
end)
- if config.float.border == nil or config.float.border == 'none' then
+ if vim.fn.has("nvim-0.9") == 0 then
util.add_title_to_win(winid)
end
end
----Open canola browser in a floating window, or close it if open
+---Open oil browser in a floating window, or close it if open
---@param dir nil|string When nil, open the parent of the current buffer, or the cwd if current buffer is not a file
----@param opts? canola.OpenOpts
----@param cb? fun() Called after the canola buffer is ready
+---@param opts? oil.OpenOpts
+---@param cb? fun() Called after the oil buffer is ready
M.toggle_float = function(dir, opts, cb)
- if vim.w.is_canola_win then
+ if vim.w.is_oil_win then
M.close()
if cb then
cb()
@@ -356,105 +355,32 @@ M.toggle_float = function(dir, opts, cb)
end
end
----@class (exact) canola.OpenSplitOpts : canola.OpenOpts
----@field vertical? boolean Open the buffer in a vertical split
----@field horizontal? boolean Open the buffer in a horizontal split
----@field split? "aboveleft"|"belowright"|"topleft"|"botright" Split modifier
-
----Open canola browser in a split window
----@param dir? string When nil, open the parent of the current buffer, or the cwd if current buffer is not a file
----@param opts? canola.OpenSplitOpts
----@param cb? fun() Called after the canola buffer is ready
-M.open_split = function(dir, opts, cb)
- opts = opts or {}
- local config = require('canola.config')
- local util = require('canola.util')
- local view = require('canola.view')
-
- local parent_url, basename = M.get_url_for_path(dir)
- if basename then
- view.set_last_cursor(parent_url, basename)
- end
-
- if not opts.vertical and opts.horizontal == nil then
- opts.horizontal = true
- end
- if not opts.split then
- if opts.horizontal then
- opts.split = vim.o.splitbelow and 'belowright' or 'aboveleft'
- else
- opts.split = vim.o.splitright and 'belowright' or 'aboveleft'
- end
- end
-
- local mods = {
- vertical = opts.vertical,
- horizontal = opts.horizontal,
- split = opts.split,
- }
-
- local original_winid = vim.api.nvim_get_current_win()
- vim.cmd.split({ mods = mods })
- local winid = vim.api.nvim_get_current_win()
-
- vim.w[winid].is_canola_win = true
- vim.w[winid].canola_original_win = original_winid
-
- vim.cmd.edit({ args = { util.escape_filename(parent_url) }, mods = { keepalt = true } })
- if config.buf_options.buflisted ~= nil then
- vim.api.nvim_set_option_value('buflisted', config.buf_options.buflisted, { buf = 0 })
- end
-
- util.run_after_load(0, function()
- if opts.preview then
- M.open_preview(opts.preview, cb)
- elseif cb then
- cb()
- end
- end)
-end
-
----Open canola browser in a split window, or close it if open
----@param dir nil|string When nil, open the parent of the current buffer, or the cwd if current buffer is not a file
----@param opts? canola.OpenSplitOpts
----@param cb? fun() Called after the canola buffer is ready
-M.toggle_split = function(dir, opts, cb)
- if vim.w.is_canola_win then
- M.close()
- if cb then
- cb()
- end
- else
- M.open_split(dir, opts, cb)
- end
-end
-
----@param canola_bufnr? integer
-local function update_preview_window(canola_bufnr)
- canola_bufnr = canola_bufnr or 0
- local util = require('canola.util')
- util.run_after_load(canola_bufnr, function()
+---@param oil_bufnr? integer
+local function update_preview_window(oil_bufnr)
+ oil_bufnr = oil_bufnr or 0
+ local util = require("oil.util")
+ util.run_after_load(oil_bufnr, function()
local cursor_entry = M.get_cursor_entry()
local preview_win_id = util.get_preview_win()
if
cursor_entry
and preview_win_id
- and cursor_entry.id ~= vim.w[preview_win_id].canola_entry_id
+ and cursor_entry.id ~= vim.w[preview_win_id].oil_entry_id
then
M.open_preview()
end
end)
end
----Open canola browser for a directory
+---Open oil browser for a directory
---@param dir? string When nil, open the parent of the current buffer, or the cwd if current buffer is not a file
----@param opts? canola.OpenOpts
----@param cb? fun() Called after the canola buffer is ready
+---@param opts? oil.OpenOpts
+---@param cb? fun() Called after the oil buffer is ready
M.open = function(dir, opts, cb)
opts = opts or {}
- local config = require('canola.config')
- local util = require('canola.util')
- local view = require('canola.view')
+ local config = require("oil.config")
+ local util = require("oil.util")
+ local view = require("oil.view")
local parent_url, basename = M.get_url_for_path(dir)
if basename then
view.set_last_cursor(parent_url, basename)
@@ -462,7 +388,7 @@ M.open = function(dir, opts, cb)
vim.cmd.edit({ args = { util.escape_filename(parent_url) }, mods = { keepalt = true } })
-- :edit will set buflisted = true, but we may not want that
if config.buf_options.buflisted ~= nil then
- vim.api.nvim_set_option_value('buflisted', config.buf_options.buflisted, { buf = 0 })
+ vim.api.nvim_set_option_value("buflisted", config.buf_options.buflisted, { buf = 0 })
end
util.run_after_load(0, function()
@@ -477,42 +403,39 @@ M.open = function(dir, opts, cb)
update_preview_window()
end
----@class canola.CloseOpts
----@field exit_if_last_buf? boolean Exit vim if this canola buffer is the last open buffer
+---@class oil.CloseOpts
+---@field exit_if_last_buf? boolean Exit vim if this oil buffer is the last open buffer
----Restore the buffer that was present when canola was opened
----@param opts? canola.CloseOpts
+---Restore the buffer that was present when oil was opened
+---@param opts? oil.CloseOpts
M.close = function(opts)
opts = opts or {}
local mode = vim.api.nvim_get_mode().mode
- if mode:match('^[vVsS\22\19]') or mode:match('^no') then
- vim.api.nvim_feedkeys(vim.api.nvim_replace_termcodes('', true, true, true), 'n', false)
+ if mode:match("^[vVsS\22\19]") or mode:match("^no") then
+ vim.api.nvim_feedkeys(vim.api.nvim_replace_termcodes("", true, true, true), "n", false)
return
end
- -- If we're in a floating canola window, close it and try to restore focus to the original window
- if vim.w.is_canola_win then
- local original_winid = vim.w.canola_original_win
- local ok, _ = pcall(vim.api.nvim_win_close, 0, true)
- if not ok then
- vim.cmd.enew()
- end
+ -- If we're in a floating oil window, close it and try to restore focus to the original window
+ if vim.w.is_oil_win then
+ local original_winid = vim.w.oil_original_win
+ vim.api.nvim_win_close(0, true)
if original_winid and vim.api.nvim_win_is_valid(original_winid) then
vim.api.nvim_set_current_win(original_winid)
end
return
end
- local ok, bufnr = pcall(vim.api.nvim_win_get_var, 0, 'canola_original_buffer')
+ local ok, bufnr = pcall(vim.api.nvim_win_get_var, 0, "oil_original_buffer")
if ok and vim.api.nvim_buf_is_valid(bufnr) then
vim.api.nvim_win_set_buf(0, bufnr)
- if vim.w.canola_original_view then
- vim.fn.winrestview(vim.w.canola_original_view)
+ if vim.w.oil_original_view then
+ vim.fn.winrestview(vim.w.oil_original_view)
end
return
end
-- Deleting the buffer closes all windows with that buffer open, so navigate to a different
-- buffer first
- local canolabuf = vim.api.nvim_get_current_buf()
+ local oilbuf = vim.api.nvim_get_current_buf()
ok = pcall(vim.cmd.bprev)
-- If `bprev` failed, there are no buffers open
if not ok then
@@ -523,22 +446,22 @@ M.close = function(opts)
vim.cmd.enew()
end
end
- vim.api.nvim_buf_delete(canolabuf, { force = true })
+ vim.api.nvim_buf_delete(oilbuf, { force = true })
end
----@class canola.OpenPreviewOpts
+---@class oil.OpenPreviewOpts
---@field vertical? boolean Open the buffer in a vertical split
---@field horizontal? boolean Open the buffer in a horizontal split
---@field split? "aboveleft"|"belowright"|"topleft"|"botright" Split modifier
---Preview the entry under the cursor in a split
----@param opts? canola.OpenPreviewOpts
+---@param opts? oil.OpenPreviewOpts
---@param callback? fun(err: nil|string) Called once the preview window has been opened
M.open_preview = function(opts, callback)
opts = opts or {}
- local config = require('canola.config')
- local layout = require('canola.layout')
- local util = require('canola.util')
+ local config = require("oil.config")
+ local layout = require("oil.layout")
+ local util = require("oil.util")
local function finish(err)
if err then
@@ -554,9 +477,9 @@ M.open_preview = function(opts, callback)
end
if not opts.split then
if opts.horizontal then
- opts.split = vim.o.splitbelow and 'belowright' or 'aboveleft'
+ opts.split = vim.o.splitbelow and "belowright" or "aboveleft"
else
- opts.split = vim.o.splitright and 'belowright' or 'aboveleft'
+ opts.split = vim.o.splitright and "belowright" or "aboveleft"
end
end
@@ -566,11 +489,11 @@ M.open_preview = function(opts, callback)
local entry = M.get_cursor_entry()
if not entry then
- return finish('Could not find entry under cursor')
+ return finish("Could not find entry under cursor")
end
local entry_title = entry.name
- if entry.type == 'directory' then
- entry_title = entry_title .. '/'
+ if entry.type == "directory" then
+ entry_title = entry_title .. "/"
end
if util.is_floating_win() then
@@ -578,8 +501,8 @@ M.open_preview = function(opts, callback)
local root_win_opts, preview_win_opts =
layout.split_window(0, config.float.preview_split, config.float.padding)
- local win_opts_canola = {
- relative = 'editor',
+ local win_opts_oil = {
+ relative = "editor",
width = root_win_opts.width,
height = root_win_opts.height,
row = root_win_opts.row,
@@ -587,9 +510,9 @@ M.open_preview = function(opts, callback)
border = config.float.border,
zindex = 45,
}
- vim.api.nvim_win_set_config(0, win_opts_canola)
+ vim.api.nvim_win_set_config(0, win_opts_oil)
local win_opts = {
- relative = 'editor',
+ relative = "editor",
width = preview_win_opts.width,
height = preview_win_opts.height,
row = preview_win_opts.row,
@@ -598,21 +521,23 @@ M.open_preview = function(opts, callback)
zindex = 45,
focusable = false,
noautocmd = true,
- style = 'minimal',
+ style = "minimal",
}
- win_opts.title = entry_title
+ if vim.fn.has("nvim-0.9") == 1 then
+ win_opts.title = entry_title
+ end
preview_win = vim.api.nvim_open_win(bufnr, true, win_opts)
- vim.api.nvim_set_option_value('previewwindow', true, { scope = 'local', win = preview_win })
- vim.api.nvim_win_set_var(preview_win, 'canola_preview', true)
+ vim.api.nvim_set_option_value("previewwindow", true, { scope = "local", win = preview_win })
+ vim.api.nvim_win_set_var(preview_win, "oil_preview", true)
vim.api.nvim_set_current_win(prev_win)
- else
+ elseif vim.fn.has("nvim-0.9") == 1 then
vim.api.nvim_win_set_config(preview_win, { title = entry_title })
end
end
- local cmd = preview_win and 'buffer' or 'sbuffer'
+ local cmd = preview_win and "buffer" or "sbuffer"
local mods = {
vertical = opts.vertical,
horizontal = opts.horizontal,
@@ -624,11 +549,11 @@ M.open_preview = function(opts, callback)
-- not get set properly. So we have to switch windows this way instead.
local hack_set_win = function(winid)
local winnr = vim.api.nvim_win_get_number(winid)
- vim.cmd.wincmd({ args = { 'w' }, count = winnr })
+ vim.cmd.wincmd({ args = { "w" }, count = winnr })
end
util.get_edit_path(bufnr, entry, function(normalized_url)
- local mc = package.loaded['multicursor-nvim']
+ local mc = package.loaded["multicursor-nvim"]
local has_multicursors = mc and mc.hasCursors()
local is_visual_mode = util.is_visual_mode()
if preview_win then
@@ -639,32 +564,16 @@ M.open_preview = function(opts, callback)
end
end
- local entry_is_file = not vim.endswith(normalized_url, '/')
+ local entry_is_file = not vim.endswith(normalized_url, "/")
local filebufnr
if entry_is_file then
- local max_mb = config.preview_win.max_file_size
- local _size = entry.meta and entry.meta.stat and entry.meta.stat.size
- if not _size then
- local _st = vim.uv.fs_stat(normalized_url)
- _size = _st and _st.size
- end
- if max_mb and _size and _size > max_mb * 1024 * 1024 then
- if preview_win then
- filebufnr = vim.api.nvim_create_buf(false, true)
- vim.bo[filebufnr].bufhidden = 'wipe'
- vim.bo[filebufnr].buftype = 'nofile'
- util.render_text(filebufnr, 'File too large to preview', { winid = preview_win })
- else
- vim.notify('File too large to preview', vim.log.levels.WARN)
- return finish()
- end
- elseif config.preview_win.disable_preview(normalized_url) then
+ if config.preview_win.disable_preview(normalized_url) then
filebufnr = vim.api.nvim_create_buf(false, true)
- vim.bo[filebufnr].bufhidden = 'wipe'
- vim.bo[filebufnr].buftype = 'nofile'
- util.render_text(filebufnr, 'Preview disabled', { winid = preview_win })
+ vim.bo[filebufnr].bufhidden = "wipe"
+ vim.bo[filebufnr].buftype = "nofile"
+ util.render_text(filebufnr, "Preview disabled", { winid = preview_win })
elseif
- config.preview_win.preview_method ~= 'load'
+ config.preview_win.preview_method ~= "load"
and not util.file_matches_bufreadcmd(normalized_url)
then
filebufnr =
@@ -675,8 +584,8 @@ M.open_preview = function(opts, callback)
if not filebufnr then
filebufnr = vim.fn.bufadd(normalized_url)
if entry_is_file and vim.fn.bufloaded(filebufnr) == 0 then
- vim.bo[filebufnr].bufhidden = 'wipe'
- vim.b[filebufnr].canola_preview_buffer = true
+ vim.bo[filebufnr].bufhidden = "wipe"
+ vim.b[filebufnr].oil_preview_buffer = true
end
end
@@ -687,30 +596,30 @@ M.open_preview = function(opts, callback)
mods = mods,
})
-- Ignore swapfile errors
- if not ok and err and not err:match('^Vim:E325:') then
- vim.api.nvim_echo({ { err, 'Error' } }, true, {})
+ if not ok and err and not err:match("^Vim:E325:") then
+ vim.api.nvim_echo({ { err, "Error" } }, true, {})
end
-- If we called open_preview during an autocmd, then the edit command may not trigger the
-- BufReadCmd to load the buffer. So we need to do it manually.
- if util.is_canola_bufnr(filebufnr) and not vim.b[filebufnr].canola_ready then
- M.load_canola_buffer(filebufnr)
+ if util.is_oil_bufnr(filebufnr) and not vim.b[filebufnr].oil_ready then
+ M.load_oil_buffer(filebufnr)
end
- vim.api.nvim_set_option_value('previewwindow', true, { scope = 'local', win = 0 })
- vim.api.nvim_win_set_var(0, 'canola_preview', true)
+ vim.api.nvim_set_option_value("previewwindow", true, { scope = "local", win = 0 })
+ vim.api.nvim_win_set_var(0, "oil_preview", true)
for k, v in pairs(config.preview_win.win_options) do
- vim.api.nvim_set_option_value(k, v, { scope = 'local', win = preview_win })
+ vim.api.nvim_set_option_value(k, v, { scope = "local", win = preview_win })
end
- vim.w.canola_entry_id = entry.id
- vim.w.canola_source_win = prev_win
+ vim.w.oil_entry_id = entry.id
+ vim.w.oil_source_win = prev_win
if has_multicursors then
hack_set_win(prev_win)
mc.restoreCursors()
elseif is_visual_mode then
hack_set_win(prev_win)
-- Restore the visual selection
- vim.cmd.normal({ args = { 'gv' }, bang = true })
+ vim.cmd.normal({ args = { "gv" }, bang = true })
else
vim.api.nvim_set_current_win(prev_win)
end
@@ -718,24 +627,24 @@ M.open_preview = function(opts, callback)
end)
end
----@class (exact) canola.SelectOpts
+---@class (exact) oil.SelectOpts
---@field vertical? boolean Open the buffer in a vertical split
---@field horizontal? boolean Open the buffer in a horizontal split
---@field split? "aboveleft"|"belowright"|"topleft"|"botright" Split modifier
---@field tab? boolean Open the buffer in a new tab
----@field close? boolean Close the original canola buffer once selection is made
+---@field close? boolean Close the original oil buffer once selection is made
---@field handle_buffer_callback? fun(buf_id: integer) If defined, all other buffer related options here would be ignored. This callback allows you to take over the process of opening the buffer yourself.
---Select the entry under the cursor
----@param opts nil|canola.SelectOpts
+---@param opts nil|oil.SelectOpts
---@param callback nil|fun(err: nil|string) Called once all entries have been opened
M.select = function(opts, callback)
- local cache = require('canola.cache')
- local config = require('canola.config')
- local constants = require('canola.constants')
- local util = require('canola.util')
+ local cache = require("oil.cache")
+ local config = require("oil.config")
+ local constants = require("oil.constants")
+ local util = require("oil.util")
local FIELD_META = constants.FIELD_META
- opts = vim.tbl_extend('keep', opts or {}, {})
+ opts = vim.tbl_extend("keep", opts or {}, {})
local function finish(err)
if err then
@@ -747,22 +656,22 @@ M.select = function(opts, callback)
end
if not opts.split and (opts.horizontal or opts.vertical) then
if opts.horizontal then
- opts.split = vim.o.splitbelow and 'belowright' or 'aboveleft'
+ opts.split = vim.o.splitbelow and "belowright" or "aboveleft"
else
- opts.split = vim.o.splitright and 'belowright' or 'aboveleft'
+ opts.split = vim.o.splitright and "belowright" or "aboveleft"
end
end
if opts.tab and opts.split then
- return finish('Cannot use split=true when tab = true')
+ return finish("Cannot use split=true when tab = true")
end
local adapter = util.get_adapter(0)
if not adapter then
- return finish('Not an canola buffer')
+ return finish("Not an oil buffer")
end
local visual_range = util.get_visual_range()
- ---@type canola.Entry[]
+ ---@type oil.Entry[]
local entries = {}
if visual_range then
for i = visual_range.start_lnum, visual_range.end_lnum do
@@ -778,7 +687,7 @@ M.select = function(opts, callback)
end
end
if vim.tbl_isempty(entries) then
- return finish('Could not find entry under cursor')
+ return finish("Could not find entry under cursor")
end
-- Check if any of these entries are moved from their original location
@@ -804,15 +713,9 @@ M.select = function(opts, callback)
end
end
if any_moved and config.prompt_save_on_select_new_entry then
- if config.auto_save_on_select_new_entry then
- M.save()
- return finish()
- end
- local ok, choice = pcall(vim.fn.confirm, 'Save changes?', 'Yes\nNo', 1)
+ local ok, choice = pcall(vim.fn.confirm, "Save changes?", "Yes\nNo", 1)
if not ok then
return finish()
- elseif choice == 0 then
- return
elseif choice == 1 then
M.save()
return finish()
@@ -820,7 +723,7 @@ M.select = function(opts, callback)
end
local prev_win = vim.api.nvim_get_current_win()
- local canola_bufnr = vim.api.nvim_get_current_buf()
+ local oil_bufnr = vim.api.nvim_get_current_buf()
-- Async iter over entries so we can normalize the url before opening
local i = 1
@@ -835,18 +738,18 @@ M.select = function(opts, callback)
-- entry. This prevents the case of MOVE /foo -> /bar + CREATE /foo.
-- If you enter the new /foo, it will show the contents of the old /foo.
if not entry.id and cache.list_url(bufname)[entry.name] then
- return cb('Please save changes before entering new directory')
+ return cb("Please save changes before entering new directory")
end
else
-- Close floating window before opening a file
- if vim.w.is_canola_win then
+ if vim.w.is_oil_win then
M.close()
end
end
-- Normalize the url before opening to prevent needing to rename them inside the BufReadCmd
-- Renaming buffers during opening can lead to missed autocmds
- util.get_edit_path(canola_bufnr, entry, function(normalized_url)
+ util.get_edit_path(oil_bufnr, entry, function(normalized_url)
local mods = {
vertical = opts.vertical,
horizontal = opts.horizontal,
@@ -854,21 +757,21 @@ M.select = function(opts, callback)
keepalt = false,
}
local filebufnr = vim.fn.bufadd(normalized_url)
- local entry_is_file = not vim.endswith(normalized_url, '/')
+ local entry_is_file = not vim.endswith(normalized_url, "/")
-- The :buffer command doesn't set buflisted=true
- -- So do that for normal files or for canola dirs if config set buflisted=true
+ -- So do that for normal files or for oil dirs if config set buflisted=true
if entry_is_file or config.buf_options.buflisted then
vim.bo[filebufnr].buflisted = true
end
- local cmd = 'buffer'
+ local cmd = "buffer"
if opts.tab then
vim.cmd.tabnew({ mods = mods })
-- Make sure the new buffer from tabnew gets cleaned up
- vim.bo.bufhidden = 'wipe'
+ vim.bo.bufhidden = "wipe"
elseif opts.split then
- cmd = 'sbuffer'
+ cmd = "sbuffer"
end
if opts.handle_buffer_callback ~= nil then
opts.handle_buffer_callback(filebufnr)
@@ -880,8 +783,8 @@ M.select = function(opts, callback)
mods = mods,
})
-- Ignore swapfile errors
- if not ok and err and not err:match('^Vim:E325:') then
- vim.api.nvim_echo({ { err, 'Error' } }, true, {})
+ if not ok and err and not err:match("^Vim:E325:") then
+ vim.api.nvim_echo({ { err, "Error" } }, true, {})
end
end
@@ -912,21 +815,21 @@ end
---@param bufnr integer
---@return boolean
local function maybe_hijack_directory_buffer(bufnr)
- local config = require('canola.config')
- local fs = require('canola.fs')
- local util = require('canola.util')
+ local config = require("oil.config")
+ local fs = require("oil.fs")
+ local util = require("oil.util")
if not config.default_file_explorer then
return false
end
local bufname = vim.api.nvim_buf_get_name(bufnr)
- if bufname == '' then
+ if bufname == "" then
return false
end
if util.parse_url(bufname) or vim.fn.isdirectory(bufname) == 0 then
return false
end
local new_name = util.addslash(
- config.adapter_to_scheme.files .. fs.os_to_posix_path(vim.fn.fnamemodify(bufname, ':p'))
+ config.adapter_to_scheme.files .. fs.os_to_posix_path(vim.fn.fnamemodify(bufname, ":p"))
)
local replaced = util.rename_buffer(bufnr, new_name)
return not replaced
@@ -936,149 +839,149 @@ end
M._get_highlights = function()
return {
{
- name = 'CanolaEmpty',
- link = 'Comment',
- desc = 'Empty column values',
+ name = "OilEmpty",
+ link = "Comment",
+ desc = "Empty column values",
},
{
- name = 'CanolaHidden',
- link = 'Comment',
- desc = 'Hidden entry in an canola buffer',
+ name = "OilHidden",
+ link = "Comment",
+ desc = "Hidden entry in an oil buffer",
},
{
- name = 'CanolaDir',
- link = 'Directory',
- desc = 'Directory names in an canola buffer',
+ name = "OilDir",
+ link = "Directory",
+ desc = "Directory names in an oil buffer",
},
{
- name = 'CanolaDirHidden',
- link = 'CanolaHidden',
- desc = 'Hidden directory names in an canola buffer',
+ name = "OilDirHidden",
+ link = "OilHidden",
+ desc = "Hidden directory names in an oil buffer",
},
{
- name = 'CanolaDirIcon',
- link = 'CanolaDir',
- desc = 'Icon for directories',
+ name = "OilDirIcon",
+ link = "OilDir",
+ desc = "Icon for directories",
},
{
- name = 'CanolaFileIcon',
+ name = "OilFileIcon",
link = nil,
- desc = 'Icon for files',
+ desc = "Icon for files",
},
{
- name = 'CanolaSocket',
- link = 'Keyword',
- desc = 'Socket files in an canola buffer',
+ name = "OilSocket",
+ link = "Keyword",
+ desc = "Socket files in an oil buffer",
},
{
- name = 'CanolaSocketHidden',
- link = 'CanolaHidden',
- desc = 'Hidden socket files in an canola buffer',
+ name = "OilSocketHidden",
+ link = "OilHidden",
+ desc = "Hidden socket files in an oil buffer",
},
{
- name = 'CanolaLink',
+ name = "OilLink",
link = nil,
- desc = 'Soft links in an canola buffer',
+ desc = "Soft links in an oil buffer",
},
{
- name = 'CanolaOrphanLink',
+ name = "OilOrphanLink",
link = nil,
- desc = 'Orphaned soft links in an canola buffer',
+ desc = "Orphaned soft links in an oil buffer",
},
{
- name = 'CanolaLinkHidden',
- link = 'CanolaHidden',
- desc = 'Hidden soft links in an canola buffer',
+ name = "OilLinkHidden",
+ link = "OilHidden",
+ desc = "Hidden soft links in an oil buffer",
},
{
- name = 'CanolaOrphanLinkHidden',
- link = 'CanolaLinkHidden',
- desc = 'Hidden orphaned soft links in an canola buffer',
+ name = "OilOrphanLinkHidden",
+ link = "OilLinkHidden",
+ desc = "Hidden orphaned soft links in an oil buffer",
},
{
- name = 'CanolaLinkTarget',
- link = 'Comment',
- desc = 'The target of a soft link',
+ name = "OilLinkTarget",
+ link = "Comment",
+ desc = "The target of a soft link",
},
{
- name = 'CanolaOrphanLinkTarget',
- link = 'DiagnosticError',
- desc = 'The target of an orphaned soft link',
+ name = "OilOrphanLinkTarget",
+ link = "DiagnosticError",
+ desc = "The target of an orphaned soft link",
},
{
- name = 'CanolaLinkTargetHidden',
- link = 'CanolaHidden',
- desc = 'The target of a hidden soft link',
+ name = "OilLinkTargetHidden",
+ link = "OilHidden",
+ desc = "The target of a hidden soft link",
},
{
- name = 'CanolaOrphanLinkTargetHidden',
- link = 'CanolaOrphanLinkTarget',
- desc = 'The target of an hidden orphaned soft link',
+ name = "OilOrphanLinkTargetHidden",
+ link = "OilOrphanLinkTarget",
+ desc = "The target of an hidden orphaned soft link",
},
{
- name = 'CanolaFile',
+ name = "OilFile",
link = nil,
- desc = 'Normal files in an canola buffer',
+ desc = "Normal files in an oil buffer",
},
{
- name = 'CanolaFileHidden',
- link = 'CanolaHidden',
- desc = 'Hidden normal files in an canola buffer',
+ name = "OilFileHidden",
+ link = "OilHidden",
+ desc = "Hidden normal files in an oil buffer",
},
{
- name = 'CanolaExecutable',
- link = 'DiagnosticOk',
- desc = 'Executable files in an canola buffer',
+ name = "OilExecutable",
+ link = "DiagnosticOk",
+ desc = "Executable files in an oil buffer",
},
{
- name = 'CanolaExecutableHidden',
- link = 'CanolaHidden',
- desc = 'Hidden executable files in an canola buffer',
+ name = "OilExecutableHidden",
+ link = "OilHidden",
+ desc = "Hidden executable files in an oil buffer",
},
{
- name = 'CanolaCreate',
- link = 'DiagnosticInfo',
- desc = 'Create action in the canola preview window',
+ name = "OilCreate",
+ link = "DiagnosticInfo",
+ desc = "Create action in the oil preview window",
},
{
- name = 'CanolaDelete',
- link = 'DiagnosticError',
- desc = 'Delete action in the canola preview window',
+ name = "OilDelete",
+ link = "DiagnosticError",
+ desc = "Delete action in the oil preview window",
},
{
- name = 'CanolaMove',
- link = 'DiagnosticWarn',
- desc = 'Move action in the canola preview window',
+ name = "OilMove",
+ link = "DiagnosticWarn",
+ desc = "Move action in the oil preview window",
},
{
- name = 'CanolaCopy',
- link = 'DiagnosticHint',
- desc = 'Copy action in the canola preview window',
+ name = "OilCopy",
+ link = "DiagnosticHint",
+ desc = "Copy action in the oil preview window",
},
{
- name = 'CanolaChange',
- link = 'Special',
- desc = 'Change action in the canola preview window',
+ name = "OilChange",
+ link = "Special",
+ desc = "Change action in the oil preview window",
},
{
- name = 'CanolaRestore',
- link = 'CanolaCreate',
- desc = 'Restore (from the trash) action in the canola preview window',
+ name = "OilRestore",
+ link = "OilCreate",
+ desc = "Restore (from the trash) action in the oil preview window",
},
{
- name = 'CanolaPurge',
- link = 'CanolaDelete',
- desc = 'Purge (Permanently delete a file from trash) action in the canola preview window',
+ name = "OilPurge",
+ link = "OilDelete",
+ desc = "Purge (Permanently delete a file from trash) action in the oil preview window",
},
{
- name = 'CanolaTrash',
- link = 'CanolaDelete',
- desc = 'Trash (delete a file to trash) action in the canola preview window',
+ name = "OilTrash",
+ link = "OilDelete",
+ desc = "Trash (delete a file to trash) action in the oil preview window",
},
{
- name = 'CanolaTrashSourcePath',
- link = 'Comment',
- desc = 'Virtual text that shows the original path of file in the trash',
+ name = "OilTrashSourcePath",
+ link = "Comment",
+ desc = "Virtual text that shows the original path of file in the trash",
},
}
end
@@ -1089,6 +992,20 @@ local function set_colors()
vim.api.nvim_set_hl(0, conf.name, { default = true, link = conf.link })
end
end
+ -- TODO can remove this call once we drop support for Neovim 0.8. FloatTitle was introduced as a
+ -- built-in highlight group in 0.9, and we can start to rely on colorschemes setting it.
+ ---@diagnostic disable-next-line: deprecated
+ if vim.fn.has("nvim-0.9") == 0 and not pcall(vim.api.nvim_get_hl_by_name, "FloatTitle", true) then
+ ---@diagnostic disable-next-line: deprecated
+ local border = vim.api.nvim_get_hl_by_name("FloatBorder", true)
+ ---@diagnostic disable-next-line: deprecated
+ local normal = vim.api.nvim_get_hl_by_name("Normal", true)
+ vim.api.nvim_set_hl(
+ 0,
+ "FloatTitle",
+ { fg = normal.foreground, bg = border.background or normal.background }
+ )
+ end
end
---Save all changes
@@ -1101,35 +1018,35 @@ M.save = function(opts, cb)
opts = opts or {}
if not cb then
cb = function(err)
- if err and err ~= 'Canceled' then
+ if err and err ~= "Canceled" then
vim.notify(err, vim.log.levels.ERROR)
end
end
end
- local mutator = require('canola.mutator')
+ local mutator = require("oil.mutator")
mutator.try_write_changes(opts.confirm, cb)
end
local function restore_alt_buf()
- if vim.bo.filetype == 'canola' then
- require('canola.view').set_win_options()
- vim.api.nvim_win_set_var(0, 'canola_did_enter', true)
- elseif vim.w.canola_did_enter then
- vim.api.nvim_win_del_var(0, 'canola_did_enter')
- -- We are entering a non-canola buffer *after* having been in an canola buffer
- local has_orig, orig_buffer = pcall(vim.api.nvim_win_get_var, 0, 'canola_original_buffer')
+ if vim.bo.filetype == "oil" then
+ require("oil.view").set_win_options()
+ vim.api.nvim_win_set_var(0, "oil_did_enter", true)
+ elseif vim.w.oil_did_enter then
+ vim.api.nvim_win_del_var(0, "oil_did_enter")
+ -- We are entering a non-oil buffer *after* having been in an oil buffer
+ local has_orig, orig_buffer = pcall(vim.api.nvim_win_get_var, 0, "oil_original_buffer")
if has_orig and vim.api.nvim_buf_is_valid(orig_buffer) then
if vim.api.nvim_get_current_buf() ~= orig_buffer then
- -- If we are editing a new file after navigating around canola, set the alternate buffer
- -- to be the last buffer we were in before opening canola
- vim.fn.setreg('#', orig_buffer)
+ -- If we are editing a new file after navigating around oil, set the alternate buffer
+ -- to be the last buffer we were in before opening oil
+ vim.fn.setreg("#", orig_buffer)
else
- -- If we are editing the same buffer that we started canola from, set the alternate to be
- -- what it was before we opened canola
+ -- If we are editing the same buffer that we started oil from, set the alternate to be
+ -- what it was before we opened oil
local has_orig_alt, alt_buffer =
- pcall(vim.api.nvim_win_get_var, 0, 'canola_original_alternate')
+ pcall(vim.api.nvim_win_get_var, 0, "oil_original_alternate")
if has_orig_alt and vim.api.nvim_buf_is_valid(alt_buffer) then
- vim.fn.setreg('#', alt_buffer)
+ vim.fn.setreg("#", alt_buffer)
end
end
end
@@ -1138,12 +1055,12 @@ end
---@private
---@param bufnr integer
-M.load_canola_buffer = function(bufnr)
- local config = require('canola.config')
- local keymap_util = require('canola.keymap_util')
- local loading = require('canola.loading')
- local util = require('canola.util')
- local view = require('canola.view')
+M.load_oil_buffer = function(bufnr)
+ local config = require("oil.config")
+ local keymap_util = require("oil.keymap_util")
+ local loading = require("oil.loading")
+ local util = require("oil.util")
+ local view = require("oil.view")
local bufname = vim.api.nvim_buf_get_name(bufnr)
local scheme, path = util.parse_url(bufname)
if config.adapter_aliases[scheme] then
@@ -1159,13 +1076,13 @@ M.load_canola_buffer = function(bufnr)
local adapter = assert(config.get_adapter_by_scheme(scheme))
- if vim.endswith(bufname, '/') then
+ if vim.endswith(bufname, "/") then
-- This is a small quality-of-life thing. If the buffer name ends with a `/`, we know it's a
-- directory, and can set the filetype early. This is helpful for adapters with a lot of latency
-- (e.g. ssh) because it will set up the filetype keybinds at the *beginning* of the loading
-- process.
- vim.bo[bufnr].filetype = 'canola'
- vim.bo[bufnr].buftype = 'acwrite'
+ vim.bo[bufnr].filetype = "oil"
+ vim.bo[bufnr].buftype = "acwrite"
keymap_util.set_keymaps(config.keymaps, bufnr)
end
loading.set_loading(bufnr, true)
@@ -1192,19 +1109,19 @@ M.load_canola_buffer = function(bufnr)
local new_scheme = util.parse_url(new_url)
if not new_scheme then
loading.set_loading(bufnr, false)
- vim.cmd.doautocmd({ args = { 'BufReadPre', new_url }, mods = { emsg_silent = true } })
- vim.cmd.doautocmd({ args = { 'BufReadPost', new_url }, mods = { emsg_silent = true } })
+ vim.cmd.doautocmd({ args = { "BufReadPre", new_url }, mods = { emsg_silent = true } })
+ vim.cmd.doautocmd({ args = { "BufReadPost", new_url }, mods = { emsg_silent = true } })
return
end
bufname = new_url
end
- if vim.endswith(bufname, '/') then
- vim.cmd.doautocmd({ args = { 'BufReadPre', bufname }, mods = { emsg_silent = true } })
+ if vim.endswith(bufname, "/") then
+ vim.cmd.doautocmd({ args = { "BufReadPre", bufname }, mods = { emsg_silent = true } })
view.initialize(bufnr)
- vim.cmd.doautocmd({ args = { 'BufReadPost', bufname }, mods = { emsg_silent = true } })
+ vim.cmd.doautocmd({ args = { "BufReadPost", bufname }, mods = { emsg_silent = true } })
else
- vim.bo[bufnr].buftype = 'acwrite'
+ vim.bo[bufnr].buftype = "acwrite"
adapter.read_file(bufnr)
end
restore_alt_buf()
@@ -1214,17 +1131,17 @@ M.load_canola_buffer = function(bufnr)
adapter.normalize_url(bufname, finish)
end
-local function close_preview_window_if_not_in_canola()
- local util = require('canola.util')
+local function close_preview_window_if_not_in_oil()
+ local util = require("oil.util")
local preview_win_id = util.get_preview_win()
- if not preview_win_id or not vim.w[preview_win_id].canola_entry_id then
+ if not preview_win_id or not vim.w[preview_win_id].oil_entry_id then
return
end
- local canola_source_win = vim.w[preview_win_id].canola_source_win
- if canola_source_win and vim.api.nvim_win_is_valid(canola_source_win) then
- local src_buf = vim.api.nvim_win_get_buf(canola_source_win)
- if util.is_canola_bufnr(src_buf) then
+ local oil_source_win = vim.w[preview_win_id].oil_source_win
+ if oil_source_win and vim.api.nvim_win_is_valid(oil_source_win) then
+ local src_buf = vim.api.nvim_win_get_buf(oil_source_win)
+ if util.is_oil_bufnr(src_buf) then
return
end
end
@@ -1234,16 +1151,16 @@ local function close_preview_window_if_not_in_canola()
end
local _on_key_ns = 0
----Initialize canola
----@param opts canola.setupOpts|nil
+---Initialize oil
+---@param opts oil.setupOpts|nil
M.setup = function(opts)
- local Ringbuf = require('canola.ringbuf')
- local config = require('canola.config')
+ local Ringbuf = require("oil.ringbuf")
+ local config = require("oil.config")
config.setup(opts)
set_colors()
local callback = function(args)
- local util = require('canola.util')
+ local util = require("oil.util")
if args.smods.tab > 0 then
vim.cmd.tabnew()
end
@@ -1253,23 +1170,23 @@ M.setup = function(opts)
local i = 1
while i <= #args.fargs do
local v = args.fargs[i]
- if v == '--float' then
+ if v == "--float" then
float = true
table.remove(args.fargs, i)
- elseif v == '--trash' then
+ elseif v == "--trash" then
trash = true
table.remove(args.fargs, i)
- elseif v == '--preview' then
+ elseif v == "--preview" then
-- In the future we may want to support specifying options for the preview window (e.g.
-- vertical/horizontal), but if you want that level of control maybe just use the API
preview = true
table.remove(args.fargs, i)
- elseif v == '--progress' then
- local mutator = require('canola.mutator')
+ elseif v == "--progress" then
+ local mutator = require("oil.mutator")
if mutator.is_mutating() then
mutator.show_progress()
else
- vim.notify('No mutation in progress', vim.log.levels.WARN)
+ vim.notify("No mutation in progress", vim.log.levels.WARN)
end
return
else
@@ -1277,7 +1194,7 @@ M.setup = function(opts)
end
end
- if not float and (args.smods.vertical or args.smods.horizontal or args.smods.split ~= '') then
+ if not float and (args.smods.vertical or args.smods.horizontal or args.smods.split ~= "") then
local range = args.count > 0 and { args.count } or nil
local cmdargs = { mods = { split = args.smods.split }, range = range }
if args.smods.vertical then
@@ -1287,49 +1204,48 @@ M.setup = function(opts)
end
end
- local method = float and 'open_float' or 'open'
+ local method = float and "open_float" or "open"
local path = args.fargs[1]
local open_opts = {}
if trash then
local url = M.get_url_for_path(path, false)
local _, new_path = util.parse_url(url)
- path = 'canola-trash://' .. new_path
+ path = "oil-trash://" .. new_path
end
if preview then
open_opts.preview = {}
end
M[method](path, open_opts)
end
- vim.api.nvim_create_user_command('Canola', callback, {
- desc = 'Open canola file browser on a directory',
- nargs = '*',
- complete = 'dir',
- count = true,
- })
- local aug = vim.api.nvim_create_augroup('Canola', {})
+ vim.api.nvim_create_user_command(
+ "Oil",
+ callback,
+ { desc = "Open oil file browser on a directory", nargs = "*", complete = "dir", count = true }
+ )
+ local aug = vim.api.nvim_create_augroup("Oil", {})
if config.default_file_explorer then
vim.g.loaded_netrw = 1
vim.g.loaded_netrwPlugin = 1
-- If netrw was already loaded, clear this augroup
- if vim.fn.exists('#FileExplorer') then
- vim.api.nvim_create_augroup('FileExplorer', { clear = true })
+ if vim.fn.exists("#FileExplorer") then
+ vim.api.nvim_create_augroup("FileExplorer", { clear = true })
end
end
local patterns = {}
local filetype_patterns = {}
for scheme in pairs(config.adapters) do
- table.insert(patterns, scheme .. '*')
- filetype_patterns[scheme .. '.*'] = { 'canola', { priority = 10 } }
+ table.insert(patterns, scheme .. "*")
+ filetype_patterns[scheme .. ".*"] = { "oil", { priority = 10 } }
end
for scheme in pairs(config.adapter_aliases) do
- table.insert(patterns, scheme .. '*')
- filetype_patterns[scheme .. '.*'] = { 'canola', { priority = 10 } }
+ table.insert(patterns, scheme .. "*")
+ filetype_patterns[scheme .. ".*"] = { "oil", { priority = 10 } }
end
- local scheme_pattern = table.concat(patterns, ',')
+ local scheme_pattern = table.concat(patterns, ",")
-- We need to add these patterns to the filetype matcher so the filetype doesn't get overridden
- -- by other patterns. See https://github.com/stevearc/canola.nvim/issues/47
+ -- by other patterns. See https://github.com/stevearc/oil.nvim/issues/47
vim.filetype.add({
pattern = filetype_patterns,
})
@@ -1340,21 +1256,21 @@ M.setup = function(opts)
keybuf:push(char)
end, _on_key_ns)
end
- vim.api.nvim_create_autocmd('ColorScheme', {
- desc = 'Set default canola highlights',
+ vim.api.nvim_create_autocmd("ColorScheme", {
+ desc = "Set default oil highlights",
group = aug,
- pattern = '*',
+ pattern = "*",
callback = set_colors,
})
- vim.api.nvim_create_autocmd('BufReadCmd', {
+ vim.api.nvim_create_autocmd("BufReadCmd", {
group = aug,
pattern = scheme_pattern,
nested = true,
callback = function(params)
- M.load_canola_buffer(params.buf)
+ M.load_oil_buffer(params.buf)
end,
})
- vim.api.nvim_create_autocmd('BufWriteCmd', {
+ vim.api.nvim_create_autocmd("BufWriteCmd", {
group = aug,
pattern = scheme_pattern,
nested = true,
@@ -1362,18 +1278,18 @@ M.setup = function(opts)
local last_keys = keybuf:as_str()
local winid = vim.api.nvim_get_current_win()
-- If the user issued a :wq or similar, we should quit after saving
- local quit_after_save = vim.endswith(last_keys, ':wq\r')
- or vim.endswith(last_keys, ':x\r')
- or vim.endswith(last_keys, 'ZZ')
- local quit_all = vim.endswith(last_keys, ':wqa\r')
- or vim.endswith(last_keys, ':wqal\r')
- or vim.endswith(last_keys, ':wqall\r')
+ local quit_after_save = vim.endswith(last_keys, ":wq\r")
+ or vim.endswith(last_keys, ":x\r")
+ or vim.endswith(last_keys, "ZZ")
+ local quit_all = vim.endswith(last_keys, ":wqa\r")
+ or vim.endswith(last_keys, ":wqal\r")
+ or vim.endswith(last_keys, ":wqall\r")
local bufname = vim.api.nvim_buf_get_name(params.buf)
- if vim.endswith(bufname, '/') then
- vim.cmd.doautocmd({ args = { 'BufWritePre', params.file }, mods = { silent = true } })
+ if vim.endswith(bufname, "/") then
+ vim.cmd.doautocmd({ args = { "BufWritePre", params.file }, mods = { silent = true } })
M.save(nil, function(err)
if err then
- if err ~= 'Canceled' then
+ if err ~= "Canceled" then
vim.notify(err, vim.log.levels.ERROR)
end
elseif winid == vim.api.nvim_get_current_win() then
@@ -1384,107 +1300,104 @@ M.setup = function(opts)
end
end
end)
- vim.cmd.doautocmd({ args = { 'BufWritePost', params.file }, mods = { silent = true } })
+ vim.cmd.doautocmd({ args = { "BufWritePost", params.file }, mods = { silent = true } })
else
local adapter = assert(config.get_adapter_by_scheme(bufname))
adapter.write_file(params.buf)
end
end,
})
- vim.api.nvim_create_autocmd('BufLeave', {
- desc = 'Save alternate buffer for later',
+ vim.api.nvim_create_autocmd("BufLeave", {
+ desc = "Save alternate buffer for later",
group = aug,
- pattern = '*',
+ pattern = "*",
callback = function()
- local util = require('canola.util')
- if not util.is_canola_bufnr(0) then
- vim.w.canola_original_buffer = vim.api.nvim_get_current_buf()
- vim.w.canola_original_view = vim.fn.winsaveview()
+ local util = require("oil.util")
+ if not util.is_oil_bufnr(0) then
+ vim.w.oil_original_buffer = vim.api.nvim_get_current_buf()
+ vim.w.oil_original_view = vim.fn.winsaveview()
---@diagnostic disable-next-line: param-type-mismatch
- vim.w.canola_original_alternate = vim.fn.bufnr('#')
+ vim.w.oil_original_alternate = vim.fn.bufnr("#")
end
end,
})
- vim.api.nvim_create_autocmd('BufEnter', {
- desc = 'Set/unset canola window options and restore alternate buffer',
+ vim.api.nvim_create_autocmd("BufEnter", {
+ desc = "Set/unset oil window options and restore alternate buffer",
group = aug,
- pattern = '*',
+ pattern = "*",
callback = function()
- local util = require('canola.util')
+ local util = require("oil.util")
local bufname = vim.api.nvim_buf_get_name(0)
local scheme = util.parse_url(bufname)
- local is_canola_buf = scheme and config.adapters[scheme]
- -- We want to filter out canola buffers that are not directories (i.e. ssh files)
- local is_canola_dir_or_unknown = (vim.bo.filetype == 'canola' or vim.bo.filetype == '')
- if is_canola_buf and is_canola_dir_or_unknown then
- local view = require('canola.view')
+ local is_oil_buf = scheme and config.adapters[scheme]
+ -- We want to filter out oil buffers that are not directories (i.e. ssh files)
+ local is_oil_dir_or_unknown = (vim.bo.filetype == "oil" or vim.bo.filetype == "")
+ if is_oil_buf and is_oil_dir_or_unknown then
+ local view = require("oil.view")
view.maybe_set_cursor()
- -- While we are in an canola buffer, set the alternate file to the buffer we were in prior to
- -- opening canola
- local has_orig, orig_buffer = pcall(vim.api.nvim_win_get_var, 0, 'canola_original_buffer')
+ -- While we are in an oil buffer, set the alternate file to the buffer we were in prior to
+ -- opening oil
+ local has_orig, orig_buffer = pcall(vim.api.nvim_win_get_var, 0, "oil_original_buffer")
if has_orig and vim.api.nvim_buf_is_valid(orig_buffer) then
- vim.fn.setreg('#', orig_buffer)
+ vim.fn.setreg("#", orig_buffer)
end
view.set_win_options()
- if config.buf_options.buflisted ~= nil then
- vim.api.nvim_set_option_value('buflisted', config.buf_options.buflisted, { buf = 0 })
- end
- vim.w.canola_did_enter = true
+ vim.w.oil_did_enter = true
elseif vim.fn.isdirectory(bufname) == 0 then
- -- Only run this logic if we are *not* in an canola buffer (and it's not a directory, which
- -- will be replaced by a canola:// url)
- -- Canola buffers have to run it in BufReadCmd after confirming they are a directory or a file
+ -- Only run this logic if we are *not* in an oil buffer (and it's not a directory, which
+ -- will be replaced by an oil:// url)
+ -- Oil buffers have to run it in BufReadCmd after confirming they are a directory or a file
restore_alt_buf()
end
- close_preview_window_if_not_in_canola()
+ close_preview_window_if_not_in_oil()
end,
})
- vim.api.nvim_create_autocmd({ 'BufWinEnter', 'WinNew', 'WinEnter' }, {
- desc = 'Reset bufhidden when entering a preview buffer',
+ vim.api.nvim_create_autocmd({ "BufWinEnter", "WinNew", "WinEnter" }, {
+ desc = "Reset bufhidden when entering a preview buffer",
group = aug,
- pattern = '*',
+ pattern = "*",
callback = function()
-- If we have entered a "preview" buffer in a non-preview window, reset bufhidden
- if vim.b.canola_preview_buffer and not vim.wo.previewwindow then
- vim.bo.bufhidden = vim.api.nvim_get_option_value('bufhidden', { scope = 'global' })
- vim.b.canola_preview_buffer = nil
+ if vim.b.oil_preview_buffer and not vim.wo.previewwindow then
+ vim.bo.bufhidden = vim.api.nvim_get_option_value("bufhidden", { scope = "global" })
+ vim.b.oil_preview_buffer = nil
end
end,
})
if not config.silence_scp_warning then
- vim.api.nvim_create_autocmd('BufNew', {
- desc = 'Warn about scp:// usage',
+ vim.api.nvim_create_autocmd("BufNew", {
+ desc = "Warn about scp:// usage",
group = aug,
- pattern = 'scp://*',
+ pattern = "scp://*",
once = true,
callback = function()
vim.notify(
- 'If you are trying to browse using Canola, use canola-ssh:// instead of scp://\nSet `silence_scp_warning = true` in canola.setup() to disable this message.\nSee https://github.com/stevearc/canola.nvim/issues/27 for more information.',
+ "If you are trying to browse using Oil, use oil-ssh:// instead of scp://\nSet `silence_scp_warning = true` in oil.setup() to disable this message.\nSee https://github.com/stevearc/oil.nvim/issues/27 for more information.",
vim.log.levels.WARN
)
end,
})
end
- vim.api.nvim_create_autocmd('WinNew', {
- desc = 'Restore window options when splitting an canola window',
+ vim.api.nvim_create_autocmd("WinNew", {
+ desc = "Restore window options when splitting an oil window",
group = aug,
- pattern = '*',
+ pattern = "*",
nested = true,
callback = function(params)
- local util = require('canola.util')
- if not util.is_canola_bufnr(params.buf) or vim.w.canola_did_enter then
+ local util = require("oil.util")
+ if not util.is_oil_bufnr(params.buf) or vim.w.oil_did_enter then
return
end
- -- This new window is a split off of an canola window. We need to transfer the window
+ -- This new window is a split off of an oil window. We need to transfer the window
-- variables. First, locate the parent window
local parent_win
-- First search windows in this tab, then search all windows
local winids = vim.list_extend(vim.api.nvim_tabpage_list_wins(0), vim.api.nvim_list_wins())
for _, winid in ipairs(winids) do
if vim.api.nvim_win_is_valid(winid) then
- if vim.w[winid].canola_did_enter then
+ if vim.w[winid].oil_did_enter then
parent_win = winid
break
end
@@ -1492,42 +1405,42 @@ M.setup = function(opts)
end
if not parent_win then
vim.notify(
- 'Canola split could not find parent window. Please try to replicate whatever you just did and report a bug on github',
+ "Oil split could not find parent window. Please try to replicate whatever you just did and report a bug on github",
vim.log.levels.WARN
)
return
end
-- Then transfer over the relevant window vars
- vim.w.canola_did_enter = true
- vim.w.canola_original_buffer = vim.w[parent_win].canola_original_buffer
- vim.w.canola_original_view = vim.w[parent_win].canola_original_view
- vim.w.canola_original_alternate = vim.w[parent_win].canola_original_alternate
+ vim.w.oil_did_enter = true
+ vim.w.oil_original_buffer = vim.w[parent_win].oil_original_buffer
+ vim.w.oil_original_view = vim.w[parent_win].oil_original_view
+ vim.w.oil_original_alternate = vim.w[parent_win].oil_original_alternate
end,
})
- -- mksession doesn't save canola buffers in a useful way. We have to manually load them after a
- -- session finishes loading. See https://github.com/stevearc/canola.nvim/issues/29
- vim.api.nvim_create_autocmd('SessionLoadPost', {
- desc = 'Load canola buffers after a session is loaded',
+ -- mksession doesn't save oil buffers in a useful way. We have to manually load them after a
+ -- session finishes loading. See https://github.com/stevearc/oil.nvim/issues/29
+ vim.api.nvim_create_autocmd("SessionLoadPost", {
+ desc = "Load oil buffers after a session is loaded",
group = aug,
- pattern = '*',
+ pattern = "*",
callback = function(params)
if vim.g.SessionLoad ~= 1 then
return
end
- local util = require('canola.util')
+ local util = require("oil.util")
local scheme = util.parse_url(params.file)
if config.adapters[scheme] and vim.api.nvim_buf_line_count(params.buf) == 1 then
- M.load_canola_buffer(params.buf)
+ M.load_oil_buffer(params.buf)
end
end,
})
if config.default_file_explorer then
- vim.api.nvim_create_autocmd('BufAdd', {
- desc = 'Detect directory buffer and open canola file browser',
+ vim.api.nvim_create_autocmd("BufAdd", {
+ desc = "Detect directory buffer and open oil file browser",
group = aug,
- pattern = '*',
+ pattern = "*",
nested = true,
callback = function(params)
maybe_hijack_directory_buffer(params.buf)
@@ -1536,7 +1449,7 @@ M.setup = function(opts)
for _, bufnr in ipairs(vim.api.nvim_list_bufs()) do
if maybe_hijack_directory_buffer(bufnr) and vim.v.vim_did_enter == 1 then
- M.load_canola_buffer(bufnr)
+ M.load_oil_buffer(bufnr)
end
end
end
diff --git a/lua/canola/keymap_util.lua b/lua/oil/keymap_util.lua
similarity index 74%
rename from lua/canola/keymap_util.lua
rename to lua/oil/keymap_util.lua
index 8c398c3..8c58738 100644
--- a/lua/canola/keymap_util.lua
+++ b/lua/oil/keymap_util.lua
@@ -1,7 +1,7 @@
-local actions = require('canola.actions')
-local config = require('canola.config')
-local layout = require('canola.layout')
-local util = require('canola.util')
+local actions = require("oil.actions")
+local config = require("oil.config")
+local layout = require("oil.layout")
+local util = require("oil.util")
local M = {}
---@param rhs string|table|fun()
@@ -9,14 +9,14 @@ local M = {}
---@return table opts
---@return string|nil mode
local function resolve(rhs)
- if type(rhs) == 'string' and vim.startswith(rhs, 'actions.') then
- local action_name = vim.split(rhs, '.', { plain = true })[2]
+ if type(rhs) == "string" and vim.startswith(rhs, "actions.") then
+ local action_name = vim.split(rhs, ".", { plain = true })[2]
local action = actions[action_name]
if not action then
- vim.notify('[canola.nvim] Unknown action name: ' .. action_name, vim.log.levels.ERROR)
+ vim.notify("[oil.nvim] Unknown action name: " .. action_name, vim.log.levels.ERROR)
end
return resolve(action)
- elseif type(rhs) == 'table' then
+ elseif type(rhs) == "table" then
local opts = vim.deepcopy(rhs)
-- We support passing in a `callback` key, or using the 1 index as the rhs of the keymap
local callback, parent_opts = resolve(opts.callback or opts[1])
@@ -25,17 +25,17 @@ local function resolve(rhs)
if parent_opts.desc and not opts.desc then
if opts.opts then
opts.desc =
- string.format('%s %s', parent_opts.desc, vim.inspect(opts.opts):gsub('%s+', ' '))
+ string.format("%s %s", parent_opts.desc, vim.inspect(opts.opts):gsub("%s+", " "))
else
opts.desc = parent_opts.desc
end
end
local mode = opts.mode
- if type(rhs.callback) == 'string' then
+ if type(rhs.callback) == "string" then
local action_opts, action_mode
callback, action_opts, action_mode = resolve(rhs.callback)
- opts = vim.tbl_extend('keep', opts, action_opts)
+ opts = vim.tbl_extend("keep", opts, action_opts)
mode = mode or action_mode
end
@@ -46,7 +46,7 @@ local function resolve(rhs)
opts.deprecated = nil
opts.parameters = nil
- if opts.opts and type(callback) == 'function' then
+ if opts.opts and type(callback) == "function" then
local callback_args = opts.opts
opts.opts = nil
local orig_callback = callback
@@ -68,7 +68,7 @@ M.set_keymaps = function(keymaps, bufnr)
for k, v in pairs(keymaps) do
local rhs, opts, mode = resolve(v)
if rhs then
- vim.keymap.set(mode or '', k, rhs, vim.tbl_extend('keep', { buffer = bufnr }, opts))
+ vim.keymap.set(mode or "", k, rhs, vim.tbl_extend("keep", { buffer = bufnr }, opts))
end
end
end
@@ -95,9 +95,9 @@ M.show_help = function(keymaps)
local all_lhs = lhs_to_all_lhs[k]
if all_lhs then
local _, opts = resolve(rhs)
- local keystr = table.concat(all_lhs, '/')
+ local keystr = table.concat(all_lhs, "/")
max_lhs = math.max(max_lhs, vim.api.nvim_strwidth(keystr))
- table.insert(keymap_entries, { str = keystr, all_lhs = all_lhs, desc = opts.desc or '' })
+ table.insert(keymap_entries, { str = keystr, all_lhs = all_lhs, desc = opts.desc or "" })
end
end
table.sort(keymap_entries, function(a, b)
@@ -108,20 +108,20 @@ M.show_help = function(keymaps)
local highlights = {}
local max_line = 1
for _, entry in ipairs(keymap_entries) do
- local line = string.format(' %s %s', util.pad_align(entry.str, max_lhs, 'left'), entry.desc)
+ local line = string.format(" %s %s", util.pad_align(entry.str, max_lhs, "left"), entry.desc)
max_line = math.max(max_line, vim.api.nvim_strwidth(line))
table.insert(lines, line)
local start = 1
for _, key in ipairs(entry.all_lhs) do
local keywidth = vim.api.nvim_strwidth(key)
- table.insert(highlights, { 'Special', #lines, start, start + keywidth })
+ table.insert(highlights, { "Special", #lines, start, start + keywidth })
start = start + keywidth + 1
end
end
local bufnr = vim.api.nvim_create_buf(false, true)
vim.api.nvim_buf_set_lines(bufnr, 0, -1, true, lines)
- local ns = vim.api.nvim_create_namespace('Canola')
+ local ns = vim.api.nvim_create_namespace("Oil")
for _, hl in ipairs(highlights) do
local hl_group, lnum, start_col, end_col = unpack(hl)
vim.api.nvim_buf_set_extmark(bufnr, ns, lnum - 1, start_col, {
@@ -129,21 +129,21 @@ M.show_help = function(keymaps)
hl_group = hl_group,
})
end
- vim.keymap.set('n', 'q', 'close', { buffer = bufnr })
- vim.keymap.set('n', '', 'close', { buffer = bufnr })
+ vim.keymap.set("n", "q", "close", { buffer = bufnr })
+ vim.keymap.set("n", "", "close", { buffer = bufnr })
vim.bo[bufnr].modifiable = false
- vim.bo[bufnr].bufhidden = 'wipe'
+ vim.bo[bufnr].bufhidden = "wipe"
local editor_width = vim.o.columns
local editor_height = layout.get_editor_height()
local winid = vim.api.nvim_open_win(bufnr, true, {
- relative = 'editor',
+ relative = "editor",
row = math.max(0, (editor_height - #lines) / 2),
col = math.max(0, (editor_width - max_line - 1) / 2),
width = math.min(editor_width, max_line + 1),
height = math.min(editor_height, #lines),
zindex = 150,
- style = 'minimal',
+ style = "minimal",
border = config.keymaps_help.border,
})
local function close()
@@ -151,13 +151,13 @@ M.show_help = function(keymaps)
vim.api.nvim_win_close(winid, true)
end
end
- vim.api.nvim_create_autocmd('BufLeave', {
+ vim.api.nvim_create_autocmd("BufLeave", {
callback = close,
once = true,
nested = true,
buffer = bufnr,
})
- vim.api.nvim_create_autocmd('WinLeave', {
+ vim.api.nvim_create_autocmd("WinLeave", {
callback = close,
once = true,
nested = true,
diff --git a/lua/canola/layout.lua b/lua/oil/layout.lua
similarity index 87%
rename from lua/canola/layout.lua
rename to lua/oil/layout.lua
index b8d3167..6d4563d 100644
--- a/lua/canola/layout.lua
+++ b/lua/oil/layout.lua
@@ -43,7 +43,7 @@ local function calc_list(values, max_value, aggregator, limit)
local ret = limit
if not max_value or not values then
return nil
- elseif type(values) == 'table' then
+ elseif type(values) == "table" then
for _, v in ipairs(values) do
ret = aggregator(ret, calc_float(v, max_value))
end
@@ -98,7 +98,7 @@ M.calculate_height = function(desired_height, opts)
)
end
----@class (exact) canola.WinLayout
+---@class (exact) oil.WinLayout
---@field width integer
---@field height integer
---@field row integer
@@ -106,12 +106,12 @@ end
---@return vim.api.keyset.win_config
M.get_fullscreen_win_opts = function()
- local config = require('canola.config')
+ local config = require("oil.config")
local total_width = M.get_editor_width()
local total_height = M.get_editor_height()
local width = total_width - 2 * config.float.padding
- if config.float.border ~= 'none' then
+ if config.float.border ~= "none" then
width = width - 2 -- The border consumes 1 col on each side
end
if config.float.max_width > 0 then
@@ -127,7 +127,7 @@ M.get_fullscreen_win_opts = function()
local col = math.floor((total_width - width) / 2) - 1 -- adjust for border width
local win_opts = {
- relative = 'editor',
+ relative = "editor",
width = width,
height = height,
row = row,
@@ -141,29 +141,29 @@ end
---@param winid integer
---@param direction "above"|"below"|"left"|"right"|"auto"
---@param gap integer
----@return canola.WinLayout root_dim New dimensions of the original window
----@return canola.WinLayout new_dim New dimensions of the new window
+---@return oil.WinLayout root_dim New dimensions of the original window
+---@return oil.WinLayout new_dim New dimensions of the new window
M.split_window = function(winid, direction, gap)
- if direction == 'auto' then
- direction = vim.o.splitright and 'right' or 'left'
+ if direction == "auto" then
+ direction = vim.o.splitright and "right" or "left"
end
local float_config = vim.api.nvim_win_get_config(winid)
- ---@type canola.WinLayout
+ ---@type oil.WinLayout
local dim_root = {
width = float_config.width,
height = float_config.height,
col = float_config.col,
row = float_config.row,
}
- if vim.fn.has('nvim-0.10') == 0 then
+ if vim.fn.has("nvim-0.10") == 0 then
-- read https://github.com/neovim/neovim/issues/24430 for more infos.
dim_root.col = float_config.col[vim.val_idx]
dim_root.row = float_config.row[vim.val_idx]
end
local dim_new = vim.deepcopy(dim_root)
- if direction == 'left' or direction == 'right' then
+ if direction == "left" or direction == "right" then
dim_new.width = math.floor(float_config.width / 2) - math.ceil(gap / 2)
dim_root.width = dim_new.width
else
@@ -171,13 +171,13 @@ M.split_window = function(winid, direction, gap)
dim_root.height = dim_new.height
end
- if direction == 'left' then
+ if direction == "left" then
dim_root.col = dim_root.col + dim_root.width + gap
- elseif direction == 'right' then
+ elseif direction == "right" then
dim_new.col = dim_new.col + dim_new.width + gap
- elseif direction == 'above' then
+ elseif direction == "above" then
dim_root.row = dim_root.row + dim_root.height + gap
- elseif direction == 'below' then
+ elseif direction == "below" then
dim_new.row = dim_new.row + dim_new.height + gap
end
diff --git a/lua/canola/loading.lua b/lua/oil/loading.lua
similarity index 78%
rename from lua/canola/loading.lua
rename to lua/oil/loading.lua
index 17b2119..6e575c5 100644
--- a/lua/canola/loading.lua
+++ b/lua/oil/loading.lua
@@ -1,4 +1,4 @@
-local util = require('canola.util')
+local util = require("oil.util")
local M = {}
local timers = {}
@@ -12,14 +12,14 @@ M.is_loading = function(bufnr)
end
local spinners = {
- dots = { '⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏' },
+ dots = { "⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏" },
}
---@param name_or_frames string|string[]
---@return fun(): string
M.get_iter = function(name_or_frames)
local frames
- if type(name_or_frames) == 'string' then
+ if type(name_or_frames) == "string" then
frames = spinners[name_or_frames]
if not frames then
error(string.format("Unrecognized spinner: '%s'", name_or_frames))
@@ -35,26 +35,26 @@ M.get_iter = function(name_or_frames)
end
M.get_bar_iter = function(opts)
- opts = vim.tbl_deep_extend('keep', opts or {}, {
+ opts = vim.tbl_deep_extend("keep", opts or {}, {
bar_size = 3,
width = 20,
})
local i = 0
return function()
- local chars = { '[' }
+ local chars = { "[" }
for _ = 1, opts.width - 2 do
- table.insert(chars, ' ')
+ table.insert(chars, " ")
end
- table.insert(chars, ']')
+ table.insert(chars, "]")
for j = i - opts.bar_size, i do
if j > 1 and j < opts.width then
- chars[j] = '='
+ chars[j] = "="
end
end
i = (i + 1) % (opts.width + opts.bar_size)
- return table.concat(chars, '')
+ return table.concat(chars, "")
end
end
@@ -75,7 +75,7 @@ M.set_loading = function(bufnr, is_loading)
return
end
local lines =
- { util.pad_align('Loading', math.floor(width / 2) - 3, 'right'), bar_iter() }
+ { util.pad_align("Loading", math.floor(width / 2) - 3, "right"), bar_iter() }
util.render_text(bufnr, lines)
end)
)
diff --git a/lua/canola/log.lua b/lua/oil/log.lua
similarity index 79%
rename from lua/canola/log.lua
rename to lua/oil/log.lua
index c49b346..28a4f9c 100644
--- a/lua/canola/log.lua
+++ b/lua/oil/log.lua
@@ -11,14 +11,14 @@ Log.level = vim.log.levels.WARN
---@return string
Log.get_logfile = function()
- local fs = require('canola.fs')
+ local fs = require("oil.fs")
- local ok, stdpath = pcall(vim.fn.stdpath, 'log')
+ local ok, stdpath = pcall(vim.fn.stdpath, "log")
if not ok then
- stdpath = vim.fn.stdpath('cache')
+ stdpath = vim.fn.stdpath("cache")
end
- assert(type(stdpath) == 'string')
- return fs.join(stdpath, 'canola.log')
+ assert(type(stdpath) == "string")
+ return fs.join(stdpath, "oil.log")
end
---@param level integer
@@ -29,19 +29,19 @@ local function format(level, msg, ...)
local args = vim.F.pack_len(...)
for i = 1, args.n do
local v = args[i]
- if type(v) == 'table' then
+ if type(v) == "table" then
args[i] = vim.inspect(v)
elseif v == nil then
- args[i] = 'nil'
+ args[i] = "nil"
end
end
local ok, text = pcall(string.format, msg, vim.F.unpack_len(args))
-- TODO figure out how to get formatted time inside luv callback
-- local timestr = vim.fn.strftime("%Y-%m-%d %H:%M:%S")
- local timestr = ''
+ local timestr = ""
if ok then
local str_level = levels_reverse[level]
- return string.format('%s[%s] %s', timestr, str_level, text)
+ return string.format("%s[%s] %s", timestr, str_level, text)
else
return string.format(
"%s[ERROR] error formatting log line: '%s' args %s",
@@ -67,22 +67,22 @@ local function initialize()
local stat = uv.fs_stat(filepath)
if stat and stat.size > 10 * 1024 * 1024 then
- local backup = filepath .. '.1'
+ local backup = filepath .. ".1"
uv.fs_unlink(backup)
uv.fs_rename(filepath, backup)
end
local parent = vim.fs.dirname(filepath)
- require('canola.fs').mkdirp(parent)
+ require("oil.fs").mkdirp(parent)
- local logfile, openerr = io.open(filepath, 'a+')
+ local logfile, openerr = io.open(filepath, "a+")
if not logfile then
- local err_msg = string.format('Failed to open canola.nvim log file: %s', openerr)
+ local err_msg = string.format("Failed to open oil.nvim log file: %s", openerr)
vim.notify(err_msg, vim.log.levels.ERROR)
else
write = function(line)
logfile:write(line)
- logfile:write('\n')
+ logfile:write("\n")
logfile:flush()
end
end
diff --git a/lua/canola/lsp/helpers.lua b/lua/oil/lsp/helpers.lua
similarity index 81%
rename from lua/canola/lsp/helpers.lua
rename to lua/oil/lsp/helpers.lua
index ad6442d..45264dc 100644
--- a/lua/canola/lsp/helpers.lua
+++ b/lua/oil/lsp/helpers.lua
@@ -1,18 +1,18 @@
-local config = require('canola.config')
-local fs = require('canola.fs')
-local util = require('canola.util')
-local workspace = require('canola.lsp.workspace')
+local config = require("oil.config")
+local fs = require("oil.fs")
+local util = require("oil.util")
+local workspace = require("oil.lsp.workspace")
local M = {}
----@param actions canola.Action[]
+---@param actions oil.Action[]
---@return fun() did_perform Call this function when the file operations have been completed
M.will_perform_file_operations = function(actions)
local moves = {}
local creates = {}
local deletes = {}
for _, action in ipairs(actions) do
- if action.type == 'move' then
+ if action.type == "move" then
local src_scheme, src_path = util.parse_url(action.src_url)
assert(src_path)
local src_adapter = assert(config.get_adapter_by_scheme(src_scheme))
@@ -20,32 +20,32 @@ M.will_perform_file_operations = function(actions)
local dest_adapter = assert(config.get_adapter_by_scheme(dest_scheme))
src_path = fs.posix_to_os_path(src_path)
dest_path = fs.posix_to_os_path(assert(dest_path))
- if src_adapter.name == 'files' and dest_adapter.name == 'files' then
+ if src_adapter.name == "files" and dest_adapter.name == "files" then
moves[src_path] = dest_path
- elseif src_adapter.name == 'files' then
+ elseif src_adapter.name == "files" then
table.insert(deletes, src_path)
- elseif dest_adapter.name == 'files' then
+ elseif dest_adapter.name == "files" then
table.insert(creates, src_path)
end
- elseif action.type == 'create' then
+ elseif action.type == "create" then
local scheme, path = util.parse_url(action.url)
path = fs.posix_to_os_path(assert(path))
local adapter = assert(config.get_adapter_by_scheme(scheme))
- if adapter.name == 'files' then
+ if adapter.name == "files" then
table.insert(creates, path)
end
- elseif action.type == 'delete' then
+ elseif action.type == "delete" then
local scheme, path = util.parse_url(action.url)
path = fs.posix_to_os_path(assert(path))
local adapter = assert(config.get_adapter_by_scheme(scheme))
- if adapter.name == 'files' then
+ if adapter.name == "files" then
table.insert(deletes, path)
end
- elseif action.type == 'copy' then
+ elseif action.type == "copy" then
local scheme, path = util.parse_url(action.dest_url)
path = fs.posix_to_os_path(assert(path))
local adapter = assert(config.get_adapter_by_scheme(scheme))
- if adapter.name == 'files' then
+ if adapter.name == "files" then
table.insert(creates, path)
end
end
@@ -84,7 +84,7 @@ M.will_perform_file_operations = function(actions)
accum(workspace.will_rename_files(moves, { timeout_ms = timeout_ms }))
if final_err then
vim.notify(
- string.format('[lsp] file operation error: %s', vim.inspect(final_err)),
+ string.format("[lsp] file operation error: %s", vim.inspect(final_err)),
vim.log.levels.WARN
)
end
@@ -102,7 +102,7 @@ M.will_perform_file_operations = function(actions)
local bufnr = vim.uri_to_bufnr(uri)
local was_open = buf_was_modified[bufnr] ~= nil
local was_modified = buf_was_modified[bufnr]
- local should_save = autosave == true or (autosave == 'unmodified' and not was_modified)
+ local should_save = autosave == true or (autosave == "unmodified" and not was_modified)
-- Autosave changed buffers if they were not modified before
if should_save then
vim.api.nvim_buf_call(bufnr, function()
diff --git a/lua/canola/lsp/workspace.lua b/lua/oil/lsp/workspace.lua
similarity index 85%
rename from lua/canola/lsp/workspace.lua
rename to lua/oil/lsp/workspace.lua
index 5c5b4ec..8e48276 100644
--- a/lua/canola/lsp/workspace.lua
+++ b/lua/oil/lsp/workspace.lua
@@ -1,13 +1,13 @@
-local fs = require('canola.fs')
-local ms = require('vim.lsp.protocol').Methods
-if vim.fn.has('nvim-0.10') == 0 then
+local fs = require("oil.fs")
+local ms = require("vim.lsp.protocol").Methods
+if vim.fn.has("nvim-0.10") == 0 then
ms = {
- workspace_willCreateFiles = 'workspace/willCreateFiles',
- workspace_didCreateFiles = 'workspace/didCreateFiles',
- workspace_willDeleteFiles = 'workspace/willDeleteFiles',
- workspace_didDeleteFiles = 'workspace/didDeleteFiles',
- workspace_willRenameFiles = 'workspace/willRenameFiles',
- workspace_didRenameFiles = 'workspace/didRenameFiles',
+ workspace_willCreateFiles = "workspace/willCreateFiles",
+ workspace_didCreateFiles = "workspace/didCreateFiles",
+ workspace_willDeleteFiles = "workspace/willDeleteFiles",
+ workspace_didDeleteFiles = "workspace/didDeleteFiles",
+ workspace_willRenameFiles = "workspace/willRenameFiles",
+ workspace_didRenameFiles = "workspace/didRenameFiles",
}
end
@@ -16,7 +16,7 @@ local M = {}
---@param method string
---@return vim.lsp.Client[]
local function get_clients(method)
- if vim.fn.has('nvim-0.10') == 1 then
+ if vim.fn.has("nvim-0.10") == 1 then
return vim.lsp.get_clients({ method = method })
else
---@diagnostic disable-next-line: deprecated
@@ -32,7 +32,7 @@ end
---@return boolean
local function match_glob(glob, path)
-- nvim-0.10 will have vim.glob.to_lpeg, so this will be a LPeg pattern
- if type(glob) ~= 'string' then
+ if type(glob) ~= "string" then
return glob:match(path) ~= nil
end
@@ -59,7 +59,7 @@ local function get_matching_paths(client, filters, paths)
local match_fns = {}
for _, filter in ipairs(filters) do
- if filter.scheme == nil or filter.scheme == 'file' then
+ if filter.scheme == nil or filter.scheme == "file" then
local pattern = filter.pattern
local glob = pattern.glob
local ignore_case = pattern.options and pattern.options.ignoreCase
@@ -69,32 +69,32 @@ local function get_matching_paths(client, filters, paths)
-- Some language servers use forward slashes as path separators on Windows (LuaLS)
-- We no longer need this after 0.12: https://github.com/neovim/neovim/commit/322a6d305d088420b23071c227af07b7c1beb41a
- if vim.fn.has('nvim-0.12') == 0 and fs.is_windows then
- glob = glob:gsub('/', '\\')
+ if vim.fn.has("nvim-0.12") == 0 and fs.is_windows then
+ glob = glob:gsub("/", "\\")
end
---@type string|vim.lpeg.Pattern
local glob_to_match = glob
if vim.glob and vim.glob.to_lpeg then
- glob = glob:gsub('{(.-)}', function(s)
- local patterns = vim.split(s, ',')
+ glob = glob:gsub("{(.-)}", function(s)
+ local patterns = vim.split(s, ",")
local filtered = {}
for _, pat in ipairs(patterns) do
- if pat ~= '' then
+ if pat ~= "" then
table.insert(filtered, pat)
end
end
if #filtered == 0 then
- return ''
+ return ""
end
-- HACK around https://github.com/neovim/neovim/issues/28931
-- find alternations and sort them by length to try to match the longest first
- if vim.fn.has('nvim-0.11') == 0 then
+ if vim.fn.has("nvim-0.11") == 0 then
table.sort(filtered, function(a, b)
return a:len() > b:len()
end)
end
- return '{' .. table.concat(filtered, ',') .. '}'
+ return "{" .. table.concat(filtered, ",") .. "}"
end)
glob_to_match = vim.glob.to_lpeg(glob)
@@ -102,7 +102,7 @@ local function get_matching_paths(client, filters, paths)
local matches = pattern.matches
table.insert(match_fns, function(path)
local is_dir = vim.fn.isdirectory(path) == 1
- if matches and ((matches == 'file' and is_dir) or (matches == 'folder' and not is_dir)) then
+ if matches and ((matches == "file" and is_dir) or (matches == "folder" and not is_dir)) then
return false
end
@@ -163,10 +163,10 @@ local function will_file_operation(method, capability_name, files, options)
for _, client in ipairs(clients) do
local filters = vim.tbl_get(
client.server_capabilities,
- 'workspace',
- 'fileOperations',
+ "workspace",
+ "fileOperations",
capability_name,
- 'filters'
+ "filters"
)
local matching_files = get_matching_paths(client, filters, files)
if matching_files then
@@ -178,7 +178,7 @@ local function will_file_operation(method, capability_name, files, options)
end, matching_files),
}
local result, err
- if vim.fn.has('nvim-0.11') == 1 then
+ if vim.fn.has("nvim-0.11") == 1 then
result, err = client:request_sync(method, params, options.timeout_ms or 1000, 0)
else
---@diagnostic disable-next-line: param-type-mismatch
@@ -205,10 +205,10 @@ local function did_file_operation(method, capability_name, files)
for _, client in ipairs(clients) do
local filters = vim.tbl_get(
client.server_capabilities,
- 'workspace',
- 'fileOperations',
+ "workspace",
+ "fileOperations",
capability_name,
- 'filters'
+ "filters"
)
local matching_files = get_matching_paths(client, filters, files)
if matching_files then
@@ -219,7 +219,7 @@ local function did_file_operation(method, capability_name, files)
}
end, matching_files),
}
- if vim.fn.has('nvim-0.11') == 1 then
+ if vim.fn.has("nvim-0.11") == 1 then
client:notify(method, params)
else
---@diagnostic disable-next-line: param-type-mismatch
@@ -239,13 +239,13 @@ end
---@return nil|{edit: lsp.WorkspaceEdit, offset_encoding: string}[]
---@return nil|string|lsp.ResponseError err
function M.will_create_files(files, options)
- return will_file_operation(ms.workspace_willCreateFiles, 'willCreate', files, options)
+ return will_file_operation(ms.workspace_willCreateFiles, "willCreate", files, options)
end
--- Notify the server that files were created from within the client.
---@param files string[] The files and folders that will be created
function M.did_create_files(files)
- did_file_operation(ms.workspace_didCreateFiles, 'didCreate', files)
+ did_file_operation(ms.workspace_didCreateFiles, "didCreate", files)
end
--- Notify the server that the client is about to delete files.
@@ -258,13 +258,13 @@ end
---@return nil|{edit: lsp.WorkspaceEdit, offset_encoding: string}[]
---@return nil|string|lsp.ResponseError err
function M.will_delete_files(files, options)
- return will_file_operation(ms.workspace_willDeleteFiles, 'willDelete', files, options)
+ return will_file_operation(ms.workspace_willDeleteFiles, "willDelete", files, options)
end
--- Notify the server that files were deleted from within the client.
---@param files string[] The files and folders that were deleted
function M.did_delete_files(files)
- did_file_operation(ms.workspace_didDeleteFiles, 'didDelete', files)
+ did_file_operation(ms.workspace_didDeleteFiles, "didDelete", files)
end
--- Notify the server that the client is about to rename files.
@@ -284,10 +284,10 @@ function M.will_rename_files(files, options)
for _, client in ipairs(clients) do
local filters = vim.tbl_get(
client.server_capabilities,
- 'workspace',
- 'fileOperations',
- 'willRename',
- 'filters'
+ "workspace",
+ "fileOperations",
+ "willRename",
+ "filters"
)
local matching_files = get_matching_paths(client, filters, vim.tbl_keys(files))
if matching_files then
@@ -300,7 +300,7 @@ function M.will_rename_files(files, options)
end, matching_files),
}
local result, err
- if vim.fn.has('nvim-0.11') == 1 then
+ if vim.fn.has("nvim-0.11") == 1 then
result, err =
client:request_sync(ms.workspace_willRenameFiles, params, options.timeout_ms or 1000, 0)
else
@@ -327,7 +327,7 @@ function M.did_rename_files(files)
local clients = get_clients(ms.workspace_didRenameFiles)
for _, client in ipairs(clients) do
local filters =
- vim.tbl_get(client.server_capabilities, 'workspace', 'fileOperations', 'didRename', 'filters')
+ vim.tbl_get(client.server_capabilities, "workspace", "fileOperations", "didRename", "filters")
local matching_files = get_matching_paths(client, filters, vim.tbl_keys(files))
if matching_files then
local params = {
@@ -338,7 +338,7 @@ function M.did_rename_files(files)
}
end, matching_files),
}
- if vim.fn.has('nvim-0.11') == 1 then
+ if vim.fn.has("nvim-0.11") == 1 then
client:notify(ms.workspace_didRenameFiles, params)
else
---@diagnostic disable-next-line: param-type-mismatch
diff --git a/lua/canola/mutator/confirmation.lua b/lua/oil/mutator/confirmation.lua
similarity index 73%
rename from lua/canola/mutator/confirmation.lua
rename to lua/oil/mutator/confirmation.lua
index b4448ee..8bc8020 100644
--- a/lua/canola/mutator/confirmation.lua
+++ b/lua/oil/mutator/confirmation.lua
@@ -1,10 +1,10 @@
-local columns = require('canola.columns')
-local config = require('canola.config')
-local layout = require('canola.layout')
-local util = require('canola.util')
+local columns = require("oil.columns")
+local config = require("oil.config")
+local layout = require("oil.layout")
+local util = require("oil.util")
local M = {}
----@param actions canola.Action[]
+---@param actions oil.Action[]
---@return boolean
local function is_simple_edit(actions)
local num_create = 0
@@ -12,17 +12,17 @@ local function is_simple_edit(actions)
local num_move = 0
for _, action in ipairs(actions) do
-- If there are any deletes, it is not a simple edit
- if action.type == 'delete' then
+ if action.type == "delete" then
return false
- elseif action.type == 'create' then
+ elseif action.type == "create" then
num_create = num_create + 1
- elseif action.type == 'copy' then
+ elseif action.type == "copy" then
num_copy = num_copy + 1
-- Cross-adapter copies are not simple
if util.parse_url(action.src_url) ~= util.parse_url(action.dest_url) then
return false
end
- elseif action.type == 'move' then
+ elseif action.type == "move" then
num_move = num_move + 1
-- Cross-adapter moves are not simple
if util.parse_url(action.src_url) ~= util.parse_url(action.dest_url) then
@@ -46,14 +46,14 @@ end
---@param lines string[]
local function render_lines(winid, bufnr, lines)
util.render_text(bufnr, lines, {
- v_align = 'top',
- h_align = 'left',
+ v_align = "top",
+ h_align = "left",
winid = winid,
- actions = { '[Y]es', '[N]o' },
+ actions = { "[Y]es", "[N]o" },
})
end
----@param actions canola.Action[]
+---@param actions oil.Action[]
---@param should_confirm nil|boolean
---@param cb fun(proceed: boolean)
M.show = vim.schedule_wrap(function(actions, should_confirm, cb)
@@ -67,67 +67,51 @@ M.show = vim.schedule_wrap(function(actions, should_confirm, cb)
cb(true)
return
end
- if should_confirm == nil and config.skip_confirm_for_delete then
- local all_deletes = true
- for _, action in ipairs(actions) do
- if action.type ~= 'delete' then
- all_deletes = false
- break
- end
- end
- if all_deletes then
- cb(true)
- return
- end
- end
-- Create the buffer
local bufnr = vim.api.nvim_create_buf(false, true)
- vim.bo[bufnr].bufhidden = 'wipe'
+ vim.bo[bufnr].bufhidden = "wipe"
local lines = {}
local max_line_width = 0
for _, action in ipairs(actions) do
local adapter = util.get_adapter_for_action(action)
local line
- if action.type == 'change' then
- ---@cast action canola.ChangeAction
+ if action.type == "change" then
+ ---@cast action oil.ChangeAction
line = columns.render_change_action(adapter, action)
else
line = adapter.render_action(action)
end
-- We can't handle lines with newlines in them
- line = line:gsub('\n', '')
+ line = line:gsub("\n", "")
table.insert(lines, line)
local line_width = vim.api.nvim_strwidth(line)
if line_width > max_line_width then
max_line_width = line_width
end
end
- table.insert(lines, '')
+ table.insert(lines, "")
-- Create the floating window
local width, height = layout.calculate_dims(max_line_width, #lines + 1, config.confirmation)
local ok, winid = pcall(vim.api.nvim_open_win, bufnr, true, {
- relative = 'editor',
+ relative = "editor",
width = width,
height = height,
row = math.floor((layout.get_editor_height() - height) / 2),
col = math.floor((layout.get_editor_width() - width) / 2),
zindex = 152, -- render on top of the floating window title
- style = 'minimal',
+ style = "minimal",
border = config.confirmation.border,
})
if not ok then
- vim.notify(
- string.format('Error showing canola preview window: %s', winid),
- vim.log.levels.ERROR
- )
+ vim.notify(string.format("Error showing oil preview window: %s", winid), vim.log.levels.ERROR)
cb(false)
end
- vim.bo[bufnr].filetype = 'canola_preview'
- vim.bo[bufnr].syntax = 'canola_preview'
+ vim.bo[bufnr].filetype = "oil_preview"
+ vim.bo[bufnr].syntax = "oil_preview"
for k, v in pairs(config.confirmation.win_options) do
- vim.api.nvim_set_option_value(k, v, { scope = 'local', win = winid })
+ vim.api.nvim_set_option_value(k, v, { scope = "local", win = winid })
end
render_lines(winid, bufnr, lines)
@@ -153,7 +137,7 @@ M.show = vim.schedule_wrap(function(actions, should_confirm, cb)
end
cancel = make_callback(false)
confirm = make_callback(true)
- vim.api.nvim_create_autocmd('BufLeave', {
+ vim.api.nvim_create_autocmd("BufLeave", {
callback = function()
cancel()
end,
@@ -161,7 +145,7 @@ M.show = vim.schedule_wrap(function(actions, should_confirm, cb)
nested = true,
buffer = bufnr,
})
- vim.api.nvim_create_autocmd('WinLeave', {
+ vim.api.nvim_create_autocmd("WinLeave", {
callback = function()
cancel()
end,
@@ -170,12 +154,12 @@ M.show = vim.schedule_wrap(function(actions, should_confirm, cb)
})
table.insert(
autocmds,
- vim.api.nvim_create_autocmd('VimResized', {
+ vim.api.nvim_create_autocmd("VimResized", {
callback = function()
if vim.api.nvim_win_is_valid(winid) then
width, height = layout.calculate_dims(max_line_width, #lines, config.confirmation)
vim.api.nvim_win_set_config(winid, {
- relative = 'editor',
+ relative = "editor",
width = width,
height = height,
row = math.floor((layout.get_editor_height() - height) / 2),
@@ -189,17 +173,17 @@ M.show = vim.schedule_wrap(function(actions, should_confirm, cb)
)
-- We used to use [C]ancel to cancel, so preserve the old keymap
- local cancel_keys = { 'n', 'N', 'c', 'C', 'q', '', '' }
+ local cancel_keys = { "n", "N", "c", "C", "q", "", "" }
for _, cancel_key in ipairs(cancel_keys) do
- vim.keymap.set('n', cancel_key, function()
+ vim.keymap.set("n", cancel_key, function()
cancel()
end, { buffer = bufnr, nowait = true })
end
-- We used to use [O]k to confirm, so preserve the old keymap
- local confirm_keys = { 'y', 'Y', 'o', 'O' }
+ local confirm_keys = { "y", "Y", "o", "O" }
for _, confirm_key in ipairs(confirm_keys) do
- vim.keymap.set('n', confirm_key, function()
+ vim.keymap.set("n", confirm_key, function()
confirm()
end, { buffer = bufnr, nowait = true })
end
diff --git a/lua/canola/mutator/init.lua b/lua/oil/mutator/init.lua
similarity index 75%
rename from lua/canola/mutator/init.lua
rename to lua/oil/mutator/init.lua
index 626ec70..f55957d 100644
--- a/lua/canola/mutator/init.lua
+++ b/lua/oil/mutator/init.lua
@@ -1,60 +1,60 @@
-local Progress = require('canola.mutator.progress')
-local Trie = require('canola.mutator.trie')
-local cache = require('canola.cache')
-local canola = require('canola')
-local columns = require('canola.columns')
-local config = require('canola.config')
-local confirmation = require('canola.mutator.confirmation')
-local constants = require('canola.constants')
-local fs = require('canola.fs')
-local lsp_helpers = require('canola.lsp.helpers')
-local parser = require('canola.mutator.parser')
-local util = require('canola.util')
-local view = require('canola.view')
+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 canola.Action canola.CreateAction|canola.DeleteAction|canola.MoveAction|canola.CopyAction|canola.ChangeAction
+---@alias oil.Action oil.CreateAction|oil.DeleteAction|oil.MoveAction|oil.CopyAction|oil.ChangeAction
----@class (exact) canola.CreateAction
+---@class (exact) oil.CreateAction
---@field type "create"
---@field url string
----@field entry_type canola.EntryType
+---@field entry_type oil.EntryType
---@field link nil|string
----@class (exact) canola.DeleteAction
+---@class (exact) oil.DeleteAction
---@field type "delete"
---@field url string
----@field entry_type canola.EntryType
+---@field entry_type oil.EntryType
----@class (exact) canola.MoveAction
+---@class (exact) oil.MoveAction
---@field type "move"
----@field entry_type canola.EntryType
+---@field entry_type oil.EntryType
---@field src_url string
---@field dest_url string
----@class (exact) canola.CopyAction
+---@class (exact) oil.CopyAction
---@field type "copy"
----@field entry_type canola.EntryType
+---@field entry_type oil.EntryType
---@field src_url string
---@field dest_url string
----@class (exact) canola.ChangeAction
+---@class (exact) oil.ChangeAction
---@field type "change"
----@field entry_type canola.EntryType
+---@field entry_type oil.EntryType
---@field url string
---@field column string
---@field value any
----@param all_diffs table
----@return canola.Action[]
+---@param all_diffs table
+---@return oil.Action[]
M.create_actions_from_diffs = function(all_diffs)
- ---@type canola.Action[]
+ ---@type oil.Action[]
local actions = {}
- ---@type table
+ ---@type table
local diff_by_id = setmetatable({}, {
__index = function(t, key)
local list = {}
@@ -69,11 +69,11 @@ M.create_actions_from_diffs = function(all_diffs)
-- > foo/bar/b.txt
local seen_creates = {}
- ---@param action canola.Action
+ ---@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 action.type == "create" then
if seen_creates[action.url] then
return
else
@@ -87,11 +87,11 @@ M.create_actions_from_diffs = function(all_diffs)
for bufnr, diffs in pairs(all_diffs) do
local adapter = util.get_adapter(bufnr, true)
if not adapter then
- error('Missing adapter')
+ 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.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
@@ -100,28 +100,28 @@ M.create_actions_from_diffs = function(all_diffs)
table.insert(by_id, diff)
else
-- Parse nested files like foo/bar/baz
- local path_sep = fs.is_windows and '[/\\]' or '/'
+ local path_sep = fs.is_windows and "[/\\]" or "/"
local pieces = vim.split(diff.name, path_sep)
- local url = parent_url:gsub('/$', '')
+ 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('{([^}]+)}')
+ 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)
+ for _, alt in ipairs(vim.split(alternation, ",")) do
+ local alt_url = url .. "/" .. v:gsub("{[^}]+}", alt)
add_action({
- type = 'create',
+ type = "create",
url = alt_url,
entry_type = entry_type,
link = diff.link,
})
end
else
- url = url .. '/' .. v
+ url = url .. "/" .. v
add_action({
- type = 'create',
+ type = "create",
url = url,
entry_type = entry_type,
link = diff.link,
@@ -129,9 +129,9 @@ M.create_actions_from_diffs = function(all_diffs)
end
end
end
- elseif diff.type == 'change' then
+ elseif diff.type == "change" then
add_action({
- type = 'change',
+ type = "change",
url = parent_url .. diff.name,
entry_type = diff.entry_type,
column = diff.column,
@@ -151,7 +151,7 @@ M.create_actions_from_diffs = function(all_diffs)
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))
+ 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
@@ -161,7 +161,7 @@ M.create_actions_from_diffs = function(all_diffs)
-- 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',
+ 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
@@ -172,7 +172,7 @@ M.create_actions_from_diffs = function(all_diffs)
else
-- DELETE when no create
add_action({
- type = 'delete',
+ type = "delete",
entry_type = entry[FIELD_TYPE],
url = cache.get_parent_url(id) .. entry[FIELD_NAME],
})
@@ -181,7 +181,7 @@ M.create_actions_from_diffs = function(all_diffs)
-- COPY when create but no delete
for _, diff in ipairs(diffs) do
add_action({
- type = 'copy',
+ 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
@@ -195,15 +195,15 @@ M.create_actions_from_diffs = function(all_diffs)
return M.enforce_action_order(actions)
end
----@param actions canola.Action[]
----@return canola.Action[]
+---@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
+ if action.type == "delete" or action.type == "change" then
src_trie:insert_action(action.url, action)
- elseif action.type == 'create' then
+ elseif action.type == "create" then
dest_trie:insert_action(action.url, action)
else
dest_trie:insert_action(action.dest_url, action)
@@ -220,21 +220,21 @@ M.enforce_action_order = function(actions)
---Gets the dependencies of a particular action. Effectively dynamically calculates the dependency
---"edges" of the graph.
- ---@param action canola.Action
+ ---@param action oil.Action
local function get_deps(action)
local ret = {}
- if action.type == 'delete' then
+ if action.type == "delete" then
src_trie:accum_children_of(action.url, ret)
- elseif action.type == 'create' then
+ 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'
+ return a.type == "move" or a.type == "delete"
end)
- elseif action.type == 'change' then
+ 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)
@@ -244,9 +244,9 @@ M.enforce_action_order = function(actions)
-- 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'
+ return entry.type == "copy"
end)
- elseif action.type == 'move' then
+ 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)
@@ -260,9 +260,9 @@ M.enforce_action_order = function(actions)
-- 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'
+ return a.type == "move" or a.type == "delete"
end)
- elseif action.type == 'copy' then
+ 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)
@@ -272,14 +272,14 @@ M.enforce_action_order = function(actions)
-- 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'
+ return a.type == "move" or a.type == "delete"
end)
end
return ret
end
- ---@return nil|canola.Action The leaf action
- ---@return nil|canola.Action When no leaves found, this is the last action in the loop
+ ---@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 = {}
@@ -312,24 +312,24 @@ M.enforce_action_order = function(actions)
if selected then
to_remove = selected
else
- if loop_action and loop_action.type == 'move' then
+ 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')
+ 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__canola_tmp_%05d', loop_action.src_url, math.random(999999))
+ string.format("%s__oil_tmp_%05d", loop_action.src_url, math.random(999999))
local move_1 = {
- type = 'move',
+ type = "move",
entry_type = loop_action.entry_type,
src_url = loop_action.src_url,
dest_url = intermediate_url,
}
local move_2 = {
- type = 'move',
+ type = "move",
entry_type = loop_action.entry_type,
src_url = intermediate_url,
dest_url = loop_action.dest_url,
@@ -340,16 +340,16 @@ M.enforce_action_order = function(actions)
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')
+ 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
+ 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',
+ "Cannot move or copy parent into itself: %s -> %s",
selected.src_url,
selected.dest_url
)
@@ -360,9 +360,9 @@ M.enforce_action_order = function(actions)
end
if to_remove then
- if to_remove.type == 'delete' or to_remove.type == 'change' 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
+ 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)
@@ -383,12 +383,12 @@ end
local progress
----@param actions canola.Action[]
+---@param actions oil.Action[]
---@param cb fun(err: nil|string)
M.process_actions = function(actions, cb)
vim.api.nvim_exec_autocmds(
- 'User',
- { pattern = 'CanolaActionsPre', modeline = false, data = { actions = actions } }
+ "User",
+ { pattern = "OilActionsPre", modeline = false, data = { actions = actions } }
)
local did_complete = nil
@@ -398,14 +398,14 @@ M.process_actions = function(actions, cb)
-- Convert some cross-adapter moves to a copy + delete
for _, action in ipairs(actions) do
- if action.type == 'move' then
+ 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
+ if cross_action == "copy" then
---@diagnostic disable-next-line: assign-type-mismatch
- action.type = 'copy'
+ action.type = "copy"
table.insert(actions, {
- type = 'delete',
+ type = "delete",
url = action.src_url,
entry_type = action.entry_type,
})
@@ -420,24 +420,9 @@ M.process_actions = function(actions, cb)
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 = 'CanolaActionsPost', modeline = false, data = { err = err, actions = actions } }
+ "User",
+ { pattern = "OilActionsPost", modeline = false, data = { err = err, actions = actions } }
)
cb(err)
end
@@ -450,7 +435,7 @@ M.process_actions = function(actions, cb)
-- TODO some actions are actually cancelable.
-- We should stop them instead of stopping after the current action
cancel = function()
- finish('Canceled')
+ finish("Canceled")
end,
})
end
@@ -487,8 +472,8 @@ M.process_actions = function(actions, cb)
next_action()
end
end)
- if action.type == 'change' then
- ---@cast action canola.ChangeAction
+ if action.type == "change" then
+ ---@cast action oil.ChangeAction
columns.perform_change_action(adapter, action, callback)
else
adapter.perform_action(action, callback)
@@ -517,14 +502,14 @@ M.try_write_changes = function(confirm, cb)
cb = function(_err) end
end
if mutation_in_progress then
- cb('Cannot perform mutation when already in progress')
+ 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
+ ---@type table
local all_errors = {}
mutation_in_progress = true
@@ -552,7 +537,7 @@ M.try_write_changes = function(confirm, cb)
mutation_in_progress = false
end
- local ns = vim.api.nvim_create_namespace('Canola')
+ 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
@@ -579,7 +564,7 @@ M.try_write_changes = function(confirm, cb)
end)
end
unlock()
- cb('Error parsing canola buffers')
+ cb("Error parsing oil buffers")
return
end
@@ -587,7 +572,7 @@ M.try_write_changes = function(confirm, cb)
confirmation.show(actions, confirm, function(proceed)
if not proceed then
unlock()
- cb('Canceled')
+ cb("Canceled")
return
end
@@ -596,23 +581,23 @@ M.try_write_changes = function(confirm, cb)
vim.schedule_wrap(function(err)
view.unlock_buffers()
if err then
- err = string.format('[canola] Error applying actions: %s', err)
- view.rerender_all_canola_buffers(nil, function()
+ err = string.format("[oil] Error applying actions: %s", err)
+ view.rerender_all_oil_buffers(nil, function()
cb(err)
end)
else
- local current_entry = canola.get_cursor_entry()
+ 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]
+ vim.split(current_entry.parsed_name or current_entry.name, "/")[1]
)
end
- view.rerender_all_canola_buffers(nil, function(render_err)
+ view.rerender_all_oil_buffers(nil, function(render_err)
vim.api.nvim_exec_autocmds(
- 'User',
- { pattern = 'CanolaMutationComplete', modeline = false }
+ "User",
+ { pattern = "OilMutationComplete", modeline = false }
)
cb(render_err)
end)
diff --git a/lua/canola/mutator/parser.lua b/lua/oil/mutator/parser.lua
similarity index 75%
rename from lua/canola/mutator/parser.lua
rename to lua/oil/mutator/parser.lua
index 8a9e278..e45a629 100644
--- a/lua/canola/mutator/parser.lua
+++ b/lua/oil/mutator/parser.lua
@@ -1,10 +1,10 @@
-local cache = require('canola.cache')
-local columns = require('canola.columns')
-local config = require('canola.config')
-local constants = require('canola.constants')
-local fs = require('canola.fs')
-local util = require('canola.util')
-local view = require('canola.view')
+local cache = require("oil.cache")
+local columns = require("oil.columns")
+local config = require("oil.config")
+local constants = require("oil.constants")
+local fs = require("oil.fs")
+local util = require("oil.util")
+local view = require("oil.view")
local M = {}
local FIELD_ID = constants.FIELD_ID
@@ -12,23 +12,23 @@ local FIELD_NAME = constants.FIELD_NAME
local FIELD_TYPE = constants.FIELD_TYPE
local FIELD_META = constants.FIELD_META
----@alias canola.Diff canola.DiffNew|canola.DiffDelete|canola.DiffChange
+---@alias oil.Diff oil.DiffNew|oil.DiffDelete|oil.DiffChange
----@class (exact) canola.DiffNew
+---@class (exact) oil.DiffNew
---@field type "new"
---@field name string
----@field entry_type canola.EntryType
+---@field entry_type oil.EntryType
---@field id nil|integer
---@field link nil|string
----@class (exact) canola.DiffDelete
+---@class (exact) oil.DiffDelete
---@field type "delete"
---@field name string
---@field id integer
----@class (exact) canola.DiffChange
+---@class (exact) oil.DiffChange
---@field type "change"
----@field entry_type canola.EntryType
+---@field entry_type oil.EntryType
---@field name string
---@field column string
---@field value any
@@ -37,7 +37,7 @@ local FIELD_META = constants.FIELD_META
---@return string
---@return boolean
local function parsedir(name)
- local isdir = vim.endswith(name, '/') or (fs.is_windows and vim.endswith(name, '\\'))
+ local isdir = vim.endswith(name, "/") or (fs.is_windows and vim.endswith(name, "\\"))
if isdir then
name = name:sub(1, name:len() - 1)
end
@@ -52,29 +52,29 @@ local function compare_link_target(meta, parsed_entry)
return false
end
-- Make sure we trim off any trailing path slashes from both sources
- local meta_name = meta.link:gsub('[/\\]$', '')
- local parsed_name = parsed_entry.link_target:gsub('[/\\]$', '')
+ local meta_name = meta.link:gsub("[/\\]$", "")
+ local parsed_name = parsed_entry.link_target:gsub("[/\\]$", "")
return meta_name == parsed_name
end
----@class (exact) canola.ParseResult
+---@class (exact) oil.ParseResult
---@field data table Parsed entry data
---@field ranges table Locations of the various columns
----@field entry nil|canola.InternalEntry If the entry already exists
+---@field entry nil|oil.InternalEntry If the entry already exists
---Parse a single line in a buffer
----@param adapter canola.Adapter
+---@param adapter oil.Adapter
---@param line string
----@param column_defs canola.ColumnSpec[]
----@return nil|canola.ParseResult
+---@param column_defs oil.ColumnSpec[]
+---@return nil|oil.ParseResult
---@return nil|string Error
M.parse_line = function(adapter, line, column_defs)
local ret = {}
local ranges = {}
local start = 1
- local value, rem = line:match('^/(%d+) (.+)$')
+ local value, rem = line:match("^/(%d+) (.+)$")
if not value then
- return nil, 'Malformed ID at start of line'
+ return nil, "Malformed ID at start of line"
end
ranges.id = { start, value:len() + 1 }
start = ranges.id[2] + 1
@@ -97,7 +97,7 @@ M.parse_line = function(adapter, line, column_defs)
local start_len = string.len(rem)
value, rem = columns.parse_col(adapter, assert(rem), def)
if not rem then
- return nil, string.format('Parsing %s failed', name)
+ return nil, string.format("Parsing %s failed", name)
end
ret[name] = value
range[2] = range[1] + start_len - string.len(rem) - 1
@@ -108,10 +108,10 @@ M.parse_line = function(adapter, line, column_defs)
if name then
local isdir
name, isdir = parsedir(vim.trim(name))
- if name ~= '' then
+ if name ~= "" then
ret.name = name
end
- ret._type = isdir and 'directory' or 'file'
+ ret._type = isdir and "directory" or "file"
end
local entry = cache.get_entry_by_id(ret.id)
ranges.name = { start, start + string.len(rem) - 1 }
@@ -122,38 +122,38 @@ M.parse_line = function(adapter, line, column_defs)
-- Parse the symlink syntax
local meta = entry[FIELD_META]
local entry_type = entry[FIELD_TYPE]
- if entry_type == 'link' and meta and meta.link then
- local name_pieces = vim.split(ret.name, ' -> ', { plain = true })
+ if entry_type == "link" and meta and meta.link then
+ local name_pieces = vim.split(ret.name, " -> ", { plain = true })
if #name_pieces ~= 2 then
- ret.name = ''
+ ret.name = ""
return { data = ret, ranges = ranges }
end
ranges.name = { start, start + string.len(name_pieces[1]) - 1 }
ret.name = parsedir(vim.trim(name_pieces[1]))
ret.link_target = name_pieces[2]
- ret._type = 'link'
+ ret._type = "link"
end
-- Try to keep the same file type
- if entry_type ~= 'directory' and entry_type ~= 'file' and ret._type ~= 'directory' then
+ if entry_type ~= "directory" and entry_type ~= "file" and ret._type ~= "directory" then
ret._type = entry[FIELD_TYPE]
end
return { data = ret, entry = entry, ranges = ranges }
end
----@class (exact) canola.ParseError
+---@class (exact) oil.ParseError
---@field lnum integer
---@field col integer
---@field message string
---@param bufnr integer
----@return canola.Diff[] diffs
----@return canola.ParseError[] errors Parsing errors
+---@return oil.Diff[] diffs
+---@return oil.ParseError[] errors Parsing errors
M.parse = function(bufnr)
- ---@type canola.Diff[]
+ ---@type oil.Diff[]
local diffs = {}
- ---@type canola.ParseError[]
+ ---@type oil.ParseError[]
local errors = {}
local bufname = vim.api.nvim_buf_get_name(bufnr)
local adapter = util.get_adapter(bufnr, true)
@@ -187,7 +187,7 @@ M.parse = function(bufnr)
name = name:lower()
end
if seen_names[name] then
- table.insert(errors, { message = 'Duplicate filename', lnum = i - 1, end_lnum = i, col = 0 })
+ table.insert(errors, { message = "Duplicate filename", lnum = i - 1, end_lnum = i, col = 0 })
else
seen_names[name] = true
end
@@ -197,7 +197,7 @@ M.parse = function(bufnr)
-- hack to be compatible with Lua 5.1
-- use return instead of goto
(function()
- if line:match('^/%d+') then
+ if line:match("^/%d+") then
-- Parse the line for an existing entry
local result, err = M.parse_line(adapter, line, column_defs)
if not result or err then
@@ -217,11 +217,11 @@ M.parse = function(bufnr)
local err_message
if not parsed_entry.name then
- err_message = 'No filename found'
+ err_message = "No filename found"
elseif not entry then
- err_message = 'Could not find existing entry (was the ID changed?)'
- elseif parsed_entry.name:match('/') or parsed_entry.name:match(fs.sep) then
- err_message = 'Filename cannot contain path separator'
+ err_message = "Could not find existing entry (was the ID changed?)"
+ elseif parsed_entry.name:match("/") or parsed_entry.name:match(fs.sep) then
+ err_message = "Filename cannot contain path separator"
end
if err_message then
table.insert(errors, {
@@ -237,16 +237,16 @@ M.parse = function(bufnr)
check_dupe(parsed_entry.name, i)
local meta = entry[FIELD_META]
if original_entries[parsed_entry.name] == parsed_entry.id then
- if entry[FIELD_TYPE] == 'link' and not compare_link_target(meta, parsed_entry) then
+ if entry[FIELD_TYPE] == "link" and not compare_link_target(meta, parsed_entry) then
table.insert(diffs, {
- type = 'new',
+ type = "new",
name = parsed_entry.name,
- entry_type = 'link',
+ entry_type = "link",
link = parsed_entry.link_target,
})
elseif entry[FIELD_TYPE] ~= parsed_entry._type then
table.insert(diffs, {
- type = 'new',
+ type = "new",
name = parsed_entry.name,
entry_type = parsed_entry._type,
})
@@ -255,7 +255,7 @@ M.parse = function(bufnr)
end
else
table.insert(diffs, {
- type = 'new',
+ type = "new",
name = parsed_entry.name,
entry_type = parsed_entry._type,
id = parsed_entry.id,
@@ -267,7 +267,7 @@ M.parse = function(bufnr)
local col_name = util.split_config(col_def)
if columns.compare(adapter, col_name, entry, parsed_entry[col_name]) then
table.insert(diffs, {
- type = 'change',
+ type = "change",
name = parsed_entry.name,
entry_type = entry[FIELD_TYPE],
column = col_name,
@@ -278,7 +278,7 @@ M.parse = function(bufnr)
else
-- Parse a new entry
local name, isdir = parsedir(vim.trim(line))
- if vim.startswith(name, '/') then
+ if vim.startswith(name, "/") then
table.insert(errors, {
message = "Paths cannot start with '/'",
lnum = i - 1,
@@ -287,17 +287,17 @@ M.parse = function(bufnr)
})
return
end
- if name ~= '' then
- local link_pieces = vim.split(name, ' -> ', { plain = true })
- local entry_type = isdir and 'directory' or 'file'
+ if name ~= "" then
+ local link_pieces = vim.split(name, " -> ", { plain = true })
+ local entry_type = isdir and "directory" or "file"
local link
if #link_pieces == 2 then
- entry_type = 'link'
+ entry_type = "link"
name, link = unpack(link_pieces)
end
check_dupe(name, i)
table.insert(diffs, {
- type = 'new',
+ type = "new",
name = name,
entry_type = entry_type,
link = link,
@@ -309,7 +309,7 @@ M.parse = function(bufnr)
for name, child_id in pairs(original_entries) do
table.insert(diffs, {
- type = 'delete',
+ type = "delete",
name = name,
id = child_id,
})
diff --git a/lua/canola/mutator/progress.lua b/lua/oil/mutator/progress.lua
similarity index 75%
rename from lua/canola/mutator/progress.lua
rename to lua/oil/mutator/progress.lua
index 4a74dbc..057f0a0 100644
--- a/lua/canola/mutator/progress.lua
+++ b/lua/oil/mutator/progress.lua
@@ -1,17 +1,17 @@
-local columns = require('canola.columns')
-local config = require('canola.config')
-local layout = require('canola.layout')
-local loading = require('canola.loading')
-local util = require('canola.util')
+local columns = require("oil.columns")
+local config = require("oil.config")
+local layout = require("oil.layout")
+local loading = require("oil.loading")
+local util = require("oil.util")
local Progress = {}
local FPS = 20
function Progress.new()
return setmetatable({
- lines = { '', '' },
- count = '',
- spinner = '',
+ lines = { "", "" },
+ count = "",
+ spinner = "",
bufnr = nil,
winid = nil,
min_bufnr = nil,
@@ -40,18 +40,18 @@ function Progress:show(opts)
return
end
local bufnr = vim.api.nvim_create_buf(false, true)
- vim.bo[bufnr].bufhidden = 'wipe'
+ vim.bo[bufnr].bufhidden = "wipe"
self.bufnr = bufnr
self.cancel = opts.cancel or self.cancel
local loading_iter = loading.get_bar_iter()
- local spinner = loading.get_iter('dots')
+ local spinner = loading.get_iter("dots")
if not self.timer then
self.timer = vim.loop.new_timer()
self.timer:start(
0,
math.floor(1000 / FPS),
vim.schedule_wrap(function()
- self.lines[2] = string.format('%s %s', self.count, loading_iter())
+ self.lines[2] = string.format("%s %s", self.count, loading_iter())
self.spinner = spinner()
self:_render()
end)
@@ -59,22 +59,22 @@ function Progress:show(opts)
end
local width, height = layout.calculate_dims(120, 10, config.progress)
self.winid = vim.api.nvim_open_win(self.bufnr, true, {
- relative = 'editor',
+ relative = "editor",
width = width,
height = height,
row = math.floor((layout.get_editor_height() - height) / 2),
col = math.floor((layout.get_editor_width() - width) / 2),
zindex = 152, -- render on top of the floating window title
- style = 'minimal',
+ style = "minimal",
border = config.progress.border,
})
- vim.bo[self.bufnr].filetype = 'canola_progress'
+ vim.bo[self.bufnr].filetype = "oil_progress"
for k, v in pairs(config.progress.win_options) do
- vim.api.nvim_set_option_value(k, v, { scope = 'local', win = self.winid })
+ vim.api.nvim_set_option_value(k, v, { scope = "local", win = self.winid })
end
table.insert(
self.autocmds,
- vim.api.nvim_create_autocmd('VimResized', {
+ vim.api.nvim_create_autocmd("VimResized", {
callback = function()
self:_reposition()
end,
@@ -82,7 +82,7 @@ function Progress:show(opts)
)
table.insert(
self.autocmds,
- vim.api.nvim_create_autocmd('WinLeave', {
+ vim.api.nvim_create_autocmd("WinLeave", {
callback = function()
self:minimize()
end,
@@ -94,17 +94,17 @@ function Progress:show(opts)
vim.api.nvim_win_close(self.winid, true)
end
end
- vim.keymap.set('n', 'c', cancel, { buffer = self.bufnr, nowait = true })
- vim.keymap.set('n', 'C', cancel, { buffer = self.bufnr, nowait = true })
- vim.keymap.set('n', 'm', minimize, { buffer = self.bufnr, nowait = true })
- vim.keymap.set('n', 'M', minimize, { buffer = self.bufnr, nowait = true })
+ vim.keymap.set("n", "c", cancel, { buffer = self.bufnr, nowait = true })
+ vim.keymap.set("n", "C", cancel, { buffer = self.bufnr, nowait = true })
+ vim.keymap.set("n", "m", minimize, { buffer = self.bufnr, nowait = true })
+ vim.keymap.set("n", "M", minimize, { buffer = self.bufnr, nowait = true })
end
function Progress:restore()
if self.closing then
return
elseif not self:is_minimized() then
- error('Cannot restore progress window: not minimized')
+ error("Cannot restore progress window: not minimized")
end
self:_cleanup_minimized_win()
self:show()
@@ -115,14 +115,14 @@ function Progress:_render()
util.render_text(
self.bufnr,
self.lines,
- { winid = self.winid, actions = { '[M]inimize', '[C]ancel' } }
+ { winid = self.winid, actions = { "[M]inimize", "[C]ancel" } }
)
end
if self.min_bufnr and vim.api.nvim_buf_is_valid(self.min_bufnr) then
util.render_text(
self.min_bufnr,
- { string.format('%sCanola: %s', self.spinner, self.count) },
- { winid = self.min_winid, h_align = 'left' }
+ { string.format("%sOil: %s", self.spinner, self.count) },
+ { winid = self.min_winid, h_align = "left" }
)
end
end
@@ -136,7 +136,7 @@ function Progress:_reposition()
end
local width, height = layout.calculate_dims(min_width, 10, config.progress)
vim.api.nvim_win_set_config(self.winid, {
- relative = 'editor',
+ relative = "editor",
width = width,
height = height,
row = math.floor((layout.get_editor_height() - height) / 2),
@@ -174,38 +174,38 @@ function Progress:minimize()
end
self:_cleanup_main_win()
local bufnr = vim.api.nvim_create_buf(false, true)
- vim.bo[bufnr].bufhidden = 'wipe'
+ vim.bo[bufnr].bufhidden = "wipe"
local winid = vim.api.nvim_open_win(bufnr, false, {
- relative = 'editor',
+ relative = "editor",
width = 16,
height = 1,
- anchor = 'SE',
+ anchor = "SE",
row = layout.get_editor_height(),
col = layout.get_editor_width(),
zindex = 152, -- render on top of the floating window title
- style = 'minimal',
+ style = "minimal",
border = config.progress.minimized_border,
})
self.min_bufnr = bufnr
self.min_winid = winid
self:_render()
- vim.notify_once('Restore progress window with :Canola --progress')
+ vim.notify_once("Restore progress window with :Oil --progress")
end
----@param action canola.Action
+---@param action oil.Action
---@param idx integer
---@param total integer
function Progress:set_action(action, idx, total)
local adapter = util.get_adapter_for_action(action)
local change_line
- if action.type == 'change' then
- ---@cast action canola.ChangeAction
+ if action.type == "change" then
+ ---@cast action oil.ChangeAction
change_line = columns.render_change_action(adapter, action)
else
change_line = adapter.render_action(action)
end
self.lines[1] = change_line
- self.count = string.format('%d/%d', idx, total)
+ self.count = string.format("%d/%d", idx, total)
self:_reposition()
self:_render()
end
diff --git a/lua/canola/mutator/trie.lua b/lua/oil/mutator/trie.lua
similarity index 88%
rename from lua/canola/mutator/trie.lua
rename to lua/oil/mutator/trie.lua
index 9dbf6d1..7bac161 100644
--- a/lua/canola/mutator/trie.lua
+++ b/lua/oil/mutator/trie.lua
@@ -1,13 +1,13 @@
-local util = require('canola.util')
+local util = require("oil.util")
----@class (exact) canola.Trie
----@field new fun(): canola.Trie
+---@class (exact) oil.Trie
+---@field new fun(): oil.Trie
---@field private root table
local Trie = {}
----@return canola.Trie
+---@return oil.Trie
Trie.new = function()
- ---@type canola.Trie
+ ---@type oil.Trie
return setmetatable({
root = { values = {}, children = {} },
}, {
@@ -20,7 +20,7 @@ end
function Trie:_url_to_path_pieces(url)
local scheme, path = util.parse_url(url)
assert(path)
- local pieces = vim.split(path, '/')
+ local pieces = vim.split(path, "/")
table.insert(pieces, 1, scheme)
return pieces
end
@@ -75,12 +75,12 @@ function Trie:remove(path_pieces, value)
return
end
end
- error('Value not present in trie: ' .. vim.inspect(value))
+ error("Value not present in trie: " .. vim.inspect(value))
end
---Add the first action that affects a parent path of the url
---@param url string
----@param ret canola.InternalEntry[]
+---@param ret oil.InternalEntry[]
function Trie:accum_first_parents_of(url, ret)
local pieces = self:_url_to_path_pieces(url)
local containers = { self.root }
@@ -117,8 +117,8 @@ end
---Add all actions affecting children of the url
---@param url string
----@param ret canola.InternalEntry[]
----@param filter nil|fun(entry: canola.Action): boolean
+---@param ret oil.InternalEntry[]
+---@param filter nil|fun(entry: oil.Action): boolean
function Trie:accum_children_of(url, ret, filter)
local pieces = self:_url_to_path_pieces(url)
local current = self.root
@@ -137,8 +137,8 @@ end
---Add all actions at a specific path
---@param url string
----@param ret canola.InternalEntry[]
----@param filter? fun(entry: canola.Action): boolean
+---@param ret oil.InternalEntry[]
+---@param filter? fun(entry: oil.Action): boolean
function Trie:accum_actions_at(url, ret, filter)
local pieces = self:_url_to_path_pieces(url)
local current = self.root
diff --git a/lua/oil/pathutil.lua b/lua/oil/pathutil.lua
new file mode 100644
index 0000000..b030389
--- /dev/null
+++ b/lua/oil/pathutil.lua
@@ -0,0 +1,29 @@
+local M = {}
+
+---@param path string
+---@return string
+M.parent = function(path)
+ if path == "/" then
+ return "/"
+ elseif path == "" then
+ return ""
+ elseif vim.endswith(path, "/") then
+ return path:match("^(.*/)[^/]*/$") or ""
+ else
+ return path:match("^(.*/)[^/]*$") or ""
+ end
+end
+
+---@param path string
+---@return nil|string
+M.basename = function(path)
+ if path == "/" or path == "" then
+ return
+ elseif vim.endswith(path, "/") then
+ return path:match("^.*/([^/]*)/$")
+ else
+ return path:match("^.*/([^/]*)$")
+ end
+end
+
+return M
diff --git a/lua/canola/ringbuf.lua b/lua/oil/ringbuf.lua
similarity index 91%
rename from lua/canola/ringbuf.lua
rename to lua/oil/ringbuf.lua
index ced0907..0f09987 100644
--- a/lua/canola/ringbuf.lua
+++ b/lua/oil/ringbuf.lua
@@ -1,4 +1,4 @@
----@class canola.Ringbuf
+---@class oil.Ringbuf
---@field private size integer
---@field private tail integer
---@field private buf string[]
@@ -23,11 +23,11 @@ end
---@return string
function Ringbuf:as_str()
- local postfix = ''
+ local postfix = ""
for i = 1, self.tail, 1 do
postfix = postfix .. self.buf[i]
end
- local prefix = ''
+ local prefix = ""
for i = self.tail + 1, #self.buf, 1 do
prefix = prefix .. self.buf[i]
end
diff --git a/lua/canola/shell.lua b/lua/oil/shell.lua
similarity index 74%
rename from lua/canola/shell.lua
rename to lua/oil/shell.lua
index 9439846..b04b27b 100644
--- a/lua/canola/shell.lua
+++ b/lua/oil/shell.lua
@@ -9,7 +9,7 @@ M.run = function(cmd, opts, callback)
local stderr = {}
local jid = vim.fn.jobstart(
cmd,
- vim.tbl_deep_extend('keep', opts, {
+ vim.tbl_deep_extend("keep", opts, {
stdout_buffered = true,
stderr_buffered = true,
on_stdout = function(j, output)
@@ -22,19 +22,19 @@ M.run = function(cmd, opts, callback)
if code == 0 then
callback(nil, stdout)
else
- local err = table.concat(stderr, '\n')
- if err == '' then
- err = 'Unknown error'
+ local err = table.concat(stderr, "\n")
+ if err == "" then
+ err = "Unknown error"
end
- local cmd_str = type(cmd) == 'string' and cmd or table.concat(cmd, ' ')
+ local cmd_str = type(cmd) == "string" and cmd or table.concat(cmd, " ")
callback(string.format("Error running command '%s'\n%s", cmd_str, err))
end
end),
})
)
local exe
- if type(cmd) == 'string' then
- exe = vim.split(cmd, '%s+')[1]
+ if type(cmd) == "string" then
+ exe = vim.split(cmd, "%s+")[1]
else
exe = cmd[1]
end
diff --git a/lua/canola/util.lua b/lua/oil/util.lua
similarity index 72%
rename from lua/canola/util.lua
rename to lua/oil/util.lua
index 2231470..37e73cc 100644
--- a/lua/canola/util.lua
+++ b/lua/oil/util.lua
@@ -1,5 +1,5 @@
-local config = require('canola.config')
-local constants = require('canola.constants')
+local config = require("oil.config")
+local constants = require("oil.constants")
local M = {}
@@ -8,13 +8,13 @@ local FIELD_NAME = constants.FIELD_NAME
local FIELD_TYPE = constants.FIELD_TYPE
local FIELD_META = constants.FIELD_META
----@alias canola.IconProvider fun(type: string, name: string, conf: table?, ft: string?): (icon: string, hl: string)
+---@alias oil.IconProvider fun(type: string, name: string, conf: table?, ft: string?): (icon: string, hl: string)
---@param url string
---@return nil|string
---@return nil|string
M.parse_url = function(url)
- return url:match('^(.*://)(.*)$')
+ return url:match("^(.*://)(.*)$")
end
---Escapes a filename for use in :edit
@@ -26,64 +26,64 @@ M.escape_filename = function(filename)
end
local _url_escape_to_char = {
- ['20'] = ' ',
- ['22'] = '“',
- ['23'] = '#',
- ['24'] = '$',
- ['25'] = '%',
- ['26'] = '&',
- ['27'] = '‘',
- ['2B'] = '+',
- ['2C'] = ',',
- ['2F'] = '/',
- ['3A'] = ':',
- ['3B'] = ';',
- ['3C'] = '<',
- ['3D'] = '=',
- ['3E'] = '>',
- ['3F'] = '?',
- ['40'] = '@',
- ['5B'] = '[',
- ['5C'] = '\\',
- ['5D'] = ']',
- ['5E'] = '^',
- ['60'] = '`',
- ['7B'] = '{',
- ['7C'] = '|',
- ['7D'] = '}',
- ['7E'] = '~',
+ ["20"] = " ",
+ ["22"] = "“",
+ ["23"] = "#",
+ ["24"] = "$",
+ ["25"] = "%",
+ ["26"] = "&",
+ ["27"] = "‘",
+ ["2B"] = "+",
+ ["2C"] = ",",
+ ["2F"] = "/",
+ ["3A"] = ":",
+ ["3B"] = ";",
+ ["3C"] = "<",
+ ["3D"] = "=",
+ ["3E"] = ">",
+ ["3F"] = "?",
+ ["40"] = "@",
+ ["5B"] = "[",
+ ["5C"] = "\\",
+ ["5D"] = "]",
+ ["5E"] = "^",
+ ["60"] = "`",
+ ["7B"] = "{",
+ ["7C"] = "|",
+ ["7D"] = "}",
+ ["7E"] = "~",
}
local _char_to_url_escape = {}
for k, v in pairs(_url_escape_to_char) do
- _char_to_url_escape[v] = '%' .. k
+ _char_to_url_escape[v] = "%" .. k
end
-- TODO this uri escape handling is very incomplete
---@param string string
---@return string
M.url_escape = function(string)
- return (string:gsub('.', _char_to_url_escape))
+ return (string:gsub(".", _char_to_url_escape))
end
---@param string string
---@return string
M.url_unescape = function(string)
return (
- string:gsub('%%([0-9A-Fa-f][0-9A-Fa-f])', function(seq)
- return _url_escape_to_char[seq:upper()] or ('%' .. seq)
+ string:gsub("%%([0-9A-Fa-f][0-9A-Fa-f])", function(seq)
+ return _url_escape_to_char[seq:upper()] or ("%" .. seq)
end)
)
end
---@param bufnr integer
---@param silent? boolean
----@return nil|canola.Adapter
+---@return nil|oil.Adapter
M.get_adapter = function(bufnr, silent)
local bufname = vim.api.nvim_buf_get_name(bufnr)
local adapter = config.get_adapter_by_scheme(bufname)
if not adapter and not silent then
vim.notify_once(
- string.format("[canola] could not find adapter for buffer '%s://'", bufname),
+ string.format("[oil] could not find adapter for buffer '%s://'", bufname),
vim.log.levels.ERROR
)
end
@@ -92,7 +92,7 @@ end
---@param text string
---@param width integer|nil
----@param align canola.ColumnAlign
+---@param align oil.ColumnAlign
---@return string padded_text
---@return integer left_padding
M.pad_align = function(text, width, align)
@@ -105,14 +105,14 @@ M.pad_align = function(text, width, align)
return text, 0
end
- if align == 'right' then
- return string.rep(' ', total_pad) .. text, total_pad
- elseif align == 'center' then
+ if align == "right" then
+ return string.rep(" ", total_pad) .. text, total_pad
+ elseif align == "center" then
local left_pad = math.floor(total_pad / 2)
local right_pad = total_pad - left_pad
- return string.rep(' ', left_pad) .. text .. string.rep(' ', right_pad), left_pad
+ return string.rep(" ", left_pad) .. text .. string.rep(" ", right_pad), left_pad
else
- return text .. string.rep(' ', total_pad), 0
+ return text .. string.rep(" ", total_pad), 0
end
end
@@ -135,8 +135,8 @@ M.tbl_slice = function(tbl, start_idx, end_idx)
return ret
end
----@param entry canola.InternalEntry
----@return canola.Entry
+---@param entry oil.InternalEntry
+---@return oil.Entry
M.export_entry = function(entry)
return {
name = entry[FIELD_NAME],
@@ -150,7 +150,7 @@ end
---@param dest_buf_name string
---@return boolean True if the buffer was replaced instead of renamed
M.rename_buffer = function(src_bufnr, dest_buf_name)
- if type(src_bufnr) == 'string' then
+ if type(src_bufnr) == "string" then
src_bufnr = vim.fn.bufadd(src_bufnr)
if not vim.api.nvim_buf_is_loaded(src_bufnr) then
vim.api.nvim_buf_delete(src_bufnr, {})
@@ -164,7 +164,7 @@ M.rename_buffer = function(src_bufnr, dest_buf_name)
-- think that the new buffer conflicts with the file next time it tries to save.
if not vim.loop.fs_stat(dest_buf_name) then
---@diagnostic disable-next-line: param-type-mismatch
- local altbuf = vim.fn.bufnr('#')
+ local altbuf = vim.fn.bufnr("#")
-- This will fail if the dest buf name already exists
local ok = pcall(vim.api.nvim_buf_set_name, src_bufnr, dest_buf_name)
if ok then
@@ -173,7 +173,7 @@ M.rename_buffer = function(src_bufnr, dest_buf_name)
-- where Neovim doesn't allow buffer modifications.
pcall(vim.api.nvim_buf_delete, vim.fn.bufadd(bufname), {})
if altbuf and vim.api.nvim_buf_is_valid(altbuf) then
- vim.fn.setreg('#', altbuf)
+ vim.fn.setreg("#", altbuf)
end
return false
@@ -229,7 +229,6 @@ end
M.cb_collect = function(count, cb)
return function(err)
if err then
- -- selene: allow(mismatched_arg_count)
cb(err)
cb = function() end
else
@@ -244,22 +243,22 @@ end
---@param url string
---@return string[]
local function get_possible_buffer_names_from_url(url)
- local fs = require('canola.fs')
+ local fs = require("oil.fs")
local scheme, path = M.parse_url(url)
- if config.adapters[scheme] == 'files' then
+ if config.adapters[scheme] == "files" then
assert(path)
return { fs.posix_to_os_path(path) }
end
return { url }
end
----@param entry_type canola.EntryType
+---@param entry_type oil.EntryType
---@param src_url string
---@param dest_url string
M.update_moved_buffers = function(entry_type, src_url, dest_url)
local src_buf_names = get_possible_buffer_names_from_url(src_url)
local dest_buf_name = get_possible_buffer_names_from_url(dest_url)[1]
- if entry_type ~= 'directory' then
+ if entry_type ~= "directory" then
for _, src_buf_name in ipairs(src_buf_names) do
M.rename_buffer(src_buf_name, dest_buf_name)
end
@@ -271,15 +270,15 @@ M.update_moved_buffers = function(entry_type, src_url, dest_url)
for _, bufnr in ipairs(vim.api.nvim_list_bufs()) do
local bufname = vim.api.nvim_buf_get_name(bufnr)
if vim.startswith(bufname, src_url) then
- -- Handle canola directory buffers
+ -- Handle oil directory buffers
vim.api.nvim_buf_set_name(bufnr, dest_url .. bufname:sub(src_url:len() + 1))
- elseif bufname ~= '' and vim.bo[bufnr].buftype == '' then
+ elseif bufname ~= "" and vim.bo[bufnr].buftype == "" then
-- Handle regular buffers
local scheme = M.parse_url(bufname)
-- If the buffer is a local file, make sure we're using the absolute path
if not scheme then
- bufname = vim.fn.fnamemodify(bufname, ':p')
+ bufname = vim.fn.fnamemodify(bufname, ":p")
end
for _, src_buf_name in ipairs(src_buf_names) do
@@ -297,23 +296,23 @@ end
---@return string
---@return table|nil
M.split_config = function(name_or_config)
- if type(name_or_config) == 'string' then
+ if type(name_or_config) == "string" then
return name_or_config, nil
else
- if not name_or_config[1] and name_or_config['1'] then
+ if not name_or_config[1] and name_or_config["1"] then
-- This was likely loaded from json, so the first element got coerced to a string key
- name_or_config[1] = name_or_config['1']
- name_or_config['1'] = nil
+ name_or_config[1] = name_or_config["1"]
+ name_or_config["1"] = nil
end
return name_or_config[1], name_or_config
end
end
----@alias canola.ColumnAlign "left"|"center"|"right"
+---@alias oil.ColumnAlign "left"|"center"|"right"
----@param lines canola.TextChunk[][]
+---@param lines oil.TextChunk[][]
---@param col_width integer[]
----@param col_align? canola.ColumnAlign[]
+---@param col_align? oil.ColumnAlign[]
---@return string[]
---@return any[][] List of highlights {group, lnum, col_start, col_end}
M.render_table = function(lines, col_width, col_align)
@@ -325,7 +324,7 @@ M.render_table = function(lines, col_width, col_align)
local pieces = {}
for i, chunk in ipairs(cols) do
local text, hl
- if type(chunk) == 'table' then
+ if type(chunk) == "table" then
text = chunk[1]
hl = chunk[2]
else
@@ -334,11 +333,11 @@ M.render_table = function(lines, col_width, col_align)
local unpadded_len = text:len()
local padding
- text, padding = M.pad_align(text, col_width[i], col_align[i] or 'left')
+ text, padding = M.pad_align(text, col_width[i], col_align[i] or "left")
table.insert(pieces, text)
if hl then
- if type(hl) == 'table' then
+ if type(hl) == "table" then
-- hl has the form { [1]: hl_name, [2]: col_start, [3]: col_end }[]
-- Notice that col_start and col_end are relative position inside
-- that col, so we need to add the offset to them
@@ -356,7 +355,7 @@ M.render_table = function(lines, col_width, col_align)
end
col = col + text:len() + 1
end
- table.insert(str_lines, table.concat(pieces, ' '))
+ table.insert(str_lines, table.concat(pieces, " "))
end
return str_lines, highlights
end
@@ -364,7 +363,7 @@ end
---@param bufnr integer
---@param highlights any[][] List of highlights {group, lnum, col_start, col_end}
M.set_highlights = function(bufnr, highlights)
- local ns = vim.api.nvim_create_namespace('Canola')
+ local ns = vim.api.nvim_create_namespace("Oil")
vim.api.nvim_buf_clear_namespace(bufnr, ns, 0, -1)
for _, hl in ipairs(highlights) do
local group, line, col_start, col_end = unpack(hl)
@@ -380,12 +379,12 @@ end
---@param os_slash? boolean use os filesystem slash instead of posix slash
---@return string
M.addslash = function(path, os_slash)
- local slash = '/'
- if os_slash and require('canola.fs').is_windows then
- slash = '\\'
+ local slash = "/"
+ if os_slash and require("oil.fs").is_windows then
+ slash = "\\"
end
- local endslash = path:match(slash .. '$')
+ local endslash = path:match(slash .. "$")
if not endslash then
return path .. slash
else
@@ -396,7 +395,7 @@ end
---@param winid nil|integer
---@return boolean
M.is_floating_win = function(winid)
- return vim.api.nvim_win_get_config(winid or 0).relative ~= ''
+ return vim.api.nvim_win_get_config(winid or 0).relative ~= ""
end
---Recalculate the window title for the current buffer
@@ -411,10 +410,10 @@ M.get_title = function(winid)
local title = vim.api.nvim_buf_get_name(src_buf)
local scheme, path = M.parse_url(title)
- if config.adapters[scheme] == 'files' then
+ if config.adapters[scheme] == "files" then
assert(path)
- local fs = require('canola.fs')
- title = vim.fn.fnamemodify(fs.posix_to_os_path(path), ':~')
+ local fs = require("oil.fs")
+ title = vim.fn.fnamemodify(fs.posix_to_os_path(path), ":~")
end
return title
end
@@ -422,7 +421,7 @@ end
local winid_map = {}
M.add_title_to_win = function(winid, opts)
opts = opts or {}
- opts.align = opts.align or 'left'
+ opts.align = opts.align or "left"
if not vim.api.nvim_win_is_valid(winid) then
return
end
@@ -439,18 +438,18 @@ M.add_title_to_win = function(winid, opts)
else
bufnr = vim.api.nvim_create_buf(false, true)
local col = 1
- if opts.align == 'center' then
+ if opts.align == "center" then
col = math.floor((vim.api.nvim_win_get_width(winid) - width) / 2)
- elseif opts.align == 'right' then
+ elseif opts.align == "right" then
col = vim.api.nvim_win_get_width(winid) - 1 - width
- elseif opts.align ~= 'left' then
+ elseif opts.align ~= "left" then
vim.notify(
- string.format("Unknown canola window title alignment: '%s'", opts.align),
+ string.format("Unknown oil window title alignment: '%s'", opts.align),
vim.log.levels.ERROR
)
end
title_winid = vim.api.nvim_open_win(bufnr, false, {
- relative = 'win',
+ relative = "win",
win = winid,
width = width,
height = 1,
@@ -458,20 +457,20 @@ M.add_title_to_win = function(winid, opts)
col = col,
focusable = false,
zindex = 151,
- style = 'minimal',
+ style = "minimal",
noautocmd = true,
})
winid_map[winid] = title_winid
vim.api.nvim_set_option_value(
- 'winblend',
+ "winblend",
vim.wo[winid].winblend,
- { scope = 'local', win = title_winid }
+ { scope = "local", win = title_winid }
)
- vim.bo[bufnr].bufhidden = 'wipe'
+ vim.bo[bufnr].bufhidden = "wipe"
- local update_autocmd = vim.api.nvim_create_autocmd('BufWinEnter', {
- desc = 'Update canola floating window title when buffer changes',
- pattern = '*',
+ local update_autocmd = vim.api.nvim_create_autocmd("BufWinEnter", {
+ desc = "Update oil floating window title when buffer changes",
+ pattern = "*",
callback = function(params)
local winbuf = params.buf
if vim.api.nvim_win_get_buf(winid) ~= winbuf then
@@ -480,17 +479,17 @@ M.add_title_to_win = function(winid, opts)
local new_title = M.get_title(winid)
local new_width =
math.min(vim.api.nvim_win_get_width(winid) - 4, 2 + vim.api.nvim_strwidth(new_title))
- vim.api.nvim_buf_set_lines(bufnr, 0, -1, true, { ' ' .. new_title .. ' ' })
+ vim.api.nvim_buf_set_lines(bufnr, 0, -1, true, { " " .. new_title .. " " })
vim.bo[bufnr].modified = false
vim.api.nvim_win_set_width(title_winid, new_width)
local new_col = 1
- if opts.align == 'center' then
+ if opts.align == "center" then
new_col = math.floor((vim.api.nvim_win_get_width(winid) - new_width) / 2)
- elseif opts.align == 'right' then
+ elseif opts.align == "right" then
new_col = vim.api.nvim_win_get_width(winid) - 1 - new_width
end
vim.api.nvim_win_set_config(title_winid, {
- relative = 'win',
+ relative = "win",
win = winid,
row = -1,
col = new_col,
@@ -499,8 +498,8 @@ M.add_title_to_win = function(winid, opts)
})
end,
})
- vim.api.nvim_create_autocmd('WinClosed', {
- desc = 'Close canola floating window title when floating window closes',
+ vim.api.nvim_create_autocmd("WinClosed", {
+ desc = "Close oil floating window title when floating window closes",
pattern = tostring(winid),
callback = function()
if title_winid and vim.api.nvim_win_is_valid(title_winid) then
@@ -513,18 +512,18 @@ M.add_title_to_win = function(winid, opts)
nested = true,
})
end
- vim.api.nvim_buf_set_lines(bufnr, 0, -1, true, { ' ' .. title .. ' ' })
+ vim.api.nvim_buf_set_lines(bufnr, 0, -1, true, { " " .. title .. " " })
vim.bo[bufnr].modified = false
vim.api.nvim_set_option_value(
- 'winhighlight',
- 'Normal:FloatTitle,NormalFloat:FloatTitle',
- { scope = 'local', win = title_winid }
+ "winhighlight",
+ "Normal:FloatTitle,NormalFloat:FloatTitle",
+ { scope = "local", win = title_winid }
)
end
----@param action canola.Action
----@return canola.Adapter
----@return nil|canola.CrossAdapterAction
+---@param action oil.Action
+---@return oil.Adapter
+---@return nil|oil.CrossAdapterAction
M.get_adapter_for_action = function(action)
local adapter = assert(config.get_adapter_by_scheme(action.url or action.src_url))
if action.dest_url then
@@ -543,7 +542,7 @@ M.get_adapter_for_action = function(action)
else
error(
string.format(
- 'Cannot copy files from %s -> %s; no cross-adapter transfer method found',
+ "Cannot copy files from %s -> %s; no cross-adapter transfer method found",
action.src_url,
action.dest_url
)
@@ -560,12 +559,12 @@ end
---@return string
---@return integer
M.h_align = function(str, align, width)
- if align == 'center' then
+ if align == "center" then
local padding = math.floor((width - vim.api.nvim_strwidth(str)) / 2)
- return string.rep(' ', padding) .. str, padding
- elseif align == 'right' then
+ return string.rep(" ", padding) .. str, padding
+ elseif align == "right" then
local padding = width - vim.api.nvim_strwidth(str)
- return string.rep(' ', padding) .. str, padding
+ return string.rep(" ", padding) .. str, padding
else
return str, 0
end
@@ -579,15 +578,15 @@ end
--- actions nil|string[]
--- winid nil|integer
M.render_text = function(bufnr, text, opts)
- opts = vim.tbl_deep_extend('keep', opts or {}, {
- h_align = 'center',
- v_align = 'center',
+ opts = vim.tbl_deep_extend("keep", opts or {}, {
+ h_align = "center",
+ v_align = "center",
})
---@cast opts -nil
if not vim.api.nvim_buf_is_valid(bufnr) then
return
end
- if type(text) == 'string' then
+ if type(text) == "string" then
text = { text }
end
local height = 40
@@ -609,17 +608,17 @@ M.render_text = function(bufnr, text, opts)
local lines = {}
-- Add vertical spacing for vertical alignment
- if opts.v_align == 'center' then
+ if opts.v_align == "center" then
for _ = 1, (height / 2) - (#text / 2) do
- table.insert(lines, '')
+ table.insert(lines, "")
end
- elseif opts.v_align == 'bottom' then
+ elseif opts.v_align == "bottom" then
local num_lines = height
if opts.actions then
num_lines = num_lines - 2
end
while #lines + #text < num_lines do
- table.insert(lines, '')
+ table.insert(lines, "")
end
end
@@ -633,12 +632,12 @@ M.render_text = function(bufnr, text, opts)
local highlights = {}
if opts.actions then
while #lines < height - 1 do
- table.insert(lines, '')
+ table.insert(lines, "")
end
- local last_line, padding = M.h_align(table.concat(opts.actions, ' '), 'center', width)
+ local last_line, padding = M.h_align(table.concat(opts.actions, " "), "center", width)
local col = padding
for _, action in ipairs(opts.actions) do
- table.insert(highlights, { 'Special', #lines, col, col + 3 })
+ table.insert(highlights, { "Special", #lines, col, col + 3 })
col = padding + action:len() + 4
end
table.insert(lines, last_line)
@@ -657,10 +656,10 @@ end
M.run_in_fullscreen_win = function(bufnr, callback)
if not bufnr then
bufnr = vim.api.nvim_create_buf(false, true)
- vim.bo[bufnr].bufhidden = 'wipe'
+ vim.bo[bufnr].bufhidden = "wipe"
end
local winid = vim.api.nvim_open_win(bufnr, false, {
- relative = 'editor',
+ relative = "editor",
width = vim.o.columns,
height = vim.o.lines,
row = 0,
@@ -668,19 +667,19 @@ M.run_in_fullscreen_win = function(bufnr, callback)
noautocmd = true,
})
local winnr = vim.api.nvim_win_get_number(winid)
- vim.cmd.wincmd({ count = winnr, args = { 'w' }, mods = { noautocmd = true } })
+ vim.cmd.wincmd({ count = winnr, args = { "w" }, mods = { noautocmd = true } })
callback()
vim.cmd.close({ count = winnr, mods = { noautocmd = true, emsg_silent = true } })
end
---@param bufnr integer
---@return boolean
-M.is_canola_bufnr = function(bufnr)
+M.is_oil_bufnr = function(bufnr)
local filetype = vim.bo[bufnr].filetype
- if filetype == 'canola' then
+ if filetype == "oil" then
return true
- elseif filetype ~= '' then
- -- If the filetype is set and is NOT "canola", then it's not an canola buffer
+ elseif filetype ~= "" then
+ -- If the filetype is set and is NOT "oil", then it's not an oil buffer
return false
end
local scheme = M.parse_url(vim.api.nvim_buf_get_name(bufnr))
@@ -694,10 +693,10 @@ M.hack_around_termopen_autocmd = function(prev_mode)
vim.defer_fn(function()
local new_mode = vim.api.nvim_get_mode().mode
if new_mode ~= prev_mode then
- if string.find(new_mode, 'i') == 1 then
- vim.api.nvim_feedkeys(vim.api.nvim_replace_termcodes('', true, true, true), 'n', false)
- if string.find(prev_mode, 'v') == 1 or string.find(prev_mode, 'V') == 1 then
- vim.cmd.normal({ bang = true, args = { 'gv' } })
+ if string.find(new_mode, "i") == 1 then
+ vim.api.nvim_feedkeys(vim.api.nvim_replace_termcodes("", true, true, true), "n", false)
+ if string.find(prev_mode, "v") == 1 or string.find(prev_mode, "V") == 1 then
+ vim.cmd.normal({ bang = true, args = { "gv" } })
end
end
end
@@ -713,7 +712,7 @@ M.get_preview_win = function(opts)
if
vim.api.nvim_win_is_valid(winid)
and vim.wo[winid].previewwindow
- and (opts.include_not_owned or vim.w[winid]['canola_preview'])
+ and (opts.include_not_owned or vim.w[winid]["oil_preview"])
then
return winid
end
@@ -722,13 +721,13 @@ end
---@return fun() restore Function that restores the cursor
M.hide_cursor = function()
- vim.api.nvim_set_hl(0, 'CanolaPreviewCursor', { nocombine = true, blend = 100 })
+ vim.api.nvim_set_hl(0, "OilPreviewCursor", { nocombine = true, blend = 100 })
local original_guicursor = vim.go.guicursor
- vim.go.guicursor = 'a:CanolaPreviewCursor/CanolaPreviewCursor'
+ vim.go.guicursor = "a:OilPreviewCursor/OilPreviewCursor"
return function()
-- HACK: see https://github.com/neovim/neovim/issues/21018
- vim.go.guicursor = 'a:'
+ vim.go.guicursor = "a:"
vim.cmd.redrawstatus()
vim.go.guicursor = original_guicursor
end
@@ -758,12 +757,12 @@ M.buf_get_win = function(bufnr, preferred_win)
return nil
end
----@param adapter canola.Adapter
+---@param adapter oil.Adapter
---@param url string
---@param opts {columns?: string[], no_cache?: boolean}
----@param callback fun(err: nil|string, entries: nil|canola.InternalEntry[])
+---@param callback fun(err: nil|string, entries: nil|oil.InternalEntry[])
M.adapter_list_all = function(adapter, url, opts, callback)
- local cache = require('canola.cache')
+ local cache = require("oil.cache")
if not opts.no_cache then
local entries = cache.list_url(url)
if not vim.tbl_isempty(entries) then
@@ -787,27 +786,27 @@ M.adapter_list_all = function(adapter, url, opts, callback)
end)
end
----Send files from the current canola directory to quickfix
+---Send files from the current oil directory to quickfix
---based on the provided options.
---@param opts {target?: "qflist"|"loclist", action?: "r"|"a", only_matching_search?: boolean}
M.send_to_quickfix = function(opts)
- if type(opts) ~= 'table' then
+ if type(opts) ~= "table" then
opts = {}
end
- local canola = require('canola')
- local dir = canola.get_current_dir()
- if type(dir) ~= 'string' then
+ local oil = require("oil")
+ local dir = oil.get_current_dir()
+ if type(dir) ~= "string" then
return
end
local range = M.get_visual_range()
if not range then
- range = { start_lnum = 1, end_lnum = vim.fn.line('$') }
+ range = { start_lnum = 1, end_lnum = vim.fn.line("$") }
end
local match_all = not opts.only_matching_search
local qf_entries = {}
for i = range.start_lnum, range.end_lnum do
- local entry = canola.get_entry_on_line(0, i)
- if entry and entry.type == 'file' and (match_all or M.is_matching(entry)) then
+ local entry = oil.get_entry_on_line(0, i)
+ if entry and entry.type == "file" and (match_all or M.is_matching(entry)) then
local qf_entry = {
filename = dir .. entry.name,
lnum = 1,
@@ -818,26 +817,26 @@ M.send_to_quickfix = function(opts)
end
end
if #qf_entries == 0 then
- vim.notify('[canola] No entries found to send to quickfix', vim.log.levels.WARN)
+ vim.notify("[oil] No entries found to send to quickfix", vim.log.levels.WARN)
return
end
- vim.api.nvim_exec_autocmds('QuickFixCmdPre', {})
- local qf_title = 'canola files'
- local action = opts.action == 'a' and 'a' or 'r'
- if opts.target == 'loclist' then
+ vim.api.nvim_exec_autocmds("QuickFixCmdPre", {})
+ local qf_title = "oil files"
+ local action = opts.action == "a" and "a" or "r"
+ if opts.target == "loclist" then
vim.fn.setloclist(0, {}, action, { title = qf_title, items = qf_entries })
vim.cmd.lopen()
else
vim.fn.setqflist({}, action, { title = qf_title, items = qf_entries })
vim.cmd.copen()
end
- vim.api.nvim_exec_autocmds('QuickFixCmdPost', {})
+ vim.api.nvim_exec_autocmds("QuickFixCmdPost", {})
end
---@return boolean
M.is_visual_mode = function()
local mode = vim.api.nvim_get_mode().mode
- return mode:match('^[vV]') ~= nil
+ return mode:match("^[vV]") ~= nil
end
---Get the current visual selection range. If not in visual mode, return nil.
@@ -848,7 +847,7 @@ M.get_visual_range = function()
end
-- This is the best way to get the visual selection at the moment
-- https://github.com/neovim/neovim/pull/13896
- local _, start_lnum, _, _ = unpack(vim.fn.getpos('v'))
+ local _, start_lnum, _, _ = unpack(vim.fn.getpos("v"))
local _, end_lnum, _, _, _ = unpack(vim.fn.getcurpos())
if start_lnum > end_lnum then
start_lnum, end_lnum = end_lnum, start_lnum
@@ -856,7 +855,7 @@ M.get_visual_range = function()
return { start_lnum = start_lnum, end_lnum = end_lnum }
end
----@param entry canola.Entry
+---@param entry oil.Entry
---@return boolean
M.is_matching = function(entry)
-- if search highlightig is not enabled, all files are considered to match
@@ -864,7 +863,7 @@ M.is_matching = function(entry)
if search_highlighting_is_off then
return true
end
- local pattern = vim.fn.getreg('/')
+ local pattern = vim.fn.getreg("/")
local position_of_match = vim.fn.match(entry.name, pattern)
return position_of_match ~= -1
end
@@ -875,11 +874,11 @@ M.run_after_load = function(bufnr, callback)
if bufnr == 0 then
bufnr = vim.api.nvim_get_current_buf()
end
- if vim.b[bufnr].canola_ready then
+ if vim.b[bufnr].oil_ready then
callback()
else
- vim.api.nvim_create_autocmd('User', {
- pattern = 'CanolaEnter',
+ vim.api.nvim_create_autocmd("User", {
+ pattern = "OilEnter",
callback = function(args)
if args.data.buf == bufnr then
vim.api.nvim_buf_call(bufnr, callback)
@@ -890,25 +889,25 @@ M.run_after_load = function(bufnr, callback)
end
end
----@param entry canola.Entry
+---@param entry oil.Entry
---@return boolean
M.is_directory = function(entry)
- local is_directory = entry.type == 'directory'
+ local is_directory = entry.type == "directory"
or (
- entry.type == 'link'
+ entry.type == "link"
and entry.meta
and entry.meta.link_stat
- and entry.meta.link_stat.type == 'directory'
+ and entry.meta.link_stat.type == "directory"
)
return is_directory == true
end
---Get the :edit path for an entry
----@param bufnr integer The canola buffer that contains the entry
----@param entry canola.Entry
+---@param bufnr integer The oil buffer that contains the entry
+---@param entry oil.Entry
---@param callback fun(normalized_url: string)
M.get_edit_path = function(bufnr, entry, callback)
- local pathutil = require('canola.pathutil')
+ local pathutil = require("oil.pathutil")
local bufname = vim.api.nvim_buf_get_name(bufnr)
local scheme, dir = M.parse_url(bufname)
@@ -917,10 +916,10 @@ M.get_edit_path = function(bufnr, entry, callback)
local url = scheme .. dir .. entry.name
if M.is_directory(entry) then
- url = url .. '/'
+ url = url .. "/"
end
- if entry.name == '..' then
+ if entry.name == ".." then
callback(scheme .. pathutil.parent(dir))
elseif adapter.get_entry_path then
adapter.get_entry_path(url, entry, callback)
@@ -930,74 +929,45 @@ M.get_edit_path = function(bufnr, entry, callback)
end
--- Check for an icon provider and return a common icon provider API
----@return (canola.IconProvider)?
+---@return (oil.IconProvider)?
M.get_icon_provider = function()
-- prefer mini.icons
- local _, mini_icons = pcall(require, 'mini.icons')
- -- selene: allow(global_usage)
+ local _, mini_icons = pcall(require, "mini.icons")
---@diagnostic disable-next-line: undefined-field
- if _G.MiniIcons then
+ if _G.MiniIcons then -- `_G.MiniIcons` is a better check to see if the module is setup
return function(type, name, conf, ft)
if ft then
- return mini_icons.get('filetype', ft)
+ return mini_icons.get("filetype", ft)
end
- return mini_icons.get(type == 'directory' and 'directory' or 'file', name)
+ return mini_icons.get(type == "directory" and "directory" or "file", name)
end
end
- local has_nonicons, nonicons = pcall(require, 'nonicons')
- if has_nonicons and nonicons.get_icon then
- local has_devicons, devicons = pcall(require, 'nvim-web-devicons')
- if not has_devicons then
- devicons = nil
- end
+ -- fallback to `nvim-web-devicons`
+ local has_devicons, devicons = pcall(require, "nvim-web-devicons")
+ if has_devicons then
return function(type, name, conf, ft)
- if type == 'directory' then
- local icon, hl = nonicons.get('file-directory-fill')
- return icon or (conf and conf.directory or ''), hl or 'CanolaDirIcon'
- end
- if ft then
- local ft_icon, ft_hl = nonicons.get_icon_by_filetype(ft)
- if ft_icon then
- return ft_icon, ft_hl or 'CanolaFileIcon'
+ if type == "directory" then
+ return conf and conf.directory or "", "OilDirIcon"
+ else
+ if ft then
+ local ft_icon, ft_hl = devicons.get_icon_by_filetype(ft)
+ if ft_icon and ft_icon ~= "" then
+ return ft_icon, ft_hl
+ end
end
+ local icon, hl = devicons.get_icon(name)
+ hl = hl or "OilFileIcon"
+ icon = icon or (conf and conf.default_file or "")
+ return icon, hl
end
- local icon, hl = nonicons.get_icon(name)
- if icon then
- return icon, hl or 'CanolaFileIcon'
- end
- local fallback, fallback_hl = nonicons.get('file')
- return fallback or (conf and conf.default_file or ''), fallback_hl or 'CanolaFileIcon'
- end
- end
-
- local has_devicons, devicons = pcall(require, 'nvim-web-devicons')
-
- if not has_devicons then
- return
- end
-
- return function(type, name, conf, ft)
- if type == 'directory' then
- return conf and conf.directory or '', 'CanolaDirIcon'
- else
- if ft then
- local ft_icon, ft_hl = devicons.get_icon_by_filetype(ft)
- if ft_icon and ft_icon ~= '' then
- return ft_icon, ft_hl
- end
- end
- local icon, hl = devicons.get_icon(name)
- hl = hl or 'CanolaFileIcon'
- icon = icon or (conf and conf.default_file or '')
- return icon, hl
end
end
end
---Read a buffer into a scratch buffer and apply syntactic highlighting when possible
---@param path string The path to the file to read
----@param preview_method canola.PreviewMethod
+---@param preview_method oil.PreviewMethod
---@return nil|integer
M.read_file_to_scratch_buffer = function(path, preview_method)
local bufnr = vim.api.nvim_create_buf(false, true)
@@ -1005,25 +975,24 @@ M.read_file_to_scratch_buffer = function(path, preview_method)
return
end
- vim.bo[bufnr].bufhidden = 'wipe'
- vim.bo[bufnr].buftype = 'nofile'
+ vim.bo[bufnr].bufhidden = "wipe"
+ vim.bo[bufnr].buftype = "nofile"
local has_lines, read_res
- if preview_method == 'fast_scratch' then
- has_lines, read_res = pcall(vim.fn.readfile, path, '', vim.o.lines)
+ if preview_method == "fast_scratch" then
+ has_lines, read_res = pcall(vim.fn.readfile, path, "", vim.o.lines)
else
has_lines, read_res = pcall(vim.fn.readfile, path)
end
- local lines = has_lines and vim.split(table.concat(read_res, '\n'), '\n') or {}
+ local lines = has_lines and vim.split(table.concat(read_res, "\n"), "\n") or {}
local ok = pcall(vim.api.nvim_buf_set_lines, bufnr, 0, -1, false, lines)
if not ok then
return
end
local ft = vim.filetype.match({ filename = path, buf = bufnr })
- if ft and ft ~= '' and vim.treesitter.language.get_lang then
+ if ft and ft ~= "" and vim.treesitter.language.get_lang then
local lang = vim.treesitter.language.get_lang(ft)
- -- selene: allow(empty_if)
if not pcall(vim.treesitter.start, bufnr, lang) then
vim.bo[bufnr].syntax = ft
else
@@ -1031,8 +1000,8 @@ M.read_file_to_scratch_buffer = function(path, preview_method)
end
-- Replace the scratch buffer with a real buffer if we enter it
- vim.api.nvim_create_autocmd('BufEnter', {
- desc = 'canola.nvim replace scratch buffer with real buffer',
+ vim.api.nvim_create_autocmd("BufEnter", {
+ desc = "oil.nvim replace scratch buffer with real buffer",
buffer = bufnr,
callback = function()
local winid = vim.api.nvim_get_current_win()
@@ -1044,8 +1013,8 @@ M.read_file_to_scratch_buffer = function(path, preview_method)
-- If we're still in a preview window, make sure this buffer still gets treated as a
-- preview
if vim.wo.previewwindow then
- vim.bo.bufhidden = 'wipe'
- vim.b.canola_preview_buffer = true
+ vim.bo.bufhidden = "wipe"
+ vim.b.oil_preview_buffer = true
end
end
end)
@@ -1061,7 +1030,7 @@ local _regcache = {}
---@return boolean
M.file_matches_bufreadcmd = function(filename)
local autocmds = vim.api.nvim_get_autocmds({
- event = 'BufReadCmd',
+ event = "BufReadCmd",
})
for _, au in ipairs(autocmds) do
local pat = _regcache[au.pattern]
diff --git a/lua/canola/view.lua b/lua/oil/view.lua
similarity index 72%
rename from lua/canola/view.lua
rename to lua/oil/view.lua
index 7a7ac89..bc21dfb 100644
--- a/lua/canola/view.lua
+++ b/lua/oil/view.lua
@@ -1,12 +1,12 @@
local uv = vim.uv or vim.loop
-local cache = require('canola.cache')
-local columns = require('canola.columns')
-local config = require('canola.config')
-local constants = require('canola.constants')
-local fs = require('canola.fs')
-local keymap_util = require('canola.keymap_util')
-local loading = require('canola.loading')
-local util = require('canola.util')
+local cache = require("oil.cache")
+local columns = require("oil.columns")
+local config = require("oil.config")
+local constants = require("oil.constants")
+local fs = require("oil.fs")
+local keymap_util = require("oil.keymap_util")
+local loading = require("oil.loading")
+local util = require("oil.util")
local M = {}
local FIELD_ID = constants.FIELD_ID
@@ -18,7 +18,7 @@ local FIELD_META = constants.FIELD_META
local last_cursor_entry = {}
---@param bufnr integer
----@param entry canola.InternalEntry
+---@param entry oil.InternalEntry
---@return boolean display
---@return boolean is_hidden Whether the file is classified as a hidden file
M.should_display = function(bufnr, entry)
@@ -41,7 +41,7 @@ end
---Set the cursor to the last_cursor_entry if one exists
M.maybe_set_cursor = function()
- local canola = require('canola')
+ local oil = require("oil")
local bufname = vim.api.nvim_buf_get_name(0)
local entry_name = last_cursor_entry[bufname]
if not entry_name then
@@ -49,10 +49,10 @@ M.maybe_set_cursor = function()
end
local line_count = vim.api.nvim_buf_line_count(0)
for lnum = 1, line_count do
- local entry = canola.get_entry_on_line(0, lnum)
+ local entry = oil.get_entry_on_line(0, lnum)
if entry and entry.name == entry_name then
local line = vim.api.nvim_buf_get_lines(0, lnum - 1, lnum, true)[1]
- local id_str = line:match('^/(%d+)')
+ local id_str = line:match("^/(%d+)")
local col = line:find(entry_name, 1, true) or (id_str:len() + 1)
vim.api.nvim_win_set_cursor(0, { lnum, col - 1 })
M.set_last_cursor(bufname, nil)
@@ -78,14 +78,14 @@ local function are_any_modified()
end
local function is_unix_executable(entry)
- if entry[FIELD_TYPE] == 'directory' then
+ if entry[FIELD_TYPE] == "directory" then
return false
end
local meta = entry[FIELD_META]
if not meta or not meta.stat then
return false
end
- if meta.stat.type == 'directory' then
+ if meta.stat.type == "directory" then
return false
end
@@ -98,51 +98,51 @@ end
M.toggle_hidden = function()
local any_modified = are_any_modified()
if any_modified then
- vim.notify('Cannot toggle hidden files when you have unsaved changes', vim.log.levels.WARN)
+ vim.notify("Cannot toggle hidden files when you have unsaved changes", vim.log.levels.WARN)
else
config.view_options.show_hidden = not config.view_options.show_hidden
- M.rerender_all_canola_buffers({ refetch = false })
+ M.rerender_all_oil_buffers({ refetch = false })
end
end
----@param is_hidden_file fun(filename: string, bufnr: integer, entry: canola.Entry): boolean
+---@param is_hidden_file fun(filename: string, bufnr: integer, entry: oil.Entry): boolean
M.set_is_hidden_file = function(is_hidden_file)
local any_modified = are_any_modified()
if any_modified then
- vim.notify('Cannot change is_hidden_file when you have unsaved changes', vim.log.levels.WARN)
+ vim.notify("Cannot change is_hidden_file when you have unsaved changes", vim.log.levels.WARN)
else
config.view_options.is_hidden_file = is_hidden_file
- M.rerender_all_canola_buffers({ refetch = false })
+ M.rerender_all_oil_buffers({ refetch = false })
end
end
M.set_columns = function(cols)
local any_modified = are_any_modified()
if any_modified then
- vim.notify('Cannot change columns when you have unsaved changes', vim.log.levels.WARN)
+ vim.notify("Cannot change columns when you have unsaved changes", vim.log.levels.WARN)
else
config.columns = cols
-- TODO only refetch if we don't have all the necessary data for the columns
- M.rerender_all_canola_buffers({ refetch = true })
+ M.rerender_all_oil_buffers({ refetch = true })
end
end
M.set_sort = function(new_sort)
local any_modified = are_any_modified()
if any_modified then
- vim.notify('Cannot change sorting when you have unsaved changes', vim.log.levels.WARN)
+ vim.notify("Cannot change sorting when you have unsaved changes", vim.log.levels.WARN)
else
config.view_options.sort = new_sort
-- TODO only refetch if we don't have all the necessary data for the columns
- M.rerender_all_canola_buffers({ refetch = true })
+ M.rerender_all_oil_buffers({ refetch = true })
end
end
----@class canola.ViewData
+---@class oil.ViewData
---@field fs_event? any uv_fs_event_t
-- List of bufnrs
----@type table
+---@type table
local session = {}
---@return integer[]
@@ -151,7 +151,7 @@ M.get_all_buffers = function()
end
local buffers_locked = false
----Make all canola buffers nomodifiable
+---Make all oil buffers nomodifiable
M.lock_buffers = function()
buffers_locked = true
for bufnr in pairs(session) do
@@ -161,7 +161,7 @@ M.lock_buffers = function()
end
end
----Restore normal modifiable settings for canola buffers
+---Restore normal modifiable settings for oil buffers
M.unlock_buffers = function()
buffers_locked = false
for bufnr in pairs(session) do
@@ -177,8 +177,8 @@ end
---@param opts? table
---@param callback? fun(err: nil|string)
---@note
---- This DISCARDS ALL MODIFICATIONS a user has made to canola buffers
-M.rerender_all_canola_buffers = function(opts, callback)
+--- This DISCARDS ALL MODIFICATIONS a user has made to oil buffers
+M.rerender_all_oil_buffers = function(opts, callback)
opts = opts or {}
local buffers = M.get_all_buffers()
local hidden_buffers = {}
@@ -193,7 +193,7 @@ M.rerender_all_canola_buffers = function(opts, callback)
local cb = util.cb_collect(#buffers, callback or function() end)
for _, bufnr in ipairs(buffers) do
if hidden_buffers[bufnr] then
- vim.b[bufnr].canola_dirty = opts
+ vim.b[bufnr].oil_dirty = opts
-- We also need to mark this as nomodified so it doesn't interfere with quitting vim
vim.bo[bufnr].modified = false
vim.schedule(cb)
@@ -207,19 +207,19 @@ M.set_win_options = function()
local winid = vim.api.nvim_get_current_win()
-- work around https://github.com/neovim/neovim/pull/27422
- vim.api.nvim_set_option_value('foldmethod', 'manual', { scope = 'local', win = winid })
+ vim.api.nvim_set_option_value("foldmethod", "manual", { scope = "local", win = winid })
for k, v in pairs(config.win_options) do
- vim.api.nvim_set_option_value(k, v, { scope = 'local', win = winid })
+ vim.api.nvim_set_option_value(k, v, { scope = "local", win = winid })
end
if vim.wo[winid].previewwindow then -- apply preview window options last
for k, v in pairs(config.preview_win.win_options) do
- vim.api.nvim_set_option_value(k, v, { scope = 'local', win = winid })
+ vim.api.nvim_set_option_value(k, v, { scope = "local", win = winid })
end
end
end
----Get a list of visible canola buffers and a list of hidden canola buffers
+---Get a list of visible oil buffers and a list of hidden oil buffers
---@note
--- If any buffers are modified, return values are nil
---@return nil|integer[] visible
@@ -244,14 +244,14 @@ local function get_visible_hidden_buffers()
return visible_buffers, vim.tbl_keys(hidden_buffers)
end
----Delete unmodified, hidden canola buffers and if none remain, clear the cache
+---Delete unmodified, hidden oil buffers and if none remain, clear the cache
M.delete_hidden_buffers = function()
local visible_buffers, hidden_buffers = get_visible_hidden_buffers()
if
not visible_buffers
or not hidden_buffers
or not vim.tbl_isempty(visible_buffers)
- or vim.fn.win_gettype() == 'command'
+ or vim.fn.win_gettype() == "command"
then
return
end
@@ -261,7 +261,7 @@ M.delete_hidden_buffers = function()
cache.clear_everything()
end
----@param adapter canola.Adapter
+---@param adapter oil.Adapter
---@param ranges table
---@return integer
local function get_first_mutable_column_col(adapter, ranges)
@@ -278,20 +278,20 @@ local function get_first_mutable_column_col(adapter, ranges)
end
--- @param bufnr integer
---- @param adapter canola.Adapter
+--- @param adapter oil.Adapter
--- @param mode false|"name"|"editable"
--- @param cur integer[]
--- @return integer[] | nil
local function calc_constrained_cursor_pos(bufnr, adapter, mode, cur)
- local parser = require('canola.mutator.parser')
+ local parser = require("oil.mutator.parser")
local line = vim.api.nvim_buf_get_lines(bufnr, cur[1] - 1, cur[1], true)[1]
local column_defs = columns.get_supported_columns(adapter)
local result = parser.parse_line(adapter, line, column_defs)
if result and result.ranges then
local min_col
- if mode == 'editable' then
+ if mode == "editable" then
min_col = get_first_mutable_column_col(adapter, result.ranges)
- elseif mode == 'name' then
+ elseif mode == "name" then
min_col = result.ranges.name[1]
else
error(string.format('Unexpected value "%s" for option constrain_cursor', mode))
@@ -318,7 +318,7 @@ local function constrain_cursor(bufnr, mode)
return
end
- local mc = package.loaded['multicursor-nvim']
+ local mc = package.loaded["multicursor-nvim"]
if mc then
mc.onSafeState(function()
mc.action(function(ctx)
@@ -340,98 +340,20 @@ local function constrain_cursor(bufnr, mode)
end
end
----@param bufnr integer
-local function show_insert_guide(bufnr)
- if not config.constrain_cursor then
- return
- end
- if bufnr ~= vim.api.nvim_get_current_buf() then
- return
- end
- local adapter = util.get_adapter(bufnr, true)
- if not adapter then
- return
- end
-
- local cur = vim.api.nvim_win_get_cursor(0)
- local current_line = vim.api.nvim_buf_get_lines(bufnr, cur[1] - 1, cur[1], true)[1]
- if current_line ~= '' then
- return
- end
-
- local all_lines = vim.api.nvim_buf_get_lines(bufnr, 0, -1, true)
- local ref_line
- if cur[1] > 1 and all_lines[cur[1] - 1] ~= '' then
- ref_line = all_lines[cur[1] - 1]
- elseif cur[1] < #all_lines and all_lines[cur[1] + 1] ~= '' then
- ref_line = all_lines[cur[1] + 1]
- else
- for i, line in ipairs(all_lines) do
- if line ~= '' and i ~= cur[1] then
- ref_line = line
- break
- end
- end
- end
- if not ref_line then
- return
- end
-
- local parser = require('canola.mutator.parser')
- local column_defs = columns.get_supported_columns(adapter)
- local result = parser.parse_line(adapter, ref_line, column_defs)
- if not result or not result.ranges then
- return
- end
-
- local id_end = result.ranges.id[2] + 1
- local col_prefix = ref_line:sub(id_end + 1, result.ranges.name[1])
- local col_width = vim.api.nvim_strwidth(col_prefix)
- local id_width
- local cole = vim.wo.conceallevel
- if cole >= 2 then
- id_width = 0
- elseif cole == 1 then
- id_width = 1
- else
- id_width = vim.api.nvim_strwidth(ref_line:sub(1, id_end))
- end
- local virtual_col = id_width + col_width
- if virtual_col <= 0 then
- return
- end
-
- vim.w.canola_saved_ve = vim.wo.virtualedit
- vim.wo.virtualedit = 'all'
- vim.api.nvim_win_set_cursor(0, { cur[1], virtual_col })
-
- vim.api.nvim_create_autocmd('TextChangedI', {
- group = 'Canola',
- buffer = bufnr,
- once = true,
- callback = function()
- if vim.w.canola_saved_ve ~= nil then
- vim.wo.virtualedit = vim.w.canola_saved_ve
- vim.w.canola_saved_ve = nil
- end
- end,
- })
-end
-
---Redraw original path virtual text for trash buffer
---@param bufnr integer
local function redraw_trash_virtual_text(bufnr)
if not vim.api.nvim_buf_is_valid(bufnr) or not vim.api.nvim_buf_is_loaded(bufnr) then
return
end
- local parser = require('canola.mutator.parser')
+ local parser = require("oil.mutator.parser")
local adapter = util.get_adapter(bufnr, true)
- if not adapter or adapter.name ~= 'trash' then
+ if not adapter or adapter.name ~= "trash" then
return
end
local _, buf_path = util.parse_url(vim.api.nvim_buf_get_name(bufnr))
local os_path = fs.posix_to_os_path(assert(buf_path))
- local ns = vim.api.nvim_create_namespace('CanolaVtext')
+ local ns = vim.api.nvim_create_namespace("OilVtext")
vim.api.nvim_buf_clear_namespace(bufnr, ns, 0, -1)
local column_defs = columns.get_supported_columns(adapter)
for lnum, line in ipairs(vim.api.nvim_buf_get_lines(bufnr, 0, -1, true)) do
@@ -439,14 +361,14 @@ local function redraw_trash_virtual_text(bufnr)
local entry = result and result.entry
if entry then
local meta = entry[FIELD_META]
- ---@type nil|canola.TrashInfo
+ ---@type nil|oil.TrashInfo
local trash_info = meta and meta.trash_info
if trash_info then
vim.api.nvim_buf_set_extmark(bufnr, ns, lnum - 1, 0, {
virt_text = {
{
- '➜ ' .. fs.shorten_path(trash_info.original_path, os_path),
- 'CanolaTrashSourcePath',
+ "➜ " .. fs.shorten_path(trash_info.original_path, os_path),
+ "OilTrashSourcePath",
},
},
})
@@ -465,13 +387,13 @@ M.initialize = function(bufnr)
end
vim.api.nvim_clear_autocmds({
buffer = bufnr,
- group = 'Canola',
+ group = "Oil",
})
- vim.bo[bufnr].buftype = 'acwrite'
+ vim.bo[bufnr].buftype = "acwrite"
vim.bo[bufnr].readonly = false
vim.bo[bufnr].swapfile = false
- vim.bo[bufnr].syntax = 'canola'
- vim.bo[bufnr].filetype = 'canola'
+ vim.bo[bufnr].syntax = "oil"
+ vim.bo[bufnr].filetype = "oil"
vim.b[bufnr].EditorConfig_disable = 1
session[bufnr] = session[bufnr] or {}
for k, v in pairs(config.buf_options) do
@@ -479,19 +401,19 @@ M.initialize = function(bufnr)
end
vim.api.nvim_buf_call(bufnr, M.set_win_options)
- vim.api.nvim_create_autocmd('BufHidden', {
- desc = 'Delete canola buffers when no longer in use',
- group = 'Canola',
+ vim.api.nvim_create_autocmd("BufHidden", {
+ desc = "Delete oil buffers when no longer in use",
+ group = "Oil",
nested = true,
buffer = bufnr,
callback = function()
-- First wait a short time (100ms) for the buffer change to settle
vim.defer_fn(function()
local visible_buffers = get_visible_hidden_buffers()
- -- Only delete canola buffers if none of them are visible
+ -- Only delete oil buffers if none of them are visible
if visible_buffers and vim.tbl_isempty(visible_buffers) then
-- Check if cleanup is enabled
- if type(config.cleanup_delay_ms) == 'number' then
+ if type(config.cleanup_delay_ms) == "number" then
if config.cleanup_delay_ms > 0 then
vim.defer_fn(function()
M.delete_hidden_buffers()
@@ -504,8 +426,8 @@ M.initialize = function(bufnr)
end, 100)
end,
})
- vim.api.nvim_create_autocmd('BufUnload', {
- group = 'Canola',
+ vim.api.nvim_create_autocmd("BufUnload", {
+ group = "Oil",
nested = true,
once = true,
buffer = bufnr,
@@ -517,47 +439,34 @@ M.initialize = function(bufnr)
end
end,
})
- vim.api.nvim_create_autocmd('BufEnter', {
- group = 'Canola',
+ vim.api.nvim_create_autocmd("BufEnter", {
+ group = "Oil",
buffer = bufnr,
callback = function(args)
- local opts = vim.b[args.buf].canola_dirty
+ local opts = vim.b[args.buf].oil_dirty
if opts then
- vim.b[args.buf].canola_dirty = nil
+ vim.b[args.buf].oil_dirty = nil
M.render_buffer_async(args.buf, opts)
end
end,
})
local timer
- vim.api.nvim_create_autocmd('InsertEnter', {
- desc = 'Constrain canola cursor position',
- group = 'Canola',
+ vim.api.nvim_create_autocmd("InsertEnter", {
+ desc = "Constrain oil cursor position",
+ group = "Oil",
buffer = bufnr,
callback = function()
-- For some reason the cursor bounces back to its original position,
-- so we have to defer the call
- vim.schedule(function()
- constrain_cursor(bufnr, config.constrain_cursor)
- show_insert_guide(bufnr)
- end)
+ vim.schedule_wrap(constrain_cursor)(bufnr, config.constrain_cursor)
end,
})
- vim.api.nvim_create_autocmd('InsertLeave', {
- group = 'Canola',
+ vim.api.nvim_create_autocmd({ "CursorMoved", "ModeChanged" }, {
+ desc = "Update oil preview window",
+ group = "Oil",
buffer = bufnr,
callback = function()
- if vim.w.canola_saved_ve ~= nil then
- vim.wo.virtualedit = vim.w.canola_saved_ve
- vim.w.canola_saved_ve = nil
- end
- end,
- })
- vim.api.nvim_create_autocmd({ 'CursorMoved', 'ModeChanged' }, {
- desc = 'Update canola preview window',
- group = 'Canola',
- buffer = bufnr,
- callback = function()
- local canola = require('canola')
+ local oil = require("oil")
if vim.wo.previewwindow then
return
end
@@ -582,14 +491,14 @@ M.initialize = function(bufnr)
if vim.api.nvim_get_current_buf() ~= bufnr then
return
end
- local entry = canola.get_cursor_entry()
+ local entry = oil.get_cursor_entry()
-- Don't update in visual mode. Visual mode implies editing not browsing,
-- and updating the preview can cause flicker and stutter.
if entry and not util.is_visual_mode() then
local winid = util.get_preview_win()
if winid then
- if entry.id ~= vim.w[winid].canola_entry_id then
- canola.open_preview()
+ if entry.id ~= vim.w[winid].oil_entry_id then
+ oil.open_preview()
end
end
end
@@ -604,7 +513,7 @@ M.initialize = function(bufnr)
-- Set up a watcher that will refresh the directory
if
adapter
- and adapter.name == 'files'
+ and adapter.name == "files"
and config.watch_for_changes
and not session[bufnr].fs_event
then
@@ -623,8 +532,8 @@ M.initialize = function(bufnr)
fs_event:stop()
return
end
- local mutator = require('canola.mutator')
- if err or vim.bo[bufnr].modified or vim.b[bufnr].canola_dirty or mutator.is_mutating() then
+ local mutator = require("oil.mutator")
+ if err or vim.bo[bufnr].modified or vim.b[bufnr].oil_dirty or mutator.is_mutating() then
return
end
@@ -637,18 +546,18 @@ M.initialize = function(bufnr)
end
-- If it is not currently visible, mark it as dirty
- vim.b[bufnr].canola_dirty = {}
+ vim.b[bufnr].oil_dirty = {}
end)
)
session[bufnr].fs_event = fs_event
end
-- Watch for TextChanged and update the trash original path extmarks
- if adapter and adapter.name == 'trash' then
+ if adapter and adapter.name == "trash" then
local debounce_timer = assert(uv.new_timer())
local pending = false
- vim.api.nvim_create_autocmd('TextChanged', {
- desc = 'Update canola virtual text of original path',
+ vim.api.nvim_create_autocmd("TextChanged", {
+ desc = "Update oil virtual text of original path",
buffer = bufnr,
callback = function()
-- Respond immediately to prevent flickering, the set the timer for a "cooldown period"
@@ -674,35 +583,35 @@ M.initialize = function(bufnr)
M.render_buffer_async(bufnr, {}, function(err)
if err then
vim.notify(
- string.format('Error rendering canola buffer %s: %s', vim.api.nvim_buf_get_name(bufnr), err),
+ string.format("Error rendering oil buffer %s: %s", vim.api.nvim_buf_get_name(bufnr), err),
vim.log.levels.ERROR
)
else
- vim.b[bufnr].canola_ready = true
+ vim.b[bufnr].oil_ready = true
vim.api.nvim_exec_autocmds(
- 'User',
- { pattern = 'CanolaEnter', modeline = false, data = { buf = bufnr } }
+ "User",
+ { pattern = "OilEnter", modeline = false, data = { buf = bufnr } }
)
end
end)
keymap_util.set_keymaps(config.keymaps, bufnr)
end
----@param adapter canola.Adapter
+---@param adapter oil.Adapter
---@param num_entries integer
----@return fun(a: canola.InternalEntry, b: canola.InternalEntry): boolean
+---@return fun(a: oil.InternalEntry, b: oil.InternalEntry): boolean
local function get_sort_function(adapter, num_entries)
local idx_funs = {}
local sort_config = config.view_options.sort
-- If empty, default to type + name sorting
if vim.tbl_isempty(sort_config) then
- sort_config = { { 'type', 'asc' }, { 'name', 'asc' } }
+ sort_config = { { "type", "asc" }, { "name", "asc" } }
end
for _, sort_pair in ipairs(sort_config) do
local col_name, order = unpack(sort_pair)
- if order ~= 'asc' and order ~= 'desc' then
+ if order ~= "asc" and order ~= "desc" then
vim.notify_once(
string.format(
"Column '%s' has invalid sort order '%s'. Should be either 'asc' or 'desc'",
@@ -730,7 +639,7 @@ local function get_sort_function(adapter, num_entries)
local a_val = get_sort_value(a)
local b_val = get_sort_value(b)
if a_val ~= b_val then
- if order == 'desc' then
+ if order == "desc" then
return a_val > b_val
else
return a_val < b_val
@@ -754,7 +663,7 @@ local function render_buffer(bufnr, opts)
return false
end
local bufname = vim.api.nvim_buf_get_name(bufnr)
- opts = vim.tbl_extend('keep', opts or {}, {
+ opts = vim.tbl_extend("keep", opts or {}, {
jump = false,
jump_first = false,
})
@@ -767,7 +676,7 @@ local function render_buffer(bufnr, opts)
local entry_list = vim.tbl_values(entries)
-- Only sort the entries once we have them all
- if not vim.b[bufnr].canola_rendering then
+ if not vim.b[bufnr].oil_rendering then
table.sort(entry_list, get_sort_function(adapter, #entry_list))
end
@@ -784,10 +693,10 @@ local function render_buffer(bufnr, opts)
for i, col_def in ipairs(column_defs) do
col_width[i + 1] = 1
local _, conf = util.split_config(col_def)
- col_align[i + 1] = conf and conf.align or 'left'
+ col_align[i + 1] = conf and conf.align or "left"
end
- local parent_entry = { 0, '..', 'directory' }
+ local parent_entry = { 0, "..", "directory" }
if M.should_display(bufnr, parent_entry) then
local cols = M.format_entry_cols(parent_entry, column_defs, col_width, adapter, true, bufnr)
table.insert(line_table, cols)
@@ -807,21 +716,6 @@ local function render_buffer(bufnr, opts)
end
end
- if config.view_options.show_hidden_when_empty and #line_table <= 1 then
- for _, entry in ipairs(entry_list) do
- local name = entry[FIELD_NAME]
- local public_entry = util.export_entry(entry)
- if not config.view_options.is_always_hidden(name, bufnr, public_entry) then
- local cols = M.format_entry_cols(entry, column_defs, col_width, adapter, true, bufnr)
- table.insert(line_table, cols)
- if seek_after_render == name then
- seek_after_render_found = true
- jump_idx = #line_table
- end
- end
- end
- end
-
local lines, highlights = util.render_table(line_table, col_width, col_align)
vim.bo[bufnr].modifiable = true
@@ -838,7 +732,7 @@ local function render_buffer(bufnr, opts)
if jump_idx then
local lnum = jump_idx
local line = vim.api.nvim_buf_get_lines(bufnr, lnum - 1, lnum, true)[1]
- local id_str = line:match('^/(%d+)')
+ local id_str = line:match("^/(%d+)")
local id = tonumber(id_str)
if id then
local entry = cache.get_entry_by_id(id)
@@ -851,7 +745,7 @@ local function render_buffer(bufnr, opts)
end
end
- constrain_cursor(bufnr, 'name')
+ constrain_cursor(bufnr, "name")
end
end
end)
@@ -866,13 +760,13 @@ end
local function get_link_text(name, meta)
local link_text
if meta then
- if meta.link_stat and meta.link_stat.type == 'directory' then
- name = name .. '/'
+ if meta.link_stat and meta.link_stat.type == "directory" then
+ name = name .. "/"
end
if meta.link then
- link_text = '-> ' .. meta.link:gsub('\n', '')
- if meta.link_stat and meta.link_stat.type == 'directory' then
+ link_text = "-> " .. meta.link:gsub("\n", "")
+ if meta.link_stat and meta.link_stat.type == "directory" then
link_text = util.addslash(link_text)
end
end
@@ -882,25 +776,25 @@ local function get_link_text(name, meta)
end
---@private
----@param entry canola.InternalEntry
+---@param entry oil.InternalEntry
---@param column_defs table[]
---@param col_width integer[]
----@param adapter canola.Adapter
+---@param adapter oil.Adapter
---@param is_hidden boolean
---@param bufnr integer
----@return canola.TextChunk[]
+---@return oil.TextChunk[]
M.format_entry_cols = function(entry, column_defs, col_width, adapter, is_hidden, bufnr)
local name = entry[FIELD_NAME]
local meta = entry[FIELD_META]
- local hl_suffix = ''
+ local hl_suffix = ""
if is_hidden then
- hl_suffix = 'Hidden'
+ hl_suffix = "Hidden"
end
if meta and meta.display_name then
name = meta.display_name
end
-- We can't handle newlines in filenames (and shame on you for doing that)
- name = name:gsub('\n', '')
+ name = name:gsub("\n", "")
-- First put the unique ID
local cols = {}
local id_key = cache.format_id(entry[FIELD_ID])
@@ -909,7 +803,7 @@ M.format_entry_cols = function(entry, column_defs, col_width, adapter, is_hidden
-- Then add all the configured columns
for i, column in ipairs(column_defs) do
local chunk = columns.render_col(adapter, column, entry, bufnr)
- local text = type(chunk) == 'table' and chunk[1] or chunk
+ local text = type(chunk) == "table" and chunk[1] or chunk
---@cast text string
col_width[i + 1] = math.max(col_width[i + 1], vim.api.nvim_strwidth(text))
table.insert(cols, chunk)
@@ -922,7 +816,7 @@ M.format_entry_cols = function(entry, column_defs, col_width, adapter, is_hidden
if get_custom_hl then
local external_entry = util.export_entry(entry)
- if entry_type == 'link' then
+ if entry_type == "link" then
link_name, link_target = get_link_text(name, meta)
local is_orphan = not (meta and meta.link_stat)
link_name_hl = get_custom_hl(external_entry, is_hidden, false, is_orphan, bufnr)
@@ -936,8 +830,8 @@ M.format_entry_cols = function(entry, column_defs, col_width, adapter, is_hidden
local hl = get_custom_hl(external_entry, is_hidden, false, false, bufnr)
if hl then
-- Add the trailing / if this is a directory, this is important
- if entry_type == 'directory' then
- name = name .. '/'
+ if entry_type == "directory" then
+ name = name .. "/"
end
table.insert(cols, { name, hl })
return cols
@@ -946,50 +840,49 @@ M.format_entry_cols = function(entry, column_defs, col_width, adapter, is_hidden
end
local highlight_as_executable = false
- if entry_type ~= 'directory' then
+ if entry_type ~= "directory" then
local lower = name:lower()
if
- lower:match('%.exe$')
- or lower:match('%.bat$')
- or lower:match('%.cmd$')
- or lower:match('%.com$')
- or lower:match('%.ps1$')
+ lower:match("%.exe$")
+ or lower:match("%.bat$")
+ or lower:match("%.cmd$")
+ or lower:match("%.com$")
+ or lower:match("%.ps1$")
then
highlight_as_executable = true
- -- selene: allow(if_same_then_else)
elseif is_unix_executable(entry) then
highlight_as_executable = true
end
end
- if entry_type == 'directory' then
- table.insert(cols, { name .. '/', 'CanolaDir' .. hl_suffix })
- elseif entry_type == 'socket' then
- table.insert(cols, { name, 'CanolaSocket' .. hl_suffix })
- elseif entry_type == 'link' then
+ if entry_type == "directory" then
+ table.insert(cols, { name .. "/", "OilDir" .. hl_suffix })
+ elseif entry_type == "socket" then
+ table.insert(cols, { name, "OilSocket" .. hl_suffix })
+ elseif entry_type == "link" then
if not link_name then
link_name, link_target = get_link_text(name, meta)
end
local is_orphan = not (meta and meta.link_stat)
if not link_name_hl then
if highlight_as_executable then
- link_name_hl = 'CanolaExecutable' .. hl_suffix
+ link_name_hl = "OilExecutable" .. hl_suffix
else
- link_name_hl = (is_orphan and 'CanolaOrphanLink' or 'CanolaLink') .. hl_suffix
+ link_name_hl = (is_orphan and "OilOrphanLink" or "OilLink") .. hl_suffix
end
end
table.insert(cols, { link_name, link_name_hl })
if link_target then
if not link_target_hl then
- link_target_hl = (is_orphan and 'CanolaOrphanLinkTarget' or 'CanolaLinkTarget') .. hl_suffix
+ link_target_hl = (is_orphan and "OilOrphanLinkTarget" or "OilLinkTarget") .. hl_suffix
end
table.insert(cols, { link_target, link_target_hl })
end
elseif highlight_as_executable then
- table.insert(cols, { name, 'CanolaExecutable' .. hl_suffix })
+ table.insert(cols, { name, "OilExecutable" .. hl_suffix })
else
- table.insert(cols, { name, 'CanolaFile' .. hl_suffix })
+ table.insert(cols, { name, "OilFile" .. hl_suffix })
end
return cols
@@ -1021,8 +914,8 @@ M.render_buffer_async = function(bufnr, opts, caller_callback)
local function callback(err)
if not err then
vim.api.nvim_exec_autocmds(
- 'User',
- { pattern = 'CanolaReadPost', modeline = false, data = { buf = bufnr } }
+ "User",
+ { pattern = "OilReadPost", modeline = false, data = { buf = bufnr } }
)
end
if caller_callback then
@@ -1030,7 +923,7 @@ M.render_buffer_async = function(bufnr, opts, caller_callback)
end
end
- opts = vim.tbl_deep_extend('keep', opts or {}, {
+ opts = vim.tbl_deep_extend("keep", opts or {}, {
refetch = true,
})
---@cast opts -nil
@@ -1039,7 +932,7 @@ M.render_buffer_async = function(bufnr, opts, caller_callback)
end
-- If we're already rendering, queue up another rerender after it's complete
- if vim.b[bufnr].canola_rendering then
+ if vim.b[bufnr].oil_rendering then
if not pending_renders[bufnr] then
pending_renders[bufnr] = { callback }
elseif callback then
@@ -1049,15 +942,15 @@ M.render_buffer_async = function(bufnr, opts, caller_callback)
end
local bufname = vim.api.nvim_buf_get_name(bufnr)
- vim.b[bufnr].canola_rendering = true
+ vim.b[bufnr].oil_rendering = true
local _, dir = util.parse_url(bufname)
-- Undo should not return to a blank buffer
-- Method taken from :h clear-undo
vim.bo[bufnr].undolevels = -1
local handle_error = vim.schedule_wrap(function(message)
- vim.b[bufnr].canola_rendering = false
- vim.bo[bufnr].undolevels = vim.api.nvim_get_option_value('undolevels', { scope = 'global' })
- util.render_text(bufnr, { 'Error: ' .. message })
+ vim.b[bufnr].oil_rendering = false
+ vim.bo[bufnr].undolevels = vim.api.nvim_get_option_value("undolevels", { scope = "global" })
+ util.render_text(bufnr, { "Error: " .. message })
if pending_renders[bufnr] then
for _, cb in ipairs(pending_renders[bufnr]) do
cb(message)
@@ -1071,12 +964,12 @@ M.render_buffer_async = function(bufnr, opts, caller_callback)
end
end)
if not dir then
- handle_error(string.format("Could not parse canola url '%s'", bufname))
+ handle_error(string.format("Could not parse oil url '%s'", bufname))
return
end
local adapter = util.get_adapter(bufnr, true)
if not adapter then
- handle_error(string.format("[canola] no adapter for buffer '%s'", bufname))
+ handle_error(string.format("[oil] no adapter for buffer '%s'", bufname))
return
end
local start_ms = uv.hrtime() / 1e6
@@ -1090,11 +983,11 @@ M.render_buffer_async = function(bufnr, opts, caller_callback)
if not vim.api.nvim_buf_is_valid(bufnr) then
return
end
- vim.b[bufnr].canola_rendering = false
+ vim.b[bufnr].oil_rendering = false
loading.set_loading(bufnr, false)
render_buffer(bufnr, { jump = true })
M.set_last_cursor(bufname, nil)
- vim.bo[bufnr].undolevels = vim.api.nvim_get_option_value('undolevels', { scope = 'global' })
+ vim.bo[bufnr].undolevels = vim.api.nvim_get_option_value("undolevels", { scope = "global" })
vim.bo[bufnr].modifiable = not buffers_locked and adapter.is_modifiable(bufnr)
if callback then
callback()
diff --git a/lua/resession/extensions/canola.lua b/lua/resession/extensions/oil.lua
similarity index 76%
rename from lua/resession/extensions/canola.lua
rename to lua/resession/extensions/oil.lua
index 8bbfe86..427843d 100644
--- a/lua/resession/extensions/canola.lua
+++ b/lua/resession/extensions/oil.lua
@@ -1,7 +1,7 @@
local M = {}
M.is_win_supported = function(winid, bufnr)
- return vim.bo[bufnr].filetype == 'canola'
+ return vim.bo[bufnr].filetype == "oil"
end
M.save_win = function(winid)
@@ -11,7 +11,7 @@ M.save_win = function(winid)
end
M.load_win = function(winid, config)
- require('canola').open(config.bufname)
+ require("oil").open(config.bufname)
end
return M
diff --git a/perf/bootstrap.lua b/perf/bootstrap.lua
index 86c170e..5f10c06 100644
--- a/perf/bootstrap.lua
+++ b/perf/bootstrap.lua
@@ -1,11 +1,11 @@
-vim.opt.runtimepath:prepend('scripts/benchmark.nvim')
-vim.opt.runtimepath:prepend('.')
+vim.opt.runtimepath:prepend("scripts/benchmark.nvim")
+vim.opt.runtimepath:prepend(".")
-local bm = require('benchmark')
+local bm = require("benchmark")
bm.sandbox()
----@module 'canola'
----@type canola.SetupOpts
+---@module 'oil'
+---@type oil.SetupOpts
local setup_opts = {
-- columns = { "icon", "permissions", "size", "mtime" },
}
@@ -14,53 +14,50 @@ local DIR_SIZE = tonumber(vim.env.DIR_SIZE) or 100000
local ITERATIONS = tonumber(vim.env.ITERATIONS) or 10
local WARM_UP = tonumber(vim.env.WARM_UP) or 1
local OUTLIERS = tonumber(vim.env.OUTLIERS) or math.floor(ITERATIONS / 10)
-local TEST_DIR = 'perf/tmp/test_' .. DIR_SIZE
+local TEST_DIR = "perf/tmp/test_" .. DIR_SIZE
-vim.fn.mkdir(TEST_DIR, 'p')
-require('benchmark.files').create_files(TEST_DIR, 'file %d.txt', DIR_SIZE)
+vim.fn.mkdir(TEST_DIR, "p")
+require("benchmark.files").create_files(TEST_DIR, "file %d.txt", DIR_SIZE)
--- selene: allow(global_usage)
function _G.jit_profile()
- require('canola').setup(setup_opts)
- local finish = bm.jit_profile({ filename = TEST_DIR .. '/profile.txt' })
- bm.wait_for_user_event('CanolaEnter', function()
+ require("oil").setup(setup_opts)
+ local finish = bm.jit_profile({ filename = TEST_DIR .. "/profile.txt" })
+ bm.wait_for_user_event("OilEnter", function()
finish()
end)
- require('canola').open(TEST_DIR)
+ require("oil").open(TEST_DIR)
end
--- selene: allow(global_usage)
function _G.flame_profile()
local start, stop = bm.flame_profile({
- pattern = 'canola*',
- filename = 'profile.json',
+ pattern = "oil*",
+ filename = "profile.json",
})
- require('canola').setup(setup_opts)
+ require("oil").setup(setup_opts)
start()
- bm.wait_for_user_event('CanolaEnter', function()
+ bm.wait_for_user_event("OilEnter", function()
stop(function()
vim.cmd.qall({ mods = { silent = true } })
end)
end)
- require('canola').open(TEST_DIR)
+ require("oil").open(TEST_DIR)
end
--- selene: allow(global_usage)
function _G.benchmark()
- require('canola').setup(setup_opts)
- bm.run({ title = 'canola.nvim', iterations = ITERATIONS, warm_up = WARM_UP }, function(callback)
- bm.wait_for_user_event('CanolaEnter', callback)
- require('canola').open(TEST_DIR)
+ require("oil").setup(setup_opts)
+ bm.run({ title = "oil.nvim", iterations = ITERATIONS, warm_up = WARM_UP }, function(callback)
+ bm.wait_for_user_event("OilEnter", callback)
+ require("oil").open(TEST_DIR)
end, function(times)
local avg = bm.avg(times, { trim_outliers = OUTLIERS })
local std_dev = bm.std_dev(times, { trim_outliers = OUTLIERS })
local lines = {
- table.concat(vim.tbl_map(bm.format_time, times), ' '),
- string.format('Average: %s', bm.format_time(avg)),
- string.format('Std deviation: %s', bm.format_time(std_dev)),
+ table.concat(vim.tbl_map(bm.format_time, times), " "),
+ string.format("Average: %s", bm.format_time(avg)),
+ string.format("Std deviation: %s", bm.format_time(std_dev)),
}
- vim.fn.writefile(lines, 'perf/tmp/benchmark.txt')
+ vim.fn.writefile(lines, "perf/tmp/benchmark.txt")
vim.cmd.qall({ mods = { silent = true } })
end)
end
diff --git a/plugin/canola.lua b/plugin/canola.lua
deleted file mode 100644
index ee1c0b7..0000000
--- a/plugin/canola.lua
+++ /dev/null
@@ -1,3 +0,0 @@
-if vim.g.canola ~= nil then
- require('canola').setup()
-end
diff --git a/plugin/oil.lua b/plugin/oil.lua
new file mode 100644
index 0000000..2b1c352
--- /dev/null
+++ b/plugin/oil.lua
@@ -0,0 +1,3 @@
+if vim.g.oil ~= nil then
+ require("oil").setup()
+end
diff --git a/run_tests.sh b/run_tests.sh
new file mode 100755
index 0000000..3018bc0
--- /dev/null
+++ b/run_tests.sh
@@ -0,0 +1,24 @@
+#!/usr/bin/env bash
+set -e
+
+mkdir -p ".testenv/config/nvim"
+mkdir -p ".testenv/data/nvim"
+mkdir -p ".testenv/state/nvim"
+mkdir -p ".testenv/run/nvim"
+mkdir -p ".testenv/cache/nvim"
+PLUGINS=".testenv/data/nvim/site/pack/plugins/start"
+
+if [ ! -e "$PLUGINS/plenary.nvim" ]; then
+ git clone --depth=1 https://github.com/nvim-lua/plenary.nvim.git "$PLUGINS/plenary.nvim"
+else
+ (cd "$PLUGINS/plenary.nvim" && git pull)
+fi
+
+XDG_CONFIG_HOME=".testenv/config" \
+ XDG_DATA_HOME=".testenv/data" \
+ XDG_STATE_HOME=".testenv/state" \
+ XDG_RUNTIME_DIR=".testenv/run" \
+ XDG_CACHE_HOME=".testenv/cache" \
+ nvim --headless -u tests/minimal_init.lua \
+ -c "PlenaryBustedDirectory ${1-tests} { minimal_init = './tests/minimal_init.lua' }"
+echo "Success"
diff --git a/scripts/ci.sh b/scripts/ci.sh
deleted file mode 100755
index 7714909..0000000
--- a/scripts/ci.sh
+++ /dev/null
@@ -1,9 +0,0 @@
-#!/bin/sh
-set -eu
-
-nix develop --command stylua --check lua spec
-git ls-files '*.lua' | xargs nix develop --command selene --display-style quiet
-nix develop --command prettier --check .
-nix fmt
-git diff --exit-code -- '*.nix'
-nix develop --command busted
diff --git a/selene.toml b/selene.toml
index 7f40a3f..96cf5ab 100644
--- a/selene.toml
+++ b/selene.toml
@@ -1,7 +1 @@
std = 'vim'
-exclude = [".direnv/*"]
-
-[lints]
-mixed_table = 'allow'
-unused_variable = 'allow'
-bad_string_escape = 'allow'
diff --git a/spec/altbuf_spec.lua b/spec/altbuf_spec.lua
deleted file mode 100644
index b74a5e2..0000000
--- a/spec/altbuf_spec.lua
+++ /dev/null
@@ -1,150 +0,0 @@
-local canola = require('canola')
-local fs = require('canola.fs')
-local test_util = require('spec.test_util')
-
-describe('Alternate buffer', function()
- after_each(function()
- test_util.reset_editor()
- end)
-
- it('sets previous buffer as alternate', function()
- vim.cmd.edit({ args = { 'foo' } })
- canola.open()
- test_util.wait_for_autocmd({ 'User', pattern = 'CanolaEnter' })
- vim.cmd.edit({ args = { 'bar' } })
- assert.equals('foo', vim.fn.expand('#'))
- end)
-
- it('sets previous buffer as alternate when editing url file', function()
- vim.cmd.edit({ args = { 'foo' } })
- canola.open()
- test_util.wait_for_autocmd({ 'User', pattern = 'CanolaEnter' })
- local readme = fs.join(vim.fn.getcwd(), 'README.md')
- vim.cmd.edit({ args = { 'canola://' .. fs.os_to_posix_path(readme) } })
- test_util.wait_for_autocmd('BufEnter')
- assert.equals(readme, vim.api.nvim_buf_get_name(0))
- assert.equals('foo', vim.fn.expand('#'))
- end)
-
- it('sets previous buffer as alternate when editing canola://', function()
- vim.cmd.edit({ args = { 'foo' } })
- vim.cmd.edit({ args = { 'canola://' .. fs.os_to_posix_path(vim.fn.getcwd()) } })
- test_util.wait_for_autocmd({ 'User', pattern = 'CanolaEnter' })
- vim.cmd.edit({ args = { 'bar' } })
- assert.equals('foo', vim.fn.expand('#'))
- end)
-
- it('preserves alternate buffer if editing the same file', function()
- vim.cmd.edit({ args = { 'foo' } })
- vim.cmd.edit({ args = { 'bar' } })
- canola.open()
- test_util.wait_for_autocmd({ 'User', pattern = 'CanolaEnter' })
- vim.cmd.edit({ args = { 'bar' } })
- assert.equals('foo', vim.fn.expand('#'))
- end)
-
- it('preserves alternate buffer if discarding changes', function()
- vim.cmd.edit({ args = { 'foo' } })
- vim.cmd.edit({ args = { 'bar' } })
- canola.open()
- test_util.wait_for_autocmd({ 'User', pattern = 'CanolaEnter' })
- canola.close()
- assert.equals('bar', vim.fn.expand('%'))
- assert.equals('foo', vim.fn.expand('#'))
- end)
-
- it('sets previous buffer as alternate after multi-dir hops', function()
- vim.cmd.edit({ args = { 'foo' } })
- canola.open()
- test_util.wait_for_autocmd({ 'User', pattern = 'CanolaEnter' })
- canola.open()
- test_util.wait_for_autocmd({ 'User', pattern = 'CanolaEnter' })
- canola.open()
- test_util.wait_for_autocmd({ 'User', pattern = 'CanolaEnter' })
- canola.open()
- test_util.wait_for_autocmd({ 'User', pattern = 'CanolaEnter' })
- vim.cmd.edit({ args = { 'bar' } })
- assert.equals('foo', vim.fn.expand('#'))
- end)
-
- it('sets previous buffer as alternate when inside canola buffer', function()
- vim.cmd.edit({ args = { 'foo' } })
- canola.open()
- test_util.wait_for_autocmd({ 'User', pattern = 'CanolaEnter' })
- assert.equals('foo', vim.fn.expand('#'))
- vim.cmd.edit({ args = { 'bar' } })
- assert.equals('foo', vim.fn.expand('#'))
- canola.open()
- assert.equals('bar', vim.fn.expand('#'))
- end)
-
- it('preserves alternate when traversing canola dirs', function()
- vim.cmd.edit({ args = { 'foo' } })
- canola.open()
- test_util.wait_for_autocmd({ 'User', pattern = 'CanolaEnter' })
- assert.equals('foo', vim.fn.expand('#'))
- vim.wait(1000, function()
- return canola.get_cursor_entry()
- end, 10)
- vim.api.nvim_win_set_cursor(0, { 1, 1 })
- canola.select()
- test_util.wait_for_autocmd({ 'User', pattern = 'CanolaEnter' })
- assert.equals('foo', vim.fn.expand('#'))
- end)
-
- it('preserves alternate when opening preview', function()
- vim.cmd.edit({ args = { 'foo' } })
- canola.open()
- test_util.wait_for_autocmd({ 'User', pattern = 'CanolaEnter' })
- assert.equals('foo', vim.fn.expand('#'))
- vim.wait(1000, function()
- return canola.get_cursor_entry()
- end, 10)
- vim.api.nvim_win_set_cursor(0, { 1, 1 })
- canola.open_preview()
- test_util.wait_for_autocmd({ 'User', pattern = 'CanolaEnter' })
- assert.equals('foo', vim.fn.expand('#'))
- end)
-
- describe('floating window', function()
- it('sets previous buffer as alternate', function()
- vim.cmd.edit({ args = { 'foo' } })
- canola.open_float()
- test_util.wait_for_autocmd({ 'User', pattern = 'CanolaEnter' })
- vim.api.nvim_win_close(0, true)
- vim.cmd.edit({ args = { 'bar' } })
- assert.equals('foo', vim.fn.expand('#'))
- end)
-
- it('preserves alternate buffer if editing the same file', function()
- vim.cmd.edit({ args = { 'foo' } })
- vim.cmd.edit({ args = { 'bar' } })
- canola.open_float()
- test_util.wait_for_autocmd({ 'User', pattern = 'CanolaEnter' })
- vim.api.nvim_win_close(0, true)
- vim.cmd.edit({ args = { 'bar' } })
- assert.equals('foo', vim.fn.expand('#'))
- end)
-
- it('preserves alternate buffer if discarding changes', function()
- vim.cmd.edit({ args = { 'foo' } })
- vim.cmd.edit({ args = { 'bar' } })
- canola.open_float()
- test_util.wait_for_autocmd({ 'User', pattern = 'CanolaEnter' })
- canola.close()
- assert.equals('foo', vim.fn.expand('#'))
- end)
-
- it('preserves alternate when traversing to a new file', function()
- vim.cmd.edit({ args = { 'foo' } })
- canola.open_float()
- test_util.wait_for_autocmd({ 'User', pattern = 'CanolaEnter' })
- assert.equals('foo', vim.fn.expand('#'))
- test_util.feedkeys({ '/LICENSE' }, 10)
- canola.select()
- test_util.wait_for_autocmd('BufEnter')
- assert.equals('LICENSE', vim.fn.expand('%:.'))
- assert.equals('foo', vim.fn.expand('#'))
- end)
- end)
-end)
diff --git a/spec/close_spec.lua b/spec/close_spec.lua
deleted file mode 100644
index dc4138e..0000000
--- a/spec/close_spec.lua
+++ /dev/null
@@ -1,44 +0,0 @@
-local canola = require('canola')
-local test_util = require('spec.test_util')
-
-describe('close', function()
- before_each(function()
- test_util.reset_editor()
- end)
- after_each(function()
- test_util.reset_editor()
- end)
-
- it('does not close buffer from visual mode', function()
- canola.open()
- test_util.wait_for_autocmd({ 'User', pattern = 'CanolaEnter' })
- assert.equals('canola', vim.bo.filetype)
- test_util.feedkeys({ 'V' }, 10)
- canola.close()
- assert.equals('canola', vim.bo.filetype)
- test_util.feedkeys({ '' }, 10)
- end)
-
- it('does not close buffer from operator-pending mode', function()
- canola.open()
- test_util.wait_for_autocmd({ 'User', pattern = 'CanolaEnter' })
- assert.equals('canola', vim.bo.filetype)
- vim.api.nvim_feedkeys('d', 'n', false)
- vim.wait(20)
- local mode = vim.api.nvim_get_mode().mode
- if mode:match('^no') then
- canola.close()
- assert.equals('canola', vim.bo.filetype)
- end
- vim.api.nvim_feedkeys(vim.api.nvim_replace_termcodes('', true, true, true), 'n', false)
- vim.wait(20)
- end)
-
- it('closes buffer from normal mode', function()
- canola.open()
- test_util.wait_for_autocmd({ 'User', pattern = 'CanolaEnter' })
- assert.equals('canola', vim.bo.filetype)
- canola.close()
- assert.not_equals('canola', vim.bo.filetype)
- end)
-end)
diff --git a/spec/config_spec.lua b/spec/config_spec.lua
deleted file mode 100644
index bb37e41..0000000
--- a/spec/config_spec.lua
+++ /dev/null
@@ -1,27 +0,0 @@
-local config = require('canola.config')
-
-describe('config', function()
- after_each(function()
- vim.g.canola = nil
- end)
-
- it('falls back to vim.g.canola when setup() is called with no args', function()
- vim.g.canola = { delete_to_trash = true, cleanup_delay_ms = 5000 }
- config.setup()
- assert.is_true(config.delete_to_trash)
- assert.equals(5000, config.cleanup_delay_ms)
- end)
-
- it('uses defaults when neither opts nor vim.g.canola is set', function()
- vim.g.canola = nil
- config.setup()
- assert.is_false(config.delete_to_trash)
- assert.equals(2000, config.cleanup_delay_ms)
- end)
-
- it('prefers explicit opts over vim.g.canola', function()
- vim.g.canola = { delete_to_trash = true }
- config.setup({ delete_to_trash = false })
- assert.is_false(config.delete_to_trash)
- end)
-end)
diff --git a/spec/files_spec.lua b/spec/files_spec.lua
deleted file mode 100644
index 0282c0b..0000000
--- a/spec/files_spec.lua
+++ /dev/null
@@ -1,209 +0,0 @@
-local TmpDir = require('spec.tmpdir')
-local files = require('canola.adapters.files')
-local test_util = require('spec.test_util')
-
-describe('files adapter', function()
- local tmpdir
- before_each(function()
- tmpdir = TmpDir.new()
- end)
- after_each(function()
- if tmpdir then
- tmpdir:dispose()
- end
- test_util.reset_editor()
- end)
-
- it('tmpdir creates files and asserts they exist', function()
- tmpdir:create({ 'a.txt', 'foo/b.txt', 'foo/c.txt', 'bar/' })
- tmpdir:assert_fs({
- ['a.txt'] = 'a.txt',
- ['foo/b.txt'] = 'foo/b.txt',
- ['foo/c.txt'] = 'foo/c.txt',
- ['bar/'] = true,
- })
- end)
-
- it('Creates files', function()
- local err = test_util.await(files.perform_action, 2, {
- url = 'canola://' .. vim.fn.fnamemodify(tmpdir.path, ':p') .. 'a.txt',
- entry_type = 'file',
- type = 'create',
- })
- assert.is_nil(err)
- tmpdir:assert_fs({
- ['a.txt'] = '',
- })
- end)
-
- it('Creates directories', function()
- local err = test_util.await(files.perform_action, 2, {
- url = 'canola://' .. vim.fn.fnamemodify(tmpdir.path, ':p') .. 'a',
- entry_type = 'directory',
- type = 'create',
- })
- assert.is_nil(err)
- tmpdir:assert_fs({
- ['a/'] = true,
- })
- end)
-
- it('Deletes files', function()
- tmpdir:create({ 'a.txt' })
- local url = 'canola://' .. vim.fn.fnamemodify(tmpdir.path, ':p') .. 'a.txt'
- local err = test_util.await(files.perform_action, 2, {
- url = url,
- entry_type = 'file',
- type = 'delete',
- })
- assert.is_nil(err)
- tmpdir:assert_fs({})
- end)
-
- it('Deletes directories', function()
- tmpdir:create({ 'a/' })
- local url = 'canola://' .. vim.fn.fnamemodify(tmpdir.path, ':p') .. 'a'
- local err = test_util.await(files.perform_action, 2, {
- url = url,
- entry_type = 'directory',
- type = 'delete',
- })
- assert.is_nil(err)
- tmpdir:assert_fs({})
- end)
-
- it('Moves files', function()
- tmpdir:create({ 'a.txt' })
- local src_url = 'canola://' .. vim.fn.fnamemodify(tmpdir.path, ':p') .. 'a.txt'
- local dest_url = 'canola://' .. vim.fn.fnamemodify(tmpdir.path, ':p') .. 'b.txt'
- local err = test_util.await(files.perform_action, 2, {
- src_url = src_url,
- dest_url = dest_url,
- entry_type = 'file',
- type = 'move',
- })
- assert.is_nil(err)
- tmpdir:assert_fs({
- ['b.txt'] = 'a.txt',
- })
- end)
-
- it('Moves directories', function()
- tmpdir:create({ 'a/a.txt' })
- local src_url = 'canola://' .. vim.fn.fnamemodify(tmpdir.path, ':p') .. 'a'
- local dest_url = 'canola://' .. vim.fn.fnamemodify(tmpdir.path, ':p') .. 'b'
- local err = test_util.await(files.perform_action, 2, {
- src_url = src_url,
- dest_url = dest_url,
- entry_type = 'directory',
- type = 'move',
- })
- assert.is_nil(err)
- tmpdir:assert_fs({
- ['b/a.txt'] = 'a/a.txt',
- ['b/'] = true,
- })
- end)
-
- it('Copies files', function()
- tmpdir:create({ 'a.txt' })
- local src_url = 'canola://' .. vim.fn.fnamemodify(tmpdir.path, ':p') .. 'a.txt'
- local dest_url = 'canola://' .. vim.fn.fnamemodify(tmpdir.path, ':p') .. 'b.txt'
- local err = test_util.await(files.perform_action, 2, {
- src_url = src_url,
- dest_url = dest_url,
- entry_type = 'file',
- type = 'copy',
- })
- assert.is_nil(err)
- tmpdir:assert_fs({
- ['a.txt'] = 'a.txt',
- ['b.txt'] = 'a.txt',
- })
- end)
-
- it('Recursively copies directories', function()
- tmpdir:create({ 'a/a.txt' })
- local src_url = 'canola://' .. vim.fn.fnamemodify(tmpdir.path, ':p') .. 'a'
- local dest_url = 'canola://' .. vim.fn.fnamemodify(tmpdir.path, ':p') .. 'b'
- local err = test_util.await(files.perform_action, 2, {
- src_url = src_url,
- dest_url = dest_url,
- entry_type = 'directory',
- type = 'copy',
- })
- assert.is_nil(err)
- tmpdir:assert_fs({
- ['b/a.txt'] = 'a/a.txt',
- ['b/'] = true,
- ['a/a.txt'] = 'a/a.txt',
- ['a/'] = true,
- })
- end)
-
- it('Editing a new canola://path/ creates an canola buffer', function()
- local tmpdir_url = 'canola://' .. vim.fn.fnamemodify(tmpdir.path, ':p') .. '/'
- vim.cmd.edit({ args = { tmpdir_url } })
- test_util.wait_canola_ready()
- local new_url = 'canola://' .. vim.fn.fnamemodify(tmpdir.path, ':p') .. 'newdir'
- vim.cmd.edit({ args = { new_url } })
- test_util.wait_canola_ready()
- assert.equals('canola', vim.bo.filetype)
- assert.equals(new_url .. '/', vim.api.nvim_buf_get_name(0))
- end)
-
- it('Editing a new canola://file.rb creates a normal buffer', function()
- local tmpdir_url = 'canola://' .. vim.fn.fnamemodify(tmpdir.path, ':p') .. '/'
- vim.cmd.edit({ args = { tmpdir_url } })
- test_util.wait_for_autocmd('BufReadPost')
- local new_url = 'canola://' .. vim.fn.fnamemodify(tmpdir.path, ':p') .. 'file.rb'
- vim.cmd.edit({ args = { new_url } })
- test_util.wait_for_autocmd('BufReadPost')
- assert.equals('ruby', vim.bo.filetype)
- assert.equals(vim.fn.fnamemodify(tmpdir.path, ':p') .. 'file.rb', vim.api.nvim_buf_get_name(0))
- assert.equals(tmpdir.path .. '/file.rb', vim.fn.bufname())
- end)
-
- describe('cleanup_buffers_on_delete', function()
- local cache = require('canola.cache')
- local config = require('canola.config')
- local mutator = require('canola.mutator')
-
- before_each(function()
- config.cleanup_buffers_on_delete = true
- end)
-
- after_each(function()
- config.cleanup_buffers_on_delete = false
- end)
-
- it('wipes the buffer for a deleted file', function()
- tmpdir:create({ 'a.txt' })
- local dirurl = 'canola://' .. vim.fn.fnamemodify(tmpdir.path, ':p')
- local filepath = vim.fn.fnamemodify(tmpdir.path, ':p') .. 'a.txt'
- cache.create_and_store_entry(dirurl, 'a.txt', 'file')
- vim.cmd.edit({ args = { filepath } })
- local bufnr = vim.api.nvim_get_current_buf()
- local url = 'canola://' .. filepath
- test_util.await(mutator.process_actions, 2, {
- { type = 'delete', url = url, entry_type = 'file' },
- })
- assert.is_false(vim.api.nvim_buf_is_valid(bufnr))
- end)
-
- it('does not wipe the buffer when disabled', function()
- config.cleanup_buffers_on_delete = false
- tmpdir:create({ 'b.txt' })
- local dirurl = 'canola://' .. vim.fn.fnamemodify(tmpdir.path, ':p')
- local filepath = vim.fn.fnamemodify(tmpdir.path, ':p') .. 'b.txt'
- cache.create_and_store_entry(dirurl, 'b.txt', 'file')
- vim.cmd.edit({ args = { filepath } })
- local bufnr = vim.api.nvim_get_current_buf()
- local url = 'canola://' .. filepath
- test_util.await(mutator.process_actions, 2, {
- { type = 'delete', url = url, entry_type = 'file' },
- })
- assert.is_true(vim.api.nvim_buf_is_valid(bufnr))
- end)
- end)
-end)
diff --git a/spec/minimal_init.lua b/spec/minimal_init.lua
deleted file mode 100644
index 09f0cd3..0000000
--- a/spec/minimal_init.lua
+++ /dev/null
@@ -1,9 +0,0 @@
-vim.cmd([[set runtimepath=$VIMRUNTIME]])
-vim.opt.runtimepath:append('.')
-vim.opt.packpath = {}
-vim.o.swapfile = false
-vim.cmd('filetype on')
-vim.fn.mkdir(vim.fn.stdpath('cache'), 'p')
-vim.fn.mkdir(vim.fn.stdpath('data'), 'p')
-vim.fn.mkdir(vim.fn.stdpath('state'), 'p')
-require('spec.test_util').reset_editor()
diff --git a/spec/move_rename_spec.lua b/spec/move_rename_spec.lua
deleted file mode 100644
index 7b2d5a5..0000000
--- a/spec/move_rename_spec.lua
+++ /dev/null
@@ -1,59 +0,0 @@
-local fs = require('canola.fs')
-local test_util = require('spec.test_util')
-local util = require('canola.util')
-
-describe('update_moved_buffers', function()
- after_each(function()
- test_util.reset_editor()
- end)
-
- it('Renames moved buffers', function()
- vim.cmd.edit({ args = { 'canola-test:///foo/bar.txt' } })
- util.update_moved_buffers('file', 'canola-test:///foo/bar.txt', 'canola-test:///foo/baz.txt')
- assert.equals('canola-test:///foo/baz.txt', vim.api.nvim_buf_get_name(0))
- end)
-
- it('Renames moved buffers when they are normal files', function()
- local tmpdir = fs.join(vim.loop.fs_realpath(vim.fn.stdpath('cache')), 'canola', 'test')
- local testfile = fs.join(tmpdir, 'foo.txt')
- vim.cmd.edit({ args = { testfile } })
- util.update_moved_buffers(
- 'file',
- 'canola://' .. fs.os_to_posix_path(testfile),
- 'canola://' .. fs.os_to_posix_path(fs.join(tmpdir, 'bar.txt'))
- )
- assert.equals(fs.join(tmpdir, 'bar.txt'), vim.api.nvim_buf_get_name(0))
- end)
-
- it('Renames directories', function()
- vim.cmd.edit({ args = { 'canola-test:///foo/' } })
- util.update_moved_buffers('directory', 'canola-test:///foo/', 'canola-test:///bar/')
- assert.equals('canola-test:///bar/', vim.api.nvim_buf_get_name(0))
- end)
-
- it('Renames subdirectories', function()
- vim.cmd.edit({ args = { 'canola-test:///foo/bar/' } })
- util.update_moved_buffers('directory', 'canola-test:///foo/', 'canola-test:///baz/')
- assert.equals('canola-test:///baz/bar/', vim.api.nvim_buf_get_name(0))
- end)
-
- it('Renames subfiles', function()
- vim.cmd.edit({ args = { 'canola-test:///foo/bar.txt' } })
- util.update_moved_buffers('directory', 'canola-test:///foo/', 'canola-test:///baz/')
- assert.equals('canola-test:///baz/bar.txt', vim.api.nvim_buf_get_name(0))
- end)
-
- it('Renames subfiles when they are normal files', function()
- local tmpdir = fs.join(vim.loop.fs_realpath(vim.fn.stdpath('cache')), 'canola', 'test')
- local foo = fs.join(tmpdir, 'foo')
- local bar = fs.join(tmpdir, 'bar')
- local testfile = fs.join(foo, 'foo.txt')
- vim.cmd.edit({ args = { testfile } })
- util.update_moved_buffers(
- 'directory',
- 'canola://' .. fs.os_to_posix_path(foo),
- 'canola://' .. fs.os_to_posix_path(bar)
- )
- assert.equals(fs.join(bar, 'foo.txt'), vim.api.nvim_buf_get_name(0))
- end)
-end)
diff --git a/spec/mutator_spec.lua b/spec/mutator_spec.lua
deleted file mode 100644
index 2060b6d..0000000
--- a/spec/mutator_spec.lua
+++ /dev/null
@@ -1,419 +0,0 @@
-local cache = require('canola.cache')
-local constants = require('canola.constants')
-local mutator = require('canola.mutator')
-local test_adapter = require('canola.adapters.test')
-local test_util = require('spec.test_util')
-
-local FIELD_ID = constants.FIELD_ID
-local FIELD_NAME = constants.FIELD_NAME
-local FIELD_TYPE = constants.FIELD_TYPE
-
-describe('mutator', function()
- after_each(function()
- test_util.reset_editor()
- end)
-
- describe('build actions', function()
- it('empty diffs produce no actions', function()
- vim.cmd.edit({ args = { 'canola-test:///foo/' } })
- local bufnr = vim.api.nvim_get_current_buf()
- local actions = mutator.create_actions_from_diffs({
- [bufnr] = {},
- })
- assert.are.same({}, actions)
- end)
-
- it('constructs CREATE actions', function()
- vim.cmd.edit({ args = { 'canola-test:///foo/' } })
- local bufnr = vim.api.nvim_get_current_buf()
- local diffs = {
- { type = 'new', name = 'a.txt', entry_type = 'file' },
- }
- local actions = mutator.create_actions_from_diffs({
- [bufnr] = diffs,
- })
- assert.are.same({
- {
- type = 'create',
- entry_type = 'file',
- url = 'canola-test:///foo/a.txt',
- },
- }, actions)
- end)
-
- it('constructs DELETE actions', function()
- local file = test_adapter.test_set('/foo/a.txt', 'file')
- vim.cmd.edit({ args = { 'canola-test:///foo/' } })
- local bufnr = vim.api.nvim_get_current_buf()
- local diffs = {
- { type = 'delete', name = 'a.txt', id = file[FIELD_ID] },
- }
- local actions = mutator.create_actions_from_diffs({
- [bufnr] = diffs,
- })
- assert.are.same({
- {
- type = 'delete',
- entry_type = 'file',
- url = 'canola-test:///foo/a.txt',
- },
- }, actions)
- end)
-
- it('constructs COPY actions', function()
- local file = test_adapter.test_set('/foo/a.txt', 'file')
- vim.cmd.edit({ args = { 'canola-test:///foo/' } })
- local bufnr = vim.api.nvim_get_current_buf()
- local diffs = {
- { type = 'new', name = 'b.txt', entry_type = 'file', id = file[FIELD_ID] },
- }
- local actions = mutator.create_actions_from_diffs({
- [bufnr] = diffs,
- })
- assert.are.same({
- {
- type = 'copy',
- entry_type = 'file',
- src_url = 'canola-test:///foo/a.txt',
- dest_url = 'canola-test:///foo/b.txt',
- },
- }, actions)
- end)
-
- it('constructs MOVE actions', function()
- local file = test_adapter.test_set('/foo/a.txt', 'file')
- vim.cmd.edit({ args = { 'canola-test:///foo/' } })
- local bufnr = vim.api.nvim_get_current_buf()
- local diffs = {
- { type = 'delete', name = 'a.txt', id = file[FIELD_ID] },
- { type = 'new', name = 'b.txt', entry_type = 'file', id = file[FIELD_ID] },
- }
- local actions = mutator.create_actions_from_diffs({
- [bufnr] = diffs,
- })
- assert.are.same({
- {
- type = 'move',
- entry_type = 'file',
- src_url = 'canola-test:///foo/a.txt',
- dest_url = 'canola-test:///foo/b.txt',
- },
- }, actions)
- end)
-
- it('correctly orders MOVE + CREATE', function()
- local file = test_adapter.test_set('/a.txt', 'file')
- vim.cmd.edit({ args = { 'canola-test:///' } })
- local bufnr = vim.api.nvim_get_current_buf()
- local diffs = {
- { type = 'delete', name = 'a.txt', id = file[FIELD_ID] },
- { type = 'new', name = 'b.txt', entry_type = 'file', id = file[FIELD_ID] },
- { type = 'new', name = 'a.txt', entry_type = 'file' },
- }
- local actions = mutator.create_actions_from_diffs({
- [bufnr] = diffs,
- })
- assert.are.same({
- {
- type = 'move',
- entry_type = 'file',
- src_url = 'canola-test:///a.txt',
- dest_url = 'canola-test:///b.txt',
- },
- {
- type = 'create',
- entry_type = 'file',
- url = 'canola-test:///a.txt',
- },
- }, actions)
- end)
-
- it('resolves MOVE loops', function()
- local afile = test_adapter.test_set('/a.txt', 'file')
- local bfile = test_adapter.test_set('/b.txt', 'file')
- vim.cmd.edit({ args = { 'canola-test:///' } })
- local bufnr = vim.api.nvim_get_current_buf()
- local diffs = {
- { type = 'delete', name = 'a.txt', id = afile[FIELD_ID] },
- { type = 'new', name = 'b.txt', entry_type = 'file', id = afile[FIELD_ID] },
- { type = 'delete', name = 'b.txt', id = bfile[FIELD_ID] },
- { type = 'new', name = 'a.txt', entry_type = 'file', id = bfile[FIELD_ID] },
- }
- math.randomseed(2983982)
- local actions = mutator.create_actions_from_diffs({
- [bufnr] = diffs,
- })
- local tmp_url = 'canola-test:///a.txt__canola_tmp_510852'
- assert.are.same({
- {
- type = 'move',
- entry_type = 'file',
- src_url = 'canola-test:///a.txt',
- dest_url = tmp_url,
- },
- {
- type = 'move',
- entry_type = 'file',
- src_url = 'canola-test:///b.txt',
- dest_url = 'canola-test:///a.txt',
- },
- {
- type = 'move',
- entry_type = 'file',
- src_url = tmp_url,
- dest_url = 'canola-test:///b.txt',
- },
- }, actions)
- end)
- end)
-
- describe('order actions', function()
- it('Creates files inside dir before move', function()
- local move = {
- type = 'move',
- src_url = 'canola-test:///a',
- dest_url = 'canola-test:///b',
- entry_type = 'directory',
- }
- local create = { type = 'create', url = 'canola-test:///a/hi.txt', entry_type = 'file' }
- local actions = { move, create }
- local ordered_actions = mutator.enforce_action_order(actions)
- assert.are.same({ create, move }, ordered_actions)
- end)
-
- it('Moves file out of parent before deleting parent', function()
- local move = {
- type = 'move',
- src_url = 'canola-test:///a/b.txt',
- dest_url = 'canola-test:///b.txt',
- entry_type = 'file',
- }
- local delete = { type = 'delete', url = 'canola-test:///a', entry_type = 'directory' }
- local actions = { delete, move }
- local ordered_actions = mutator.enforce_action_order(actions)
- assert.are.same({ move, delete }, ordered_actions)
- end)
-
- it('Handles parent child move ordering', function()
- local move1 = {
- type = 'move',
- src_url = 'canola-test:///a/b',
- dest_url = 'canola-test:///b',
- entry_type = 'directory',
- }
- local move2 = {
- type = 'move',
- src_url = 'canola-test:///a',
- dest_url = 'canola-test:///b/a',
- entry_type = 'directory',
- }
- local actions = { move2, move1 }
- local ordered_actions = mutator.enforce_action_order(actions)
- assert.are.same({ move1, move2 }, ordered_actions)
- end)
-
- it('Handles a delete inside a moved folder', function()
- local del = {
- type = 'delete',
- url = 'canola-test:///a/b.txt',
- entry_type = 'file',
- }
- local move = {
- type = 'move',
- src_url = 'canola-test:///a',
- dest_url = 'canola-test:///b',
- entry_type = 'directory',
- }
- local actions = { move, del }
- local ordered_actions = mutator.enforce_action_order(actions)
- assert.are.same({ del, move }, ordered_actions)
- end)
-
- it('Detects move directory loops', function()
- local move = {
- type = 'move',
- src_url = 'canola-test:///a',
- dest_url = 'canola-test:///a/b',
- entry_type = 'directory',
- }
- assert.has_error(function()
- mutator.enforce_action_order({ move })
- end)
- end)
-
- it('Detects copy directory loops', function()
- local move = {
- type = 'copy',
- src_url = 'canola-test:///a',
- dest_url = 'canola-test:///a/b',
- entry_type = 'directory',
- }
- assert.has_error(function()
- mutator.enforce_action_order({ move })
- end)
- end)
-
- it('Detects nested copy directory loops', function()
- local move = {
- type = 'copy',
- src_url = 'canola-test:///a',
- dest_url = 'canola-test:///a/b/a',
- entry_type = 'directory',
- }
- assert.has_error(function()
- mutator.enforce_action_order({ move })
- end)
- end)
-
- describe('change', function()
- it('applies CHANGE after CREATE', function()
- local create = { type = 'create', url = 'canola-test:///a/hi.txt', entry_type = 'file' }
- local change = {
- type = 'change',
- url = 'canola-test:///a/hi.txt',
- entry_type = 'file',
- column = 'TEST',
- value = 'TEST',
- }
- local actions = { change, create }
- local ordered_actions = mutator.enforce_action_order(actions)
- assert.are.same({ create, change }, ordered_actions)
- end)
-
- it('applies CHANGE after COPY src', function()
- local copy = {
- type = 'copy',
- src_url = 'canola-test:///a/hi.txt',
- dest_url = 'canola-test:///b.txt',
- entry_type = 'file',
- }
- local change = {
- type = 'change',
- url = 'canola-test:///a/hi.txt',
- entry_type = 'file',
- column = 'TEST',
- value = 'TEST',
- }
- local actions = { change, copy }
- local ordered_actions = mutator.enforce_action_order(actions)
- assert.are.same({ copy, change }, ordered_actions)
- end)
-
- it('applies CHANGE after COPY dest', function()
- local copy = {
- type = 'copy',
- src_url = 'canola-test:///b.txt',
- dest_url = 'canola-test:///a/hi.txt',
- entry_type = 'file',
- }
- local change = {
- type = 'change',
- url = 'canola-test:///a/hi.txt',
- entry_type = 'file',
- column = 'TEST',
- value = 'TEST',
- }
- local actions = { change, copy }
- local ordered_actions = mutator.enforce_action_order(actions)
- assert.are.same({ copy, change }, ordered_actions)
- end)
-
- it('applies CHANGE after MOVE dest', function()
- local move = {
- type = 'move',
- src_url = 'canola-test:///b.txt',
- dest_url = 'canola-test:///a/hi.txt',
- entry_type = 'file',
- }
- local change = {
- type = 'change',
- url = 'canola-test:///a/hi.txt',
- entry_type = 'file',
- column = 'TEST',
- value = 'TEST',
- }
- local actions = { change, move }
- local ordered_actions = mutator.enforce_action_order(actions)
- assert.are.same({ move, change }, ordered_actions)
- end)
- end)
- end)
-
- describe('perform actions', function()
- it('creates new entries', function()
- local actions = {
- { type = 'create', url = 'canola-test:///a.txt', entry_type = 'file' },
- }
- test_util.await(mutator.process_actions, 2, actions)
- local files = cache.list_url('canola-test:///')
- assert.are.same({
- ['a.txt'] = {
- [FIELD_ID] = 1,
- [FIELD_TYPE] = 'file',
- [FIELD_NAME] = 'a.txt',
- },
- }, files)
- end)
-
- it('deletes entries', function()
- local file = test_adapter.test_set('/a.txt', 'file')
- local actions = {
- { type = 'delete', url = 'canola-test:///a.txt', entry_type = 'file' },
- }
- test_util.await(mutator.process_actions, 2, actions)
- local files = cache.list_url('canola-test:///')
- assert.are.same({}, files)
- assert.is_nil(cache.get_entry_by_id(file[FIELD_ID]))
- assert.has_error(function()
- cache.get_parent_url(file[FIELD_ID])
- end)
- end)
-
- it('moves entries', function()
- local file = test_adapter.test_set('/a.txt', 'file')
- local actions = {
- {
- type = 'move',
- src_url = 'canola-test:///a.txt',
- dest_url = 'canola-test:///b.txt',
- entry_type = 'file',
- },
- }
- test_util.await(mutator.process_actions, 2, actions)
- local files = cache.list_url('canola-test:///')
- local new_entry = {
- [FIELD_ID] = file[FIELD_ID],
- [FIELD_TYPE] = 'file',
- [FIELD_NAME] = 'b.txt',
- }
- assert.are.same({
- ['b.txt'] = new_entry,
- }, files)
- assert.are.same(new_entry, cache.get_entry_by_id(file[FIELD_ID]))
- assert.equals('canola-test:///', cache.get_parent_url(file[FIELD_ID]))
- end)
-
- it('copies entries', function()
- local file = test_adapter.test_set('/a.txt', 'file')
- local actions = {
- {
- type = 'copy',
- src_url = 'canola-test:///a.txt',
- dest_url = 'canola-test:///b.txt',
- entry_type = 'file',
- },
- }
- test_util.await(mutator.process_actions, 2, actions)
- local files = cache.list_url('canola-test:///')
- local new_entry = {
- [FIELD_ID] = file[FIELD_ID] + 1,
- [FIELD_TYPE] = 'file',
- [FIELD_NAME] = 'b.txt',
- }
- assert.are.same({
- ['a.txt'] = file,
- ['b.txt'] = new_entry,
- }, files)
- end)
- end)
-end)
diff --git a/spec/parser_spec.lua b/spec/parser_spec.lua
deleted file mode 100644
index ffc638b..0000000
--- a/spec/parser_spec.lua
+++ /dev/null
@@ -1,249 +0,0 @@
-local constants = require('canola.constants')
-local parser = require('canola.mutator.parser')
-local test_adapter = require('canola.adapters.test')
-local test_util = require('spec.test_util')
-local util = require('canola.util')
-local view = require('canola.view')
-
-local FIELD_ID = constants.FIELD_ID
-local FIELD_META = constants.FIELD_META
-
-local function set_lines(bufnr, lines)
- vim.bo[bufnr].modifiable = true
- vim.api.nvim_buf_set_lines(bufnr, 0, -1, true, lines)
-end
-
-describe('parser', function()
- after_each(function()
- test_util.reset_editor()
- end)
-
- it('detects new files', function()
- vim.cmd.edit({ args = { 'canola-test:///foo/' } })
- local bufnr = vim.api.nvim_get_current_buf()
- set_lines(bufnr, {
- 'a.txt',
- })
- local diffs = parser.parse(bufnr)
- assert.are.same({ { entry_type = 'file', name = 'a.txt', type = 'new' } }, diffs)
- end)
-
- it('detects new directories', function()
- vim.cmd.edit({ args = { 'canola-test:///foo/' } })
- local bufnr = vim.api.nvim_get_current_buf()
- set_lines(bufnr, {
- 'foo/',
- })
- local diffs = parser.parse(bufnr)
- assert.are.same({ { entry_type = 'directory', name = 'foo', type = 'new' } }, diffs)
- end)
-
- it('detects new links', function()
- vim.cmd.edit({ args = { 'canola-test:///foo/' } })
- local bufnr = vim.api.nvim_get_current_buf()
- set_lines(bufnr, {
- 'a.txt -> b.txt',
- })
- local diffs = parser.parse(bufnr)
- assert.are.same(
- { { entry_type = 'link', name = 'a.txt', type = 'new', link = 'b.txt' } },
- diffs
- )
- end)
-
- it('detects deleted files', function()
- local file = test_adapter.test_set('/foo/a.txt', 'file')
- vim.cmd.edit({ args = { 'canola-test:///foo/' } })
- local bufnr = vim.api.nvim_get_current_buf()
- set_lines(bufnr, {})
- local diffs = parser.parse(bufnr)
- assert.are.same({
- { name = 'a.txt', type = 'delete', id = file[FIELD_ID] },
- }, diffs)
- end)
-
- it('detects deleted directories', function()
- local dir = test_adapter.test_set('/foo/bar', 'directory')
- vim.cmd.edit({ args = { 'canola-test:///foo/' } })
- local bufnr = vim.api.nvim_get_current_buf()
- set_lines(bufnr, {})
- local diffs = parser.parse(bufnr)
- assert.are.same({
- { name = 'bar', type = 'delete', id = dir[FIELD_ID] },
- }, diffs)
- end)
-
- it('detects deleted links', function()
- local file = test_adapter.test_set('/foo/a.txt', 'link')
- file[FIELD_META] = { link = 'b.txt' }
- vim.cmd.edit({ args = { 'canola-test:///foo/' } })
- local bufnr = vim.api.nvim_get_current_buf()
- set_lines(bufnr, {})
- local diffs = parser.parse(bufnr)
- assert.are.same({
- { name = 'a.txt', type = 'delete', id = file[FIELD_ID] },
- }, diffs)
- end)
-
- it('ignores empty lines', function()
- local file = test_adapter.test_set('/foo/a.txt', 'file')
- vim.cmd.edit({ args = { 'canola-test:///foo/' } })
- local bufnr = vim.api.nvim_get_current_buf()
- local cols = view.format_entry_cols(file, {}, {}, test_adapter, false)
- local lines = util.render_table({ cols }, {})
- table.insert(lines, '')
- table.insert(lines, ' ')
- set_lines(bufnr, lines)
- local diffs = parser.parse(bufnr)
- assert.are.same({}, diffs)
- end)
-
- it('errors on missing filename', function()
- vim.cmd.edit({ args = { 'canola-test:///foo/' } })
- local bufnr = vim.api.nvim_get_current_buf()
- set_lines(bufnr, {
- '/008',
- })
- local _, errors = parser.parse(bufnr)
- assert.are_same({
- {
- message = 'Malformed ID at start of line',
- lnum = 0,
- end_lnum = 1,
- col = 0,
- },
- }, errors)
- end)
-
- it('errors on empty dirname', function()
- vim.cmd.edit({ args = { 'canola-test:///foo/' } })
- local bufnr = vim.api.nvim_get_current_buf()
- set_lines(bufnr, {
- '/008 /',
- })
- local _, errors = parser.parse(bufnr)
- assert.are.same({
- {
- message = 'No filename found',
- lnum = 0,
- end_lnum = 1,
- col = 0,
- },
- }, errors)
- end)
-
- it('errors on duplicate names', function()
- vim.cmd.edit({ args = { 'canola-test:///foo/' } })
- local bufnr = vim.api.nvim_get_current_buf()
- set_lines(bufnr, {
- 'foo',
- 'foo/',
- })
- local _, errors = parser.parse(bufnr)
- assert.are.same({
- {
- message = 'Duplicate filename',
- lnum = 1,
- end_lnum = 2,
- col = 0,
- },
- }, errors)
- end)
-
- it('errors on duplicate names for existing files', function()
- local file = test_adapter.test_set('/foo/a.txt', 'file')
- vim.cmd.edit({ args = { 'canola-test:///foo/' } })
- local bufnr = vim.api.nvim_get_current_buf()
- set_lines(bufnr, {
- 'a.txt',
- string.format('/%d a.txt', file[FIELD_ID]),
- })
- local _, errors = parser.parse(bufnr)
- assert.are.same({
- {
- message = 'Duplicate filename',
- lnum = 1,
- end_lnum = 2,
- col = 0,
- },
- }, errors)
- end)
-
- it('ignores new dirs with empty name', function()
- vim.cmd.edit({ args = { 'canola-test:///foo/' } })
- local bufnr = vim.api.nvim_get_current_buf()
- set_lines(bufnr, {
- '/',
- })
- local diffs = parser.parse(bufnr)
- assert.are.same({}, diffs)
- end)
-
- it('parses a rename as a delete + new', function()
- local file = test_adapter.test_set('/foo/a.txt', 'file')
- vim.cmd.edit({ args = { 'canola-test:///foo/' } })
- local bufnr = vim.api.nvim_get_current_buf()
- set_lines(bufnr, {
- string.format('/%d b.txt', file[FIELD_ID]),
- })
- local diffs = parser.parse(bufnr)
- assert.are.same({
- { type = 'new', id = file[FIELD_ID], name = 'b.txt', entry_type = 'file' },
- { type = 'delete', id = file[FIELD_ID], name = 'a.txt' },
- }, diffs)
- end)
-
- it('detects a new trailing slash as a delete + create', function()
- local file = test_adapter.test_set('/foo', 'file')
- vim.cmd.edit({ args = { 'canola-test:///' } })
- local bufnr = vim.api.nvim_get_current_buf()
- set_lines(bufnr, {
- string.format('/%d foo/', file[FIELD_ID]),
- })
- local diffs = parser.parse(bufnr)
- assert.are.same({
- { type = 'new', name = 'foo', entry_type = 'directory' },
- { type = 'delete', id = file[FIELD_ID], name = 'foo' },
- }, diffs)
- end)
-
- it('detects renamed files that conflict', function()
- local afile = test_adapter.test_set('/foo/a.txt', 'file')
- local bfile = test_adapter.test_set('/foo/b.txt', 'file')
- vim.cmd.edit({ args = { 'canola-test:///foo/' } })
- local bufnr = vim.api.nvim_get_current_buf()
- set_lines(bufnr, {
- string.format('/%d a.txt', bfile[FIELD_ID]),
- string.format('/%d b.txt', afile[FIELD_ID]),
- })
- local diffs = parser.parse(bufnr)
- local first_two = { diffs[1], diffs[2] }
- local last_two = { diffs[3], diffs[4] }
- table.sort(first_two, function(a, b)
- return a.id < b.id
- end)
- table.sort(last_two, function(a, b)
- return a.id < b.id
- end)
- assert.are.same({
- { name = 'b.txt', type = 'new', id = afile[FIELD_ID], entry_type = 'file' },
- { name = 'a.txt', type = 'new', id = bfile[FIELD_ID], entry_type = 'file' },
- }, first_two)
- assert.are.same({
- { name = 'a.txt', type = 'delete', id = afile[FIELD_ID] },
- { name = 'b.txt', type = 'delete', id = bfile[FIELD_ID] },
- }, last_two)
- end)
-
- it('views link targets with trailing slashes as the same', function()
- local file = test_adapter.test_set('/foo/mydir', 'link')
- file[FIELD_META] = { link = 'dir/' }
- vim.cmd.edit({ args = { 'canola-test:///foo/' } })
- local bufnr = vim.api.nvim_get_current_buf()
- set_lines(bufnr, {
- string.format('/%d mydir/ -> dir/', file[FIELD_ID]),
- })
- local diffs = parser.parse(bufnr)
- assert.are.same({}, diffs)
- end)
-end)
diff --git a/spec/preview_spec.lua b/spec/preview_spec.lua
deleted file mode 100644
index 137c9f9..0000000
--- a/spec/preview_spec.lua
+++ /dev/null
@@ -1,40 +0,0 @@
-local TmpDir = require('spec.tmpdir')
-local canola = require('canola')
-local test_util = require('spec.test_util')
-local util = require('canola.util')
-
-describe('canola preview', function()
- local tmpdir
- before_each(function()
- tmpdir = TmpDir.new()
- end)
- after_each(function()
- if tmpdir then
- tmpdir:dispose()
- end
- test_util.reset_editor()
- end)
-
- it('opens preview window', function()
- tmpdir:create({ 'a.txt' })
- test_util.canola_open(tmpdir.path)
- test_util.await(canola.open_preview, 2)
- local preview_win = util.get_preview_win()
- assert.not_nil(preview_win)
- assert(preview_win)
- local bufnr = vim.api.nvim_win_get_buf(preview_win)
- local preview_lines = vim.api.nvim_buf_get_lines(bufnr, 0, -1, false)
- assert.are.same({ 'a.txt' }, preview_lines)
- end)
-
- it('opens preview window when open(preview={})', function()
- tmpdir:create({ 'a.txt' })
- test_util.canola_open(tmpdir.path, { preview = {} })
- local preview_win = util.get_preview_win()
- assert.not_nil(preview_win)
- assert(preview_win)
- local bufnr = vim.api.nvim_win_get_buf(preview_win)
- local preview_lines = vim.api.nvim_buf_get_lines(bufnr, 0, -1, false)
- assert.are.same({ 'a.txt' }, preview_lines)
- end)
-end)
diff --git a/spec/regression_spec.lua b/spec/regression_spec.lua
deleted file mode 100644
index fddb1f8..0000000
--- a/spec/regression_spec.lua
+++ /dev/null
@@ -1,137 +0,0 @@
-local TmpDir = require('spec.tmpdir')
-local actions = require('canola.actions')
-local canola = require('canola')
-local test_util = require('spec.test_util')
-local view = require('canola.view')
-
-describe('regression tests', function()
- local tmpdir
- before_each(function()
- tmpdir = TmpDir.new()
- end)
- after_each(function()
- if tmpdir then
- tmpdir:dispose()
- tmpdir = nil
- end
- test_util.reset_editor()
- end)
-
- it('can edit dirs that will be renamed to an existing buffer', function()
- vim.cmd.edit({ args = { 'README.md' } })
- vim.cmd.vsplit()
- vim.cmd.edit({ args = { '%:p:h' } })
- assert.equals('canola', vim.bo.filetype)
- vim.cmd.wincmd({ args = { 'p' } })
- assert.equals('markdown', vim.bo.filetype)
- vim.cmd.edit({ args = { '%:p:h' } })
- test_util.wait_for_autocmd({ 'User', pattern = 'CanolaEnter' })
- assert.equals('canola', vim.bo.filetype)
- end)
-
- it('places the cursor on correct entry when opening on file', function()
- vim.cmd.edit({ args = { '.' } })
- test_util.wait_for_autocmd({ 'User', pattern = 'CanolaEnter' })
- local entry = canola.get_cursor_entry()
- assert.not_nil(entry)
- assert.not_equals('README.md', entry and entry.name)
- vim.cmd.edit({ args = { 'README.md' } })
- view.delete_hidden_buffers()
- canola.open()
- test_util.wait_for_autocmd({ 'User', pattern = 'CanolaEnter' })
- entry = canola.get_cursor_entry()
- assert.equals('README.md', entry and entry.name)
- end)
-
- it("doesn't close floating windows canola didn't open itself", function()
- local winid = vim.api.nvim_open_win(vim.fn.bufadd('README.md'), true, {
- relative = 'editor',
- row = 1,
- col = 1,
- width = 100,
- height = 100,
- })
- canola.open()
- vim.wait(10)
- canola.close()
- vim.wait(10)
- assert.equals(winid, vim.api.nvim_get_current_win())
- end)
-
- it("doesn't close splits on canola.close", function()
- vim.cmd.edit({ args = { 'README.md' } })
- vim.cmd.vsplit()
- local winid = vim.api.nvim_get_current_win()
- local bufnr = vim.api.nvim_get_current_buf()
- canola.open()
- vim.wait(10)
- canola.close()
- vim.wait(10)
- assert.equals(2, #vim.api.nvim_tabpage_list_wins(0))
- assert.equals(winid, vim.api.nvim_get_current_win())
- assert.equals(bufnr, vim.api.nvim_get_current_buf())
- end)
-
- it('Returns to empty buffer on close', function()
- canola.open()
- test_util.wait_for_autocmd({ 'User', pattern = 'CanolaEnter' })
- canola.close()
- assert.not_equals('canola', vim.bo.filetype)
- assert.equals('', vim.api.nvim_buf_get_name(0))
- end)
-
- it('All buffers set nomodified after save', function()
- tmpdir:create({ 'a.txt' })
- vim.cmd.edit({ args = { 'canola://' .. vim.fn.fnamemodify(tmpdir.path, ':p') } })
- local first_dir = vim.api.nvim_get_current_buf()
- test_util.wait_for_autocmd({ 'User', pattern = 'CanolaEnter' })
- test_util.feedkeys({ 'dd', 'itest/', '' }, 10)
- vim.wait(1000, function()
- return vim.bo.modifiable
- end, 10)
- test_util.feedkeys({ 'p' }, 10)
- canola.save({ confirm = false })
- vim.wait(1000, function()
- return vim.bo.modifiable
- end, 10)
- tmpdir:assert_fs({
- ['test/a.txt'] = 'a.txt',
- })
- assert.falsy(vim.bo[first_dir].modified)
- end)
-
- it("refreshing buffer doesn't lose track of it", function()
- vim.cmd.edit({ args = { '.' } })
- test_util.wait_for_autocmd({ 'User', pattern = 'CanolaEnter' })
- local bufnr = vim.api.nvim_get_current_buf()
- vim.cmd.edit({ bang = true })
- test_util.wait_for_autocmd({ 'User', pattern = 'CanolaEnter' })
- assert.are.same({ bufnr }, require('canola.view').get_all_buffers())
- end)
-
- it('can copy a file multiple times', function()
- test_util.actions.open({ tmpdir.path })
- vim.api.nvim_feedkeys('ifoo.txt', 'x', true)
- test_util.actions.save()
- vim.api.nvim_feedkeys('yyp$ciWbar.txt', 'x', true)
- vim.api.nvim_feedkeys('yyp$ciWbaz.txt', 'x', true)
- test_util.actions.save()
- assert.are.same({ 'bar.txt', 'baz.txt', 'foo.txt' }, test_util.parse_entries(0))
- tmpdir:assert_fs({
- ['foo.txt'] = '',
- ['bar.txt'] = '',
- ['baz.txt'] = '',
- })
- end)
-
- it('can open files from floating window', function()
- tmpdir:create({ 'a.txt' })
- canola.open_float(tmpdir.path)
- test_util.wait_for_autocmd({ 'User', pattern = 'CanolaEnter' })
- actions.select.callback()
- vim.wait(1000, function()
- return vim.fn.expand('%:t') == 'a.txt'
- end, 10)
- assert.equals('a.txt', vim.fn.expand('%:t'))
- end)
-end)
diff --git a/spec/test_util.lua b/spec/test_util.lua
deleted file mode 100644
index 3afdf75..0000000
--- a/spec/test_util.lua
+++ /dev/null
@@ -1,172 +0,0 @@
-local cache = require('canola.cache')
-local test_adapter = require('canola.adapters.test')
-local util = require('canola.util')
-local M = {}
-
-M.reset_editor = function()
- require('canola').setup({
- columms = {},
- adapters = {
- ['canola-test://'] = 'test',
- },
- prompt_save_on_select_new_entry = false,
- })
- vim.cmd.tabonly({ mods = { silent = true } })
- vim.cmd.new()
- vim.cmd.only()
- for _, bufnr in ipairs(vim.api.nvim_list_bufs()) do
- vim.api.nvim_buf_delete(bufnr, { force = true })
- end
- cache.clear_everything()
- test_adapter.test_clear()
-end
-
-local function throwiferr(err, ...)
- if err then
- error(err)
- else
- return ...
- end
-end
-
-M.await = function(fn, nargs, ...)
- local done = false
- local results
- local n_results = 0
- local args = { ... }
- args[nargs] = function(...)
- results = { ... }
- n_results = select('#', ...)
- done = true
- end
- fn(unpack(args, 1, nargs))
- vim.wait(10000, function()
- return done
- end, 10)
- if not done then
- error('M.await timed out')
- end
- return unpack(results, 1, n_results)
-end
-
-M.await_throwiferr = function(fn, nargs, ...)
- return throwiferr(M.await(fn, nargs, ...))
-end
-
-M.canola_open = function(...)
- M.await(require('canola').open, 3, ...)
-end
-
-M.wait_for_autocmd = function(autocmd)
- local triggered = false
- local opts = {
- pattern = '*',
- nested = true,
- once = true,
- }
- if type(autocmd) == 'table' then
- opts = vim.tbl_extend('force', opts, autocmd)
- autocmd = autocmd[1]
- opts[1] = nil
- end
- opts.callback = vim.schedule_wrap(function()
- triggered = true
- end)
- vim.api.nvim_create_autocmd(autocmd, opts)
- vim.wait(10000, function()
- return triggered
- end, 10)
- if not triggered then
- error('wait_for_autocmd timed out waiting for ' .. tostring(autocmd))
- end
-end
-
-M.wait_canola_ready = function()
- local ready = false
- util.run_after_load(
- 0,
- vim.schedule_wrap(function()
- ready = true
- end)
- )
- vim.wait(10000, function()
- return ready
- end, 10)
- if not ready then
- error('wait_canola_ready timed out')
- end
-end
-
----@param actions string[]
----@param timestep integer
-M.feedkeys = function(actions, timestep)
- timestep = timestep or 10
- vim.wait(timestep)
- for _, action in ipairs(actions) do
- vim.wait(timestep)
- local escaped = vim.api.nvim_replace_termcodes(action, true, false, true)
- vim.api.nvim_feedkeys(escaped, 'm', true)
- end
- vim.wait(timestep)
- vim.api.nvim_feedkeys('', 'x', true)
- vim.wait(timestep)
-end
-
-M.actions = {
- ---Open canola and wait for it to finish rendering
- ---@param args string[]
- open = function(args)
- vim.schedule(function()
- vim.cmd.Canola({ args = args })
- if vim.b.canola_ready then
- vim.api.nvim_exec_autocmds('User', {
- pattern = 'CanolaEnter',
- modeline = false,
- data = { buf = vim.api.nvim_get_current_buf() },
- })
- end
- end)
- M.wait_for_autocmd({ 'User', pattern = 'CanolaEnter' })
- end,
-
- ---Save all changes and wait for operation to complete
- save = function()
- vim.schedule_wrap(require('canola').save)({ confirm = false })
- M.wait_for_autocmd({ 'User', pattern = 'CanolaMutationComplete' })
- end,
-
- ---@param bufnr? integer
- reload = function(bufnr)
- M.await(require('canola.view').render_buffer_async, 3, bufnr or 0)
- end,
-
- ---Move cursor to a file or directory in an canola buffer
- ---@param filename string
- focus = function(filename)
- local lines = vim.api.nvim_buf_get_lines(0, 0, -1, true)
- local search = ' ' .. filename .. '$'
- for i, line in ipairs(lines) do
- if line:match(search) then
- vim.api.nvim_win_set_cursor(0, { i, 0 })
- return
- end
- end
- error('Could not find file ' .. filename)
- end,
-}
-
----Get the raw list of filenames from an unmodified canola buffer
----@param bufnr? integer
----@return string[]
-M.parse_entries = function(bufnr)
- bufnr = bufnr or 0
- if vim.bo[bufnr].modified then
- error("parse_entries doesn't work on a modified canola buffer")
- end
- local lines = vim.api.nvim_buf_get_lines(bufnr, 0, -1, true)
- return vim.tbl_map(function(line)
- return line:match('^/%d+ +(.+)$')
- end, lines)
-end
-
-return M
diff --git a/spec/trash_spec.lua b/spec/trash_spec.lua
deleted file mode 100644
index f3db67f..0000000
--- a/spec/trash_spec.lua
+++ /dev/null
@@ -1,149 +0,0 @@
-local TmpDir = require('spec.tmpdir')
-local test_util = require('spec.test_util')
-
-describe('freedesktop', function()
- local tmpdir
- local tmphome
- local home = vim.env.XDG_DATA_HOME
- before_each(function()
- require('canola.config').delete_to_trash = true
- tmpdir = TmpDir.new()
- tmphome = TmpDir.new()
- package.loaded['canola.adapters.trash'] = require('canola.adapters.trash.freedesktop')
- vim.env.XDG_DATA_HOME = tmphome.path
- end)
- after_each(function()
- vim.env.XDG_DATA_HOME = home
- if tmpdir then
- tmpdir:dispose()
- end
- if tmphome then
- tmphome:dispose()
- end
- test_util.reset_editor()
- package.loaded['canola.adapters.trash'] = nil
- end)
-
- it('files can be moved to the trash', function()
- tmpdir:create({ 'a.txt', 'foo/b.txt' })
- test_util.actions.open({ tmpdir.path })
- test_util.actions.focus('a.txt')
- vim.api.nvim_feedkeys('dd', 'x', true)
- test_util.actions.open({ '--trash', tmpdir.path })
- vim.api.nvim_feedkeys('p', 'x', true)
- test_util.actions.save()
- tmpdir:assert_not_exists('a.txt')
- tmpdir:assert_exists('foo/b.txt')
- test_util.actions.reload()
- assert.are.same({ 'a.txt' }, test_util.parse_entries(0))
- end)
-
- it('deleting a file moves it to trash', function()
- tmpdir:create({ 'a.txt', 'foo/b.txt' })
- test_util.actions.open({ tmpdir.path })
- test_util.actions.focus('a.txt')
- vim.api.nvim_feedkeys('dd', 'x', true)
- test_util.actions.save()
- tmpdir:assert_not_exists('a.txt')
- tmpdir:assert_exists('foo/b.txt')
- test_util.actions.open({ '--trash', tmpdir.path })
- assert.are.same({ 'a.txt' }, test_util.parse_entries(0))
- end)
-
- it('deleting a directory moves it to trash', function()
- tmpdir:create({ 'a.txt', 'foo/b.txt' })
- test_util.actions.open({ tmpdir.path })
- test_util.actions.focus('foo/')
- vim.api.nvim_feedkeys('dd', 'x', true)
- test_util.actions.save()
- tmpdir:assert_not_exists('foo')
- tmpdir:assert_exists('a.txt')
- test_util.actions.open({ '--trash', tmpdir.path })
- assert.are.same({ 'foo/' }, test_util.parse_entries(0))
- end)
-
- it('deleting a file from trash deletes it permanently', function()
- tmpdir:create({ 'a.txt' })
- test_util.actions.open({ tmpdir.path })
- test_util.actions.focus('a.txt')
- vim.api.nvim_feedkeys('dd', 'x', true)
- test_util.actions.save()
- test_util.actions.open({ '--trash', tmpdir.path })
- test_util.actions.focus('a.txt')
- vim.api.nvim_feedkeys('dd', 'x', true)
- test_util.actions.save()
- test_util.actions.reload()
- tmpdir:assert_not_exists('a.txt')
- assert.are.same({}, test_util.parse_entries(0))
- end)
-
- it('cannot create files in the trash', function()
- tmpdir:create({ 'a.txt' })
- test_util.actions.open({ tmpdir.path })
- test_util.actions.focus('a.txt')
- vim.api.nvim_feedkeys('dd', 'x', true)
- test_util.actions.save()
- test_util.actions.open({ '--trash', tmpdir.path })
- vim.api.nvim_feedkeys('onew_file.txt', 'x', true)
- test_util.actions.save()
- test_util.actions.reload()
- assert.are.same({ 'a.txt' }, test_util.parse_entries(0))
- end)
-
- it('cannot rename files in the trash', function()
- tmpdir:create({ 'a.txt' })
- test_util.actions.open({ tmpdir.path })
- test_util.actions.focus('a.txt')
- vim.api.nvim_feedkeys('dd', 'x', true)
- test_util.actions.save()
- test_util.actions.open({ '--trash', tmpdir.path })
- vim.api.nvim_feedkeys('0facwnew_name', 'x', true)
- test_util.actions.save()
- test_util.actions.reload()
- assert.are.same({ 'a.txt' }, test_util.parse_entries(0))
- end)
-
- it('cannot copy files in the trash', function()
- tmpdir:create({ 'a.txt' })
- test_util.actions.open({ tmpdir.path })
- test_util.actions.focus('a.txt')
- vim.api.nvim_feedkeys('dd', 'x', true)
- test_util.actions.save()
- test_util.actions.open({ '--trash', tmpdir.path })
- vim.api.nvim_feedkeys('yypp', 'x', true)
- test_util.actions.save()
- test_util.actions.reload()
- assert.are.same({ 'a.txt' }, test_util.parse_entries(0))
- end)
-
- it('can restore files from trash', function()
- tmpdir:create({ 'a.txt' })
- test_util.actions.open({ tmpdir.path })
- test_util.actions.focus('a.txt')
- vim.api.nvim_feedkeys('dd', 'x', true)
- test_util.actions.save()
- test_util.actions.open({ '--trash', tmpdir.path })
- vim.api.nvim_feedkeys('dd', 'x', true)
- test_util.actions.open({ tmpdir.path })
- vim.api.nvim_feedkeys('p', 'x', true)
- test_util.actions.save()
- test_util.actions.reload()
- assert.are.same({ 'a.txt' }, test_util.parse_entries(0))
- tmpdir:assert_fs({
- ['a.txt'] = 'a.txt',
- })
- end)
-
- it('can have multiple files with the same name in trash', function()
- tmpdir:create({ 'a.txt' })
- test_util.actions.open({ tmpdir.path })
- vim.api.nvim_feedkeys('dd', 'x', true)
- test_util.actions.save()
- tmpdir:create({ 'a.txt' })
- test_util.actions.reload()
- vim.api.nvim_feedkeys('dd', 'x', true)
- test_util.actions.save()
- test_util.actions.open({ '--trash', tmpdir.path })
- assert.are.same({ 'a.txt', 'a.txt' }, test_util.parse_entries(0))
- end)
-end)
diff --git a/spec/url_spec.lua b/spec/url_spec.lua
deleted file mode 100644
index 68dfc3f..0000000
--- a/spec/url_spec.lua
+++ /dev/null
@@ -1,32 +0,0 @@
-local canola = require('canola')
-local util = require('canola.util')
-describe('url', function()
- it('get_url_for_path', function()
- local cases = {
- { '', 'canola://' .. util.addslash(vim.fn.getcwd()) },
- {
- 'term://~/canola.nvim//52953:/bin/sh',
- 'canola://' .. vim.loop.os_homedir() .. '/canola.nvim/',
- },
- { '/foo/bar.txt', 'canola:///foo/', 'bar.txt' },
- { 'canola:///foo/bar.txt', 'canola:///foo/', 'bar.txt' },
- { 'canola:///', 'canola:///' },
- {
- 'canola-ssh://user@hostname:8888//bar.txt',
- 'canola-ssh://user@hostname:8888//',
- 'bar.txt',
- },
- { 'canola-ssh://user@hostname:8888//', 'canola-ssh://user@hostname:8888//' },
- }
- for _, case in ipairs(cases) do
- local input, expected, expected_basename = unpack(case)
- local output, basename = canola.get_buffer_parent_url(input, true)
- assert.equals(expected, output, string.format('Parent url for path "%s" failed', input))
- assert.equals(
- expected_basename,
- basename,
- string.format('Basename for path "%s" failed', input)
- )
- end
- end)
-end)
diff --git a/spec/win_options_spec.lua b/spec/win_options_spec.lua
deleted file mode 100644
index 54f94f2..0000000
--- a/spec/win_options_spec.lua
+++ /dev/null
@@ -1,65 +0,0 @@
-local canola = require('canola')
-local test_util = require('spec.test_util')
-
-describe('window options', function()
- after_each(function()
- test_util.reset_editor()
- end)
-
- it('Restores window options on close', function()
- vim.cmd.edit({ args = { 'README.md' } })
- test_util.canola_open()
- assert.equals('no', vim.o.signcolumn)
- canola.close()
- assert.equals('auto', vim.o.signcolumn)
- end)
-
- it('Restores window options on edit', function()
- test_util.canola_open()
- assert.equals('no', vim.o.signcolumn)
- vim.cmd.edit({ args = { 'README.md' } })
- assert.equals('auto', vim.o.signcolumn)
- end)
-
- it('Restores window options on split ', function()
- test_util.canola_open()
- assert.equals('no', vim.o.signcolumn)
- vim.cmd.split({ args = { 'README.md' } })
- assert.equals('auto', vim.o.signcolumn)
- end)
-
- it('Restores window options on split', function()
- test_util.canola_open()
- assert.equals('no', vim.o.signcolumn)
- vim.cmd.split()
- vim.cmd.edit({ args = { 'README.md' } })
- assert.equals('auto', vim.o.signcolumn)
- end)
-
- it('Restores window options on tabnew ', function()
- test_util.canola_open()
- assert.equals('no', vim.o.signcolumn)
- vim.cmd.tabnew({ args = { 'README.md' } })
- assert.equals('auto', vim.o.signcolumn)
- end)
-
- it('Restores window options on tabnew', function()
- test_util.canola_open()
- assert.equals('no', vim.o.signcolumn)
- vim.cmd.tabnew()
- vim.cmd.edit({ args = { 'README.md' } })
- assert.equals('auto', vim.o.signcolumn)
- end)
-
- it('Sets the window options when re-entering canola buffer', function()
- canola.open()
- test_util.wait_for_autocmd({ 'User', pattern = 'CanolaEnter' })
- assert.truthy(vim.w.canola_did_enter)
- vim.cmd.edit({ args = { 'README.md' } })
- assert.falsy(vim.w.canola_did_enter)
- canola.open()
- assert.truthy(vim.w.canola_did_enter)
- vim.cmd.vsplit()
- assert.truthy(vim.w.canola_did_enter)
- end)
-end)
diff --git a/syntax/canola.vim b/syntax/canola.vim
deleted file mode 100644
index 330abc7..0000000
--- a/syntax/canola.vim
+++ /dev/null
@@ -1,7 +0,0 @@
-if exists("b:current_syntax")
- finish
-endif
-
-syn match canolaId /^\/\d* / conceal
-
-let b:current_syntax = "canola"
diff --git a/syntax/canola_preview.vim b/syntax/canola_preview.vim
deleted file mode 100644
index 2473f1e..0000000
--- a/syntax/canola_preview.vim
+++ /dev/null
@@ -1,15 +0,0 @@
-if exists("b:current_syntax")
- finish
-endif
-
-syn match canolaCreate /^CREATE\( BUCKET\)\? /
-syn match canolaMove /^ MOVE /
-syn match canolaDelete /^DELETE\( BUCKET\)\? /
-syn match canolaCopy /^ COPY /
-syn match canolaChange /^CHANGE /
-" Trash operations
-syn match canolaRestore /^RESTORE /
-syn match canolaPurge /^ PURGE /
-syn match canolaTrash /^ TRASH /
-
-let b:current_syntax = "canola_preview"
diff --git a/syntax/oil.vim b/syntax/oil.vim
new file mode 100644
index 0000000..0f2a4a3
--- /dev/null
+++ b/syntax/oil.vim
@@ -0,0 +1,7 @@
+if exists("b:current_syntax")
+ finish
+endif
+
+syn match oilId /^\/\d* / conceal
+
+let b:current_syntax = "oil"
diff --git a/syntax/oil_preview.vim b/syntax/oil_preview.vim
new file mode 100644
index 0000000..2f14df9
--- /dev/null
+++ b/syntax/oil_preview.vim
@@ -0,0 +1,15 @@
+if exists("b:current_syntax")
+ finish
+endif
+
+syn match oilCreate /^CREATE\( BUCKET\)\? /
+syn match oilMove /^ MOVE /
+syn match oilDelete /^DELETE\( BUCKET\)\? /
+syn match oilCopy /^ COPY /
+syn match oilChange /^CHANGE /
+" Trash operations
+syn match oilRestore /^RESTORE /
+syn match oilPurge /^ PURGE /
+syn match oilTrash /^ TRASH /
+
+let b:current_syntax = "oil_preview"
diff --git a/tests/altbuf_spec.lua b/tests/altbuf_spec.lua
new file mode 100644
index 0000000..beece15
--- /dev/null
+++ b/tests/altbuf_spec.lua
@@ -0,0 +1,157 @@
+require("plenary.async").tests.add_to_env()
+local fs = require("oil.fs")
+local oil = require("oil")
+local test_util = require("tests.test_util")
+
+a.describe("Alternate buffer", function()
+ after_each(function()
+ test_util.reset_editor()
+ end)
+
+ a.it("sets previous buffer as alternate", function()
+ vim.cmd.edit({ args = { "foo" } })
+ oil.open()
+ test_util.wait_for_autocmd({ "User", pattern = "OilEnter" })
+ vim.cmd.edit({ args = { "bar" } })
+ assert.equals("foo", vim.fn.expand("#"))
+ end)
+
+ a.it("sets previous buffer as alternate when editing url file", function()
+ vim.cmd.edit({ args = { "foo" } })
+ oil.open()
+ test_util.wait_for_autocmd({ "User", pattern = "OilEnter" })
+ local readme = fs.join(vim.fn.getcwd(), "README.md")
+ vim.cmd.edit({ args = { "oil://" .. fs.os_to_posix_path(readme) } })
+ -- We're gonna jump around to 2 different buffers
+ test_util.wait_for_autocmd("BufEnter")
+ test_util.wait_for_autocmd("BufEnter")
+ assert.equals(readme, vim.api.nvim_buf_get_name(0))
+ assert.equals("foo", vim.fn.expand("#"))
+ end)
+
+ a.it("sets previous buffer as alternate when editing oil://", function()
+ vim.cmd.edit({ args = { "foo" } })
+ vim.cmd.edit({ args = { "oil://" .. fs.os_to_posix_path(vim.fn.getcwd()) } })
+ test_util.wait_for_autocmd({ "User", pattern = "OilEnter" })
+ vim.cmd.edit({ args = { "bar" } })
+ assert.equals("foo", vim.fn.expand("#"))
+ end)
+
+ a.it("preserves alternate buffer if editing the same file", function()
+ vim.cmd.edit({ args = { "foo" } })
+ vim.cmd.edit({ args = { "bar" } })
+ oil.open()
+ test_util.wait_for_autocmd({ "User", pattern = "OilEnter" })
+ vim.cmd.edit({ args = { "bar" } })
+ assert.equals("foo", vim.fn.expand("#"))
+ end)
+
+ a.it("preserves alternate buffer if discarding changes", function()
+ vim.cmd.edit({ args = { "foo" } })
+ vim.cmd.edit({ args = { "bar" } })
+ oil.open()
+ test_util.wait_for_autocmd({ "User", pattern = "OilEnter" })
+ oil.close()
+ assert.equals("bar", vim.fn.expand("%"))
+ assert.equals("foo", vim.fn.expand("#"))
+ end)
+
+ a.it("sets previous buffer as alternate after multi-dir hops", function()
+ vim.cmd.edit({ args = { "foo" } })
+ oil.open()
+ test_util.wait_for_autocmd({ "User", pattern = "OilEnter" })
+ oil.open()
+ test_util.wait_for_autocmd({ "User", pattern = "OilEnter" })
+ oil.open()
+ test_util.wait_for_autocmd({ "User", pattern = "OilEnter" })
+ oil.open()
+ test_util.wait_for_autocmd({ "User", pattern = "OilEnter" })
+ vim.cmd.edit({ args = { "bar" } })
+ assert.equals("foo", vim.fn.expand("#"))
+ end)
+
+ a.it("sets previous buffer as alternate when inside oil buffer", function()
+ vim.cmd.edit({ args = { "foo" } })
+ oil.open()
+ test_util.wait_for_autocmd({ "User", pattern = "OilEnter" })
+ assert.equals("foo", vim.fn.expand("#"))
+ vim.cmd.edit({ args = { "bar" } })
+ assert.equals("foo", vim.fn.expand("#"))
+ oil.open()
+ assert.equals("bar", vim.fn.expand("#"))
+ end)
+
+ a.it("preserves alternate when traversing oil dirs", function()
+ vim.cmd.edit({ args = { "foo" } })
+ oil.open()
+ test_util.wait_for_autocmd({ "User", pattern = "OilEnter" })
+ assert.equals("foo", vim.fn.expand("#"))
+ vim.wait(1000, function()
+ return oil.get_cursor_entry()
+ end, 10)
+ vim.api.nvim_win_set_cursor(0, { 1, 1 })
+ oil.select()
+ test_util.wait_for_autocmd({ "User", pattern = "OilEnter" })
+ assert.equals("foo", vim.fn.expand("#"))
+ end)
+
+ a.it("preserves alternate when opening preview", function()
+ vim.cmd.edit({ args = { "foo" } })
+ oil.open()
+ test_util.wait_for_autocmd({ "User", pattern = "OilEnter" })
+ assert.equals("foo", vim.fn.expand("#"))
+ vim.wait(1000, function()
+ return oil.get_cursor_entry()
+ end, 10)
+ vim.api.nvim_win_set_cursor(0, { 1, 1 })
+ oil.open_preview()
+ test_util.wait_for_autocmd({ "User", pattern = "OilEnter" })
+ assert.equals("foo", vim.fn.expand("#"))
+ end)
+
+ a.describe("floating window", function()
+ a.it("sets previous buffer as alternate", function()
+ vim.cmd.edit({ args = { "foo" } })
+ oil.open_float()
+ test_util.wait_for_autocmd({ "User", pattern = "OilEnter" })
+ -- This is lazy, but testing the actual select logic is more difficult. We can simply
+ -- replicate it by closing the current window and then doing the edit
+ vim.api.nvim_win_close(0, true)
+ vim.cmd.edit({ args = { "bar" } })
+ assert.equals("foo", vim.fn.expand("#"))
+ end)
+
+ a.it("preserves alternate buffer if editing the same file", function()
+ vim.cmd.edit({ args = { "foo" } })
+ vim.cmd.edit({ args = { "bar" } })
+ oil.open_float()
+ test_util.wait_for_autocmd({ "User", pattern = "OilEnter" })
+ -- This is lazy, but testing the actual select logic is more difficult. We can simply
+ -- replicate it by closing the current window and then doing the edit
+ vim.api.nvim_win_close(0, true)
+ vim.cmd.edit({ args = { "bar" } })
+ assert.equals("foo", vim.fn.expand("#"))
+ end)
+
+ a.it("preserves alternate buffer if discarding changes", function()
+ vim.cmd.edit({ args = { "foo" } })
+ vim.cmd.edit({ args = { "bar" } })
+ oil.open_float()
+ test_util.wait_for_autocmd({ "User", pattern = "OilEnter" })
+ oil.close()
+ assert.equals("foo", vim.fn.expand("#"))
+ end)
+
+ a.it("preserves alternate when traversing to a new file", function()
+ vim.cmd.edit({ args = { "foo" } })
+ oil.open_float()
+ test_util.wait_for_autocmd({ "User", pattern = "OilEnter" })
+ assert.equals("foo", vim.fn.expand("#"))
+ test_util.feedkeys({ "/LICENSE" }, 10)
+ oil.select()
+ test_util.wait_for_autocmd("BufEnter")
+ assert.equals("LICENSE", vim.fn.expand("%:."))
+ assert.equals("foo", vim.fn.expand("#"))
+ end)
+ end)
+end)
diff --git a/tests/close_spec.lua b/tests/close_spec.lua
new file mode 100644
index 0000000..ff14738
--- /dev/null
+++ b/tests/close_spec.lua
@@ -0,0 +1,45 @@
+require("plenary.async").tests.add_to_env()
+local oil = require("oil")
+local test_util = require("tests.test_util")
+
+a.describe("close", function()
+ a.before_each(function()
+ test_util.reset_editor()
+ end)
+ a.after_each(function()
+ test_util.reset_editor()
+ end)
+
+ a.it("does not close buffer from visual mode", function()
+ oil.open()
+ test_util.wait_for_autocmd({ "User", pattern = "OilEnter" })
+ assert.equals("oil", vim.bo.filetype)
+ test_util.feedkeys({ "V" }, 10)
+ oil.close()
+ assert.equals("oil", vim.bo.filetype)
+ test_util.feedkeys({ "" }, 10)
+ end)
+
+ a.it("does not close buffer from operator-pending mode", function()
+ oil.open()
+ test_util.wait_for_autocmd({ "User", pattern = "OilEnter" })
+ assert.equals("oil", vim.bo.filetype)
+ vim.api.nvim_feedkeys("d", "n", false)
+ a.util.sleep(20)
+ local mode = vim.api.nvim_get_mode().mode
+ if mode:match("^no") then
+ oil.close()
+ assert.equals("oil", vim.bo.filetype)
+ end
+ vim.api.nvim_feedkeys(vim.api.nvim_replace_termcodes("", true, true, true), "n", false)
+ a.util.sleep(20)
+ end)
+
+ a.it("closes buffer from normal mode", function()
+ oil.open()
+ test_util.wait_for_autocmd({ "User", pattern = "OilEnter" })
+ assert.equals("oil", vim.bo.filetype)
+ oil.close()
+ assert.not_equals("oil", vim.bo.filetype)
+ end)
+end)
diff --git a/tests/config_spec.lua b/tests/config_spec.lua
new file mode 100644
index 0000000..aac4eb1
--- /dev/null
+++ b/tests/config_spec.lua
@@ -0,0 +1,27 @@
+local config = require("oil.config")
+
+describe("config", function()
+ after_each(function()
+ vim.g.oil = nil
+ end)
+
+ it("falls back to vim.g.oil when setup() is called with no args", function()
+ vim.g.oil = { delete_to_trash = true, cleanup_delay_ms = 5000 }
+ config.setup()
+ assert.is_true(config.delete_to_trash)
+ assert.equals(5000, config.cleanup_delay_ms)
+ end)
+
+ it("uses defaults when neither opts nor vim.g.oil is set", function()
+ vim.g.oil = nil
+ config.setup()
+ assert.is_false(config.delete_to_trash)
+ assert.equals(2000, config.cleanup_delay_ms)
+ end)
+
+ it("prefers explicit opts over vim.g.oil", function()
+ vim.g.oil = { delete_to_trash = true }
+ config.setup({ delete_to_trash = false })
+ assert.is_false(config.delete_to_trash)
+ end)
+end)
diff --git a/tests/files_spec.lua b/tests/files_spec.lua
new file mode 100644
index 0000000..4333d80
--- /dev/null
+++ b/tests/files_spec.lua
@@ -0,0 +1,173 @@
+require("plenary.async").tests.add_to_env()
+local TmpDir = require("tests.tmpdir")
+local files = require("oil.adapters.files")
+local test_util = require("tests.test_util")
+
+a.describe("files adapter", function()
+ local tmpdir
+ a.before_each(function()
+ tmpdir = TmpDir.new()
+ end)
+ a.after_each(function()
+ if tmpdir then
+ tmpdir:dispose()
+ end
+ test_util.reset_editor()
+ end)
+
+ a.it("tmpdir creates files and asserts they exist", function()
+ tmpdir:create({ "a.txt", "foo/b.txt", "foo/c.txt", "bar/" })
+ tmpdir:assert_fs({
+ ["a.txt"] = "a.txt",
+ ["foo/b.txt"] = "foo/b.txt",
+ ["foo/c.txt"] = "foo/c.txt",
+ ["bar/"] = true,
+ })
+ end)
+
+ a.it("Creates files", function()
+ local err = a.wrap(files.perform_action, 2)({
+ url = "oil://" .. vim.fn.fnamemodify(tmpdir.path, ":p") .. "a.txt",
+ entry_type = "file",
+ type = "create",
+ })
+ assert.is_nil(err)
+ tmpdir:assert_fs({
+ ["a.txt"] = "",
+ })
+ end)
+
+ a.it("Creates directories", function()
+ local err = a.wrap(files.perform_action, 2)({
+ url = "oil://" .. vim.fn.fnamemodify(tmpdir.path, ":p") .. "a",
+ entry_type = "directory",
+ type = "create",
+ })
+ assert.is_nil(err)
+ tmpdir:assert_fs({
+ ["a/"] = true,
+ })
+ end)
+
+ a.it("Deletes files", function()
+ tmpdir:create({ "a.txt" })
+ a.util.scheduler()
+ local url = "oil://" .. vim.fn.fnamemodify(tmpdir.path, ":p") .. "a.txt"
+ local err = a.wrap(files.perform_action, 2)({
+ url = url,
+ entry_type = "file",
+ type = "delete",
+ })
+ assert.is_nil(err)
+ tmpdir:assert_fs({})
+ end)
+
+ a.it("Deletes directories", function()
+ tmpdir:create({ "a/" })
+ local url = "oil://" .. vim.fn.fnamemodify(tmpdir.path, ":p") .. "a"
+ local err = a.wrap(files.perform_action, 2)({
+ url = url,
+ entry_type = "directory",
+ type = "delete",
+ })
+ assert.is_nil(err)
+ tmpdir:assert_fs({})
+ end)
+
+ a.it("Moves files", function()
+ tmpdir:create({ "a.txt" })
+ a.util.scheduler()
+ local src_url = "oil://" .. vim.fn.fnamemodify(tmpdir.path, ":p") .. "a.txt"
+ local dest_url = "oil://" .. vim.fn.fnamemodify(tmpdir.path, ":p") .. "b.txt"
+ local err = a.wrap(files.perform_action, 2)({
+ src_url = src_url,
+ dest_url = dest_url,
+ entry_type = "file",
+ type = "move",
+ })
+ assert.is_nil(err)
+ tmpdir:assert_fs({
+ ["b.txt"] = "a.txt",
+ })
+ end)
+
+ a.it("Moves directories", function()
+ tmpdir:create({ "a/a.txt" })
+ a.util.scheduler()
+ local src_url = "oil://" .. vim.fn.fnamemodify(tmpdir.path, ":p") .. "a"
+ local dest_url = "oil://" .. vim.fn.fnamemodify(tmpdir.path, ":p") .. "b"
+ local err = a.wrap(files.perform_action, 2)({
+ src_url = src_url,
+ dest_url = dest_url,
+ entry_type = "directory",
+ type = "move",
+ })
+ assert.is_nil(err)
+ tmpdir:assert_fs({
+ ["b/a.txt"] = "a/a.txt",
+ ["b/"] = true,
+ })
+ end)
+
+ a.it("Copies files", function()
+ tmpdir:create({ "a.txt" })
+ a.util.scheduler()
+ local src_url = "oil://" .. vim.fn.fnamemodify(tmpdir.path, ":p") .. "a.txt"
+ local dest_url = "oil://" .. vim.fn.fnamemodify(tmpdir.path, ":p") .. "b.txt"
+ local err = a.wrap(files.perform_action, 2)({
+ src_url = src_url,
+ dest_url = dest_url,
+ entry_type = "file",
+ type = "copy",
+ })
+ assert.is_nil(err)
+ tmpdir:assert_fs({
+ ["a.txt"] = "a.txt",
+ ["b.txt"] = "a.txt",
+ })
+ end)
+
+ a.it("Recursively copies directories", function()
+ tmpdir:create({ "a/a.txt" })
+ a.util.scheduler()
+ local src_url = "oil://" .. vim.fn.fnamemodify(tmpdir.path, ":p") .. "a"
+ local dest_url = "oil://" .. vim.fn.fnamemodify(tmpdir.path, ":p") .. "b"
+ local err = a.wrap(files.perform_action, 2)({
+ src_url = src_url,
+ dest_url = dest_url,
+ entry_type = "directory",
+ type = "copy",
+ })
+ assert.is_nil(err)
+ tmpdir:assert_fs({
+ ["b/a.txt"] = "a/a.txt",
+ ["b/"] = true,
+ ["a/a.txt"] = "a/a.txt",
+ ["a/"] = true,
+ })
+ end)
+
+ a.it("Editing a new oil://path/ creates an oil buffer", function()
+ local tmpdir_url = "oil://" .. vim.fn.fnamemodify(tmpdir.path, ":p") .. "/"
+ vim.cmd.edit({ args = { tmpdir_url } })
+ test_util.wait_oil_ready()
+ local new_url = "oil://" .. vim.fn.fnamemodify(tmpdir.path, ":p") .. "newdir"
+ vim.cmd.edit({ args = { new_url } })
+ test_util.wait_oil_ready()
+ assert.equals("oil", vim.bo.filetype)
+ -- The normalization will add a '/'
+ assert.equals(new_url .. "/", vim.api.nvim_buf_get_name(0))
+ end)
+
+ a.it("Editing a new oil://file.rb creates a normal buffer", function()
+ local tmpdir_url = "oil://" .. vim.fn.fnamemodify(tmpdir.path, ":p") .. "/"
+ vim.cmd.edit({ args = { tmpdir_url } })
+ test_util.wait_for_autocmd("BufReadPost")
+ local new_url = "oil://" .. vim.fn.fnamemodify(tmpdir.path, ":p") .. "file.rb"
+ vim.cmd.edit({ args = { new_url } })
+ test_util.wait_for_autocmd("BufReadPost")
+ assert.equals("ruby", vim.bo.filetype)
+ assert.equals(vim.fn.fnamemodify(tmpdir.path, ":p") .. "file.rb", vim.api.nvim_buf_get_name(0))
+ assert.equals(tmpdir.path .. "/file.rb", vim.fn.bufname())
+ end)
+end)
diff --git a/spec/manual_progress.lua b/tests/manual_progress.lua
similarity index 64%
rename from spec/manual_progress.lua
rename to tests/manual_progress.lua
index 3842674..bb838e2 100644
--- a/spec/manual_progress.lua
+++ b/tests/manual_progress.lua
@@ -1,5 +1,5 @@
-- Manual test for minimizing/restoring progress window
-local Progress = require('canola.mutator.progress')
+local Progress = require("oil.mutator.progress")
local progress = Progress.new()
@@ -12,9 +12,9 @@ progress:show({
for i = 1, 10, 1 do
vim.defer_fn(function()
progress:set_action({
- type = 'create',
- url = string.format('canola:///tmp/test_%d.txt', i),
- entry_type = 'file',
+ type = "create",
+ url = string.format("oil:///tmp/test_%d.txt", i),
+ entry_type = "file",
}, i, 10)
end, (i - 1) * 1000)
end
@@ -23,6 +23,6 @@ vim.defer_fn(function()
progress:close()
end, 10000)
-vim.keymap.set('n', 'R', function()
+vim.keymap.set("n", "R", function()
progress:restore()
end, {})
diff --git a/tests/minimal_init.lua b/tests/minimal_init.lua
new file mode 100644
index 0000000..70a66b1
--- /dev/null
+++ b/tests/minimal_init.lua
@@ -0,0 +1,5 @@
+vim.opt.runtimepath:append(".")
+
+vim.o.swapfile = false
+vim.bo.swapfile = false
+require("tests.test_util").reset_editor()
diff --git a/tests/move_rename_spec.lua b/tests/move_rename_spec.lua
new file mode 100644
index 0000000..660ab64
--- /dev/null
+++ b/tests/move_rename_spec.lua
@@ -0,0 +1,59 @@
+local fs = require("oil.fs")
+local test_util = require("tests.test_util")
+local util = require("oil.util")
+
+describe("update_moved_buffers", function()
+ after_each(function()
+ test_util.reset_editor()
+ end)
+
+ it("Renames moved buffers", function()
+ vim.cmd.edit({ args = { "oil-test:///foo/bar.txt" } })
+ util.update_moved_buffers("file", "oil-test:///foo/bar.txt", "oil-test:///foo/baz.txt")
+ assert.equals("oil-test:///foo/baz.txt", vim.api.nvim_buf_get_name(0))
+ end)
+
+ it("Renames moved buffers when they are normal files", function()
+ local tmpdir = fs.join(vim.loop.fs_realpath(vim.fn.stdpath("cache")), "oil", "test")
+ local testfile = fs.join(tmpdir, "foo.txt")
+ vim.cmd.edit({ args = { testfile } })
+ util.update_moved_buffers(
+ "file",
+ "oil://" .. fs.os_to_posix_path(testfile),
+ "oil://" .. fs.os_to_posix_path(fs.join(tmpdir, "bar.txt"))
+ )
+ assert.equals(fs.join(tmpdir, "bar.txt"), vim.api.nvim_buf_get_name(0))
+ end)
+
+ it("Renames directories", function()
+ vim.cmd.edit({ args = { "oil-test:///foo/" } })
+ util.update_moved_buffers("directory", "oil-test:///foo/", "oil-test:///bar/")
+ assert.equals("oil-test:///bar/", vim.api.nvim_buf_get_name(0))
+ end)
+
+ it("Renames subdirectories", function()
+ vim.cmd.edit({ args = { "oil-test:///foo/bar/" } })
+ util.update_moved_buffers("directory", "oil-test:///foo/", "oil-test:///baz/")
+ assert.equals("oil-test:///baz/bar/", vim.api.nvim_buf_get_name(0))
+ end)
+
+ it("Renames subfiles", function()
+ vim.cmd.edit({ args = { "oil-test:///foo/bar.txt" } })
+ util.update_moved_buffers("directory", "oil-test:///foo/", "oil-test:///baz/")
+ assert.equals("oil-test:///baz/bar.txt", vim.api.nvim_buf_get_name(0))
+ end)
+
+ it("Renames subfiles when they are normal files", function()
+ local tmpdir = fs.join(vim.loop.fs_realpath(vim.fn.stdpath("cache")), "oil", "test")
+ local foo = fs.join(tmpdir, "foo")
+ local bar = fs.join(tmpdir, "bar")
+ local testfile = fs.join(foo, "foo.txt")
+ vim.cmd.edit({ args = { testfile } })
+ util.update_moved_buffers(
+ "directory",
+ "oil://" .. fs.os_to_posix_path(foo),
+ "oil://" .. fs.os_to_posix_path(bar)
+ )
+ assert.equals(fs.join(bar, "foo.txt"), vim.api.nvim_buf_get_name(0))
+ end)
+end)
diff --git a/tests/mutator_spec.lua b/tests/mutator_spec.lua
new file mode 100644
index 0000000..17548d3
--- /dev/null
+++ b/tests/mutator_spec.lua
@@ -0,0 +1,426 @@
+require("plenary.async").tests.add_to_env()
+local cache = require("oil.cache")
+local constants = require("oil.constants")
+local mutator = require("oil.mutator")
+local test_adapter = require("oil.adapters.test")
+local test_util = require("tests.test_util")
+
+local FIELD_ID = constants.FIELD_ID
+local FIELD_NAME = constants.FIELD_NAME
+local FIELD_TYPE = constants.FIELD_TYPE
+
+a.describe("mutator", function()
+ after_each(function()
+ test_util.reset_editor()
+ end)
+
+ describe("build actions", function()
+ it("empty diffs produce no actions", function()
+ vim.cmd.edit({ args = { "oil-test:///foo/" } })
+ local bufnr = vim.api.nvim_get_current_buf()
+ local actions = mutator.create_actions_from_diffs({
+ [bufnr] = {},
+ })
+ assert.are.same({}, actions)
+ end)
+
+ it("constructs CREATE actions", function()
+ vim.cmd.edit({ args = { "oil-test:///foo/" } })
+ local bufnr = vim.api.nvim_get_current_buf()
+ local diffs = {
+ { type = "new", name = "a.txt", entry_type = "file" },
+ }
+ local actions = mutator.create_actions_from_diffs({
+ [bufnr] = diffs,
+ })
+ assert.are.same({
+ {
+ type = "create",
+ entry_type = "file",
+ url = "oil-test:///foo/a.txt",
+ },
+ }, actions)
+ end)
+
+ it("constructs DELETE actions", function()
+ local file = test_adapter.test_set("/foo/a.txt", "file")
+ vim.cmd.edit({ args = { "oil-test:///foo/" } })
+ local bufnr = vim.api.nvim_get_current_buf()
+ local diffs = {
+ { type = "delete", name = "a.txt", id = file[FIELD_ID] },
+ }
+ local actions = mutator.create_actions_from_diffs({
+ [bufnr] = diffs,
+ })
+ assert.are.same({
+ {
+ type = "delete",
+ entry_type = "file",
+ url = "oil-test:///foo/a.txt",
+ },
+ }, actions)
+ end)
+
+ it("constructs COPY actions", function()
+ local file = test_adapter.test_set("/foo/a.txt", "file")
+ vim.cmd.edit({ args = { "oil-test:///foo/" } })
+ local bufnr = vim.api.nvim_get_current_buf()
+ local diffs = {
+ { type = "new", name = "b.txt", entry_type = "file", id = file[FIELD_ID] },
+ }
+ local actions = mutator.create_actions_from_diffs({
+ [bufnr] = diffs,
+ })
+ assert.are.same({
+ {
+ type = "copy",
+ entry_type = "file",
+ src_url = "oil-test:///foo/a.txt",
+ dest_url = "oil-test:///foo/b.txt",
+ },
+ }, actions)
+ end)
+
+ it("constructs MOVE actions", function()
+ local file = test_adapter.test_set("/foo/a.txt", "file")
+ vim.cmd.edit({ args = { "oil-test:///foo/" } })
+ local bufnr = vim.api.nvim_get_current_buf()
+ local diffs = {
+ { type = "delete", name = "a.txt", id = file[FIELD_ID] },
+ { type = "new", name = "b.txt", entry_type = "file", id = file[FIELD_ID] },
+ }
+ local actions = mutator.create_actions_from_diffs({
+ [bufnr] = diffs,
+ })
+ assert.are.same({
+ {
+ type = "move",
+ entry_type = "file",
+ src_url = "oil-test:///foo/a.txt",
+ dest_url = "oil-test:///foo/b.txt",
+ },
+ }, actions)
+ end)
+
+ it("correctly orders MOVE + CREATE", function()
+ local file = test_adapter.test_set("/a.txt", "file")
+ vim.cmd.edit({ args = { "oil-test:///" } })
+ local bufnr = vim.api.nvim_get_current_buf()
+ local diffs = {
+ { type = "delete", name = "a.txt", id = file[FIELD_ID] },
+ { type = "new", name = "b.txt", entry_type = "file", id = file[FIELD_ID] },
+ { type = "new", name = "a.txt", entry_type = "file" },
+ }
+ local actions = mutator.create_actions_from_diffs({
+ [bufnr] = diffs,
+ })
+ assert.are.same({
+ {
+ type = "move",
+ entry_type = "file",
+ src_url = "oil-test:///a.txt",
+ dest_url = "oil-test:///b.txt",
+ },
+ {
+ type = "create",
+ entry_type = "file",
+ url = "oil-test:///a.txt",
+ },
+ }, actions)
+ end)
+
+ it("resolves MOVE loops", function()
+ local afile = test_adapter.test_set("/a.txt", "file")
+ local bfile = test_adapter.test_set("/b.txt", "file")
+ vim.cmd.edit({ args = { "oil-test:///" } })
+ local bufnr = vim.api.nvim_get_current_buf()
+ local diffs = {
+ { type = "delete", name = "a.txt", id = afile[FIELD_ID] },
+ { type = "new", name = "b.txt", entry_type = "file", id = afile[FIELD_ID] },
+ { type = "delete", name = "b.txt", id = bfile[FIELD_ID] },
+ { type = "new", name = "a.txt", entry_type = "file", id = bfile[FIELD_ID] },
+ }
+ math.randomseed(2983982)
+ local actions = mutator.create_actions_from_diffs({
+ [bufnr] = diffs,
+ })
+ local tmp_url = "oil-test:///a.txt__oil_tmp_510852"
+ assert.are.same({
+ {
+ type = "move",
+ entry_type = "file",
+ src_url = "oil-test:///a.txt",
+ dest_url = tmp_url,
+ },
+ {
+ type = "move",
+ entry_type = "file",
+ src_url = "oil-test:///b.txt",
+ dest_url = "oil-test:///a.txt",
+ },
+ {
+ type = "move",
+ entry_type = "file",
+ src_url = tmp_url,
+ dest_url = "oil-test:///b.txt",
+ },
+ }, actions)
+ end)
+ end)
+
+ describe("order actions", function()
+ it("Creates files inside dir before move", function()
+ local move = {
+ type = "move",
+ src_url = "oil-test:///a",
+ dest_url = "oil-test:///b",
+ entry_type = "directory",
+ }
+ local create = { type = "create", url = "oil-test:///a/hi.txt", entry_type = "file" }
+ local actions = { move, create }
+ local ordered_actions = mutator.enforce_action_order(actions)
+ assert.are.same({ create, move }, ordered_actions)
+ end)
+
+ it("Moves file out of parent before deleting parent", function()
+ local move = {
+ type = "move",
+ src_url = "oil-test:///a/b.txt",
+ dest_url = "oil-test:///b.txt",
+ entry_type = "file",
+ }
+ local delete = { type = "delete", url = "oil-test:///a", entry_type = "directory" }
+ local actions = { delete, move }
+ local ordered_actions = mutator.enforce_action_order(actions)
+ assert.are.same({ move, delete }, ordered_actions)
+ end)
+
+ it("Handles parent child move ordering", function()
+ -- move parent into a child and child OUT of parent
+ -- MOVE /a/b -> /b
+ -- MOVE /a -> /b/a
+ local move1 = {
+ type = "move",
+ src_url = "oil-test:///a/b",
+ dest_url = "oil-test:///b",
+ entry_type = "directory",
+ }
+ local move2 = {
+ type = "move",
+ src_url = "oil-test:///a",
+ dest_url = "oil-test:///b/a",
+ entry_type = "directory",
+ }
+ local actions = { move2, move1 }
+ local ordered_actions = mutator.enforce_action_order(actions)
+ assert.are.same({ move1, move2 }, ordered_actions)
+ end)
+
+ it("Handles a delete inside a moved folder", function()
+ -- delete in directory and move directory
+ -- DELETE /a/b.txt
+ -- MOVE /a/ -> /b/
+ local del = {
+ type = "delete",
+ url = "oil-test:///a/b.txt",
+ entry_type = "file",
+ }
+ local move = {
+ type = "move",
+ src_url = "oil-test:///a",
+ dest_url = "oil-test:///b",
+ entry_type = "directory",
+ }
+ local actions = { move, del }
+ local ordered_actions = mutator.enforce_action_order(actions)
+ assert.are.same({ del, move }, ordered_actions)
+ end)
+
+ it("Detects move directory loops", function()
+ local move = {
+ type = "move",
+ src_url = "oil-test:///a",
+ dest_url = "oil-test:///a/b",
+ entry_type = "directory",
+ }
+ assert.has_error(function()
+ mutator.enforce_action_order({ move })
+ end)
+ end)
+
+ it("Detects copy directory loops", function()
+ local move = {
+ type = "copy",
+ src_url = "oil-test:///a",
+ dest_url = "oil-test:///a/b",
+ entry_type = "directory",
+ }
+ assert.has_error(function()
+ mutator.enforce_action_order({ move })
+ end)
+ end)
+
+ it("Detects nested copy directory loops", function()
+ local move = {
+ type = "copy",
+ src_url = "oil-test:///a",
+ dest_url = "oil-test:///a/b/a",
+ entry_type = "directory",
+ }
+ assert.has_error(function()
+ mutator.enforce_action_order({ move })
+ end)
+ end)
+
+ describe("change", function()
+ it("applies CHANGE after CREATE", function()
+ local create = { type = "create", url = "oil-test:///a/hi.txt", entry_type = "file" }
+ local change = {
+ type = "change",
+ url = "oil-test:///a/hi.txt",
+ entry_type = "file",
+ column = "TEST",
+ value = "TEST",
+ }
+ local actions = { change, create }
+ local ordered_actions = mutator.enforce_action_order(actions)
+ assert.are.same({ create, change }, ordered_actions)
+ end)
+
+ it("applies CHANGE after COPY src", function()
+ local copy = {
+ type = "copy",
+ src_url = "oil-test:///a/hi.txt",
+ dest_url = "oil-test:///b.txt",
+ entry_type = "file",
+ }
+ local change = {
+ type = "change",
+ url = "oil-test:///a/hi.txt",
+ entry_type = "file",
+ column = "TEST",
+ value = "TEST",
+ }
+ local actions = { change, copy }
+ local ordered_actions = mutator.enforce_action_order(actions)
+ assert.are.same({ copy, change }, ordered_actions)
+ end)
+
+ it("applies CHANGE after COPY dest", function()
+ local copy = {
+ type = "copy",
+ src_url = "oil-test:///b.txt",
+ dest_url = "oil-test:///a/hi.txt",
+ entry_type = "file",
+ }
+ local change = {
+ type = "change",
+ url = "oil-test:///a/hi.txt",
+ entry_type = "file",
+ column = "TEST",
+ value = "TEST",
+ }
+ local actions = { change, copy }
+ local ordered_actions = mutator.enforce_action_order(actions)
+ assert.are.same({ copy, change }, ordered_actions)
+ end)
+
+ it("applies CHANGE after MOVE dest", function()
+ local move = {
+ type = "move",
+ src_url = "oil-test:///b.txt",
+ dest_url = "oil-test:///a/hi.txt",
+ entry_type = "file",
+ }
+ local change = {
+ type = "change",
+ url = "oil-test:///a/hi.txt",
+ entry_type = "file",
+ column = "TEST",
+ value = "TEST",
+ }
+ local actions = { change, move }
+ local ordered_actions = mutator.enforce_action_order(actions)
+ assert.are.same({ move, change }, ordered_actions)
+ end)
+ end)
+ end)
+
+ a.describe("perform actions", function()
+ a.it("creates new entries", function()
+ local actions = {
+ { type = "create", url = "oil-test:///a.txt", entry_type = "file" },
+ }
+ a.wrap(mutator.process_actions, 2)(actions)
+ local files = cache.list_url("oil-test:///")
+ assert.are.same({
+ ["a.txt"] = {
+ [FIELD_ID] = 1,
+ [FIELD_TYPE] = "file",
+ [FIELD_NAME] = "a.txt",
+ },
+ }, files)
+ end)
+
+ a.it("deletes entries", function()
+ local file = test_adapter.test_set("/a.txt", "file")
+ local actions = {
+ { type = "delete", url = "oil-test:///a.txt", entry_type = "file" },
+ }
+ a.wrap(mutator.process_actions, 2)(actions)
+ local files = cache.list_url("oil-test:///")
+ assert.are.same({}, files)
+ assert.is_nil(cache.get_entry_by_id(file[FIELD_ID]))
+ assert.has_error(function()
+ cache.get_parent_url(file[FIELD_ID])
+ end)
+ end)
+
+ a.it("moves entries", function()
+ local file = test_adapter.test_set("/a.txt", "file")
+ local actions = {
+ {
+ type = "move",
+ src_url = "oil-test:///a.txt",
+ dest_url = "oil-test:///b.txt",
+ entry_type = "file",
+ },
+ }
+ a.wrap(mutator.process_actions, 2)(actions)
+ local files = cache.list_url("oil-test:///")
+ local new_entry = {
+ [FIELD_ID] = file[FIELD_ID],
+ [FIELD_TYPE] = "file",
+ [FIELD_NAME] = "b.txt",
+ }
+ assert.are.same({
+ ["b.txt"] = new_entry,
+ }, files)
+ assert.are.same(new_entry, cache.get_entry_by_id(file[FIELD_ID]))
+ assert.equals("oil-test:///", cache.get_parent_url(file[FIELD_ID]))
+ end)
+
+ a.it("copies entries", function()
+ local file = test_adapter.test_set("/a.txt", "file")
+ local actions = {
+ {
+ type = "copy",
+ src_url = "oil-test:///a.txt",
+ dest_url = "oil-test:///b.txt",
+ entry_type = "file",
+ },
+ }
+ a.wrap(mutator.process_actions, 2)(actions)
+ local files = cache.list_url("oil-test:///")
+ local new_entry = {
+ [FIELD_ID] = file[FIELD_ID] + 1,
+ [FIELD_TYPE] = "file",
+ [FIELD_NAME] = "b.txt",
+ }
+ assert.are.same({
+ ["a.txt"] = file,
+ ["b.txt"] = new_entry,
+ }, files)
+ end)
+ end)
+end)
diff --git a/tests/parser_spec.lua b/tests/parser_spec.lua
new file mode 100644
index 0000000..9884ca1
--- /dev/null
+++ b/tests/parser_spec.lua
@@ -0,0 +1,250 @@
+require("plenary.async").tests.add_to_env()
+local constants = require("oil.constants")
+local parser = require("oil.mutator.parser")
+local test_adapter = require("oil.adapters.test")
+local test_util = require("tests.test_util")
+local util = require("oil.util")
+local view = require("oil.view")
+
+local FIELD_ID = constants.FIELD_ID
+local FIELD_META = constants.FIELD_META
+
+local function set_lines(bufnr, lines)
+ vim.bo[bufnr].modifiable = true
+ vim.api.nvim_buf_set_lines(bufnr, 0, -1, true, lines)
+end
+
+describe("parser", function()
+ after_each(function()
+ test_util.reset_editor()
+ end)
+
+ it("detects new files", function()
+ vim.cmd.edit({ args = { "oil-test:///foo/" } })
+ local bufnr = vim.api.nvim_get_current_buf()
+ set_lines(bufnr, {
+ "a.txt",
+ })
+ local diffs = parser.parse(bufnr)
+ assert.are.same({ { entry_type = "file", name = "a.txt", type = "new" } }, diffs)
+ end)
+
+ it("detects new directories", function()
+ vim.cmd.edit({ args = { "oil-test:///foo/" } })
+ local bufnr = vim.api.nvim_get_current_buf()
+ set_lines(bufnr, {
+ "foo/",
+ })
+ local diffs = parser.parse(bufnr)
+ assert.are.same({ { entry_type = "directory", name = "foo", type = "new" } }, diffs)
+ end)
+
+ it("detects new links", function()
+ vim.cmd.edit({ args = { "oil-test:///foo/" } })
+ local bufnr = vim.api.nvim_get_current_buf()
+ set_lines(bufnr, {
+ "a.txt -> b.txt",
+ })
+ local diffs = parser.parse(bufnr)
+ assert.are.same(
+ { { entry_type = "link", name = "a.txt", type = "new", link = "b.txt" } },
+ diffs
+ )
+ end)
+
+ it("detects deleted files", function()
+ local file = test_adapter.test_set("/foo/a.txt", "file")
+ vim.cmd.edit({ args = { "oil-test:///foo/" } })
+ local bufnr = vim.api.nvim_get_current_buf()
+ set_lines(bufnr, {})
+ local diffs = parser.parse(bufnr)
+ assert.are.same({
+ { name = "a.txt", type = "delete", id = file[FIELD_ID] },
+ }, diffs)
+ end)
+
+ it("detects deleted directories", function()
+ local dir = test_adapter.test_set("/foo/bar", "directory")
+ vim.cmd.edit({ args = { "oil-test:///foo/" } })
+ local bufnr = vim.api.nvim_get_current_buf()
+ set_lines(bufnr, {})
+ local diffs = parser.parse(bufnr)
+ assert.are.same({
+ { name = "bar", type = "delete", id = dir[FIELD_ID] },
+ }, diffs)
+ end)
+
+ it("detects deleted links", function()
+ local file = test_adapter.test_set("/foo/a.txt", "link")
+ file[FIELD_META] = { link = "b.txt" }
+ vim.cmd.edit({ args = { "oil-test:///foo/" } })
+ local bufnr = vim.api.nvim_get_current_buf()
+ set_lines(bufnr, {})
+ local diffs = parser.parse(bufnr)
+ assert.are.same({
+ { name = "a.txt", type = "delete", id = file[FIELD_ID] },
+ }, diffs)
+ end)
+
+ it("ignores empty lines", function()
+ local file = test_adapter.test_set("/foo/a.txt", "file")
+ vim.cmd.edit({ args = { "oil-test:///foo/" } })
+ local bufnr = vim.api.nvim_get_current_buf()
+ local cols = view.format_entry_cols(file, {}, {}, test_adapter, false)
+ local lines = util.render_table({ cols }, {})
+ table.insert(lines, "")
+ table.insert(lines, " ")
+ set_lines(bufnr, lines)
+ local diffs = parser.parse(bufnr)
+ assert.are.same({}, diffs)
+ end)
+
+ it("errors on missing filename", function()
+ vim.cmd.edit({ args = { "oil-test:///foo/" } })
+ local bufnr = vim.api.nvim_get_current_buf()
+ set_lines(bufnr, {
+ "/008",
+ })
+ local _, errors = parser.parse(bufnr)
+ assert.are_same({
+ {
+ message = "Malformed ID at start of line",
+ lnum = 0,
+ end_lnum = 1,
+ col = 0,
+ },
+ }, errors)
+ end)
+
+ it("errors on empty dirname", function()
+ vim.cmd.edit({ args = { "oil-test:///foo/" } })
+ local bufnr = vim.api.nvim_get_current_buf()
+ set_lines(bufnr, {
+ "/008 /",
+ })
+ local _, errors = parser.parse(bufnr)
+ assert.are.same({
+ {
+ message = "No filename found",
+ lnum = 0,
+ end_lnum = 1,
+ col = 0,
+ },
+ }, errors)
+ end)
+
+ it("errors on duplicate names", function()
+ vim.cmd.edit({ args = { "oil-test:///foo/" } })
+ local bufnr = vim.api.nvim_get_current_buf()
+ set_lines(bufnr, {
+ "foo",
+ "foo/",
+ })
+ local _, errors = parser.parse(bufnr)
+ assert.are.same({
+ {
+ message = "Duplicate filename",
+ lnum = 1,
+ end_lnum = 2,
+ col = 0,
+ },
+ }, errors)
+ end)
+
+ it("errors on duplicate names for existing files", function()
+ local file = test_adapter.test_set("/foo/a.txt", "file")
+ vim.cmd.edit({ args = { "oil-test:///foo/" } })
+ local bufnr = vim.api.nvim_get_current_buf()
+ set_lines(bufnr, {
+ "a.txt",
+ string.format("/%d a.txt", file[FIELD_ID]),
+ })
+ local _, errors = parser.parse(bufnr)
+ assert.are.same({
+ {
+ message = "Duplicate filename",
+ lnum = 1,
+ end_lnum = 2,
+ col = 0,
+ },
+ }, errors)
+ end)
+
+ it("ignores new dirs with empty name", function()
+ vim.cmd.edit({ args = { "oil-test:///foo/" } })
+ local bufnr = vim.api.nvim_get_current_buf()
+ set_lines(bufnr, {
+ "/",
+ })
+ local diffs = parser.parse(bufnr)
+ assert.are.same({}, diffs)
+ end)
+
+ it("parses a rename as a delete + new", function()
+ local file = test_adapter.test_set("/foo/a.txt", "file")
+ vim.cmd.edit({ args = { "oil-test:///foo/" } })
+ local bufnr = vim.api.nvim_get_current_buf()
+ set_lines(bufnr, {
+ string.format("/%d b.txt", file[FIELD_ID]),
+ })
+ local diffs = parser.parse(bufnr)
+ assert.are.same({
+ { type = "new", id = file[FIELD_ID], name = "b.txt", entry_type = "file" },
+ { type = "delete", id = file[FIELD_ID], name = "a.txt" },
+ }, diffs)
+ end)
+
+ it("detects a new trailing slash as a delete + create", function()
+ local file = test_adapter.test_set("/foo", "file")
+ vim.cmd.edit({ args = { "oil-test:///" } })
+ local bufnr = vim.api.nvim_get_current_buf()
+ set_lines(bufnr, {
+ string.format("/%d foo/", file[FIELD_ID]),
+ })
+ local diffs = parser.parse(bufnr)
+ assert.are.same({
+ { type = "new", name = "foo", entry_type = "directory" },
+ { type = "delete", id = file[FIELD_ID], name = "foo" },
+ }, diffs)
+ end)
+
+ it("detects renamed files that conflict", function()
+ local afile = test_adapter.test_set("/foo/a.txt", "file")
+ local bfile = test_adapter.test_set("/foo/b.txt", "file")
+ vim.cmd.edit({ args = { "oil-test:///foo/" } })
+ local bufnr = vim.api.nvim_get_current_buf()
+ set_lines(bufnr, {
+ string.format("/%d a.txt", bfile[FIELD_ID]),
+ string.format("/%d b.txt", afile[FIELD_ID]),
+ })
+ local diffs = parser.parse(bufnr)
+ local first_two = { diffs[1], diffs[2] }
+ local last_two = { diffs[3], diffs[4] }
+ table.sort(first_two, function(a, b)
+ return a.id < b.id
+ end)
+ table.sort(last_two, function(a, b)
+ return a.id < b.id
+ end)
+ assert.are.same({
+ { name = "b.txt", type = "new", id = afile[FIELD_ID], entry_type = "file" },
+ { name = "a.txt", type = "new", id = bfile[FIELD_ID], entry_type = "file" },
+ }, first_two)
+ assert.are.same({
+ { name = "a.txt", type = "delete", id = afile[FIELD_ID] },
+ { name = "b.txt", type = "delete", id = bfile[FIELD_ID] },
+ }, last_two)
+ end)
+
+ it("views link targets with trailing slashes as the same", function()
+ local file = test_adapter.test_set("/foo/mydir", "link")
+ file[FIELD_META] = { link = "dir/" }
+ vim.cmd.edit({ args = { "oil-test:///foo/" } })
+ local bufnr = vim.api.nvim_get_current_buf()
+ set_lines(bufnr, {
+ string.format("/%d mydir/ -> dir/", file[FIELD_ID]),
+ })
+ local diffs = parser.parse(bufnr)
+ assert.are.same({}, diffs)
+ end)
+end)
diff --git a/spec/path_spec.lua b/tests/path_spec.lua
similarity index 55%
rename from spec/path_spec.lua
rename to tests/path_spec.lua
index f066d1c..a92a1ca 100644
--- a/spec/path_spec.lua
+++ b/tests/path_spec.lua
@@ -1,13 +1,13 @@
-local pathutil = require('canola.pathutil')
-describe('pathutil', function()
- it('calculates parent path', function()
+local pathutil = require("oil.pathutil")
+describe("pathutil", function()
+ it("calculates parent path", function()
local cases = {
- { '/foo/bar', '/foo/' },
- { '/foo/bar/', '/foo/' },
- { '/', '/' },
- { '', '' },
- { 'foo/bar/', 'foo/' },
- { 'foo', '' },
+ { "/foo/bar", "/foo/" },
+ { "/foo/bar/", "/foo/" },
+ { "/", "/" },
+ { "", "" },
+ { "foo/bar/", "foo/" },
+ { "foo", "" },
}
for _, case in ipairs(cases) do
local input, expected = unpack(case)
@@ -16,12 +16,12 @@ describe('pathutil', function()
end
end)
- it('calculates basename', function()
+ it("calculates basename", function()
local cases = {
- { '/foo/bar', 'bar' },
- { '/foo/bar/', 'bar' },
- { '/', nil },
- { '', nil },
+ { "/foo/bar", "bar" },
+ { "/foo/bar/", "bar" },
+ { "/", nil },
+ { "", nil },
}
for _, case in ipairs(cases) do
local input, expected = unpack(case)
diff --git a/tests/preview_spec.lua b/tests/preview_spec.lua
new file mode 100644
index 0000000..08aba78
--- /dev/null
+++ b/tests/preview_spec.lua
@@ -0,0 +1,41 @@
+require("plenary.async").tests.add_to_env()
+local TmpDir = require("tests.tmpdir")
+local oil = require("oil")
+local test_util = require("tests.test_util")
+local util = require("oil.util")
+
+a.describe("oil preview", function()
+ local tmpdir
+ a.before_each(function()
+ tmpdir = TmpDir.new()
+ end)
+ a.after_each(function()
+ if tmpdir then
+ tmpdir:dispose()
+ end
+ test_util.reset_editor()
+ end)
+
+ a.it("opens preview window", function()
+ tmpdir:create({ "a.txt" })
+ test_util.oil_open(tmpdir.path)
+ a.wrap(oil.open_preview, 2)()
+ local preview_win = util.get_preview_win()
+ assert.not_nil(preview_win)
+ assert(preview_win)
+ local bufnr = vim.api.nvim_win_get_buf(preview_win)
+ local preview_lines = vim.api.nvim_buf_get_lines(bufnr, 0, -1, false)
+ assert.are.same({ "a.txt" }, preview_lines)
+ end)
+
+ a.it("opens preview window when open(preview={})", function()
+ tmpdir:create({ "a.txt" })
+ test_util.oil_open(tmpdir.path, { preview = {} })
+ local preview_win = util.get_preview_win()
+ assert.not_nil(preview_win)
+ assert(preview_win)
+ local bufnr = vim.api.nvim_win_get_buf(preview_win)
+ local preview_lines = vim.api.nvim_buf_get_lines(bufnr, 0, -1, false)
+ assert.are.same({ "a.txt" }, preview_lines)
+ end)
+end)
diff --git a/tests/regression_spec.lua b/tests/regression_spec.lua
new file mode 100644
index 0000000..9d8f944
--- /dev/null
+++ b/tests/regression_spec.lua
@@ -0,0 +1,148 @@
+require("plenary.async").tests.add_to_env()
+local TmpDir = require("tests.tmpdir")
+local actions = require("oil.actions")
+local oil = require("oil")
+local test_util = require("tests.test_util")
+local view = require("oil.view")
+
+a.describe("regression tests", function()
+ local tmpdir
+ a.before_each(function()
+ tmpdir = TmpDir.new()
+ end)
+ a.after_each(function()
+ if tmpdir then
+ tmpdir:dispose()
+ tmpdir = nil
+ end
+ test_util.reset_editor()
+ end)
+
+ -- see https://github.com/stevearc/oil.nvim/issues/25
+ a.it("can edit dirs that will be renamed to an existing buffer", function()
+ vim.cmd.edit({ args = { "README.md" } })
+ vim.cmd.vsplit()
+ vim.cmd.edit({ args = { "%:p:h" } })
+ assert.equals("oil", vim.bo.filetype)
+ vim.cmd.wincmd({ args = { "p" } })
+ assert.equals("markdown", vim.bo.filetype)
+ vim.cmd.edit({ args = { "%:p:h" } })
+ test_util.wait_for_autocmd({ "User", pattern = "OilEnter" })
+ assert.equals("oil", vim.bo.filetype)
+ end)
+
+ -- https://github.com/stevearc/oil.nvim/issues/37
+ a.it("places the cursor on correct entry when opening on file", function()
+ vim.cmd.edit({ args = { "." } })
+ test_util.wait_for_autocmd({ "User", pattern = "OilEnter" })
+ local entry = oil.get_cursor_entry()
+ assert.not_nil(entry)
+ assert.not_equals("README.md", entry and entry.name)
+ vim.cmd.edit({ args = { "README.md" } })
+ view.delete_hidden_buffers()
+ oil.open()
+ test_util.wait_for_autocmd({ "User", pattern = "OilEnter" })
+ entry = oil.get_cursor_entry()
+ assert.equals("README.md", entry and entry.name)
+ end)
+
+ -- https://github.com/stevearc/oil.nvim/issues/64
+ a.it("doesn't close floating windows oil didn't open itself", function()
+ local winid = vim.api.nvim_open_win(vim.fn.bufadd("README.md"), true, {
+ relative = "editor",
+ row = 1,
+ col = 1,
+ width = 100,
+ height = 100,
+ })
+ oil.open()
+ a.util.sleep(10)
+ oil.close()
+ a.util.sleep(10)
+ assert.equals(winid, vim.api.nvim_get_current_win())
+ end)
+
+ -- https://github.com/stevearc/oil.nvim/issues/64
+ a.it("doesn't close splits on oil.close", function()
+ vim.cmd.edit({ args = { "README.md" } })
+ vim.cmd.vsplit()
+ local winid = vim.api.nvim_get_current_win()
+ local bufnr = vim.api.nvim_get_current_buf()
+ oil.open()
+ a.util.sleep(10)
+ oil.close()
+ a.util.sleep(10)
+ assert.equals(2, #vim.api.nvim_tabpage_list_wins(0))
+ assert.equals(winid, vim.api.nvim_get_current_win())
+ assert.equals(bufnr, vim.api.nvim_get_current_buf())
+ end)
+
+ -- https://github.com/stevearc/oil.nvim/issues/79
+ a.it("Returns to empty buffer on close", function()
+ oil.open()
+ test_util.wait_for_autocmd({ "User", pattern = "OilEnter" })
+ oil.close()
+ assert.not_equals("oil", vim.bo.filetype)
+ assert.equals("", vim.api.nvim_buf_get_name(0))
+ end)
+
+ a.it("All buffers set nomodified after save", function()
+ tmpdir:create({ "a.txt" })
+ a.util.scheduler()
+ vim.cmd.edit({ args = { "oil://" .. vim.fn.fnamemodify(tmpdir.path, ":p") } })
+ local first_dir = vim.api.nvim_get_current_buf()
+ test_util.wait_for_autocmd({ "User", pattern = "OilEnter" })
+ test_util.feedkeys({ "dd", "itest/", "" }, 10)
+ vim.wait(1000, function()
+ return vim.bo.modifiable
+ end, 10)
+ test_util.feedkeys({ "p" }, 10)
+ a.util.scheduler()
+ oil.save({ confirm = false })
+ vim.wait(1000, function()
+ return vim.bo.modifiable
+ end, 10)
+ tmpdir:assert_fs({
+ ["test/a.txt"] = "a.txt",
+ })
+ -- The first oil buffer should not be modified anymore
+ assert.falsy(vim.bo[first_dir].modified)
+ end)
+
+ a.it("refreshing buffer doesn't lose track of it", function()
+ vim.cmd.edit({ args = { "." } })
+ test_util.wait_for_autocmd({ "User", pattern = "OilEnter" })
+ local bufnr = vim.api.nvim_get_current_buf()
+ vim.cmd.edit({ bang = true })
+ test_util.wait_for_autocmd({ "User", pattern = "OilEnter" })
+ assert.are.same({ bufnr }, require("oil.view").get_all_buffers())
+ end)
+
+ a.it("can copy a file multiple times", function()
+ test_util.actions.open({ tmpdir.path })
+ vim.api.nvim_feedkeys("ifoo.txt", "x", true)
+ test_util.actions.save()
+ vim.api.nvim_feedkeys("yyp$ciWbar.txt", "x", true)
+ vim.api.nvim_feedkeys("yyp$ciWbaz.txt", "x", true)
+ test_util.actions.save()
+ assert.are.same({ "bar.txt", "baz.txt", "foo.txt" }, test_util.parse_entries(0))
+ tmpdir:assert_fs({
+ ["foo.txt"] = "",
+ ["bar.txt"] = "",
+ ["baz.txt"] = "",
+ })
+ end)
+
+ -- https://github.com/stevearc/oil.nvim/issues/355
+ a.it("can open files from floating window", function()
+ tmpdir:create({ "a.txt" })
+ a.util.scheduler()
+ oil.open_float(tmpdir.path)
+ test_util.wait_for_autocmd({ "User", pattern = "OilEnter" })
+ actions.select.callback()
+ vim.wait(1000, function()
+ return vim.fn.expand("%:t") == "a.txt"
+ end, 10)
+ assert.equals("a.txt", vim.fn.expand("%:t"))
+ end)
+end)
diff --git a/spec/select_spec.lua b/tests/select_spec.lua
similarity index 51%
rename from spec/select_spec.lua
rename to tests/select_spec.lua
index 6708618..9de2eb4 100644
--- a/spec/select_spec.lua
+++ b/tests/select_spec.lua
@@ -1,85 +1,90 @@
-local canola = require('canola')
-local test_util = require('spec.test_util')
+require("plenary.async").tests.add_to_env()
+local oil = require("oil")
+local test_util = require("tests.test_util")
-describe('canola select', function()
+a.describe("oil select", function()
after_each(function()
test_util.reset_editor()
end)
- it('opens file under cursor', function()
- test_util.canola_open()
- vim.cmd.normal({ args = { 'G' } })
- test_util.await(canola.select, 2)
+ a.it("opens file under cursor", function()
+ test_util.oil_open()
+ -- Go to the bottom, so the cursor is not on a directory
+ vim.cmd.normal({ args = { "G" } })
+ a.wrap(oil.select, 2)()
assert.equals(1, #vim.api.nvim_tabpage_list_wins(0))
- assert.not_equals('canola', vim.bo.filetype)
+ assert.not_equals("oil", vim.bo.filetype)
end)
- it('opens file in new tab', function()
- test_util.canola_open()
+ a.it("opens file in new tab", function()
+ test_util.oil_open()
local tabpage = vim.api.nvim_get_current_tabpage()
- test_util.await(canola.select, 2, { tab = true })
+ a.wrap(oil.select, 2)({ tab = true })
assert.equals(2, #vim.api.nvim_list_tabpages())
assert.equals(1, #vim.api.nvim_tabpage_list_wins(0))
assert.not_equals(tabpage, vim.api.nvim_get_current_tabpage())
end)
- it('opens file in new split', function()
- test_util.canola_open()
+ a.it("opens file in new split", function()
+ test_util.oil_open()
local winid = vim.api.nvim_get_current_win()
- test_util.await(canola.select, 2, { vertical = true })
+ a.wrap(oil.select, 2)({ vertical = true })
assert.equals(1, #vim.api.nvim_list_tabpages())
assert.equals(2, #vim.api.nvim_tabpage_list_wins(0))
assert.not_equals(winid, vim.api.nvim_get_current_win())
end)
- it('opens multiple files in new tabs', function()
- test_util.canola_open()
- vim.api.nvim_feedkeys('Vj', 'x', true)
+ a.it("opens multiple files in new tabs", function()
+ test_util.oil_open()
+ vim.api.nvim_feedkeys("Vj", "x", true)
local tabpage = vim.api.nvim_get_current_tabpage()
- test_util.await(canola.select, 2, { tab = true })
+ a.wrap(oil.select, 2)({ tab = true })
assert.equals(3, #vim.api.nvim_list_tabpages())
assert.equals(1, #vim.api.nvim_tabpage_list_wins(0))
assert.not_equals(tabpage, vim.api.nvim_get_current_tabpage())
end)
- it('opens multiple files in new splits', function()
- test_util.canola_open()
- vim.api.nvim_feedkeys('Vj', 'x', true)
+ a.it("opens multiple files in new splits", function()
+ test_util.oil_open()
+ vim.api.nvim_feedkeys("Vj", "x", true)
local winid = vim.api.nvim_get_current_win()
- test_util.await(canola.select, 2, { vertical = true })
+ a.wrap(oil.select, 2)({ vertical = true })
assert.equals(1, #vim.api.nvim_list_tabpages())
assert.equals(3, #vim.api.nvim_tabpage_list_wins(0))
assert.not_equals(winid, vim.api.nvim_get_current_win())
end)
- describe('close after open', function()
- it('same window', function()
- vim.cmd.edit({ args = { 'foo' } })
+ a.describe("close after open", function()
+ a.it("same window", function()
+ vim.cmd.edit({ args = { "foo" } })
local bufnr = vim.api.nvim_get_current_buf()
- test_util.canola_open()
- vim.cmd.normal({ args = { 'G' } })
- test_util.await(canola.select, 2, { close = true })
+ test_util.oil_open()
+ -- Go to the bottom, so the cursor is not on a directory
+ vim.cmd.normal({ args = { "G" } })
+ a.wrap(oil.select, 2)({ close = true })
assert.equals(1, #vim.api.nvim_tabpage_list_wins(0))
+ -- This one we actually don't expect the buffer to be the same as the initial buffer, because
+ -- we opened a file
assert.not_equals(bufnr, vim.api.nvim_get_current_buf())
- assert.not_equals('canola', vim.bo.filetype)
+ assert.not_equals("oil", vim.bo.filetype)
end)
- it('split', function()
- vim.cmd.edit({ args = { 'foo' } })
+ a.it("split", function()
+ vim.cmd.edit({ args = { "foo" } })
local bufnr = vim.api.nvim_get_current_buf()
local winid = vim.api.nvim_get_current_win()
- test_util.canola_open()
- test_util.await(canola.select, 2, { vertical = true, close = true })
+ test_util.oil_open()
+ a.wrap(oil.select, 2)({ vertical = true, close = true })
assert.equals(2, #vim.api.nvim_tabpage_list_wins(0))
assert.equals(bufnr, vim.api.nvim_win_get_buf(winid))
end)
- it('tab', function()
- vim.cmd.edit({ args = { 'foo' } })
+ a.it("tab", function()
+ vim.cmd.edit({ args = { "foo" } })
local bufnr = vim.api.nvim_get_current_buf()
local tabpage = vim.api.nvim_get_current_tabpage()
- test_util.canola_open()
- test_util.await(canola.select, 2, { tab = true, close = true })
+ test_util.oil_open()
+ a.wrap(oil.select, 2)({ tab = true, close = true })
assert.equals(1, #vim.api.nvim_tabpage_list_wins(0))
assert.equals(2, #vim.api.nvim_list_tabpages())
vim.api.nvim_set_current_tabpage(tabpage)
diff --git a/tests/test_util.lua b/tests/test_util.lua
new file mode 100644
index 0000000..46f63df
--- /dev/null
+++ b/tests/test_util.lua
@@ -0,0 +1,140 @@
+require("plenary.async").tests.add_to_env()
+local cache = require("oil.cache")
+local test_adapter = require("oil.adapters.test")
+local util = require("oil.util")
+local M = {}
+
+M.reset_editor = function()
+ require("oil").setup({
+ columms = {},
+ adapters = {
+ ["oil-test://"] = "test",
+ },
+ prompt_save_on_select_new_entry = false,
+ })
+ vim.cmd.tabonly({ mods = { silent = true } })
+ for i, winid in ipairs(vim.api.nvim_tabpage_list_wins(0)) do
+ if i > 1 then
+ vim.api.nvim_win_close(winid, true)
+ end
+ end
+ vim.api.nvim_win_set_buf(0, vim.api.nvim_create_buf(false, true))
+ for _, bufnr in ipairs(vim.api.nvim_list_bufs()) do
+ vim.api.nvim_buf_delete(bufnr, { force = true })
+ end
+ cache.clear_everything()
+ test_adapter.test_clear()
+end
+
+local function throwiferr(err, ...)
+ if err then
+ error(err)
+ else
+ return ...
+ end
+end
+
+M.oil_open = function(...)
+ a.wrap(require("oil").open, 3)(...)
+end
+
+M.await = function(fn, nargs, ...)
+ return throwiferr(a.wrap(fn, nargs)(...))
+end
+
+M.wait_for_autocmd = a.wrap(function(autocmd, cb)
+ local opts = {
+ pattern = "*",
+ nested = true,
+ once = true,
+ }
+ if type(autocmd) == "table" then
+ opts = vim.tbl_extend("force", opts, autocmd)
+ autocmd = autocmd[1]
+ opts[1] = nil
+ end
+ opts.callback = vim.schedule_wrap(cb)
+
+ vim.api.nvim_create_autocmd(autocmd, opts)
+end, 2)
+
+M.wait_oil_ready = a.wrap(function(cb)
+ util.run_after_load(0, vim.schedule_wrap(cb))
+end, 1)
+
+---@param actions string[]
+---@param timestep integer
+M.feedkeys = function(actions, timestep)
+ timestep = timestep or 10
+ a.util.sleep(timestep)
+ for _, action in ipairs(actions) do
+ a.util.sleep(timestep)
+ local escaped = vim.api.nvim_replace_termcodes(action, true, false, true)
+ vim.api.nvim_feedkeys(escaped, "m", true)
+ end
+ a.util.sleep(timestep)
+ -- process pending keys until the queue is empty.
+ -- Note that this will exit insert mode.
+ vim.api.nvim_feedkeys("", "x", true)
+ a.util.sleep(timestep)
+end
+
+M.actions = {
+ ---Open oil and wait for it to finish rendering
+ ---@param args string[]
+ open = function(args)
+ vim.schedule(function()
+ vim.cmd.Oil({ args = args })
+ -- If this buffer was already open, manually dispatch the autocmd to finish the wait
+ if vim.b.oil_ready then
+ vim.api.nvim_exec_autocmds("User", {
+ pattern = "OilEnter",
+ modeline = false,
+ data = { buf = vim.api.nvim_get_current_buf() },
+ })
+ end
+ end)
+ M.wait_for_autocmd({ "User", pattern = "OilEnter" })
+ end,
+
+ ---Save all changes and wait for operation to complete
+ save = function()
+ vim.schedule_wrap(require("oil").save)({ confirm = false })
+ M.wait_for_autocmd({ "User", pattern = "OilMutationComplete" })
+ end,
+
+ ---@param bufnr? integer
+ reload = function(bufnr)
+ M.await(require("oil.view").render_buffer_async, 3, bufnr or 0)
+ end,
+
+ ---Move cursor to a file or directory in an oil buffer
+ ---@param filename string
+ focus = function(filename)
+ local lines = vim.api.nvim_buf_get_lines(0, 0, -1, true)
+ local search = " " .. filename .. "$"
+ for i, line in ipairs(lines) do
+ if line:match(search) then
+ vim.api.nvim_win_set_cursor(0, { i, 0 })
+ return
+ end
+ end
+ error("Could not find file " .. filename)
+ end,
+}
+
+---Get the raw list of filenames from an unmodified oil buffer
+---@param bufnr? integer
+---@return string[]
+M.parse_entries = function(bufnr)
+ bufnr = bufnr or 0
+ if vim.bo[bufnr].modified then
+ error("parse_entries doesn't work on a modified oil buffer")
+ end
+ local lines = vim.api.nvim_buf_get_lines(bufnr, 0, -1, true)
+ return vim.tbl_map(function(line)
+ return line:match("^/%d+ +(.+)$")
+ end, lines)
+end
+
+return M
diff --git a/spec/tmpdir.lua b/tests/tmpdir.lua
similarity index 61%
rename from spec/tmpdir.lua
rename to tests/tmpdir.lua
index 42dd44e..bb8a9c0 100644
--- a/spec/tmpdir.lua
+++ b/tests/tmpdir.lua
@@ -1,18 +1,25 @@
-local fs = require('canola.fs')
-local test_util = require('spec.test_util')
+local fs = require("oil.fs")
+local test_util = require("tests.test_util")
+
+local await = test_util.await
---@param path string
-local function touch(path)
- local fd, open_err = vim.loop.fs_open(path, 'w', 420) -- 0644
- if not fd then
- error(open_err)
- end
- local shortpath = path:gsub('^[^' .. fs.sep .. ']*' .. fs.sep, '')
- local _, write_err = vim.loop.fs_write(fd, shortpath)
- if write_err then
- error(write_err)
- end
- vim.loop.fs_close(fd)
+---@param cb fun(err: nil|string)
+local function touch(path, cb)
+ vim.loop.fs_open(path, "w", 420, function(err, fd) -- 0644
+ if err then
+ cb(err)
+ else
+ local shortpath = path:gsub("^[^" .. fs.sep .. "]*" .. fs.sep, "")
+ vim.loop.fs_write(fd, shortpath, nil, function(err2)
+ if err2 then
+ cb(err2)
+ else
+ vim.loop.fs_close(fd, cb)
+ end
+ end)
+ end
+ end)
end
---@param filepath string
@@ -21,14 +28,11 @@ local function exists(filepath)
local stat = vim.loop.fs_stat(filepath)
return stat ~= nil and stat.type ~= nil
end
-
local TmpDir = {}
TmpDir.new = function()
- local path, err = vim.loop.fs_mkdtemp('canola_test_XXXXXXXXX')
- if not path then
- error(err)
- end
+ local path = await(vim.loop.fs_mkdtemp, 2, "oil_test_XXXXXXXXX")
+ a.util.scheduler()
return setmetatable({ path = path }, {
__index = TmpDir,
})
@@ -42,28 +46,31 @@ function TmpDir:create(paths)
for i, piece in ipairs(pieces) do
partial_path = fs.join(partial_path, piece)
if i == #pieces and not vim.endswith(partial_path, fs.sep) then
- touch(partial_path)
+ await(touch, 2, partial_path)
elseif not exists(partial_path) then
vim.loop.fs_mkdir(partial_path, 493)
end
end
end
+ a.util.scheduler()
end
---@param filepath string
---@return string?
local read_file = function(filepath)
- local fd = vim.loop.fs_open(filepath, 'r', 420)
+ local fd = vim.loop.fs_open(filepath, "r", 420)
if not fd then
return nil
end
local stat = vim.loop.fs_fstat(fd)
local content = vim.loop.fs_read(fd, stat.size)
vim.loop.fs_close(fd)
+ a.util.scheduler()
return content
end
---@param dir string
+---@param cb fun(err: nil|string, entry: {type: oil.EntryType, name: string, root: string}
local function walk(dir)
local ret = {}
for name, type in vim.fs.dir(dir) do
@@ -72,7 +79,7 @@ local function walk(dir)
type = type,
root = dir,
})
- if type == 'directory' then
+ if type == "directory" then
vim.list_extend(ret, walk(fs.join(dir, name)))
end
end
@@ -83,10 +90,10 @@ end
local assert_fs = function(root, paths)
local unlisted_dirs = {}
for k in pairs(paths) do
- local pieces = vim.split(k, '/')
- local partial_path = ''
+ local pieces = vim.split(k, "/")
+ local partial_path = ""
for i, piece in ipairs(pieces) do
- partial_path = partial_path .. piece .. '/'
+ partial_path = partial_path .. piece .. "/"
if i ~= #pieces then
unlisted_dirs[partial_path] = true
end
@@ -100,16 +107,17 @@ local assert_fs = function(root, paths)
for _, entry in ipairs(entries) do
local fullpath = fs.join(entry.root, entry.name)
local shortpath = fullpath:sub(root:len() + 2)
- if entry.type == 'directory' then
- shortpath = shortpath .. '/'
+ if entry.type == "directory" then
+ shortpath = shortpath .. "/"
end
local expected_content = paths[shortpath]
paths[shortpath] = nil
- assert(expected_content, string.format("Unexpected entry '%s'", shortpath))
- if entry.type == 'file' then
+ assert.truthy(expected_content, string.format("Unexpected entry '%s'", shortpath))
+ if entry.type == "file" then
local data = read_file(fullpath)
- assert(
- expected_content == data,
+ assert.equals(
+ expected_content,
+ data,
string.format(
"File '%s' expected content '%s' received '%s'",
shortpath,
@@ -121,11 +129,11 @@ local assert_fs = function(root, paths)
end
for k, v in pairs(paths) do
- assert(
- not k,
+ assert.falsy(
+ k,
string.format(
"Expected %s '%s', but it was not found",
- v == true and 'directory' or 'file',
+ v == true and "directory" or "file",
k
)
)
@@ -134,23 +142,27 @@ end
---@param paths table
function TmpDir:assert_fs(paths)
+ a.util.scheduler()
assert_fs(self.path, paths)
end
function TmpDir:assert_exists(path)
+ a.util.scheduler()
path = fs.join(self.path, path)
local stat = vim.loop.fs_stat(path)
- assert(stat, string.format("Expected path '%s' to exist", path))
+ assert.truthy(stat, string.format("Expected path '%s' to exist", path))
end
function TmpDir:assert_not_exists(path)
+ a.util.scheduler()
path = fs.join(self.path, path)
local stat = vim.loop.fs_stat(path)
- assert(not stat, string.format("Expected path '%s' to not exist", path))
+ assert.falsy(stat, string.format("Expected path '%s' to not exist", path))
end
function TmpDir:dispose()
- test_util.await_throwiferr(fs.recursive_delete, 3, 'directory', self.path)
+ await(fs.recursive_delete, 3, "directory", self.path)
+ a.util.scheduler()
end
return TmpDir
diff --git a/tests/trash_spec.lua b/tests/trash_spec.lua
new file mode 100644
index 0000000..d09a57f
--- /dev/null
+++ b/tests/trash_spec.lua
@@ -0,0 +1,150 @@
+require("plenary.async").tests.add_to_env()
+local TmpDir = require("tests.tmpdir")
+local test_util = require("tests.test_util")
+
+a.describe("freedesktop", function()
+ local tmpdir
+ local tmphome
+ local home = vim.env.XDG_DATA_HOME
+ a.before_each(function()
+ require("oil.config").delete_to_trash = true
+ tmpdir = TmpDir.new()
+ tmphome = TmpDir.new()
+ package.loaded["oil.adapters.trash"] = require("oil.adapters.trash.freedesktop")
+ vim.env.XDG_DATA_HOME = tmphome.path
+ end)
+ a.after_each(function()
+ vim.env.XDG_DATA_HOME = home
+ if tmpdir then
+ tmpdir:dispose()
+ end
+ if tmphome then
+ tmphome:dispose()
+ end
+ test_util.reset_editor()
+ package.loaded["oil.adapters.trash"] = nil
+ end)
+
+ a.it("files can be moved to the trash", function()
+ tmpdir:create({ "a.txt", "foo/b.txt" })
+ test_util.actions.open({ tmpdir.path })
+ test_util.actions.focus("a.txt")
+ vim.api.nvim_feedkeys("dd", "x", true)
+ test_util.actions.open({ "--trash", tmpdir.path })
+ vim.api.nvim_feedkeys("p", "x", true)
+ test_util.actions.save()
+ tmpdir:assert_not_exists("a.txt")
+ tmpdir:assert_exists("foo/b.txt")
+ test_util.actions.reload()
+ assert.are.same({ "a.txt" }, test_util.parse_entries(0))
+ end)
+
+ a.it("deleting a file moves it to trash", function()
+ tmpdir:create({ "a.txt", "foo/b.txt" })
+ test_util.actions.open({ tmpdir.path })
+ test_util.actions.focus("a.txt")
+ vim.api.nvim_feedkeys("dd", "x", true)
+ test_util.actions.save()
+ tmpdir:assert_not_exists("a.txt")
+ tmpdir:assert_exists("foo/b.txt")
+ test_util.actions.open({ "--trash", tmpdir.path })
+ assert.are.same({ "a.txt" }, test_util.parse_entries(0))
+ end)
+
+ a.it("deleting a directory moves it to trash", function()
+ tmpdir:create({ "a.txt", "foo/b.txt" })
+ test_util.actions.open({ tmpdir.path })
+ test_util.actions.focus("foo/")
+ vim.api.nvim_feedkeys("dd", "x", true)
+ test_util.actions.save()
+ tmpdir:assert_not_exists("foo")
+ tmpdir:assert_exists("a.txt")
+ test_util.actions.open({ "--trash", tmpdir.path })
+ assert.are.same({ "foo/" }, test_util.parse_entries(0))
+ end)
+
+ a.it("deleting a file from trash deletes it permanently", function()
+ tmpdir:create({ "a.txt" })
+ test_util.actions.open({ tmpdir.path })
+ test_util.actions.focus("a.txt")
+ vim.api.nvim_feedkeys("dd", "x", true)
+ test_util.actions.save()
+ test_util.actions.open({ "--trash", tmpdir.path })
+ test_util.actions.focus("a.txt")
+ vim.api.nvim_feedkeys("dd", "x", true)
+ test_util.actions.save()
+ test_util.actions.reload()
+ tmpdir:assert_not_exists("a.txt")
+ assert.are.same({}, test_util.parse_entries(0))
+ end)
+
+ a.it("cannot create files in the trash", function()
+ tmpdir:create({ "a.txt" })
+ test_util.actions.open({ tmpdir.path })
+ test_util.actions.focus("a.txt")
+ vim.api.nvim_feedkeys("dd", "x", true)
+ test_util.actions.save()
+ test_util.actions.open({ "--trash", tmpdir.path })
+ vim.api.nvim_feedkeys("onew_file.txt", "x", true)
+ test_util.actions.save()
+ test_util.actions.reload()
+ assert.are.same({ "a.txt" }, test_util.parse_entries(0))
+ end)
+
+ a.it("cannot rename files in the trash", function()
+ tmpdir:create({ "a.txt" })
+ test_util.actions.open({ tmpdir.path })
+ test_util.actions.focus("a.txt")
+ vim.api.nvim_feedkeys("dd", "x", true)
+ test_util.actions.save()
+ test_util.actions.open({ "--trash", tmpdir.path })
+ vim.api.nvim_feedkeys("0facwnew_name", "x", true)
+ test_util.actions.save()
+ test_util.actions.reload()
+ assert.are.same({ "a.txt" }, test_util.parse_entries(0))
+ end)
+
+ a.it("cannot copy files in the trash", function()
+ tmpdir:create({ "a.txt" })
+ test_util.actions.open({ tmpdir.path })
+ test_util.actions.focus("a.txt")
+ vim.api.nvim_feedkeys("dd", "x", true)
+ test_util.actions.save()
+ test_util.actions.open({ "--trash", tmpdir.path })
+ vim.api.nvim_feedkeys("yypp", "x", true)
+ test_util.actions.save()
+ test_util.actions.reload()
+ assert.are.same({ "a.txt" }, test_util.parse_entries(0))
+ end)
+
+ a.it("can restore files from trash", function()
+ tmpdir:create({ "a.txt" })
+ test_util.actions.open({ tmpdir.path })
+ test_util.actions.focus("a.txt")
+ vim.api.nvim_feedkeys("dd", "x", true)
+ test_util.actions.save()
+ test_util.actions.open({ "--trash", tmpdir.path })
+ vim.api.nvim_feedkeys("dd", "x", true)
+ test_util.actions.open({ tmpdir.path })
+ vim.api.nvim_feedkeys("p", "x", true)
+ test_util.actions.save()
+ test_util.actions.reload()
+ assert.are.same({ "a.txt" }, test_util.parse_entries(0))
+ tmpdir:assert_fs({
+ ["a.txt"] = "a.txt",
+ })
+ end)
+
+ a.it("can have multiple files with the same name in trash", function()
+ tmpdir:create({ "a.txt" })
+ test_util.actions.open({ tmpdir.path })
+ vim.api.nvim_feedkeys("dd", "x", true)
+ test_util.actions.save()
+ tmpdir:create({ "a.txt" })
+ test_util.actions.reload()
+ vim.api.nvim_feedkeys("dd", "x", true)
+ test_util.actions.save()
+ test_util.actions.open({ "--trash", tmpdir.path })
+ assert.are.same({ "a.txt", "a.txt" }, test_util.parse_entries(0))
+ end)
+end)
diff --git a/tests/url_spec.lua b/tests/url_spec.lua
new file mode 100644
index 0000000..32d801e
--- /dev/null
+++ b/tests/url_spec.lua
@@ -0,0 +1,25 @@
+local oil = require("oil")
+local util = require("oil.util")
+describe("url", function()
+ it("get_url_for_path", function()
+ local cases = {
+ { "", "oil://" .. util.addslash(vim.fn.getcwd()) },
+ { "term://~/oil.nvim//52953:/bin/sh", "oil://" .. vim.loop.os_homedir() .. "/oil.nvim/" },
+ { "/foo/bar.txt", "oil:///foo/", "bar.txt" },
+ { "oil:///foo/bar.txt", "oil:///foo/", "bar.txt" },
+ { "oil:///", "oil:///" },
+ { "oil-ssh://user@hostname:8888//bar.txt", "oil-ssh://user@hostname:8888//", "bar.txt" },
+ { "oil-ssh://user@hostname:8888//", "oil-ssh://user@hostname:8888//" },
+ }
+ for _, case in ipairs(cases) do
+ local input, expected, expected_basename = unpack(case)
+ local output, basename = oil.get_buffer_parent_url(input, true)
+ assert.equals(expected, output, string.format('Parent url for path "%s" failed', input))
+ assert.equals(
+ expected_basename,
+ basename,
+ string.format('Basename for path "%s" failed', input)
+ )
+ end
+ end)
+end)
diff --git a/spec/util_spec.lua b/tests/util_spec.lua
similarity index 53%
rename from spec/util_spec.lua
rename to tests/util_spec.lua
index bb8fce9..3193842 100644
--- a/spec/util_spec.lua
+++ b/tests/util_spec.lua
@@ -1,10 +1,10 @@
-local util = require('canola.util')
-describe('util', function()
- it('url_escape', function()
+local util = require("oil.util")
+describe("util", function()
+ it("url_escape", function()
local cases = {
- { 'foobar', 'foobar' },
- { 'foo bar', 'foo%20bar' },
- { '/foo/bar', '%2Ffoo%2Fbar' },
+ { "foobar", "foobar" },
+ { "foo bar", "foo%20bar" },
+ { "/foo/bar", "%2Ffoo%2Fbar" },
}
for _, case in ipairs(cases) do
local input, expected = unpack(case)
@@ -13,12 +13,12 @@ describe('util', function()
end
end)
- it('url_unescape', function()
+ it("url_unescape", function()
local cases = {
- { 'foobar', 'foobar' },
- { 'foo%20bar', 'foo bar' },
- { '%2Ffoo%2Fbar', '/foo/bar' },
- { 'foo%%bar', 'foo%%bar' },
+ { "foobar", "foobar" },
+ { "foo%20bar", "foo bar" },
+ { "%2Ffoo%2Fbar", "/foo/bar" },
+ { "foo%%bar", "foo%%bar" },
}
for _, case in ipairs(cases) do
local input, expected = unpack(case)
diff --git a/tests/win_options_spec.lua b/tests/win_options_spec.lua
new file mode 100644
index 0000000..cb638a7
--- /dev/null
+++ b/tests/win_options_spec.lua
@@ -0,0 +1,66 @@
+require("plenary.async").tests.add_to_env()
+local oil = require("oil")
+local test_util = require("tests.test_util")
+
+a.describe("window options", function()
+ after_each(function()
+ test_util.reset_editor()
+ end)
+
+ a.it("Restores window options on close", function()
+ vim.cmd.edit({ args = { "README.md" } })
+ test_util.oil_open()
+ assert.equals("no", vim.o.signcolumn)
+ oil.close()
+ assert.equals("auto", vim.o.signcolumn)
+ end)
+
+ a.it("Restores window options on edit", function()
+ test_util.oil_open()
+ assert.equals("no", vim.o.signcolumn)
+ vim.cmd.edit({ args = { "README.md" } })
+ assert.equals("auto", vim.o.signcolumn)
+ end)
+
+ a.it("Restores window options on split ", function()
+ test_util.oil_open()
+ assert.equals("no", vim.o.signcolumn)
+ vim.cmd.split({ args = { "README.md" } })
+ assert.equals("auto", vim.o.signcolumn)
+ end)
+
+ a.it("Restores window options on split", function()
+ test_util.oil_open()
+ assert.equals("no", vim.o.signcolumn)
+ vim.cmd.split()
+ vim.cmd.edit({ args = { "README.md" } })
+ assert.equals("auto", vim.o.signcolumn)
+ end)
+
+ a.it("Restores window options on tabnew ", function()
+ test_util.oil_open()
+ assert.equals("no", vim.o.signcolumn)
+ vim.cmd.tabnew({ args = { "README.md" } })
+ assert.equals("auto", vim.o.signcolumn)
+ end)
+
+ a.it("Restores window options on tabnew", function()
+ test_util.oil_open()
+ assert.equals("no", vim.o.signcolumn)
+ vim.cmd.tabnew()
+ vim.cmd.edit({ args = { "README.md" } })
+ assert.equals("auto", vim.o.signcolumn)
+ end)
+
+ a.it("Sets the window options when re-entering oil buffer", function()
+ oil.open()
+ test_util.wait_for_autocmd({ "User", pattern = "OilEnter" })
+ assert.truthy(vim.w.oil_did_enter)
+ vim.cmd.edit({ args = { "README.md" } })
+ assert.falsy(vim.w.oil_did_enter)
+ oil.open()
+ assert.truthy(vim.w.oil_did_enter)
+ vim.cmd.vsplit()
+ assert.truthy(vim.w.oil_did_enter)
+ end)
+end)
diff --git a/vim.yaml b/vim.yaml
deleted file mode 100644
index 3821d25..0000000
--- a/vim.yaml
+++ /dev/null
@@ -1,26 +0,0 @@
----
-base: lua51
-name: vim
-lua_versions:
- - luajit
-globals:
- vim:
- any: true
- jit:
- any: true
- assert:
- any: true
- describe:
- any: true
- it:
- any: true
- before_each:
- any: true
- after_each:
- any: true
- spy:
- any: true
- stub:
- any: true
- bit:
- any: true