Release 0.9.2 preparation (#112)

* Fix PVS studio warnings

* Fix clang warning

* Fix and improve diagnostic for imported/included templates #63

* Add extra tests for render-time diagnostic

* Update thirdparty references

* Update reference to variant-lite

* Update reference to expected-lite

* Fix build

Author: flexferrum

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);