add normalize and clean up

Author: jamestrew

lua/plenary/path2.lua

@@ -13,13 +13,14 @@ local hasshellslash = vim.fn.exists "+shellslash" == 1
 ---@field split_root fun(self: plenary._Path, part:string): string, string, string
 ---@field join fun(self: plenary._Path, path: string, ...: string): string
 ---@field expand fun(self: plenary._Path, parts: string[], sep: string?): string[]
+---@field is_relative fun(self: plenary._Path, path: plenary.Path2, to: plenary.Path2): boolean
 
 ---@class plenary._WindowsPath : plenary._Path
 local _WindowsPath = {
   sep = "\\",
   altsep = "/",
   has_drv = true,
-  case_sensitive = true,
+  case_sensitive = false,
 }
 
 setmetatable(_WindowsPath, { __index = _WindowsPath })
@@ -165,12 +166,28 @@ function _WindowsPath:expand(parts, sep)
   return new_parts
 end
 
+---@param path plenary.Path2
+---@param to plenary.Path2
+---@return boolean
+function _WindowsPath:is_relative(path, to)
+  if path.anchor:lower() ~= to.anchor:lower() then
+    return false
+  end
+
+  for i, to_part in ipairs(to.relparts) do
+    if to_part:lower() ~= path.relparts[i]:lower() then
+      return false
+    end
+  end
+  return true
+end
+
 ---@class plenary._PosixPath : plenary._Path
 local _PosixPath = {
   sep = "/",
   altsep = "",
   has_drv = false,
-  case_sensitive = false,
+  case_sensitive = true,
 }
 setmetatable(_PosixPath, { __index = _PosixPath })
 
@@ -242,6 +259,22 @@ function _PosixPath:expand(parts)
   return new_parts
 end
 
