Merge pull request #40 from thygesteffensen/fix/valuecontainerconvert

Fix/valuecontainerconvert
thygesteffensen · Mar 1, 2021 · 4c0eabd · 4c0eabd
2 parents 0cd0c63 + c0e71a3
commit 4c0eabd
Show file tree

Hide file tree

Showing 34 changed files with 1,103 additions and 442 deletions.
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
@@ -46,7 +46,7 @@ jobs:
           GIT_AUTHOR_NAME: thygesteffensen
           GIT_AUTHOR_EMAIL: [email protected]
         run: |
-          echo "RELEASE_VERSION=$((npx semantic-release --dry-run).Where({ $_ -like '*Release note*' }) | Out-String | Select-String '[0-9]+\.[0-9]+\.[0-9]+([-][a-zA-z]+[.][0-9]*)' | % { $_.Matches } | % { $_.Value })" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
+          echo "RELEASE_VERSION=$((npx semantic-release --dry-run).Where({ $_ -like '*Release note*' }) | Out-String | Select-String '[0-9]+\.[0-9]+\.[0-9]+([-][a-zA-z]+[.][0-9]*)?' | % { $_.Matches } | % { $_.Value })" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
 
       - name: Print release verison
         run: echo ${env:RELEASE_VERSION}

diff --git a/PowerAutomateMockUp/ExpressionParser/Functions/CustomException/InvalidTemplateException.cs b/PowerAutomateMockUp/ExpressionParser/Functions/CustomException/InvalidTemplateException.cs
@@ -59,5 +59,15 @@ public static InvalidTemplateException BuildInvalidTemplateExceptionParameterTyp
 
             return new InvalidTemplateException(msg);
         }
+
+        public static InvalidTemplateException BuildInvalidLanguageFunction(string actionName, string functionName)
+        {
+            var msg = $"InvalidTemplate. Unable to process template language expressions in action '{actionName}' inputs at " +
+                      $"line 'x' and column 'y': 'The template language function '{functionName}' expects a comma separated " +
+                      "list of parameters. The function was invoked with no parameters. " +
+                      "Please see https://aka.ms/logicexpressions#createArray for usage details.'.";
+
+            return new InvalidTemplateException(msg);
+        }
     }
 }
diff --git a/...kUp/ExpressionParser/Functions/Implementations/ConversionFunctions/CreateArrayFunction.cs b/...kUp/ExpressionParser/Functions/Implementations/ConversionFunctions/CreateArrayFunction.cs
@@ -0,0 +1,23 @@
+using System.Linq;
+using Parser.ExpressionParser.Functions.Base;
+using Parser.ExpressionParser.Functions.CustomException;
+
+namespace Parser.ExpressionParser.Functions.Implementations.ConversionFunctions
+{
+    public class CreateArrayFunction : Function
+    {
+        public CreateArrayFunction() : base("createArray")
+        {
+        }
+
+        public override ValueContainer ExecuteFunction(params ValueContainer[] parameters)
+        {
+            if (parameters.Length == 0)
+            {
+                throw InvalidTemplateException.BuildInvalidLanguageFunction("SomeActon", "createArray");
+            }
+
+            return new ValueContainer(parameters.ToList());
+        }
+    }
+}
diff --git a/...eMockUp/ExpressionParser/Functions/Implementations/ConversionFunctions/DataUriFunction.cs b/...eMockUp/ExpressionParser/Functions/Implementations/ConversionFunctions/DataUriFunction.cs
@@ -1,4 +1,5 @@
 using Parser.ExpressionParser.Functions.Base;
