mex: relative

Author: scivision

+stdlib/relative_to.m

@@ -6,16 +6,19 @@
   other (1,1) string
 end
 
-r = "";
+if strcmp(base, other)
+  r = ".";
+  return
+end
 
-if stdlib.is_url(base) || stdlib.is_url(other), return, end
+if ~stdlib.len(base) || ~stdlib.len(other)
+  r = "";
+  return
+end
 
 % must remove trailing slashes
-b1 = stdlib.drop_slash(base);
-o1 = stdlib.drop_slash(other);
-
-b1 = strrep(b1, "/./", "/");
-o1 = strrep(o1, "/./", "/");
+b1 = stdlib.canonical(base);
+o1 = stdlib.canonical(other);
 
 if strcmp(b1, o1)
   r = ".";
@@ -25,10 +28,6 @@
 b = javaPathObject(b1);
 o = javaPathObject(o1);
 
-if ~isempty(strfind(b1, "..")) %#ok<STREMP>
-  warning("relative_to(%s) is ambiguous base with '..'  consider using stdlib.canonical() first", b1)
-end
-
 try
   r = jPosix(b.relativize(o));
 catch e

buildfile.m

@@ -97,6 +97,7 @@ function publishTask(context)
 srcs = {
 ["src/is_admin.cpp", "src/admin_fs.cpp"] ...
 "src/is_char_device.cpp", ...
+"src/relative_to.cpp", ...
 ["src/is_wsl.cpp", linux], ...
 "src/set_permissions.cpp", ...
 ["src/is_rosetta.cpp", mac], ...

src/read_symlink.cpp

@@ -36,7 +36,6 @@ class MexFunction : public matlab::mex::Function {
 // actual function algorithm / computation
     std::string out = fs_read_symlink(in);
 
-// convert to Matlab output
     outputs[0] = factory.createScalar(out);
   }
 };

src/relative_to.cpp

@@ -0,0 +1,65 @@
+#include "mex.hpp"
+#include "mexAdapter.hpp"
+
+#include <string>
+
+#include <vector>
+#include <memory>
+
+#include <system_error>
+#include <filesystem>
+
+#include "ffilesystem.h"
+
+
+
+class MexFunction : public matlab::mex::Function {
+public:
+  void operator()(matlab::mex::ArgumentList outputs, matlab::mex::ArgumentList inputs) {
+// boilerplate engine & ArrayFactory setup
+    std::shared_ptr<matlab::engine::MATLABEngine> matlabEng = getEngine();
+
+    matlab::data::ArrayFactory factory;
+// wrangle inputs
+    std::string base, other;
+
+    if (inputs.size() != 2) {
+      matlabEng->feval(u"error", 0,
+        std::vector<matlab::data::Array>({ factory.createScalar("Mex: Two inputs required") }));
+    }
+
+    if ((inputs[0].getType() == matlab::data::ArrayType::MATLAB_STRING && inputs[0].getNumberOfElements() == 1)){
+        matlab::data::TypedArray<matlab::data::MATLABString> stringArr = inputs[0];
+        base = stringArr[0];
+    } else if (inputs[0].getType() == matlab::data::ArrayType::CHAR){
+        matlab::data::CharArray charArr = inputs[0];
+        base.assign(charArr.begin(), charArr.end());
+    } else {
+        matlabEng->feval(u"error", 0,
+        std::vector<matlab::data::Array>({ factory.createScalar("Mex: First input must be a scalar string or char vector") }));
+    }
+
+     if ((inputs[1].getType() == matlab::data::ArrayType::MATLAB_STRING && inputs[1].getNumberOfElements() == 1)){
+        matlab::data::TypedArray<matlab::data::MATLABString> stringArr = inputs[1];
+        other = stringArr[0];
+    } else if (inputs[1].getType() == matlab::data::ArrayType::CHAR){
+        matlab::data::CharArray charArr = inputs[1];
+        other.assign(charArr.begin(), charArr.end());
+    } else {
+        matlabEng->feval(u"error", 0,
+        std::vector<matlab::data::Array>({ factory.createScalar("Mex: Second input must be a scalar string or char vector") }));
+    }
+
+// actual function algorithm / computation
+    std::error_code ec;
+    std::string out;
+
+    out = std::filesystem::relative(other, base, ec).generic_string();
+
+    if(ec)
+      matlabEng->feval(u"error", 0,
+        std::vector<matlab::data::Array>({ factory.createScalar(ec.message()) }));
+
+    outputs[0] = factory.createScalar(out);
+  }
+};

test/TestRelative.m

@@ -35,28 +35,30 @@ function test_proximate_to(tc, pp)
 {"Hello", "Hello/", "."}, ...
 {"a/./b", "a/b", "."}, ...
 {"a/b", "a/./b", "."}, ...
-{"./this/one", "./this/two", "../two"}, ...
-{"/path/same", "/path/same/hi/..", "hi/.."}, ...
-{"", "/", ""}, ...
-{"/", "", ""}, ...
+{"./a/b", "./a/c", "../c"}, ...
 {"/", "/", "."}, ...
-{"/dev/null", "/dev/null", "."}, ...
-{"/a/b", "c", ""}, ...
-{"c", "/a/b", ""}, ...
-{"/a/b", "/a/b", "."}, ...
-{"/a/b", "/a", ".."}, ...
-{"/a/b/c/d", "/a/b", "../.."}, ...
-{"this/one", "this/two", "../two"}};
+{"a/b/c/d", "a/b", "../.."}, ...
+{"a/b", "a/c", "../c"}, ...
+{"a/b", "c", "../../c"}, ...
+{"c", "a/b", "../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:/", "../.."}, ...
+{"C:/", "C:/a/b", "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:/path", "D:/path", ""}}];
+% note: on Windows the drive letter should be uppercase!
+else
+  p = [p, ...
+{{"", "a", "a"}, ...
+{"/dev/null", "/dev/null", "."}}];
 end
 
 end
@@ -66,18 +68,9 @@ function test_proximate_to(tc, pp)
 
 p = init_rel();
 
-p{8}{3} = "/";
-p{12}{3} = "c";
-p{13}{3} = "/a/b";
 
 if ispc
-p{8}{3} = "/";
-p{12}{3} = "c";
-p{13}{3} = "/a/b";
-
-p{end}{3} = "d:/path";
+p{end}{3} = "D:/path";
 end
 
-p{end+1} = {"file:///", "file:///", ""};
-
 end