refactor: no intermediary buffers for wrapper template

Author: alandefreitas

src/lib/Gen/hbs/Builder.cpp

@@ -35,11 +35,8 @@ Builder(
 {
     namespace fs = std::filesystem;
 
-    Config const& config = domCorpus->config;
-
     // load partials
-    std::string partialsPath = files::appendPath(
-        config->addons, "generator", domCorpus.fileExtension, "partials");
+    std::string partialsPath = templatesDir("partials");
     forEachFile(partialsPath, true,
         [&](std::string_view pathName) -> Error
         {
@@ -60,8 +57,7 @@ Builder(
         }).maybeThrow();
 
     // Load JavaScript helpers
-    std::string helpersPath = files::appendPath(
-        config->addons, "generator", domCorpus.fileExtension, "helpers");
+    std::string helpersPath = templatesDir("helpers");
     forEachFile(helpersPath, true,
         [&](std::string_view pathName)-> Expected<void>
         {
@@ -126,11 +122,7 @@ callTemplate(
     std::string_view name,
     dom::Value const& context)
 {
-    Config const& config = domCorpus->config;
-
-    auto layoutDir = files::appendPath(config->addons,
-            "generator", domCorpus.fileExtension, "layouts");
-    auto pathName = files::appendPath(layoutDir, name);
+    auto pathName = files::appendPath(layoutDir(), name);
     MRDOCS_TRY(auto fileText, files::getFileText(pathName));
     HandlebarsOptions options;
     options.noEscape = true;
@@ -244,40 +236,68 @@ operator()(OverloadSet const& OS)
 
 Expected<void>
 Builder::
-wrapPage(
-    std::ostream& out,
-    std::istream& in)
+renderWrapped(std::ostream& os, std::function<Error()> contentsCb)
 {
-    auto const wrapperFile = fmt::format("wrapper.{}.hbs", domCorpus.fileExtension);
+    auto const wrapperFile = fmt::format(
+        "wrapper.{}.hbs", domCorpus.fileExtension);
     dom::Object ctx;
-    ctx.set("contents", dom::makeInvocable([&in](
-         dom::Value const& options) -> Expected<dom::Value>
+    ctx.set("contents", dom::makeInvocable([&](
+        dom::Value const& options) -> Expected<dom::Value>
     {
-        // Helper to write contents directly to stream
-        // AFREITAS: custom functions should set options["write"]
-        // to avoid creating a string.
-        return std::string(
-            std::istreambuf_iterator<char>(in),
-            std::istreambuf_iterator<char>());
+        Error e = contentsCb();
+        if (e.failed())
+        {
+            return Unexpected(e);
+        }
+        return {};
     }));
-    // Render directly to ostream
-    Config const& config = domCorpus->config;
-    auto layoutDir = files::appendPath(config->addons,
-        "generator", domCorpus.fileExtension, "layouts");
-    auto pathName = files::appendPath(layoutDir, wrapperFile);
+
+    // Render the wrapper directly to ostream
+    auto pathName = files::appendPath(layoutDir(), wrapperFile);
     MRDOCS_TRY(auto fileText, files::getFileText(pathName));
     HandlebarsOptions options;
     options.noEscape = true;
-    OutputRef outRef(out);
+    OutputRef outRef(os);
     Expected<void, HandlebarsError> exp =
-        hbs_.try_render_to(outRef, fileText, ctx, options);
+        hbs_.try_render_to(
+            outRef, fileText, ctx, options);
     if (!exp)
     {
-        return Unexpected(Error(exp.error().what()));
+        Error(exp.error().what()).Throw();
     }
     return {};
 }
 
+std::string
+Builder::
+layoutDir() const
+{
+    return templatesDir("layouts");
+}
+
+std::string
+Builder::
+templatesDir() const
+{
+    Config const& config = domCorpus->config;
+    return files::appendPath(
+        config->addons,
+        "generator",
+        domCorpus.fileExtension);
+}
+
+std::string
+Builder::
+templatesDir(std::string_view subdir) const
+{
+    Config const& config = domCorpus->config;
+    return files::appendPath(
+        config->addons,
+        "generator",
+        domCorpus.fileExtension,
+        subdir);
+}
+
 
 // Define Builder::operator() for each Info type
 #define DEFINE(T) template Expected<std::string> \

src/lib/Gen/hbs/Builder.hpp

@@ -44,24 +44,53 @@ class Builder
     Builder(HandlebarsCorpus const& corpus);
 
     /** Render the contents for a symbol.
+
+        If the output is single page or embedded,
+        this function renders the index template
+        with the symbol.
+
+        If the output is multi-page and not embedded,
+        this function renders the wrapper template
+        with the index template as the contents.
      */
     template<class T>
     Expected<std::string>
     operator()(T const&);
 
-    /** Render the contents for an overload set.
-     */
+    /// @copydoc operator()(T const&)
     Expected<std::string>
     operator()(OverloadSet const&);
 
-    /** Wrap the contents of a page in the page template.
+    /** Render the contents in the wrapper layout.
+
+        This function will render the contents
+        of the wrapper template.
+
+        When the {{contents}} are rendered in the
+        wrapper template, the specified function
+        will be executed to render the contents
+        of the page.
+
      */
     Expected<void>
-    wrapPage(
-        std::ostream& out,
-        std::istream& in);
+    renderWrapped(std::ostream& os, std::function<Error()> contentsCb);
 
 private:
+    /** The directory with the all templates.
+     */
+    std::string
+    templatesDir() const;
+
+    /** A subdirectory of the templates dir
+     */
+    std::string
+    templatesDir(std::string_view subdir) const;
+
+    /** The directory with the layout templates.
+     */
+    std::string
+    layoutDir() const;
+
     /** Create a handlebars context with the symbol and helper information.
 
         The helper information includes all information from the

src/lib/Gen/hbs/HandlebarsGenerator.cpp

@@ -99,26 +99,37 @@ buildOne(
     auto ex = createExecutors(domCorpus);
     MRDOCS_CHECK_OR(ex, ex.error());
 
-    // Visit the corpus
-    std::stringstream ss;
-    std::ostream& oss = corpus.config->embedded ? os : ss;
-    SinglePageVisitor visitor(*ex, corpus, oss);
-    visitor(corpus.globalNamespace());
+    // Embedded mode
+    if (corpus.config->embedded)
+    {
+        // Visit the corpus
+        SinglePageVisitor visitor(*ex, corpus, os);
+        visitor(corpus.globalNamespace());
 
-    // Wait for all executors to finish and check errors
-    auto errors = ex->wait();
-    MRDOCS_CHECK_OR(errors.empty(), errors);
+        // Wait for all executors to finish and check errors
+        auto errors = ex->wait();
+        MRDOCS_CHECK_OR(errors.empty(), errors);
 
-    // Wrap page
-    if (!corpus.config->embedded)
-    {
-        ex->async([&os, &ss](Builder& builder) {
-            builder.wrapPage(os, ss);
-        });
-        errors = ex->wait();
-        MRDOCS_CHECK_OR(errors.empty(), {errors});
+        return Error::success();
     }
 
+    // Wrapped mode
+    Builder inlineBuilder(domCorpus);
+    auto exp = inlineBuilder.renderWrapped(os, [&]() -> Error {
+        // This helper will write contents directly to ostream
+        SinglePageVisitor visitor(*ex, corpus, os);
+        visitor(corpus.globalNamespace());
+
+        // Wait for all executors to finish and check errors
+        auto errors = ex->wait();
+        MRDOCS_CHECK_OR(errors.empty(), errors);
+
+        return Error::success();
+    });
+
+    // Check for errors in the wrapping process
+    MRDOCS_CHECK_OR(exp, exp.error());
+
     return Error::success();
 }