Merge pull request #8137 from edolstra/lazy-trees-cherrypicks

Add CanonPath::makeRelative()

src/libutil/canon-path.cc

@@ -100,4 +100,30 @@ std::ostream & operator << (std::ostream & stream, const CanonPath & path)
     return stream;
 }
 
+std::string CanonPath::makeRelative(const CanonPath & path) const
+{
+    auto p1 = begin();
+    auto p2 = path.begin();
+
+    for (; p1 != end() && p2 != path.end() && *p1 == *p2; ++p1, ++p2) ;
+
+    if (p1 == end() && p2 == path.end())
+        return ".";
+    else if (p1 == end())
+        return std::string(p2.remaining);
+    else {
+        std::string res;
+        while (p1 != end()) {
+            ++p1;
+            if (!res.empty()) res += '/';
+            res += "..";
+        }
+        if (p2 != path.end()) {
+            if (!res.empty()) res += '/';
+            res += p2.remaining;
+        }
+        return res;
+    }
+}
+
 }

src/libutil/canon-path.hh

@@ -85,6 +85,9 @@ public:
         bool operator != (const Iterator & x) const
         { return remaining.data() != x.remaining.data(); }
 
+        bool operator == (const Iterator & x) const
+        { return !(*this != x); }
+
         const std::string_view operator * () const
         { return remaining.substr(0, slash); }
 
@@ -166,6 +169,10 @@ public:
        the `allowed` paths are within `this`. (The latter condition
        ensures access to the parents of allowed paths.) */
     bool isAllowed(const std::set<CanonPath> & allowed) const;
+
+    /* Return a representation `x` of `path` relative to `this`, i.e.
+       `CanonPath(this.makeRelative(x), this) == path`. */
+    std::string makeRelative(const CanonPath & path) const;
 };
 
 std::ostream & operator << (std::ostream & stream, const CanonPath & path);

src/libutil/tests/canon-path.cc

@@ -107,7 +107,6 @@ namespace nix {
     }
 
     TEST(CanonPath, within) {
-        {
         ASSERT_TRUE(CanonPath("foo").isWithin(CanonPath("foo")));
         ASSERT_FALSE(CanonPath("foo").isWithin(CanonPath("bar")));
         ASSERT_FALSE(CanonPath("foo").isWithin(CanonPath("fo")));
@@ -116,7 +115,6 @@ namespace nix {
         ASSERT_TRUE(CanonPath("/foo/bar/default.nix").isWithin(CanonPath("/")));
         ASSERT_TRUE(CanonPath("/").isWithin(CanonPath("/")));
     }
-    }
 
     TEST(CanonPath, sort) {
         ASSERT_FALSE(CanonPath("foo") < CanonPath("foo"));
@@ -127,7 +125,6 @@ namespace nix {
     }
 
     TEST(CanonPath, allowed) {
-        {
         std::set<CanonPath> allowed {
             CanonPath("foo/bar"),
             CanonPath("foo!"),
@@ -151,5 +148,15 @@ namespace nix {
         ASSERT_FALSE(CanonPath("zzz").isAllowed(allowed));
         ASSERT_TRUE (CanonPath("/").isAllowed(allowed));
     }
+
+    TEST(CanonPath, makeRelative) {
+        CanonPath d("/foo/bar");
+        ASSERT_EQ(d.makeRelative(CanonPath("/foo/bar")), ".");
+        ASSERT_EQ(d.makeRelative(CanonPath("/foo")), "..");
+        ASSERT_EQ(d.makeRelative(CanonPath("/")), "../..");
+        ASSERT_EQ(d.makeRelative(CanonPath("/foo/bar/xyzzy")), "xyzzy");
+        ASSERT_EQ(d.makeRelative(CanonPath("/foo/bar/xyzzy/bla")), "xyzzy/bla");
+        ASSERT_EQ(d.makeRelative(CanonPath("/foo/xyzzy/bla")), "../xyzzy/bla");
+        ASSERT_EQ(d.makeRelative(CanonPath("/xyzzy/bla")), "../../xyzzy/bla");
     }
 }