Release 0.9.2 preparation

include/jinja2cpp/error_info.h

@@ -34,7 +34,9 @@ enum class ErrorCode
     TemplateNotFound,
     TemplateNotParsed,
     InvalidValueType,
+    InvalidTemplateName,
     ExtensionDisabled,
+    TemplateEnvAbsent,
 };
 
 struct SourceLocation

include/jinja2cpp/filesystem_handler.h

@@ -48,7 +48,7 @@ class RealFileSystem : public IFilesystemHandler
 
     void SetRootFolder(std::string newRoot)
     {
-        m_rootFolder = newRoot;
+        m_rootFolder = std::move(newRoot);
     }
 
     CharFileStreamPtr OpenStream(const std::string& name) const override;

src/error_info.cpp

@@ -110,8 +110,11 @@ void RenderErrorInfo(std::basic_ostream<CharT>& os, const ErrorInfoTpl<CharT>& e
         os << UNIVERSAL_STR("Parse error");
         break;
     case ErrorCode::UnexpectedException:
-        os << UNIVERSAL_STR("Unexpected exception occurred during template processing");
+    {
+        auto& extraParams = errInfo.GetExtraParams();
+        os << UNIVERSAL_STR("Unexpected exception occurred during template processing. Exception: ") << extraParams[0];
         break;
+    }
     case ErrorCode::YetUnsupported:
         os << UNIVERSAL_STR("This feature has not been supported yet");
         break;
@@ -197,12 +200,18 @@ void RenderErrorInfo(std::basic_ostream<CharT>& os, const ErrorInfoTpl<CharT>& e
     case ErrorCode::TemplateNotFound:
         os << UNIVERSAL_STR("Template(s) not found: ") << errInfo.GetExtraParams()[0];
         break;
+    case ErrorCode::InvalidTemplateName:
+        os << UNIVERSAL_STR("Invalid template name: ") << errInfo.GetExtraParams()[0];
+        break;
     case ErrorCode::InvalidValueType:
         os << UNIVERSAL_STR("Invalid value type");
         break;
     case ErrorCode::ExtensionDisabled:
         os << UNIVERSAL_STR("Extension disabled");
         break;
+    case ErrorCode::TemplateEnvAbsent:
+        os << UNIVERSAL_STR("Template environment doesn't set");
+        break;
     }
     os << std::endl << errInfo.GetLocationDescr();
 }

src/expression_evaluator.cpp

@@ -181,9 +181,9 @@ InternalValue DictCreator::Evaluate(RenderContext& context)
     return MapAdapter::CreateAdapter(std::move(result));;
 }
 
-ExpressionFilter::ExpressionFilter(std::string filterName, CallParams params)
+ExpressionFilter::ExpressionFilter(const std::string& filterName, CallParams params)
 {
-    m_filter = CreateFilter(std::move(filterName), std::move(params));
+    m_filter = CreateFilter(filterName, std::move(params));
     if (!m_filter)
         throw std::runtime_error("Can't find filter '" + filterName + "'");
 }
@@ -196,10 +196,10 @@ InternalValue ExpressionFilter::Evaluate(const InternalValue& baseVal, RenderCon
     return m_filter->Filter(baseVal, context);
 }
 
-IsExpression::IsExpression(ExpressionEvaluatorPtr<> value, std::string tester, CallParams params)
+IsExpression::IsExpression(ExpressionEvaluatorPtr<> value, const std::string& tester, CallParams params)
     : m_value(value)
 {
-    m_tester = CreateTester(std::move(tester), std::move(params));
+    m_tester = CreateTester(tester, std::move(params));
     if (!m_tester)
         throw std::runtime_error("Can't find tester '" + tester + "'");
 }

src/expression_evaluator.h

@@ -49,7 +49,7 @@ struct ParsedArguments
     std::unordered_map<std::string, ExpressionEvaluatorPtr<>> extraKwArgs;
     std::vector<ExpressionEvaluatorPtr<>> extraPosArgs;
 
