Add global scope bound to TemplateEnv

Author: flexferrum

include/jinja2cpp/template_env.h

@@ -7,6 +7,7 @@
 #include "template.h"
 
 #include <unordered_map>
+#include <shared_mutex>
 
 namespace jinja2
 {
@@ -61,6 +62,24 @@ class TemplateEnv
     nonstd::expected<Template, ErrorInfo> LoadTemplate(std::string fileName);
     nonstd::expected<TemplateW, ErrorInfoW> LoadTemplateW(std::string fileName);
 
+    void AddGlobal(std::string name, Value val)
+    {
+        std::unique_lock<std::shared_timed_mutex> l(m_guard);
+        m_globalValues[std::move(name)] = std::move(val);
+    }
+
+    void RemoveGlobal(const std::string& name)
+    {
+        std::unique_lock<std::shared_timed_mutex> l(m_guard);
+        m_globalValues.erase(name);
+    }
+
+    template<typename Fn>
+    void ApplyGlobals(Fn&& fn)
+    {
+        std::shared_lock<std::shared_timed_mutex> l(m_guard);
+        fn(m_globalValues);
+    }
 private:
     IErrorHandler* m_errorHandler;
     struct FsHandler
@@ -70,6 +89,8 @@ class TemplateEnv
     };
     std::vector<FsHandler> m_filesystemHandlers;
     Settings m_settings;
+    ValuesMap m_globalValues;
+    std::shared_timed_mutex m_guard;
 };
 
 } // jinja2

src/render_context.h

@@ -29,10 +29,11 @@ struct IRendererCallback
 class RenderContext
 {
 public:
-    RenderContext(const InternalValueMap& extValues, IRendererCallback* rendererCallback)
+    RenderContext(const InternalValueMap& extValues, const InternalValueMap& globalValues, IRendererCallback* rendererCallback)
         : m_rendererCallback(rendererCallback)
     {
         m_externalScope = &extValues;
+        m_globalScope = &globalValues;
         EnterScope();
         (*m_currentScope)["self"] = MapAdapter::CreateAdapter(InternalValueMap());
     }
@@ -77,7 +78,12 @@ class RenderContext
             if (found)
                 return valP;
         }
-        return finder(*m_externalScope);
+
+        auto valP = finder(*m_externalScope);
+        if (found)
+            return valP;
+
+        return finder(*m_globalScope);
     }
 
     auto& GetCurrentScope() const
@@ -100,7 +106,7 @@ class RenderContext
     RenderContext Clone(bool includeCurrentContext) const
     {
         if (!includeCurrentContext)
-            return RenderContext(m_emptyScope, m_rendererCallback);
+            return RenderContext(m_emptyScope, *m_globalScope, m_rendererCallback);
 
         return RenderContext(*this);
     }
@@ -112,6 +118,7 @@ class RenderContext
 private:
     InternalValueMap* m_currentScope;
     const InternalValueMap* m_externalScope;
+    const InternalValueMap* m_globalScope;
     InternalValueMap m_emptyScope;
     std::list<InternalValueMap> m_scopes;
     IRendererCallback* m_rendererCallback;

src/template_impl.h

@@ -138,18 +138,31 @@ class TemplateImpl : public ITemplateImpl
 
         try
         {
+            InternalValueMap extParams;
             InternalValueMap intParams;
-            for (auto& ip : params)
+
+            auto convertFn = [&intParams](auto& params) {
+                for (auto& ip : params)
+                {
+                    auto valRef = &ip.second.data();
+                    auto newParam = visit(visitors::InputValueConvertor(), *valRef);
+                    if (!newParam)
+                        intParams[ip.first] = ValueRef(static_cast<const Value&>(*valRef));
+                    else
+                        intParams[ip.first] = newParam.get();
+                }
+            };
+
+            if (m_env)
             {
-                auto valRef = &ip.second.data();
-                auto newParam = visit(visitors::InputValueConvertor(), *valRef);
-                if (!newParam)
-                    intParams[ip.first] = ValueRef(static_cast<const Value&>(*valRef));
-                else
-                    intParams[ip.first] = newParam.get();
+                m_env->ApplyGlobals(convertFn);
+                std::swap(extParams, intParams);
             }
+
+            convertFn(params);
+
             RendererCallback callback(this);
-            RenderContext context(intParams, &callback);
+            RenderContext context(intParams, extParams, &callback);
             InitRenderContext(context);
             OutStream outStream([writer = GenericStreamWriter<CharT>(os)]() mutable -> OutStream::StreamWriter* {return &writer;});
             m_renderer->Render(outStream, context);

test/includes_test.cpp

@@ -12,8 +12,10 @@ class IncludeTest : public TemplateEnvFixture
     {
         TemplateEnvFixture::SetUp();
 
-        AddFile("header", "[{{ foo }}|{{ 23 }}]");
+        AddFile("header", "[{{ foo }}|{{ bar }}]");
         AddFile("o_printer", "({{ o }})");
+
+        m_env.AddGlobal("bar", 23);
     }
 };