Merge pull request #7 from delegateas/thygesteffensen/dotIndexAndBool

Thygesteffensen/dot index and bool

Author: thygesteffensen

ExpressionEngine/ExpressionGrammar.cs

@@ -17,6 +17,9 @@ public ExpressionGrammar(IEnumerable<IFunction> functions)
 
             #region BasicAuxParsers
 
+            Parser<IRule> boolean = Parse.String("true").Select(b => new ConstantRule(new ValueContainer(true)))
+                .Or(Parse.String("false").Select(b => new ConstantRule(new ValueContainer(false))));
+
             Parser<IRule> integer =
                 Parse.Digit.AtLeastOnce().Text()
                     .Select(
@@ -26,10 +29,6 @@ public ExpressionGrammar(IEnumerable<IFunction> functions)
             Parser<string> simpleString =
                 Parse.AnyChar.Except(Parse.Char('@')).AtLeastOnce().Text();
 
-            Parser<ConstantRule> simpleStringRule =
-                Parse.AnyChar.Except(Parse.Char('@')).Except(Parse.Char('(').Except(Parse.Char(')'))).AtLeastOnce()
-                    .Text().Select(x => new ConstantRule(new ValueContainer(x)));
-
             Parser<char> escapedCharacters =
                 from c in
                     Parse.String("''").Select(n => '\'')
@@ -49,27 +48,34 @@ from content in Parse.CharExcept('\'').Or(escapedCharacters).Many().Text()
 
             #endregion
 
-
             var lBracket = Parse.Char('[');
             var rBracket = Parse.Char(']');
             var lParenthesis = Parse.Char('(');
             var rParenthesis = Parse.Char(')');
 
             Parser<bool> nullConditional = Parse.Char('?').Optional().Select(nC => !nC.IsEmpty);
 
-            Parser<IRule> indices =
+            Parser<IRule> bracketIndices =
                 from nll in nullConditional
                 from index in _method.Or(stringLiteral).Or(integer).Contained(lBracket, rBracket)
                 select new IndexRule(index, nll);
+            
+            Parser<IRule> dotIndices =
+                from nll in nullConditional
+                from dot in Parse.Char('.')
+                from index in Parse.AnyChar.Except(
+                    lBracket
+                        .Or(rBracket)
+                        .Or(lParenthesis)
+                        .Or(rParenthesis)
+                        .Or(Parse.Char('@'))
+                    ).Many().Text()
+                select new IndexRule(new StringLiteralRule(new ValueContainer(index)), nll);
 
             Parser<IRule> argument =
-                from arg in Parse.Ref(() => _method.Or(stringLiteral).Or(integer))
+                from arg in Parse.Ref(() => _method.Or(stringLiteral).Or(integer).Or(boolean))
                 select arg;
 
-            Parser<IRule[]> emptyArgument =
-                from empty in Parse.String("()")
-                select new IRule[0];
-
             Parser<IOption<IEnumerable<IRule>>> arguments =
                 from args in argument.Token().DelimitedBy(Parse.Char(',')).Optional()
                 select args;
@@ -86,9 +92,8 @@ from args in arguments.Contained(lParenthesis, rParenthesis)
             _method =
                 Parse.Ref(() =>
                     from func in function
-                    from indexes in indices.Many()
+                    from indexes in bracketIndices.Or(dotIndices).Many()
                     select (IRule) new AccessValueRule(func, indexes));
-            // .Or(simpleStringRule);
 
             Parser<ValueContainer> enclosedExpression =
                 _method.Contained(
@@ -100,8 +105,7 @@ from indexes in indices.Many()
                 from at in Parse.Char('@')
                 from method in _method
                 select method.Evaluate();
-
-
+            
             Parser<string> allowedString =
                 from t in simpleString.Or(allowedCharacters).Many()
                 select string.Concat(t);

ExpressionEngine/FlowRunnerDependencyExtension.cs

@@ -1,20 +1,18 @@
-using ExpressionEngine;
-using ExpressionEngine.Functions.Base;
+using ExpressionEngine.Functions.Base;
 using ExpressionEngine.Functions.Implementations.CollectionFunctions;
 using ExpressionEngine.Functions.Implementations.ConversionFunctions;
 using ExpressionEngine.Functions.Implementations.LogicalComparisonFunctions;
 using ExpressionEngine.Functions.Implementations.StringFunctions;
 using Microsoft.Extensions.DependencyInjection;
-using Parser.ExpressionParser.Functions.Implementations.StringFunctions;
 
-namespace Parser
+namespace ExpressionEngine
 {
     public static class FlowRunnerDependencyExtension
     {
         public static void AddExpressionEngine(this IServiceCollection services)
         {
-            services.AddScoped<IExpressionEngine, ExpressionEngine.ExpressionEngine>();
-            services.AddScoped<ExpressionGrammar>();
+            services.AddScoped<IExpressionEngine, ExpressionEngine>();
+            services.AddSingleton<ExpressionGrammar>();
 
             AddStringFunctions(services);
             AddCollectionFunction(services);

ExpressionEngine/Functions/Implementations/StringFunctions/GuidFunction.cs

@@ -1,11 +1,9 @@
 using System;
 using System.Linq;
-using ExpressionEngine;
 using ExpressionEngine.Functions.Base;
 using ExpressionEngine.Functions.CustomException;
-using ExpressionEngine.Functions.Implementations.StringFunctions;
 
-namespace Parser.ExpressionParser.Functions.Implementations.StringFunctions
+namespace ExpressionEngine.Functions.Implementations.StringFunctions
 {
     public class GuidFunction : Function
     {

ExpressionEngine/ReadMe.md

@@ -0,0 +1,84 @@
+# Parser
+
+This is the readme for the parser project which is a part of the FlowRunner.
+
+
+## BNF
+
+This is the BNF, [Backus-Nuar form](https://da.wikipedia.org/wiki/Backus-Naur_form), of the language used in Power Automate / Logic Apps expressions. 
+Their JSON definition can be found [here](https://docs.microsoft.com/en-us/azure/logic-apps/workflow-definition-language-functions-reference) and [here](https://docs.microsoft.com/en-us/azure/logic-apps/logic-apps-workflow-definition-language#functions) and the [json](https://schema.management.azure.com/providers/Microsoft.Logic/schemas/2016-06-01/workflowdefinition.json).
+
+### Examples
+`@triggerOutputs()`
+
+`@toLower('TEXT')`
+
+`@toLower(toUpper('text'))`
+
+`@variables('var')`
+
+`@variables('array')[0]`
+
+`@variables('object')['user']`
+
+`@variables('object')[toLower('USER')]`
+
+`@{toLower('USER')}@{toUpper('user')}`
+
+`Name: @{variables('object')[toLower('USER')]}`
+
+
+```xml
+<input>                 ::= <expression> | <joinedString> | <atPrefixedString>
+<atPrefixedString>      ::= <string> <!-- NO ( ) -->
+
+<joinedString>          ::= *(*<allowedString> *<enclosedExpression>)
+<allowedString>         ::= *([A-Za-z] | [0-9] | [\_]) <!-- Add the correct characters -->
+
+<expression>	        ::= "@" <method>
+<enclosedExpression>	::= "@{" <method> "}"
+
+<method>                ::= <function> *<operators>
+
+<function>      	    ::= <string> "(" [ <arguments> ] ")"
+<arguments>             ::= <argument> *("," <argument>)
+<argument>	            ::= <method> | <string>
+
+<operators>	            ::= *( [ <nullconditional> ] "[" <index> "]") | <dot>
+<nullconditional>       ::= "?"
+<index>                 ::= <int> | <string> | <method>
+<dot>                   ::= "." <string>
+```
+
+`string` contains a valid string including characters according to Azure Workflow definition language.
+
+
+## Special expressions
+Some expressions the user can define itself, since it is idempotent and does not use the engine state.
+
+Some expression should not be user dependent, such as
+
+ * compose
+ * outputs
+ * triggerOutputs
+ * variables
+
+These are all expression which interact with data stored in the state.
+
+
+
+Eventuelt skriv om hvordan det var sværet bare at gå igang, men efter du læste en artikel og lavede en BNF var det nemt. Dette var måske også fordi du vidste hvordan Sprache virkede og hvad der skete under moteren og aritklen gav dig en dybere forståelse af hvad man kan! :D
+
+
+## Extra observations
+### Null conditional
+We'll handle this, of course, and I've created a flow to figure out how to handle this :D
+
+As seen in the currect version of owner grammer, we'll accept null conditional after a function or after a indexer. If the part before the null conditional is null, we'll stop executing and return??
+
+The flow used to test is called: `null condtional` and is located in DG Lab 6; [link to flow](https://emea.flow.microsoft.com/manage/environments/934e6690-2c92-4a37-ab81-31be17f7724a/solutions/86491904-39dd-ea11-a813-000d3ab11761/flows/d40eaddf-55a2-4b98-87e3-c21c4fcfc57a).
+
+Error (with out null condition):
+> InvalidTemplate. Unable to process template language expressions in action 'Respond_to_a_PowerApp_or_flow_-_Without_null_conditional' inputs at line '1' and column '2357': 'The template language expression 'variables('NullVariable')['first']' cannot be evaluated because property 'first' cannot be selected. Please see https://aka.ms/logicexpressions for usage details.'.
+
+With null condtion, the answer is null and read as an empty string in some cases?

Test/Expression/StringFunctionTests.cs

@@ -1,7 +1,6 @@
 using ExpressionEngine;
 using ExpressionEngine.Functions.Implementations.StringFunctions;
 using NUnit.Framework;
-using Parser.ExpressionParser.Functions.Implementations.StringFunctions;
 
 namespace Test.Expression
 {

Test/ExpressionGrammarTest.cs

@@ -0,0 +1,89 @@
+using System.Collections.Generic;
+using ExpressionEngine;
+using ExpressionEngine.Functions.Base;
+using NUnit.Framework;
+
+namespace Test
+{
+    public class ExpressionGrammarTest
+    {
+        private ExpressionGrammar _expressionGrammar;
+        private DummyFunction _dummyFunction;
+
+        [SetUp]
+        public void SetUp()
+        {
+            _dummyFunction = new DummyFunction(new ValueContainer(new Dictionary<string, ValueContainer>
+            {
+                {
+                    "prop1", new ValueContainer(new Dictionary<string, ValueContainer>
+                    {
+                        {
+                            "prop2", new ValueContainer(new Dictionary<string, ValueContainer>
+                            {
+                                {"prop3", new ValueContainer("value")}
+                            })
+                        }
+                    })
+                }
+            }));
+
+            var functions = new List<IFunction>
+            {
+                _dummyFunction
+            };
+
+            _expressionGrammar = new ExpressionGrammar(functions);
+        }
+
+        [Test]
+        public void IndicesTest()
+        {
+            const string expressionString = "@dummyFunction()['prop1'].prop2['prop3']";
+
+            var res = _expressionGrammar.EvaluateToString(expressionString);
+
+            Assert.AreEqual("value", res);
+        }
+
+        [Test]
+        public void BooleanTest()
+        {
+            const string expressionString = "@dummyFunction(true, false)";
+
+            _expressionGrammar.EvaluateToValueContainer(expressionString);
+
+            Assert.NotNull(_dummyFunction._parameters);
+            Assert.AreEqual(2, _dummyFunction._parameters.Length);
+            var param1 = _dummyFunction._parameters[0];
+            var param2 = _dummyFunction._parameters[1];
+            Assert.NotNull(param1);
+            Assert.NotNull(param2);
+            Assert.AreEqual(ValueContainer.ValueType.Boolean, param1.Type());
+            Assert.AreEqual(ValueContainer.ValueType.Boolean, param2.Type());
+            Assert.AreEqual(true, param1.GetValue<bool>());
+            Assert.AreEqual(false, param2.GetValue<bool>());
+        }
+    }
+
+    public class DummyFunction : Function
+    {
+        private readonly ValueContainer _valueContainer;
+        internal ValueContainer[] _parameters;
+
+        public DummyFunction() : base("dummyFunction")
+        {
+        }
+
+        public DummyFunction(ValueContainer valueContainer) : base("dummyFunction")
+        {
+            _valueContainer = valueContainer;
+        }
+
+        public override ValueContainer ExecuteFunction(params ValueContainer[] parameters)
+        {
+            _parameters = parameters;
+            return _valueContainer;
+        }
+    }
+}

Test/ParserTest.cs

@@ -3,7 +3,6 @@
 using ExpressionEngine.Functions.CustomException;
 using Microsoft.Extensions.DependencyInjection;
 using NUnit.Framework;
-using Parser;
 
 
 namespace Test