-    ExpressionEvaluatorPtr<> operator[](std::string name) const
+    ExpressionEvaluatorPtr<> operator[](const std::string& name) const
     {
         auto p = args.find(name);
         if (p == args.end())
@@ -67,15 +67,15 @@ class FullExpressionEvaluator : public ExpressionEvaluatorBase
 public:
     void SetExpression(ExpressionEvaluatorPtr<Expression> expr)
     {
-        m_expression = expr;
+        m_expression = std::move(expr);
     }
     void SetFilter(ExpressionEvaluatorPtr<ExpressionFilter> expr)
     {
-        m_filter = expr;
+        m_filter = std::move(expr);
     }
     void SetTester(ExpressionEvaluatorPtr<IfExpression> expr)
     {
-        m_tester = expr;
+        m_tester = std::move(expr);
     }
     InternalValue Evaluate(RenderContext& values) override;
     void Render(OutStream &stream, RenderContext &values) override;
@@ -204,7 +204,7 @@ class IsExpression : public Expression
 
     using TesterFactoryFn = std::function<std::shared_ptr<ITester> (CallParams params)>;
 
-    IsExpression(ExpressionEvaluatorPtr<> value, std::string tester, CallParams params);
+    IsExpression(ExpressionEvaluatorPtr<> value, const std::string& tester, CallParams params);
     InternalValue Evaluate(RenderContext& context) override;
 
 private:
@@ -293,12 +293,12 @@ class ExpressionFilter
 
     using FilterFactoryFn = std::function<std::shared_ptr<IExpressionFilter> (CallParams params)>;
 
-    ExpressionFilter(std::string filterName, CallParams params);
+    ExpressionFilter(const std::string& filterName, CallParams params);
 
     InternalValue Evaluate(const InternalValue& baseVal, RenderContext& context);
     void SetParentFilter(std::shared_ptr<ExpressionFilter> parentFilter)
     {
-        m_parentFilter = parentFilter;
+        m_parentFilter = std::move(parentFilter);
     }
 private:
     std::shared_ptr<IExpressionFilter> m_filter;
@@ -322,7 +322,7 @@ class IfExpression
 
     void SetAltValue(ExpressionEvaluatorPtr<> altValue)
     {
-        m_altValue = altValue;
+        m_altValue = std::move(altValue);
     }
 
 private:

src/expression_parser.cpp

@@ -17,7 +17,7 @@ auto ReplaceErrorIfPossible(T& result, const Token& pivotTok, ErrorCode newError
     return result.get_unexpected();
 }
 
-ExpressionParser::ExpressionParser(const Settings& /* settings */)
+ExpressionParser::ExpressionParser(const Settings& /* settings */, TemplateEnv* /* env */)
 {
 
 }
@@ -63,13 +63,10 @@ ExpressionParser::ParseResult<ExpressionEvaluatorPtr<FullExpressionEvaluator>> E
 
     if (includeIfPart && lexer.EatIfEqual(Keyword::If))
     {
-        if (includeIfPart)
-        {
-            auto ifExpr = ParseIfExpression(lexer);
-            if (!ifExpr)
-                return ifExpr.get_unexpected();
-            evaluator->SetTester(*ifExpr);
-        }
+        auto ifExpr = ParseIfExpression(lexer);
+        if (!ifExpr)
+            return ifExpr.get_unexpected();
+        evaluator->SetTester(*ifExpr);
     }
 
     saver.Commit();

src/expression_parser.h

@@ -17,7 +17,7 @@ class ExpressionParser
     template<typename T>
     using ParseResult = nonstd::expected<T, ParseError>;
 
-    ExpressionParser(const Settings& settings);
+    explicit ExpressionParser(const Settings& settings, TemplateEnv* env = nullptr);
     ParseResult<RendererPtr> Parse(LexScanner& lexer);
     ParseResult<ExpressionEvaluatorPtr<FullExpressionEvaluator>> ParseFullExpression(LexScanner& lexer, bool includeIfPart = true);
     ParseResult<CallParams> ParseCallParams(LexScanner& lexer);

src/filesystem_handler.cpp

@@ -71,7 +71,7 @@ WCharFileStreamPtr MemoryFileSystem::OpenWStream(const std::string& name) const
 }
 
 RealFileSystem::RealFileSystem(std::string rootFolder)
