public JobContainer EvaluateJobContainer( TemplateToken token, DictionaryContextData contextData) { var result = default(JobContainer); if (token != null && token.Type != TokenType.Null) { var context = CreateContext(contextData); try { token = TemplateEvaluator.Evaluate(context, PipelineTemplateConstants.Container, token, 0, null, omitHeader: true); context.Errors.Check(); result = PipelineTemplateConverter.ConvertToJobContainer(context, token); } catch (Exception ex) when(!(ex is TemplateValidationException)) { context.Errors.Add(ex); } context.Errors.Check(); } return(result); }
public Dictionary <String, String> EvaluateJobDefaultsRun( TemplateToken token, DictionaryContextData contextData) { var result = default(Dictionary <String, String>); if (token != null && token.Type != TokenType.Null) { var context = CreateContext(contextData); try { token = TemplateEvaluator.Evaluate(context, PipelineTemplateConstants.JobDefaultsRun, token, 0, null, omitHeader: true); context.Errors.Check(); result = new Dictionary <String, String>(StringComparer.OrdinalIgnoreCase); var mapping = token.AssertMapping("defaults run"); foreach (var pair in mapping) { // Literal key var key = pair.Key.AssertString("defaults run key"); // Literal value var value = pair.Value.AssertString("defaults run value"); result[key.Value] = value.Value; } } catch (Exception ex) when(!(ex is TemplateValidationException)) { context.Errors.Add(ex); } context.Errors.Check(); } return(result); }
public Int32 EvaluateStepTimeout( TemplateToken token, DictionaryContextData contextData) { var result = default(Int32?); if (token != null && token.Type != TokenType.Null) { var context = CreateContext(contextData); try { token = TemplateEvaluator.Evaluate(context, PipelineTemplateConstants.NumberStepsContext, token, 0, null, omitHeader: true); context.Errors.Check(); result = PipelineTemplateConverter.ConvertToStepTimeout(context, token); } catch (Exception ex) when(!(ex is TemplateValidationException)) { context.Errors.Add(ex); } context.Errors.Check(); } return(result ?? 0); }
public Dictionary <String, String> EvaluateStepEnvironment( TemplateToken token, DictionaryContextData contextData, StringComparer keyComparer) { var result = default(Dictionary <String, String>); if (token != null && token.Type != TokenType.Null) { var context = CreateContext(contextData); try { token = TemplateEvaluator.Evaluate(context, PipelineTemplateConstants.StepEnv, token, 0, null, omitHeader: true); context.Errors.Check(); result = PipelineTemplateConverter.ConvertToStepEnvironment(context, token, keyComparer); } catch (Exception ex) when(!(ex is TemplateValidationException)) { context.Errors.Add(ex); } context.Errors.Check(); } return(result ?? new Dictionary <String, String>(keyComparer)); }
public static Tuple <Region, List <Method> > Serialize(IMethodImpl method, DocumentConfig documentConfig) { var template = documentConfig.Templates.FirstOrDefault(t => t.Name == method.Template); if (template == null) { throw new InvalidOperationException($"Template '{method.Template}' does not exist"); } template = new TemplateEvaluator(method, template, documentConfig.Templates).ResolveAll(); var finalRegions = template.Regions.Select(r => r.Serialize(method, documentConfig)).Where(r => r != null).ToReadOnlyList(); var finalMethods = template.MethodDefs.SelectMany(m => m.Serialize(method, documentConfig)).ToList(); if (method.Region) { var regionName = (method.Description ?? method.Name); if (method.PluralRegion) { regionName += "s"; } return(Tuple.Create(new Region(regionName, finalRegions, finalMethods.ToReadOnlyList(), false), new List <Method>())); } else { return(Tuple.Create <Region, List <Method> >(null, finalMethods)); } }
public DictionaryContextData EvaluateStepScopeOutputs( TemplateToken token, DictionaryContextData contextData) { var result = default(DictionaryContextData); if (token != null && token.Type != TokenType.Null) { var context = CreateContext(contextData); try { token = TemplateEvaluator.Evaluate(context, PipelineTemplateConstants.StepsScopeOutputs, token, 0, null, omitHeader: true); context.Errors.Check(); result = token.ToContextData().AssertDictionary("steps scope outputs"); } catch (Exception ex) when(!(ex is TemplateValidationException)) { context.Errors.Add(ex); } context.Errors.Check(); } return(result ?? new DictionaryContextData()); }
public Boolean EvaluateStepIf( TemplateToken token, DictionaryContextData contextData, IList <IFunctionInfo> expressionFunctions, IEnumerable <KeyValuePair <String, Object> > expressionState) { var result = default(Boolean?); if (token != null && token.Type != TokenType.Null) { var context = CreateContext(contextData, expressionFunctions, expressionState); try { token = TemplateEvaluator.Evaluate(context, PipelineTemplateConstants.StepIfResult, token, 0, null, omitHeader: true); context.Errors.Check(); result = PipelineTemplateConverter.ConvertToIfResult(context, token); } catch (Exception ex) when(!(ex is TemplateValidationException)) { context.Errors.Add(ex); } context.Errors.Check(); } return(result ?? throw new InvalidOperationException("Step if cannot be null")); }
/// <summary> /// Evaluates a given expression for truthiness. /// </summary> /// <param name="expressionOrVariableOrText">The value or expression to evaluate.</param> /// <returns>Whether the expression evaluates with no errors and the result is truthy (Not empty, 0 or false).</returns> public bool EvaluateTruthy(string expressionOrVariableOrText) { string error; var result = Evaluate(expressionOrVariableOrText, out error); return(string.IsNullOrWhiteSpace(error) && result != null && TemplateEvaluator.IsTruthy(result)); }
public DictionaryContextData EvaluateCompositeOutputs( IExecutionContext executionContext, TemplateToken token, IDictionary <string, PipelineContextData> extraExpressionValues) { var result = default(DictionaryContextData); if (token != null) { var context = CreateContext(executionContext, extraExpressionValues); try { token = TemplateEvaluator.Evaluate(context, "outputs", token, 0, null, omitHeader: true); context.Errors.Check(); result = token.ToContextData().AssertDictionary("composite outputs"); } catch (Exception ex) when(!(ex is TemplateValidationException)) { context.Errors.Add(ex); } context.Errors.Check(); } return(result ?? new DictionaryContextData()); }
public List <ActionStep> LoadCompositeSteps( TemplateToken token ) { var result = default(List <ActionStep>); if (token != null && token.Type != TokenType.Null) { var context = CreateContext(null, null, setMissingContext: false); // TODO: we might want to to have a bool to prevent it from filling in with missing context w/ dummy variables try { token = TemplateEvaluator.Evaluate(context, PipelineTemplateConstants.StepsInTemplate, token, 0, null, omitHeader: true); context.Errors.Check(); result = PipelineTemplateConverter.ConvertToSteps(context, token); } catch (Exception ex) when(!(ex is TemplateValidationException)) { context.Errors.Add(ex); } context.Errors.Check(); } return(result); }
public string EvaluateDefaultInput( IExecutionContext executionContext, string inputName, TemplateToken token) { string result = ""; if (token != null) { var context = CreateContext(executionContext); try { var evaluateResult = TemplateEvaluator.Evaluate(context, "input-default-context", token, 0, null, omitHeader: true); context.Errors.Check(); Trace.Info($"Input '{inputName}': default value evaluate result: {StringUtil.ConvertToJson(evaluateResult)}"); // String result = evaluateResult.AssertString($"default value for input '{inputName}'").Value; } catch (Exception ex) when(!(ex is TemplateValidationException)) { Trace.Error(ex); context.Errors.Add(ex); } context.Errors.Check(); } return(result); }
public String EvaluateStepDisplayName( TemplateToken token, DictionaryContextData contextData, IList <IFunctionInfo> expressionFunctions) { var result = default(String); if (token != null && token.Type != TokenType.Null) { var context = CreateContext(contextData, expressionFunctions); try { token = TemplateEvaluator.Evaluate(context, PipelineTemplateConstants.StringStepsContext, token, 0, null, omitHeader: true); context.Errors.Check(); result = PipelineTemplateConverter.ConvertToStepDisplayName(context, token); } catch (Exception ex) when(!(ex is TemplateValidationException)) { context.Errors.Add(ex); } context.Errors.Check(); } return(result); }
//Serialize to either a collection of methods or a region that contains the methods public static IEnumerable <IElement> Serialize(IMethodImpl method, DocumentConfig documentConfig) { var template = documentConfig.Templates.FirstOrDefault(t => t.Name == method.Template); if (template == null) { throw new InvalidOperationException($"Template '{method.Template}' does not exist"); } template = new TemplateEvaluator(method, template, documentConfig.Templates).ResolveAll(); var finalRegions = template.Regions.Select(r => r.Serialize(method, documentConfig)).Where(r => r != null); var finalMethods = template.MethodDefs.SelectMany(m => m.Serialize(method, documentConfig)).ToList(); if (method.Region) { var regionName = (method.Description ?? method.Name); if (method.PluralRegion) { regionName += "s"; } var regionMembers = new List <IElement>(); regionMembers.AddRange(finalRegions); regionMembers.AddRange(finalMethods); return(new IElement[] { new Region(regionName, regionMembers.ToReadOnlyList(), false) }); } else { return(finalMethods); } }
public IList <KeyValuePair <String, JobContainer> > EvaluateJobServiceContainers( TemplateToken token, DictionaryContextData contextData, IList <IFunctionInfo> expressionFunctions) { var result = default(List <KeyValuePair <String, JobContainer> >); if (token != null && token.Type != TokenType.Null) { var context = CreateContext(contextData, expressionFunctions); try { token = TemplateEvaluator.Evaluate(context, PipelineTemplateConstants.Services, token, 0, null, omitHeader: true); context.Errors.Check(); result = PipelineTemplateConverter.ConvertToJobServiceContainers(context, token); } catch (Exception ex) when(!(ex is TemplateValidationException)) { context.Errors.Add(ex); } context.Errors.Check(); } return(result); }
public TemplateToken EvaluateEnvironmentUrl( TemplateToken token, DictionaryContextData contextData, IList <IFunctionInfo> expressionFunctions) { var result = default(TemplateToken); if (token != null && token.Type != TokenType.Null) { var context = CreateContext(contextData, expressionFunctions); try { token = TemplateEvaluator.Evaluate(context, TemplateConstants.StringRunnerContextNoSecrets, token, 0, null, omitHeader: true); context.Errors.Check(); result = token.AssertString("environment.url"); } catch (Exception ex) when(!(ex is TemplateValidationException)) { context.Errors.Add(ex); } context.Errors.Check(); } return(result); }
public Dictionary <String, String> EvaluateStepInputs( TemplateToken token, DictionaryContextData contextData, IList <IFunctionInfo> expressionFunctions) { var result = default(Dictionary <String, String>); if (token != null && token.Type != TokenType.Null) { var context = CreateContext(contextData, expressionFunctions); try { token = TemplateEvaluator.Evaluate(context, PipelineTemplateConstants.StepWith, token, 0, null, omitHeader: true); context.Errors.Check(); result = PipelineTemplateConverter.ConvertToStepInputs(context, token); } catch (Exception ex) when(!(ex is TemplateValidationException)) { context.Errors.Add(ex); } context.Errors.Check(); } return(result ?? new Dictionary <String, String>(StringComparer.OrdinalIgnoreCase)); }
/// <summary> /// Evaluates a given expression as if it were the value of a variable. /// </summary> /// <param name="expressionOrVariableOrText">The value or expression to evaluate.</param> /// <param name="error">Any parsing errors silently found.</param> /// <param name="haltOnError">Stop parsing if an error is found.</param> /// <returns>The result of the expression.</returns> public string Evaluate(string expressionOrVariableOrText, out string error, bool haltOnError = true) { error = null; if (expressionOrVariableOrText == null) { return(null); } if (CanEvaluationBeSkippedForExpression(expressionOrVariableOrText)) { return(expressionOrVariableOrText); } Template template; if (!TemplateParser.TryParseTemplate(expressionOrVariableOrText, out template, out error, haltOnError)) { return(expressionOrVariableOrText); } using (var writer = new StringWriter()) { string[] missingTokens; TemplateEvaluator.Evaluate(template, Binding, writer, out missingTokens); if (missingTokens.Any()) { var tokenList = string.Join(", ", missingTokens.Select(token => "'" + token + "'")); error = string.Format("The following tokens were unable to be evaluated: {0}", tokenList); } return(writer.ToString()); } }
public void Setup() { var mocker = new AutoMoqer(); _templateEvaluator = mocker.Create <TemplateEvaluator>(); _evaluator = mocker.GetMock <ICSharpEvaluator>(); _evaluator.Setup(e => e.Run(It.IsAny <string>())).Returns(EmptyResult); }
public void Evaluate_template_that_has_no_expressions() { TemplateEvaluator templateEvaluator = new TemplateEvaluator(); string[] actualEvaluations = templateEvaluator.Evaluate(StringConstants.TemplateWithNoExpressions); Assert.Equal(StringConstants.TemplateWithNoExpressions, actualEvaluations[0]); }
private Template GetResolvedTemplate(IMethodImpl methodImpl, DocumentConfig config) { var template = config.Templates.First(t => t.Name == methodImpl.Template); var evaluatedTemplate = new TemplateEvaluator(methodImpl, template, config.Templates); var resolvedTemplate = evaluatedTemplate.ResolveAll(); return(resolvedTemplate); }
public void GetResult_return_empty_string() { var model = new Model(null); var templateEvaluator = new TemplateEvaluator(model); string result = templateEvaluator.GetResult(); Assert.IsEmpty(result); }
public void EvalText_GetResult_return_text() { var model = new Model(null); var templateEvaluator = new TemplateEvaluator(model); var element = new TextTemplateElement("123"); templateEvaluator.EvalText(element); string result = templateEvaluator.GetResult(); Assert.AreEqual("123", result); }
public static string Eval(string template, Model model) { var parser = new Parser(); TemplateModel templateModel = parser.Parse(template); var evaluator = new TemplateEvaluator(model); foreach (TemplateElement element in templateModel.Elements) { element.Accept(evaluator); } return(evaluator.GetResult()); }
public void EvalMethod_GetResult_return_result_of_method() { var model = new ModelWithMethod(null, "123"); var evaluator = new TemplateEvaluator(model); var element = new MethodCallTemplateElement { MethodName = "GetText" }; evaluator.EvalMethod(element); Assert.AreEqual("123", evaluator.GetResult()); }
public void EvalMethod_throw_TemplateEvaluateException_if_method_does_not_exist() { var model = new Model(null); var evaluator = new TemplateEvaluator(model); var element = new MethodCallTemplateElement { MethodName = "SomeMethod" }; var exception = Assert.Throws <TemplateEvaluateException>(() => evaluator.EvalMethod(element)); Assert.AreEqual("Method with name 'SomeMethod' does not exist in model.", exception.Message); }
public Dictionary <string, string> EvaluateContainerEnvironment( IExecutionContext executionContext, MappingToken token, IDictionary <string, PipelineContextData> extraExpressionValues) { var result = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase); if (token != null) { var context = CreateContext(executionContext, extraExpressionValues); try { var evaluateResult = TemplateEvaluator.Evaluate(context, "container-runs-env", token, 0, null, omitHeader: true); context.Errors.Check(); Trace.Info($"Environments evaluate result: {StringUtil.ConvertToJson(evaluateResult)}"); // Mapping var mapping = evaluateResult.AssertMapping("container env"); foreach (var pair in mapping) { // Literal key var key = pair.Key.AssertString("container env key"); // Literal value var value = pair.Value.AssertString("container env value"); result[key.Value] = value.Value; Trace.Info($"Add env {key} = {value}"); } } catch (Exception ex) when(!(ex is TemplateValidationException)) { Trace.Error(ex); context.Errors.Add(ex); } context.Errors.Check(); } return(result); }
public void EvalOutputValue_GetResult_return_property_value_as_string() { var model = new Model(new { Count = 5 }); var templateEvaluator = new TemplateEvaluator(model); var element = new OutputValueTemplateElement { ValueAccess = new PropertyValueAccess { Name = "Count" } }; templateEvaluator.EvalOutputValue(element); string result = templateEvaluator.GetResult(); Assert.AreEqual("5", result); }
public List <string> EvaluateContainerArguments( IExecutionContext executionContext, SequenceToken token, IDictionary <string, PipelineContextData> extraExpressionValues) { var result = new List <string>(); if (token != null) { var context = CreateContext(executionContext, extraExpressionValues); try { var evaluateResult = TemplateEvaluator.Evaluate(context, "container-runs-args", token, 0, null, omitHeader: true); context.Errors.Check(); Trace.Info($"Arguments evaluate result: {StringUtil.ConvertToJson(evaluateResult)}"); // Sequence var args = evaluateResult.AssertSequence("container args"); foreach (var arg in args) { var str = arg.AssertString("container arg").Value; result.Add(str); Trace.Info($"Add argument {str}"); } } catch (Exception ex) when(!(ex is TemplateValidationException)) { Trace.Error(ex); context.Errors.Add(ex); } context.Errors.Check(); } return(result); }
internal override void Accept(TemplateEvaluator evaluator) { evaluator.EvalCondition(this); }
internal override void Accept(TemplateEvaluator evaluator) { evaluator.EvalText(this); }