+using Parser.ExpressionParser.Functions.CustomException;
 
 namespace Parser.ExpressionParser.Functions.Implementations.ConversionFunctions
 {
@@ -10,6 +11,11 @@ public DataUriFunction() : base("dataUri")
 
         public override ValueContainer ExecuteFunction(params ValueContainer[] parameters)
         {
+            if (parameters.Length == 0)
+            {
+                throw InvalidTemplateException.BuildInvalidLanguageFunction("SomeActon", "dataUri");
+            }
+
             return parameters[0].Type() switch
             {
                 ValueContainer.ValueType.String =>

diff --git a/...ExpressionParser/Functions/Implementations/ConversionFunctions/DataUriToBinaryFunction.cs b/...ExpressionParser/Functions/Implementations/ConversionFunctions/DataUriToBinaryFunction.cs
@@ -0,0 +1,32 @@
+using System;
+using System.Linq;
+using System.Text;
+using Parser.ExpressionParser.Functions.Base;
+using Parser.ExpressionParser.Functions.CustomException;
+
+namespace Parser.ExpressionParser.Functions.Implementations.ConversionFunctions
+{
+    public class DataUriToBinaryFunction : Function
+    {
+        public DataUriToBinaryFunction() : base("dataUriToBinary")
+        {
+        }
+
+        public override ValueContainer ExecuteFunction(params ValueContainer[] parameters)
+        {
+            if (parameters.Length == 0)
+            {
+                throw InvalidTemplateException.BuildInvalidLanguageFunction("SomeActon", "dataUriToBinary");
+            }
+
+            return parameters[0].Type() switch
+            {
+                ValueContainer.ValueType.String =>
+                    new ValueContainer(Encoding.UTF8.GetBytes(parameters[0].GetValue<string>())
+                        .Aggregate("", (s, b) => s + Convert.ToString(b, 2).PadLeft(8, '0'))),
+                _ => throw new PowerAutomateMockUpException(
+                    $"Array function can only operate on strings, not {parameters[0].Type()}.")
+            };
+        }
+    }
+}
diff --git a/PowerAutomateMockUp/ExpressionParser/Functions/Math/AddFunction.cs b/PowerAutomateMockUp/ExpressionParser/Functions/Math/AddFunction.cs
@@ -0,0 +1,25 @@
+using Parser.ExpressionParser.Functions.Base;
+using Parser.ExpressionParser.Functions.CustomException;
+
+namespace Parser.ExpressionParser.Functions.Math
+{
+    public class AddFunction : Function
+    {
+        public AddFunction() : base("add")
+        {
+        }
+
+        public override ValueContainer ExecuteFunction(params ValueContainer[] parameters)
+        {
+            if (parameters.Length != 2)
+            {
+                throw new InvalidTemplateException("Paramters count does not match expected");
+            }
+
+            var first = parameters[0].GetValue<float>();
+            var second = parameters[1].GetValue<float>();
+
+            return new ValueContainer(first + second);
+        }
+    }
+}
diff --git a/PowerAutomateMockUp/ExpressionParser/Rules/AccessValueRule.cs b/PowerAutomateMockUp/ExpressionParser/Rules/AccessValueRule.cs
@@ -30,7 +30,7 @@ public AccessValueRule(IRule func, IEnumerable<IRule> indexRules)
 
                     foreach (var accessor in indexes.Skip(1))
                     {
-                        tempIndexRules.Add(new IndexRule(new ConstantRule(new ValueContainer(accessor)), false));
+                        tempIndexRules.Add(new IndexRule(new ConstantRule(new ValueContainer(accessor)), nullConditional));
                     }
                 }
                 else

diff --git a/PowerAutomateMockUp/ExpressionParser/ValueContainer.cs b/PowerAutomateMockUp/ExpressionParser/ValueContainer.cs
@@ -59,7 +59,7 @@ public ValueContainer(string stringValue)
 
         public ValueContainer(float floatValue)
         {
-            _value = floatValue;
+            _value = Convert.ToDouble(floatValue);
             _type = ValueType.Float;
         }
 
@@ -114,8 +114,9 @@ public ValueContainer()
 
         public ValueContainer(JToken json)
         {
-            _type = ValueType.Object;
-            _value = JsonToValueContainer(json).GetValue<Dictionary<string, ValueContainer>>();
+            var v = JsonToValueContainer(json);
+            _type = v._type;
+            _value = v._value;
         }
 
         public ValueType Type()
@@ -223,32 +224,51 @@ public Dictionary<string, ValueContainer> AsDict()
 
         private ValueContainer JsonToValueContainer(JToken json)
         {
-            if (json is JObject jObject)
+            switch (json)
             {
-                var dictionary = json.ToDictionary(pair => ((JProperty) pair).Name, token =>
+                case JObject jObject:
                 {
-                    if (token.Children().Count() != 1) return JsonToValueContainer(token.Children().First());
+                    var dictionary = json.ToDictionary(pair => ((JProperty) pair).Name, token =>
+                    {
+                        if (token.Children().Count() != 1) return JsonToValueContainer(token.Children().First());
+
+                        var t = token.First;
+                        return t.Type switch
+                        {
+                            JTokenType.String => new ValueContainer(t.Value<string>(), true),
+                            JTokenType.Boolean => new ValueContainer(t.Value<bool>()),
+                            JTokenType.Integer => new ValueContainer(t.Value<int>()),
+                            JTokenType.Float => new ValueContainer(t.Value<float>()),
+                            _ => JsonToValueContainer(token.Children().First())
+                        };
+                    });
+
+                    return new ValueContainer(dictionary);
+                }
+                case JArray jArray:
+                    return jArray.Count > 0 ? new ValueContainer() : JArrayToValueContainer(jArray);
+                case JValue jValue:
+                    if (jValue.HasValues)
+                    {
+                        throw new PowerAutomateMockUpException(
+                            "When parsing JToken to ValueContainer, the JToken as JValue can only contain one value.");
+                    }
 
-                    var t = token.First;
-                    return t.Type switch
+                    return jValue.Type switch
                     {
-                        JTokenType.String => new ValueContainer(t.Value<string>(), true),
-                        JTokenType.Boolean => new ValueContainer(t.Value<bool>()),
-                        JTokenType.Integer => new ValueContainer(t.Value<int>()),
-                        JTokenType.Float => new ValueContainer(t.Value<float>()),
-                        _ => JsonToValueContainer(token.Children().First())
+                        JTokenType.Boolean => new ValueContainer(jValue.Value<bool>()),
+                        JTokenType.Integer => new ValueContainer(jValue.Value<int>()),
+                        JTokenType.Float => new ValueContainer(jValue.Value<float>()),
+                        JTokenType.Null => new ValueContainer(),
+                        JTokenType.String => new ValueContainer(jValue.Value<string>()),
+                        JTokenType.None => new ValueContainer(),
+                        JTokenType.Guid => new ValueContainer(jValue.Value<Guid>().ToString()),
+                        _ => throw new PowerAutomateMockUpException(
+                            $"{jValue.Type} is not yet supported in ValueContainer conversion")
                     };
-                });
-
-                return new ValueContainer(dictionary);
-            }
-
-            if (json is JArray jArray)
-            {
-                return jArray.Count > 0 ? new ValueContainer() : JArrayToValueContainer(jArray);
+                default:
+                    throw new PowerAutomateMockUpException("Could not parse JToken to ValueContainer.");
             }
-
-            throw new Exception();
         }
 
         private ValueContainer JArrayToValueContainer(JArray json)
@@ -373,6 +393,19 @@ public bool Equals(ValueContainer other)
 
                     return thisDict.Count == otherDict.Count && !thisDict.Except(otherDict).Any();
                 }