-    : m_rootFolder(rootFolder)
+    : m_rootFolder(std::move(rootFolder))
 {
 
 }

src/filters.cpp

@@ -537,10 +537,8 @@ SequenceAccessor::SequenceAccessor(FilterParams params, SequenceAccessor::Mode m
     case LengthMode:
         break;
     case MaxItemMode:
-        ParseParams({{"case_sensitive", false, InternalValue(false)}, {"attribute", false}}, params);
-        break;
-    case MinItemMode:
-        ParseParams({{"case_sensitive", false, InternalValue(false)}, {"attribute", false}}, params);
+	case MinItemMode:
+		ParseParams({{"case_sensitive", false, InternalValue(false)}, {"attribute", false}}, params);
         break;
     case RandomMode:
     case ReverseMode:

src/function_base.h

@@ -11,7 +11,7 @@ class FunctionBase
 public:
 protected:
     bool ParseParams(const std::initializer_list<ArgumentInfo>& argsInfo, const CallParams& params);
-    InternalValue GetArgumentValue(std::string argName, RenderContext& context, InternalValue defVal = InternalValue());
+    InternalValue GetArgumentValue(const std::string& argName, RenderContext& context, InternalValue defVal = InternalValue());
 
 protected:
     ParsedArguments m_args;
@@ -26,7 +26,7 @@ inline bool FunctionBase::ParseParams(const std::initializer_list<ArgumentInfo>&
     return result;
 }
 
-inline InternalValue FunctionBase::GetArgumentValue(std::string argName, RenderContext& context, InternalValue defVal)
+inline InternalValue FunctionBase::GetArgumentValue(const std::string& argName, RenderContext& context, InternalValue defVal)
 {
     auto argExpr = m_args[argName];
     return argExpr ? argExpr->Evaluate(context) : std::move(defVal);

src/internal_value.h

@@ -218,7 +218,7 @@ class ListAdapter
     InternalValueList ToValueList() const;
     GenericList CreateGenericList() const
     {
-        if (m_accessorProvider && m_accessorProvider)
+        if (m_accessorProvider && m_accessorProvider())
             return m_accessorProvider()->CreateGenericList();
 
         return GenericList();

src/lexertk.h

@@ -349,7 +349,8 @@ namespace lexertk
 
       token()
       : type(e_none),
-        position(std::numeric_limits<std::size_t>::max())
+        position(std::numeric_limits<std::size_t>::max()),
+        length(0)
       {}
 
       void clear()
@@ -498,7 +499,7 @@ namespace lexertk
          s_end_    = 0;
          token_list_.clear();
          token_itr_ = token_list_.end();
-         store_token_itr_ = token_list_.end();
+         store_token_itr_ = token_itr_;
       }
 
       inline bool process(const std::basic_string<CharT>& str)
@@ -542,7 +543,7 @@ namespace lexertk
       inline void begin()
       {
          token_itr_ = token_list_.begin();
-         store_token_itr_ = token_list_.begin();
+         store_token_itr_ = token_itr_;
       }
 
       inline void store()
@@ -867,7 +868,7 @@ namespace lexertk
                if (endChar == *s_itr_)
                   break;
             }
-            else if (escaped)
+            else
                escaped = false;
 
             ++s_itr_;

src/statements.cpp

@@ -363,13 +363,28 @@ void IncludeStatement::Render(OutStream& os, RenderContext& values)
     auto doRender = [this, &values, &os](auto&& name) -> bool
     {
         auto tpl = values.GetRendererCallback()->LoadTemplate(name);
-        auto renderer = VisitTemplateImpl<RendererPtr>(tpl, false, [this](auto tplPtr) {
-            return CreateTemplateRenderer<IncludedTemplateRenderer>(tplPtr, m_withContext);
-        });
-        if (renderer)
+
+        try
+        {
+            auto renderer = VisitTemplateImpl<RendererPtr>(tpl, true, [this](auto tplPtr) {
+                return CreateTemplateRenderer<IncludedTemplateRenderer>(tplPtr, m_withContext);
+            });
+
+            if (renderer)
+            {
+                renderer->Render(os, values);
+                return true;
+            }
+        }
+        catch (const ErrorInfoTpl<char>& err)
+        {
+            if (err.GetCode() != ErrorCode::FileNotFound)
+                throw;
+        }
+        catch (const ErrorInfoTpl<wchar_t>& err)
         {
-            renderer->Render(os, values);
-            return true;
+            if (err.GetCode() != ErrorCode::FileNotFound)
+                throw;
         }
 
         return false;

src/statements.h

@@ -44,12 +44,12 @@ class ForStatement : public Statement
 
     void SetMainBody(RendererPtr renderer)
     {
-        m_mainBody = renderer;
+        m_mainBody = std::move(renderer);
     }
 
     void SetElseBody(RendererPtr renderer)
     {
-        m_elseBody = renderer;
+        m_elseBody = std::move(renderer);
     }
 
     void Render(OutStream& os, RenderContext& values) override;
@@ -80,7 +80,7 @@ class IfStatement : public Statement
 
     void SetMainBody(RendererPtr renderer)
     {
-        m_mainBody = renderer;
+        m_mainBody = std::move(renderer);
     }
 
     void AddElseBranch(StatementPtr<ElseBranchStatement> branch)
@@ -110,7 +110,7 @@ class ElseBranchStatement : public Statement
     bool ShouldRender(RenderContext& values) const;
     void SetMainBody(RendererPtr renderer)
     {
-        m_mainBody = renderer;
+        m_mainBody = std::move(renderer);
     }
     void Render(OutStream& os, RenderContext& values) override;
 
@@ -131,7 +131,7 @@ class SetStatement : public Statement
 
     void SetAssignmentExpr(ExpressionEvaluatorPtr<> expr)
     {
-        m_expr = expr;
+        m_expr = std::move(expr);
     }
     void Render(OutStream& os, RenderContext& values) override;
 
@@ -153,7 +153,7 @@ class ParentBlockStatement : public Statement
 
     void SetMainBody(RendererPtr renderer)
     {
-        m_mainBody = renderer;
+        m_mainBody = std::move(renderer);
     }
     void Render(OutStream &os, RenderContext &values) override;
 
@@ -177,7 +177,7 @@ class BlockStatement : public Statement
 
     void SetMainBody(RendererPtr renderer)
     {
-        m_mainBody = renderer;
+        m_mainBody = std::move(renderer);
     }
     void Render(OutStream &os, RenderContext &values) override;
 
@@ -223,7 +223,7 @@ class IncludeStatement : public Statement
 
     void SetIncludeNamesExpr(ExpressionEvaluatorPtr<> expr)
     {
-        m_expr = expr;
+        m_expr = std::move(expr);
     }
 
     void Render(OutStream& os, RenderContext& values) override;
@@ -244,7 +244,7 @@ class ImportStatement : public Statement
 
     void SetImportNameExpr(ExpressionEvaluatorPtr<> expr)
     {
-        m_nameExpr = expr;
+        m_nameExpr = std::move(expr);
     }
 
     void SetNamespace(std::string name)
@@ -283,7 +283,7 @@ class MacroStatement : public Statement
 
     void SetMainBody(RendererPtr renderer)
     {
-        m_mainBody = renderer;
+        m_mainBody = std::move(renderer);
     }
 
     void Render(OutStream &os, RenderContext &values) override;
@@ -347,7 +347,7 @@ class WithStatement : public Statement
     }
     void SetMainBody(RendererPtr renderer)
     {
-        m_mainBody = renderer;
+        m_mainBody = std::move(renderer);
     }
 
     void Render(OutStream &os, RenderContext &values) override;

src/template_env.cpp

@@ -52,7 +52,7 @@ auto LoadTemplateImpl(TemplateEnv* env, std::string fileName, const T& filesyste
         auto stream = Functions::LoadFile(fileName, fh.handler.get());
         if (stream)
         {
-            auto res = tpl.Load(*stream);
+            auto res = tpl.Load(*stream, fileName);
             if (!res)
                 return ResultType(res.get_unexpected());