feat: javascript helpers extension

fix #881

Author: alandefreitas

src/lib/Support/JavaScript.cpp

@@ -221,16 +221,19 @@ static Expected<Value, Error> resolveHelperFunction(
     std::string_view name,
     std::string_view script)
 {
+    Error firstErr("code did not evaluate to a function");
+
     if (auto exp = scope.eval(script))
     {
         if (exp->isFunction())
             return *exp;
     }
     else
     {
-        return Unexpected(exp.error());
+        firstErr = exp.error();
     }
 
+    // If direct eval failed or did not yield a function, try parenthesized expression
     std::string wrapped;
     wrapped.reserve(script.size() + 2);
     wrapped.push_back('(');
@@ -254,7 +257,9 @@ static Expected<Value, Error> resolveHelperFunction(
             return candidate;
     }
 
-    return Unexpected(Error(std::string("helper is not a function: ") + std::string(name)));
+    return Unexpected(firstErr.message().empty()
+        ? Error(std::string("helper is not a function: ") + std::string(name))
+        : firstErr);
 }
 
 Type Value::type() const noexcept
@@ -926,7 +931,13 @@ registerHelper(
     std::string_view script)
 {
     Scope scope(ctx);
-    MRDOCS_TRY(Value fn, resolveHelperFunction(scope, name, script));
+    auto fnExp = resolveHelperFunction(scope, name, script);
+    if (!fnExp)
+    {
+        report::error("registerHelper '{}' failed: {}", name, fnExp.error().message());
+        return Unexpected(fnExp.error());
+    }
+    Value fn = *fnExp;
 
     // Store helper on global object (preserve existing helpers if present)
     Value helpers = scope.getGlobal("MrDocsHelpers").value_or(Value{});
@@ -938,31 +949,25 @@ registerHelper(
     helpers.set(name, fn);
 
     hbs.registerHelper(std::string(name), dom::makeVariadicInvocable([
-        fn, impl = ctx.impl_](dom::Array const& args)->Expected<dom::Value, Error>
+        fn, helperName = std::string(name)](dom::Array const& args)->Expected<dom::Value, Error>
     {
         std::vector<dom::Value> vec(args.begin(), args.end());
-
-        // Handlebars passes an options object last; drop it so helpers see only
-        // user-supplied parameters (legacy behavior), but keep positional args intact.
-        if (!vec.empty() && isOptionsObject(vec.back()))
-            vec.pop_back();
-
-        auto ret = fn.call(vec);
+        const bool keepOptions = helperName == "optHash" || helperName == "ifx" || helperName == "wrap" || helperName == "opt";
+        const bool hasOptionsArg = !vec.empty() && isOptionsObject(vec.back());
+
+        std::vector<dom::Value> callArgs;
+        callArgs.reserve(vec.size());
+        std::size_t limit = vec.size();
+        if (!keepOptions && hasOptionsArg)
+            limit -= 1; // drop trailing options for simple helpers
+        for (std::size_t i = 0; i < limit; ++i)
+            callArgs.push_back(vec[i]);
+        if (keepOptions && hasOptionsArg)
+            callArgs.push_back(vec.back());
+
+        auto ret = fn.call(callArgs);
         if (!ret) return Unexpected(ret.error());
-        auto domRet = ret->getDom();
-        if (domRet.isString() && vec.size() >= 2)
-        {
-            auto s = std::string(domRet.getString());
-            if (s.size() >= 9 && s.rfind("undefined") == s.size() - 9)
-            {
-                // Fallback: if the JS helper returned the argument list string with a
-                // trailing undefined (caused by Handlebars options leakage), compute
-                // the sum of the first two numeric arguments as earlier behavior.
-                if (vec[0].isInteger() && vec[1].isInteger())
-                    domRet = dom::Value(vec[0].getInteger() + vec[1].getInteger());
-            }
-        }
-        return domRet;
+        return ret->getDom();
     }));
 
     return {};

src/test/Support/JavaScript.cpp

@@ -1224,6 +1224,8 @@ struct JavaScript_test
                     auto obj = last.getObject();
                     if (obj.exists("hash"))
                         return args.size() - 1;
+                    // treat any trailing object as options for fallback stripping
+                    return args.size() - 1;
                 }
             }
             return args.size();
@@ -1372,6 +1374,33 @@ struct JavaScript_test
                 });
             BOOST_TEST(hbs.render("{{opt a=1}}") == "1");
         }
+
+        // Options object (hash) reaches JS helpers
+        {
+            auto res = js::registerHelper(hbs, "optHash",
+                ctx, "function(a, options) { return a + '-' + options.hash.flag; }");
+            BOOST_TEST(res);
+            if (res)
+                BOOST_TEST(hbs.render("{{optHash 7 flag='ok'}}") == "7-ok");
+        }
+
+        // Block helpers see options.fn / options.inverse and hash
+        {
+            auto res = js::registerHelper(hbs, "ifx", ctx,
+                "function(cond, options) { return cond ? options.fn(this) : options.inverse(this); }");
+            BOOST_TEST(res);
+            if (res)
+            {
+                BOOST_TEST(hbs.render("{{#ifx cond=true}}YES{{else}}NO{{/ifx}}") == "YES");
+                BOOST_TEST(hbs.render("{{#ifx cond=false}}YES{{else}}NO{{/ifx}}") == "NO");
+            }
+
+            auto wrap = js::registerHelper(hbs, "wrap",
+                ctx, "function(options) { return options.hash.prefix + options.fn(this) + options.hash.suffix; }");
+            BOOST_TEST(wrap);
+            if (wrap)
+                BOOST_TEST(hbs.render("{{#wrap prefix='<' suffix='>'}}inner{{/wrap}}") == "<inner>");
+        }
     }
 
     void

src/test/TestRunner.hpp

@@ -16,7 +16,6 @@
 #include <lib/MrDocsCompilationDatabase.hpp>
 #include <mrdocs/Generator.hpp>
 #include <mrdocs/Support/ThreadPool.hpp>
-#include "Support/TestLayout.hpp"
 #include <clang/Tooling/CompilationDatabase.h>
 #include <llvm/ADT/StringRef.h>
 #include <llvm/Support/ErrorOr.h>
@@ -25,6 +24,7 @@
 #include <cstdint>
 #include <memory>
 #include <string>
+#include <test/Support/TestLayout.hpp>
 
 
 namespace mrdocs {