+---@param path plenary.Path2
+---@param to plenary.Path2
+---@return boolean
+function _PosixPath:is_relative(path, to)
+  if path.root ~= to.root then
+    return false
+  end
+
+  for i, to_part in ipairs(to.relparts) do
+    if to_part ~= path.relparts[i] then
+      return false
+    end
+  end
+  return true
+end
+
 local S_IF = {
   -- S_IFDIR  = 0o040000  # directory
   DIR = 0x4000,
@@ -437,7 +470,14 @@ Path.__eq = function(self, other)
   end
   ---@cast other plenary.Path2
 
-  return self:absolute() == other:absolute()
+  if self._flavor ~= other._flavor then
+    return false
+  end
+
+  if self._flavor.case_sensitive then
+    return self.filename == other.filename
+  end
+  return self.filename:lower() == other.filename:lower()
 end
 
 local _readonly_mt = {
@@ -544,10 +584,7 @@ local function is_path_like(x)
 end
 
 local function is_path_like_opt(x)
-  if x == nil then
-    return true
-  end
-  return is_path_like(x)
+  return x == nil or is_path_like(x)
 end
 
 ---@return boolean
@@ -749,41 +786,21 @@ function Path:is_relative(to)
     return true
   end
 
-  -- NOTE: could probably be optimized by letting _WindowsPath/_WindowsPath
-  -- handle this.
-
-  local to_abs = to:absolute()
-  for parent in self:iter_parents() do
-    if to_abs == parent then
-      return true
-    end
-  end
-
-  return false
+  return self._flavor:is_relative(self, to)
 end
 
---- makes a path relative to another (by default the cwd).
---- if path is already a relative path, it will first be turned absolute using
---- the cwd then made relative to the `to` path.
----@param to string|plenary.Path2? absolute path to make relative to (default: cwd)
----@param walk_up boolean? walk up to the provided path using '..' (default: `false`)
----@return string
-function Path:make_relative(to, walk_up)
+---@return plenary.Path2
+function Path:_make_relative(to, walk_up)
   vim.validate {
     to = { to, is_path_like_opt },
     walk_up = { walk_up, "b", true },
   }
 
-  -- NOTE: could probably take some shortcuts and avoid some `Path:new` calls
-  -- by allowing _WindowsPath/_PosixPath handle this individually.
-  -- As always, Windows root complicates things, so generating a new Path often
-  -- easier/less error prone than manual string manipulate but at the cost of
-  -- perf.
   walk_up = vim.F.if_nil(walk_up, false)
 
   if to == nil then
     if not self:is_absolute() then
-      return "."
+      return Path:new "."
     end
 
     to = Path:new(self.cwd)
@@ -793,11 +810,11 @@ function Path:make_relative(to, walk_up)
 
   local abs = self:absolute()
   if abs == to:absolute() then
-    return "."
+    return Path:new "."
   end
 
   if self:is_relative(to) then
-    return Path:new((abs:sub(#to:absolute() + 1):gsub("^" .. self.sep, ""))).filename
+    return Path:new((abs:sub(#to:absolute() + 1):gsub("^" .. self.sep, "")))
   end
 
   if not walk_up then
@@ -820,7 +837,35 @@ function Path:make_relative(to, walk_up)
 
   local res_path = abs:sub(#common_path + 1):gsub("^" .. self.sep, "")
   table.insert(steps, res_path)
-  return Path:new(steps).filename
+  return Path:new(steps)
+end
+
+--- makes a path relative to another (by default the cwd).
+--- if path is already a relative path, it will first be turned absolute using
+--- the cwd then made relative to the `to` path.
+---@param to string|plenary.Path2? path to make relative to (default: cwd)
+---@param walk_up boolean? walk up to the provided path using '..' (default: `false`)
+---@return string
+function Path:make_relative(to, walk_up)
+  return self:_make_relative(to, walk_up).filename
+end
+
+--- Normalize path, resolving any intermediate ".."
+--- eg. `a//b`, `a/./b`, `a/foo/../b` will all become `a/b`
+--- Can optionally convert a path to relative to another.
+---@param relative_to string|plenary.Path2|nil path to make relative to, if nil path isn't made relative
+---@param walk_up boolean? walk up to the make relative path (if provided) using '..' (default: `false`)
+---@return string
+function Path:normalize(relative_to, walk_up)
+  local p
+  if relative_to == nil then
+    p = self
+  else
+    p = self:_make_relative(relative_to, walk_up)
+  end
+
+  local relparts = resolve_dots(p.relparts)
+  return p:_filename(nil, nil, relparts)
 end
 
 --- Shorten path parts.

tests/plenary/path2_spec.lua

@@ -46,6 +46,16 @@ local function plat_path(p)
   return p:gsub("/", "\\")
 end
 
+local function root()
+  if not iswin then
+    return "/"
+  end
+  if hasshellslash and vim.o.shellslash then
+    return "C:/"
+  end
+  return "C:\\"
+end
+
 -- set up mock file with consistent eol regardless of system (git autocrlf settings)
 -- simplifies reading tests
 local licence_lines = {
@@ -301,16 +311,6 @@ describe("Path2", function()
   end)
 
   describe(":make_relative", function()
-    local root = function()
-      if not iswin then
-        return "/"
-      end
-      if hasshellslash and vim.o.shellslash then
-        return "C:/"
-      end
-      return "C:\\"
-    end
-
     it_cross_plat("can take absolute paths and make them relative to the cwd", function()
       local p = Path:new { "lua", "plenary", "path.lua" }
       local absolute = vim.fn.getcwd() .. path.sep .. p.filename
@@ -380,6 +380,57 @@ describe("Path2", function()
       local expect = Path:new { "..", "foo", "bar", "baz" }
       assert.are.same(expect.filename, p:make_relative(cwd, true))
     end)
+
+    it_win("handles drive letters case insensitively", function()
+      local p = Path:new { "C:/", "foo", "bar", "baz" }
+      local cwd = Path:new { "c:/", "foo" }
+      local expect = Path:new { "bar", "baz" }
+      assert.are.same(expect.filename, p:make_relative(cwd))
+    end)
+  end)
+
+  describe("normalize", function()
+    it_cross_plat("handles empty path", function()
+      local p = Path:new ""
+      assert.are.same(".", p:normalize())
+    end)
+
+    it_cross_plat("removes middle ..", function()
+      local p = Path:new "lua/../lua/say.lua"
+      local expect = Path:new { "lua", "say.lua" }
+      assert.are.same(expect.filename, p:normalize())
+    end)
+
+    it_cross_plat("walk up relative path", function()
+      local p = Path:new "async/../../lua/say.lua"
+      local expect = Path:new { "..", "lua", "say.lua" }
+      assert.are.same(expect.filename, p:normalize())
+    end)
+
+    it_cross_plat("handles absolute path", function()
+      local p = Path:new { root(), "a", "..", "a", "b" }
+      local expect = Path:new { root(), "a", "b" }
+      assert.are.same(expect.filename, p:normalize())
+    end)
+
+    it_cross_plat("makes relative", function()
+      local p = Path:new { path.home, "a", "..", "", "a", "b" }
+      local expect = Path:new { "a", "b" }
+      assert.are.same(expect.filename, p:normalize(path.home))
+    end)
+
+    it_cross_plat("make relative walk_up", function()
+      local p = Path:new { path.home, "a", "..", "", "a", "b" }
+      local cwd = Path:new { path.home, "c" }
+      local expect = Path:new { "..", "a", "b" }
+      assert.are.same(expect.filename, p:normalize(cwd, true))
+    end)
+
+    it_win("windows drive relative paths", function()
+      local p = Path:new { "C:", "a", "..", "", "a", "b" }
+      local expect = Path:new { "C:", "a", "b" }
+      assert.are.same(expect.filename, p:normalize())
+    end)
   end)
 
   describe(":shorten", function()
@@ -441,13 +492,6 @@ describe("Path2", function()
     end)
   end)
 
-  local function assert_permission(expect, actual)
-    if iswin then
-      return
-    end
-    assert.equal(expect, actual)
-  end
-
   describe("mkdir / rmdir", function()
     after_each(function()
       uv.fs_rmdir "_dir_not_exist"
@@ -464,7 +508,6 @@ describe("Path2", function()
       p:mkdir()
       assert.is_true(p:exists())
       assert.is_true(p:is_dir())
-      assert_permission(755, p:permission()) -- umask dependent, probably bad test
 
       p:rmdir()
       assert.is_false(p:exists())
@@ -497,17 +540,6 @@ describe("Path2", function()
       assert.is_false(p:exists())
       assert.is_false(Path:new("impossible"):exists())
     end)
-
-    it_cross_plat("can set different modes", function()
-      local p = Path:new "_dir_not_exist"
-      assert.has_no_error(function()
-        p:mkdir { mode = 292 } -- o444
-      end)
-      assert_permission(444, p:permission())
-
-      p:rmdir()
-      assert.is_false(p:exists())
-    end)
   end)
 
   describe("touch/rm", function()
@@ -764,17 +796,6 @@ describe("Path2", function()
         table.insert(trg_dirs, trg_dir:joinpath(dir))
       end
 
-      -- vim.tbl_flatten doesn't work here as copy doesn't return a list
-      local function flatten(ret, t)
-        for _, v in pairs(t) do
-          if type(v) == "table" then
-            flatten(ret, v)
-          else
-            table.insert(ret, v)
-          end
-        end
-      end
-
       before_each(function()
         -- generate {file}_{level}.lua on every directory level in src
         -- src
@@ -1198,14 +1219,14 @@ SOFTWARE.]]
       local p = Path:new "lua/plenary"
       local res = assert(p:find_upwards "busted.lua")
       local expect = Path:new "lua/plenary/busted.lua"
-      assert.are.same(expect, res)
+      assert.are.same(expect.filename, res.filename)
     end)
 
     it_cross_plat("finds file in parent dir", function()
       local p = Path:new "lua/plenary"
       local res = assert(p:find_upwards "say.lua")
-      local expect = Path:new "lua/say.lua"
-      assert.are.same(expect, res)
+      local expect = vim.fn.fnamemodify("lua/say.lua", ":p")
+      assert.are.same(expect, res.filename)
     end)
 
     it_cross_plat("doesn't find file", function()