+                case ValueType.Integer when other._type == ValueType.Float:
+                    var v = (double) _value;
+                    return Math.Abs(Math.Floor(v) - other._value) < double.Epsilon;
+                case ValueType.Float when other._type == ValueType.Integer:
+                {
+                    return Math.Abs(Math.Floor(_value) - other._value) < double.Epsilon;
+                }
+                case ValueType.Float:
+                {
+                    // TODO: Figure out how to handle comparison and in general how to handle float/double..
+                    // assignee: thygesteffensen
+                    return Math.Abs(_value - other._value) < 0.01;
+                }
                 default:
                     return Equals(_value, other._value) && _type == other._type;
             }

diff --git a/.../Implementations/DoUntilActionExecutor.cs → ...s/ControlActions/DoUntilActionExecutor.cs b/.../Implementations/DoUntilActionExecutor.cs → ...s/ControlActions/DoUntilActionExecutor.cs
@@ -5,7 +5,7 @@
 using Newtonsoft.Json.Linq;
 using Parser.ExpressionParser;
 
-namespace Parser.FlowParser.ActionExecutors.Implementations
+namespace Parser.FlowParser.ActionExecutors.Implementations.ControlActions
 {
     public class DoUntilActionExecutor : DefaultBaseActionExecutor, IScopeActionExecutor
     {

diff --git a/.../Implementations/ForEachActionExecutor.cs → ...s/ControlActions/ForEachActionExecutor.cs b/.../Implementations/ForEachActionExecutor.cs → ...s/ControlActions/ForEachActionExecutor.cs
@@ -6,7 +6,7 @@
 using Newtonsoft.Json.Linq;
 using Parser.ExpressionParser;
 
-namespace Parser.FlowParser.ActionExecutors.Implementations
+namespace Parser.FlowParser.ActionExecutors.Implementations.ControlActions
 {
     public class ForEachActionExecutor : DefaultBaseActionExecutor, IScopeActionExecutor, IItemHandler
     {