Maintaining parentheses around a ternary operation operand in a string concatenation / Extra test coverage over pathentheis maintenance, re: issue #12

Author: SteveWilkes

ReadableExpressions.UnitTests/WhenTranslatingMathsOperations.cs

@@ -238,5 +238,16 @@ public void ShouldTranslateAPostDecrementExpression()
 
             Assert.AreEqual("i--", translated);
         }
+
+        [TestMethod]
+        public void ShouldMaintainRelevantParentheses()
+        {
+            Expression<Func<int, int, int, int>> mather =
+                (i, j, k) => (i + j) * k;
+
+            var translated = mather.Body.ToReadableString();
+
+            Assert.AreEqual("((i + j) * k)", translated);
+        }
     }
 }

ReadableExpressions.UnitTests/WhenTranslatingStringConcatenation.cs

@@ -77,5 +77,28 @@ public void ShouldTranslateAnExplicitMixedTypeThreeArgumentConcatenation()
 
             Assert.AreEqual("str1 + i + l", translated);
         }
+
+        // See https://github.com/agileobjects/ReadableExpressions/issues/12
+        [TestMethod]
+        public void ShouldMaintainTernaryOperandParentheses()
+        {
+            Expression<Func<bool, string, string, string>> ternaryResultAdder =
+                (condition, ifTrue, ifFalse) => (condition ? ifTrue : ifFalse) + "Hello!";
+
+            var translated = ternaryResultAdder.Body.ToReadableString();
+
+            Assert.AreEqual("(condition ? ifTrue : ifFalse) + \"Hello!\"", translated);
+        }
+
+        [TestMethod]
+        public void ShouldMaintainNumericOperandParentheses()
+        {
+            Expression<Func<int, int, int, string>> mathResultAdder =
+                (i, j, k) => ((i - j) / k) + " Maths!";
+
+            var translated = mathResultAdder.Body.ToReadableString();
+
+            Assert.AreEqual("((i - j) / k) + \" Maths!\"", translated);
+        }
     }
 }

ReadableExpressions/StringExtensions.cs

@@ -193,7 +193,16 @@ private static string GetStringValue(Expression value, TranslationContext contex
                 }
             }
 
-            return context.Translate(value);
+            var stringValue = context.Translate(value);
+
+            switch (value.NodeType)
+            {
+                case ExpressionType.Conditional:
+                    stringValue = stringValue.WithSurroundingParentheses();
+                    break;
+            }
+
+            return stringValue;
         }
     }
 }