relative,proximate: can use .net

Author: scivision

+stdlib/file_checksum.m

@@ -1,5 +1,5 @@
 %% FILE_CHECKSUM compute hash of file
-% requires: java
+% optional: java
 %
 % read in chunks to avoid excessive RAM use
 %

+stdlib/is_symlink.m

@@ -12,7 +12,7 @@
   switch e.identifier
     case "MATLAB:UndefinedFunction"
       if stdlib.has_dotnet()
-        if stdlib.dotnet_api >= 6
+        if stdlib.dotnet_api() >= 6
           ok = ~isempty(System.IO.FileInfo(p).LinkTarget);
         else
            attr = string(System.IO.File.GetAttributes(p).ToString());

+stdlib/proximate_to.m

@@ -1,16 +1,24 @@
 %% PROXIMATE_TO relative path to base
-% requires: mex
-
+% optional: mex
+%
 %%% Inputs
 % * base {mustBeTextScalar}
 % * other {mustBeTextScalar}
 %%% Outputs
 % * rel {mustBeTextScalar}
-%
-% This function is written in C++ using STL <filesystem>
 
-function proximate_to(~,~)
-error("buildtool mex")
+function rel = proximate_to(base, other)
+arguments
+  base {mustBeTextScalar}
+  other {mustBeTextScalar}
+end
+
+rel = stdlib.relative_to(base, other);
+if strempty(rel)
+  rel = fullfile(other);
+end
+
+
 end
 
 %!testif 0

+stdlib/relative_to.m

@@ -1,19 +1,47 @@
 %% RELATIVE_TO relative path to base
-% requires: mex
+% optional: mex
 %
 %%% Inputs
 % * base {mustBeTextScalar}
 % * other {mustBeTextScalar}
 %%% Outputs
 % * rel {mustBeTextScalar}
 %
-% This function is written in C++ using STL <filesystem>
-%
 % Note: Java Path.relativize has an algorithm so different that we choose not to use it.
 % https://docs.oracle.com/javase/8/docs/api/java/nio/file/Path.html#relativize-java.nio.file.Path-
 
-function relative_to(~,~)
-error("buildtool mex")
+function rel = relative_to(base, other)
+arguments
+  base {mustBeTextScalar}
+  other {mustBeTextScalar}
+end
+
+
+if stdlib.has_dotnet() && stdlib.dotnet_api() >= 5
+
+  if strempty(base) && strempty(other), rel = "."; return, end
+
+  if strempty(other), rel = base; return, end
+  if strempty(base), rel = other; return, end
+
+  bis = stdlib.is_absolute(base);
+  ois = stdlib.is_absolute(other);
+
+  if bis ~= ois, rel = ""; return, end
+
+  base = fullfile(base);
+  other = fullfile(other);
+
+  if bis && ~(startsWith(base, other) || startsWith(other, base))
+    rel = "";
+  else
+    % https://learn.microsoft.com/en-us/dotnet/api/system.io.path.getrelativepath
+    rel = string(System.IO.Path.GetRelativePath(base, other));
+  end
+else
+  error('no supported relative path method found, please install .NET or "buildtool mex"')
+end
+
 end
 
 %!testif 0

buildfile.m

@@ -265,8 +265,6 @@ function build_exe(context)
 ["src/is_admin.cpp", "src/admin_fs.cpp"] ...
 "src/is_char_device.cpp", ...
 ["src/normalize.cpp", normal], ...
-"src/relative_to.cpp", ...
-"src/proximate_to.cpp", ...
 "src/disk_available.cpp", ...
 "src/disk_capacity.cpp", ...
 "src/set_permissions.cpp", ...

src/relative_to.cpp

@@ -28,7 +28,7 @@ class MexFunction : public matlab::mex::Function {
     matlab_2string(inputs, &base, &other);
 
     std::error_code ec;
-    std::string out = std::filesystem::relative(other, base, ec).generic_string();
+    std::string out = std::filesystem::relative(other, base, ec).string();
 
     if(ec)
       matlabEng->feval(u"error", 0,

test/TestRelative.m

@@ -5,20 +5,20 @@
 pp = init_prox()
 end
 
-methods (Test, TestTags = "mex")
+methods (Test)
 
 function test_relative_to(tc, pr)
-tc.assertTrue(stdlib.is_mex_fun("stdlib.relative_to"))
+tc.assumeTrue((stdlib.has_dotnet() && stdlib.dotnet_api() >= 5) || stdlib.is_mex_fun("stdlib.relative_to"))
 
 tc.verifyEqual(stdlib.relative_to(pr{1}, pr{2}), pr{3}, ...
   "relative_to(" + pr{1} + "," + pr{2}+")")
 end
 
 function test_proximate_to(tc, pp)
-tc.assertTrue(stdlib.is_mex_fun("stdlib.proximate_to"))
+tc.assumeTrue((stdlib.has_dotnet() && stdlib.dotnet_api() >= 5) || stdlib.is_mex_fun("stdlib.proximate_to"))
 
 tc.verifyEqual(stdlib.proximate_to(pp{1}, pp{2}), pp{3}, ...
-  "proximate_to(" + pp{1} + "," + pp{2}+")")
+  "proximate_to(" + pp{1} + ", " + pp{2}+")")
 end
 
 end
@@ -32,30 +32,32 @@ function test_proximate_to(tc, pp)
 {"Hello", "Hello/", "."}, ...
 {"a/./b", "a/b", "."}, ...
 {"a/b", "a/./b", "."}, ...
-{"./a/b", "./a/c", "../c"}, ...
+{"./a/b", "./a/c", fullfile("..", "c")}, ...
 {"/", "/", "."}, ...
-{"a/b/c/d", "a/b", "../.."}, ...
-{"a/b", "a/c", "../c"}, ...
-{"a/b", "c", "../../c"}, ...
-{"c", "a/b", "../a/b"}, ...
+{"a/b/c/d", "a/b", fullfile("..", "..")}, ...
+{"a/b", "a/c", fullfile("..", "c")}, ...
+{"a/b", "c", fullfile("..", "..", "c")}, ...
+{"c", "a/b", fullfile("..", "a", "b")}, ...
 {"a/b", "a/b", "."}, ...
 {"a/b", "a", ".."}
 };
 % NOTE: ".." in relative_to(base) is ambiguous including for python.pathlib, C++ <filesystem>, etc.
 
 if ispc
 p = [p, ...
-{{"C:/a/b", "C:/", "../.."}, ...
-{"C:/", "C:/a/b", "a/b"}, ...
+{{"C:/a/b", "C:/", fullfile("..", "..")}, ...
+{"C:/", "C:/a/b", fullfile("a", "b")}, ...
 {"c:/a/b", "c:/a/b", "."}, ...
 {"c:/a/b", "c:/a", ".."}, ...
-{"c:\a/b\c/d", "c:/a\b", "../.."}, ...
-{"C:/path", "D:/path", ""}}];
+{"c:\a/b\c/d", "c:/a\b", fullfile("..", "..")}, ...
+{"C:/path", "D:/path", ""}, ...
+{"D:/a/b", "c", ""}}];
 % note: on Windows the drive letter should be uppercase!
 else
   p = [p, ...
 {{"", "a", "a"}, ...
-{"/dev/null", "/dev/null", "."}}];
+{"/dev/null", "/dev/null", "."}, ...
+{"/a/b", "c", ""}}];
 end
 
 end
@@ -67,7 +69,8 @@ function test_proximate_to(tc, pp)
 
 
 if ispc
-p{end}{3} = "D:/path";
+p{end-1}{3} = fullfile("D:", "path");
+p{end}{3} = "c";
 end
 
 end