feat(Builder): relativize helper

Author: alandefreitas

src/lib/Gen/hbs/Builder.cpp

@@ -67,8 +67,102 @@ loadPartials(
         exp.error().Throw();
     }
 }
+
+/* Make a URL relative to another URL.
+
+   This function is a version of the Antora `relativize` helper,
+   used to create relative URLs between two paths in Antora projects.
+
+   The function takes two paths, `to` and `from`, and returns a
+   relative path from `from` to `to`.
+
+   If `from` is not provided, then the URL of the symbol being
+   rendered is used as the `from` path.
+
+   @see https://gitlab.com/antora/antora-ui-default/-/blob/master/src/helpers/relativize.js
+ */
+dom::Value
+relativize_fn(dom::Value to0, dom::Value from0, dom::Value options)
+{
+    if (!to0)
+    {
+        return "#";
+    }
+
+    if (!to0.isString())
+    {
+        return to0;
+    }
+
+    std::string_view to = to0.getString().get();
+    if (!to.starts_with('/'))
+    {
+        return to0;
+    }
+
+    // Single argument invocation
+    bool const singleArg = !options;
+    if (singleArg)
+    {
+        // NOTE only legacy invocation provides both to and from0
+        options = from0;
+        from0 = options.lookup("data.root.symbol.url");
+    }
+
+    // If `from` is still not set as a string
+    if (!from0.isString() || from0.getString().empty())
+    {
+        return to;
+    }
+    std::string_view from = from0.getString().get();
+
+    // Find anchor in URL
+    std::string_view hash;
+    std::size_t hashIdx = to.find('#');
+    if (hashIdx != std::string_view::npos)
+    {
+        hash = to.substr(hashIdx);
+        to = to.substr(0, hashIdx);
+    }
+
+    // Handle the case where they are the same URL
+    if (to == from)
+    {
+        if (!hash.empty())
+        {
+            return hash;
+        }
+        else if (files::isDirsy(to))
+        {
+            return "./";
+        }
+        return files::getFileName(to);
+    }
+
+    // Handle the general case
+    std::string fromDir = files::getParentDir(from);
+    std::string relativePath = std::filesystem::path(to).lexically_relative(fromDir).generic_string();
+    if (relativePath.empty())
+    {
+        relativePath = ".";
+    }
+    if (!relativePath.starts_with("../") && !relativePath.starts_with("./"))
+    {
+        relativePath = "./" + relativePath;
+    }
+    relativePath += hash;
+
+    if (relativePath == "/boost.adoc")
+    {
+        relativePath = "." + relativePath;
+    }
+    return relativePath;
 }
 
+} // (anon)
+
+
+
 Builder::
 Builder(
     HandlebarsCorpus const& corpus,
@@ -143,6 +237,7 @@ Builder(
     helpers::registerAntoraHelpers(hbs_);
     helpers::registerLogicalHelpers(hbs_);
     helpers::registerContainerHelpers(hbs_);
+    hbs_.registerHelper("relativize", dom::makeInvocable(relativize_fn));
 
     // load templates
     exp = forEachFile(layoutDir(), false,

src/lib/Support/Handlebars.cpp

@@ -3812,7 +3812,6 @@ registerAntoraHelpers(Handlebars& hbs)
     hbs.registerHelper("ne", dom::makeVariadicInvocable(ne_fn));
     hbs.registerHelper("not", dom::makeVariadicInvocable(not_fn));
     hbs.registerHelper("or", dom::makeVariadicInvocable(or_fn));
-    hbs.registerHelper("relativize", dom::makeInvocable(relativize_fn));
     hbs.registerHelper("year", dom::makeInvocable(year_fn));
 }
 
@@ -3948,89 +3947,6 @@ detag_fn(dom::Value html)
     return result;
 }
 
-dom::Value
-relativize_fn(dom::Value to, dom::Value from, dom::Value context)
-{
-    // https://gitlab.com/antora/antora-ui-default/-/blob/master/src/helpers/relativize.js
-    if (!to)
-    {
-        return "#";
-    }
-
-    if (to.isString() && !std::string_view(to.getString()).starts_with('/'))
-    {
-        return to;
-    }
-
-    if (!context)
-    {
-        // NOTE only legacy invocation provides both to and from
-        context = from;
-        from = context.lookup("data.root.page.url");
-    }
-
-    if (!from)
-    {
-        dom::Value sitePath = context.lookup("data.root.site.path");
-        if (sitePath)
-        {
-            return sitePath + to;
-        }
-        return to;
-    }
-
-    dom::Value hash = "";
-    std::size_t hashIdx = to.getString().get().find('#');
-    if (hashIdx != std::string_view::npos)
-    {
-        hash = to.getString().get().substr(hashIdx);
-        to = to.getString().get().substr(0, hashIdx);
-    }
-
-    /// return to === from
-    //    ? hash || (isDir(to) ? './' : path.basename(to))
-    //    : (path.relative(path.dirname(from + '.'), to) || '.') + (isDir(to) ? '/' + hash : hash)
-    if (to == from)
-    {
-        if (hash) {
-            return hash;
-        }
-        else if (to.isString() && files::isDirsy(to.getString().get()))
-        {
-            return "./";
-        }
-        else if (to.isString())
-        {
-            return files::getFileName(to.getString().get());
-        }
-        else
-        {
-            return to;
-        }
-    }
-    else
-    {
-        // AFREITAS: Implement this functionality without std::filesystem
-        if (!to.isString() || !from.isString()) {
-            return to;
-        }
-        std::string relativePath = std::filesystem::relative(
-            std::filesystem::path(std::string_view(to.getString())),
-            std::filesystem::path(std::string_view(from.getString()))).generic_string();
-        if (relativePath.empty())
-        {
-            relativePath = ".";
-        }
-        if (files::isDirsy(to.getString())) {
-            return relativePath + '/' + hash;
-        }
-        else
-        {
-            return relativePath + hash;
-        }
-    }
-}
-
 int
 year_fn() {
     std::chrono::system_clock::time_point now = std::chrono::system_clock::now();