feat: drop plenary (#58)

* fix: has return value

* feat: drop plenary.job and plenary.path

* fix: right parenthese

* feat: use jobstart

* fix: log name

* fix: result_has_err

* feat: drop plenary

* feat: drop plenary.job

* doc: feat

* doc: feat

* fix: visual mode

README.md

@@ -13,7 +13,7 @@ An example of git permalink:
 Personally, I use this all the time to easily share code locations with my
 co-workers.
 
-- [Break changes & updates](#break-changes--updates)
+- [New Features & Break Changes](#new-features--break-changes)
   - [Lua pattern based rules](#lua-pattern-based-rules)
 - [Installation](#installation)
   - [packer.nvim](#packernvim)
@@ -22,11 +22,14 @@ co-workers.
 - [Key Mappings](#key-mappings)
 - [Configuration](#configuration)
 
-## Break changes & updates
+## New Features & Break Changes
 
-1. Platform support: windows is supported.
-2. Url mapping engine changed: pattern based rules instead of hard coding.
-3. Rewrittens: API re-designed, logger added, code base re-structured.
+1. Bug fix: you can disable/custom the default key mappings.
+2. Windows support: you can use it on Windows.
+3. Url mapping engine changed: pattern based rules instead of hard coding.
+4. Refactor: use git error message instead of self-defined error.
+5. Refactor: drop off `plenary` third-party dependency.
+6. Rewrittens: API re-designed, logger added, code base re-structured.
 
 ### Lua pattern based rules
 
@@ -48,14 +51,12 @@ Requirement:
 
 - git
 - neovim 0.8
-- [plenary.nvim](https://github.com/nvim-lua/plenary.nvim)
 
 ### [packer.nvim](https://github.com/wbthomason/packer.nvim)
 
 ```lua
 use {
     'linrongbin16/gitlinker.nvim',
-    requires = { 'nvim-lua/plenary.nvim' },
     branch = 'master',
     config = function()
         require('gitlinker').setup()
@@ -68,7 +69,6 @@ use {
 ```vim
 call plug#begin()
 
-Plug 'nvim-lua/plenary.nvim'
 Plug 'linrongbin16/gitlinker.nvim', { 'branch': 'master' }
 
 call plug#end()
@@ -83,7 +83,6 @@ EOF
 ```lua
 {
     'linrongbin16/gitlinker.nvim',
-    dependencies = { 'nvim-lua/plenary.nvim' },
     config = function()
         require('gitlinker').setup()
     end,

lua/gitlinker.lua

@@ -1,7 +1,6 @@
 local git = require("gitlinker.git")
 local util = require("gitlinker.util")
 local logger = require("gitlinker.logger")
-local path = require("plenary.path")
 
 --- @type table<string, any>
 local Defaults = {
@@ -215,7 +214,7 @@ local function make_link_data()
     vim.inspect(rev)
   )
 
-  local root = tostring(path:new(root_result.stdout[1]))
+  local root = root_result.stdout[1]
   local buf_path_on_root = util.relative_path(root)
   logger.debug(
     "|make_link_data| root(%s):%s, buf_path_on_root(%s):%s",

lua/gitlinker/actions.lua

@@ -1,4 +1,3 @@
-local job = require("plenary.job")
 local util = require("gitlinker.util")
 
 --- @alias ActionType fun(url:string):nil
@@ -15,15 +14,15 @@ end
 --- @param url string
 --- @return nil
 local function system(url)
-  local j
+  local job
   if util.is_macos() then
-    j = job:new({ command = "open", args = { url } })
+    job = vim.fn.jobstart({ "open", url })
   elseif util.is_windows() then
-    j = job:new({ command = "cmd", args = { "/C", "start", url } })
+    job = vim.fn.jobstart({ "cmd", "/C", "start", url })
   else
-    j = job:new({ command = "xdg-open", args = { url } })
+    job = vim.fn.jobstart({ "xdg-open", url })
   end
-  j:start()
+  vim.fn.jobwait({ job })
 end
 
 --- @type table<string, function>

lua/gitlinker/git.lua

@@ -1,5 +1,3 @@
-local job = require("plenary.job")
-local path = require("plenary.path")
 local logger = require("gitlinker.logger")
 
 --- @class JobResult
@@ -17,7 +15,9 @@ end
 --- @param result JobResult
 --- @return boolean
 local function result_has_err(result)
-  return result.stderr ~= nil
+  return result["stderr"] ~= nil
+    and type(result["stderr"]) == "table"
+    and #result["stderr"] > 0
 end
 
 --- @param result JobResult
@@ -37,75 +37,125 @@ end
 --- @param cwd string|nil
 --- @return JobResult
 local function cmd(args, cwd)
-  --- @type JobResult
-  local result = {}
-  local process = job:new({
-    command = "git",
-    args = args,
+  local result = { stdout = {}, stderr = {} }
+  local job = vim.fn.jobstart(args, {
     cwd = cwd,
+    on_stdout = function(chanid, data, name)
+      logger.debug(
+        "|cmd.on_stdout| args(%s):%s, cwd(%s):%s, chanid(%s):%s, data(%s):%s, name(%s):%s",
+        vim.inspect(type(args)),
+        vim.inspect(args),
+        vim.inspect(type(cwd)),
+        vim.inspect(cwd),
+        vim.inspect(type(chanid)),
+        vim.inspect(chanid),
+        vim.inspect(type(data)),
+        vim.inspect(data),
+        vim.inspect(type(name)),
+        vim.inspect(name)
+      )
+      for _, line in ipairs(data) do
+        if string.len(line) > 0 then
+          table.insert(result.stdout, line)
+        end
+      end
+    end,
+    on_stderr = function(chanid, data, name)
+      logger.debug(
+        "|cmd.on_stderr| args(%s):%s, cwd(%s):%s, chanid(%s):%s, data(%s):%s, name(%s):%s",
+        vim.inspect(type(args)),
+        vim.inspect(args),
+        vim.inspect(type(cwd)),
+        vim.inspect(cwd),
+        vim.inspect(type(chanid)),
+        vim.inspect(chanid),
+        vim.inspect(type(data)),
+        vim.inspect(data),
+        vim.inspect(type(name)),
+        vim.inspect(name)
+      )
+      for _, line in ipairs(data) do
+        if string.len(line) > 0 then
+          table.insert(result.stderr, line)
+        end
+      end
+    end,
   })
-  process:after_success(function(j)
-    result.stdout = j:result()
-  end)
-  process:after_failure(function(j)
-    result.stderr = j:stderr_result()
-  end)
-  process:sync()
+  vim.fn.jobwait({ job })
+  logger.debug(
+    "|cmd| args(%s):%s, cwd(%s):%s, result(%s):%s",
+    vim.inspect(type(args)),
+    vim.inspect(args),
+    vim.inspect(type(cwd)),
+    vim.inspect(cwd),
+    vim.inspect(type(result)),
+    vim.inspect(result)
+  )
   return result
 end
 
 --- @package
 --- @return JobResult
 local function get_remote()
-  local result = cmd({ "remote" })
-  -- logger.debug("[git.get_remote] result:%s", vim.inspect(result))
+  local result = cmd({ "git", "remote" })
+  logger.debug(
+    "|git.get_remote| result(%s):%s",
+    vim.inspect(type(result)),
+    vim.inspect(result)
+  )
   return result
 end
 
 --- @param remote string
 --- @return JobResult
 local function get_remote_url(remote)
   assert(remote, "remote cannot be nil")
-  local result = cmd({ "remote", "get-url", remote })
-  -- logger.debug(
-  --   "[git.get_remote_url] remote:%s, result:%s",
-  --   vim.inspect(remote),
-  --   vim.inspect(result)
-  -- )
+  local result = cmd({ "git", "remote", "get-url", remote })
+  logger.debug(
+    "|git.get_remote_url| remote(%s):%s, result(%s):%s",
+    vim.inspect(type(remote)),
+    vim.inspect(remote),
+    vim.inspect(type(result)),
+    vim.inspect(result)
+  )
   return result
 end
 
 --- @package
 --- @param revspec string|nil
 --- @return string|nil
 local function get_rev(revspec)
-  local result = cmd({ "rev-parse", revspec })
-  -- logger.debug(
-  --   "[git._get_rev] revspec:%s, result:%s",
-  --   vim.inspect(revspec),
-  --   vim.inspect(result)
-  -- )
+  local result = cmd({ "git", "rev-parse", revspec })
+  logger.debug(
+    "|git.get_rev| revspec(%s):%s, result(%s):%s",
+    vim.inspect(type(revspec)),
+    vim.inspect(revspec),
+    vim.inspect(type(result)),
+    vim.inspect(result)
+  )
   return result_has_out(result) and result.stdout[1] or nil
 end
 
 --- @package
 --- @param revspec string
 --- @return JobResult
 local function get_rev_name(revspec)
-  local result = cmd({ "rev-parse", "--abbrev-ref", revspec })
-  -- logger.debug(
-  --   "[git.get_rev_name] revspec:%s, result:%s",
-  --   vim.inspect(revspec),
-  --   vim.inspect(result)
-  -- )
+  local result = cmd({ "git", "rev-parse", "--abbrev-ref", revspec })
+  logger.debug(
+    "|git.get_rev_name| revspec(%s):%s, result(%s):%s",
+    vim.inspect(type(revspec)),
+    vim.inspect(revspec),
+    vim.inspect(type(result)),
+    vim.inspect(result)
+  )
   return result
 end
 
 --- @param file string
 --- @param revspec string
 --- @return JobResult
 local function is_file_in_rev(file, revspec)
-  local result = cmd({ "cat-file", "-e", revspec .. ":" .. file })
+  local result = cmd({ "git", "cat-file", "-e", revspec .. ":" .. file })
   logger.debug(
     "|git.is_file_in_rev| file(%s):%s, revspec(%s):%s, result(%s):%s",
     vim.inspect(type(file)),
@@ -122,13 +172,16 @@ end
 --- @param rev string
 --- @return boolean
 local function has_file_changed(file, rev)
-  local result = cmd({ "diff", rev, "--", file })
-  -- logger.debug(
-  --   "[git.has_file_changed] file:%s, rev:%s, result:%s",
-  --   vim.inspect(file),
-  --   vim.inspect(rev),
-  --   vim.inspect(result)
-  -- )
+  local result = cmd({ "git", "diff", rev, "--", file })
+  logger.debug(
+    "|git.has_file_changed| file(%s):%s, rev(%s):%s, result(%s):%s",
+    vim.inspect(type(file)),
+    vim.inspect(file),
+    vim.inspect(type(rev)),
+    vim.inspect(rev),
+    vim.inspect(type(result)),
+    vim.inspect(result)
+  )
   return result_has_out(result)
 end
 
@@ -137,13 +190,16 @@ end
 --- @param remote string
 --- @return boolean
 local function is_rev_in_remote(revspec, remote)
-  local result = cmd({ "branch", "--remotes", "--contains", revspec })
-  -- logger.debug(
-  --   "[git.is_rev_in_remote] revspec:%s, remote:%s, result:%s",
-  --   vim.inspect(revspec),
-  --   vim.inspect(remote),
-  --   vim.inspect(result)
-  -- )
+  local result = cmd({ "git", "branch", "--remotes", "--contains", revspec })
+  logger.debug(
+    "|git.is_rev_in_remote| revspec(%s):%s, remote(%s):%s, result(%s):%s",
+    vim.inspect(type(revspec)),
+    vim.inspect(revspec),
+    vim.inspect(type(remote)),
+    vim.inspect(remote),
+    vim.inspect(type(result)),
+    vim.inspect(result)
+  )
   local output = result.stdout
   for _, rbranch in ipairs(output) do
     if rbranch:match(remote) then
@@ -200,15 +256,18 @@ end
 
 --- @return JobResult
 local function get_root()
-  local buf_path = path:new(vim.api.nvim_buf_get_name(0))
-  local buf_dir = tostring(buf_path:parent())
-  local result = cmd({ "rev-parse", "--show-toplevel" }, buf_dir)
-  -- logger.debug(
-  --   "[git.get_root] buf_path:%s, buf_dir:%s, result:%s",
-  --   vim.inspect(buf_path),
-  --   vim.inspect(buf_dir),
-  --   vim.inspect(result)
-  -- )
+  local buf_path = vim.api.nvim_buf_get_name(0)
+  local buf_dir = vim.fn.fnamemodify(buf_path, ":p:h")
+  local result = cmd({ "git", "rev-parse", "--show-toplevel" }, buf_dir)
+  logger.debug(
+    "|git.get_root| buf_path(%s):%s, buf_dir(%s):%s, result(%s):%s",
+    vim.inspect(type(buf_path)),
+    vim.inspect(buf_path),
+    vim.inspect(type(buf_dir)),
+    vim.inspect(buf_dir),
+    vim.inspect(type(result)),
+    vim.inspect(result)
+  )
   return result
 end
 

lua/gitlinker/logger.lua

@@ -1,6 +1,6 @@
-local PathSeparator = (vim.fn.has("win32") or vim.fn.has("win64")) and "\\"
+local Separator = (vim.fn.has("win32") > 0 or vim.fn.has("win64") > 0) and "\\"
   or "/"
-local LogFilePath = vim.fn.stdpath("data") .. PathSeparator .. "gitlinker.log"
+local LogFilePath = vim.fn.stdpath("data") .. Separator .. "gitlinker.log"
 local EchoHl = {
   ["ERROR"] = "ErrorMsg",
   ["WARN"] = "ErrorMsg",