add shorten

Author: jamestrew

lua/plenary/path2.lua

@@ -3,9 +3,6 @@
 --- including 'shellslash' support.
 --- Effort to improve performance made (notably `:absolue` ~2x faster).
 ---
---- Some finiky behaviors ironed out
---- eg. `:normalize`
---- TODO: demonstrate
 ---
 --- BREAKING CHANGES:
 --- - `Path.new` no longer supported (think it's more confusing that helpful
@@ -29,6 +26,28 @@
 ---
 ---   eg. `Path:new("foo/bar_baz"):make_relative("foo/bar", true)` => returns
 ---   "../bar_baz"
+---
+--- - remove `Path:normalize`. It doesn't make any sense. eg. this test case
+---   ```lua
+---   it("can normalize ~ when file is within home directory (trailing slash)", function()
+---     local home = "/home/test/"
+---     local p = Path:new { home, "./test_file" }
+---     p.path.home = home
+---     p._cwd = "/tmp/lua"
+---     assert.are.same("~/test_file", p:normalize())
+---   end)
+---   ```
+---   if the idea is to make `/home/test/test_file` relative to `/tmp/lua`, the result
+---   should be `../../home/test/test_file`, only then can you substitue the
+---   home directory for `~`.
+---   So should really be `../../~/test_file`. But using `~` in a relative path
+---   like that looks weird to me. And as this function first makes paths
+---   relative, you will never get a leading `~` (since `~` literally
+---   represents the absolute path of the home directory).
+---   To top it off, something like `../../~/test_file` is impossible on Windows.
+---   `C:/Users/test/test_file` relative to `C:/Windows/temp` is
+---   `../../Users/test/test_file` and there's no home directory absolute path
+---   in this.
 
 local uv = vim.loop
 local iswin = uv.os_uname().sysname == "Windows_NT"
@@ -482,8 +501,12 @@ function Path:_filename(drv, root, relparts)
 
   relparts = vim.F.if_nil(relparts, self.relparts)
   local relpath = table.concat(relparts, self.sep)
+  local res = drv .. root .. relpath
 
-  return drv .. root .. relpath
+  if res ~= "" then
+    return res
+  end
+  return "."
 end
 
 ---@param x any
@@ -704,4 +727,40 @@ function Path:make_relative(to, walk_up)
   return Path:new(steps).filename
 end
 
+
+--- Shorten path parts.
+--- By default, shortens all part except the last tail part to a length of 1.
+--- eg.
+--- ```lua
+--- local p = Path:new("this/is/a/long/path")
+--- p:shorten() -- Output: "t/i/a/l/path"
+--- ```
+---@param len integer? length to shorthen path parts to (default: `1`)
+--- indices of path parts to exclude from being shortened, supports negative index
+---@param excludes integer[]?
+---@return string
+function Path:shorten(len, excludes)
+  len = vim.F.if_nil(len, 1)
+  excludes = vim.F.if_nil(excludes, { #self.relparts })
+
+  local new_parts = {}
+
+  for i, part in ipairs(self.relparts) do
+    local neg_i = -(#self.relparts + 1) + i
+    if #part > len and not vim.list_contains(excludes, i) and not vim.list_contains(excludes, neg_i) then
+      part = part:sub(1, len)
+    end
+    table.insert(new_parts, part)
+  end
+
+  return self:_filename(nil, nil, new_parts)
+end
+
+-- vim.o.shellslash = false
+local long_path = "/this/is/a/long/path"
+local p = Path:new(long_path)
+local short_path = p:shorten()
+print(p.filename, short_path)
+vim.o.shellslash = true
+
 return Path

tests/plenary/path2_spec.lua

@@ -58,6 +58,7 @@ describe("Path2", function()
         { "foo/bar/", "foo/bar" },
         { { readme_path }, readme_path },
         { { readme_path, license_path }, license_path }, -- takes only the last abs path
+        { ".", "." },
       }
 
       return paths
@@ -334,6 +335,65 @@ describe("Path2", function()
     end)
   end)
 
+  describe(":shorten", function()
+    it_cross_plat("can shorten a path", function()
+      local long_path = "this/is/a/long/path"
+      local short_path = Path:new(long_path):shorten()
+      assert.are.same(short_path, plat_path "t/i/a/l/path")
+    end)
+
+    it_cross_plat("can shorten a path's components to a given length", function()
+      local long_path = "this/is/a/long/path"
+      local short_path = Path:new(long_path):shorten(2)
+      assert.are.same(short_path, plat_path "th/is/a/lo/path")
+
+      -- without the leading /
+      long_path = "this/is/a/long/path"
+      short_path = Path:new(long_path):shorten(3)
+      assert.are.same(short_path, plat_path "thi/is/a/lon/path")
+
+      -- where len is greater than the length of the final component
+      long_path = "this/is/an/extremely/long/path"
+      short_path = Path:new(long_path):shorten(5)
+      assert.are.same(short_path, plat_path "this/is/an/extre/long/path")
+    end)
+
+    it_cross_plat("can shorten a path's components when excluding parts", function()
+      local long_path = "this/is/a/long/path"
+      local short_path = Path:new(long_path):shorten(nil, { 1, -1 })
+      assert.are.same(short_path, plat_path "this/i/a/l/path")
+
+      -- without the leading /
+      long_path = "this/is/a/long/path"
+      short_path = Path:new(long_path):shorten(nil, { 1, -1 })
+      assert.are.same(short_path, plat_path "this/i/a/l/path")
+
+      -- where excluding positions greater than the number of parts
+      long_path = "this/is/an/extremely/long/path"
+      short_path = Path:new(long_path):shorten(nil, { 2, 4, 6, 8 })
+      assert.are.same(short_path, plat_path "t/is/a/extremely/l/path")
+
+      -- where excluding positions less than the negation of the number of parts
+      long_path = "this/is/an/extremely/long/path"
+      short_path = Path:new(long_path):shorten(nil, { -2, -4, -6, -8 })
+      assert.are.same(short_path, plat_path "this/i/an/e/long/p")
+    end)
+
+    it_cross_plat("can shorten a path's components to a given length and exclude positions", function()
+      local long_path = "this/is/a/long/path"
+      local short_path = Path:new(long_path):shorten(2, { 1, -1 })
+      assert.are.same(short_path, plat_path "this/is/a/lo/path")
+
+      long_path = "this/is/a/long/path"
+      short_path = Path:new(long_path):shorten(3, { 2, -2 })
+      assert.are.same(short_path, plat_path "thi/is/a/long/pat")
+
+      long_path = "this/is/an/extremely/long/path"
+      short_path = Path:new(long_path):shorten(5, { 3, -3 })
+      assert.are.same(short_path, plat_path "this/is/an/extremely/long/path")
+    end)
+  end)
+
   describe("parents", function()
     it_cross_plat("should extract the ancestors of the path", function()
       local p = Path:new(vim.fn.getcwd())