Safer evaluation for nested expressions

Ref postcss/postcss-calc#2

Author: MoOx

CHANGELOG.md

@@ -1,3 +1,9 @@
+# 1.1.2 - 2014-08-10
+
+* Prevent infinite loop by adding a `Call stack overflow`
+* Correctly ignore unrecognized values (safer evaluation for nested expressions, see [postcss/postcss-calc#2](https://github.com/postcss/postcss-calc/issues/2))
+* Handle rounding issues (eg: 10% * 20% now give 2%, not 2.0000000000000004%)
+
 # 1.1.1 - 2014-08-06
 
 * Fix issue when using mutiples differents prefixes in the same function

index.js

@@ -9,6 +9,7 @@ var reduceFunctionCall = require("reduce-function-call")
  */
 var MAX_STACK = 100 // should be enough for a single calc()...
 var DECIMAL_PRECISION = 10000 // 5 decimals
+var NESTED_CALC_RE = /(\+|\-|\*|\\|[^a-z]|)(\s*)(\()/g
 
 /**
  * Global variables
@@ -37,9 +38,7 @@ function reduceCSSCalc(value) {
  *
  * @param {String} expression
  * @returns {String}
- * @api private
  */
-
 function evaluateExpression (expression, functionIdentifier, call) {
   if (stack++ > MAX_STACK) {
     stack = 0
@@ -50,23 +49,7 @@ function evaluateExpression (expression, functionIdentifier, call) {
     throw new Error(functionIdentifier + "(): '" + call + "' must contain a non-whitespace string")
   }
 
-  var balancedExpr = balanced("(", ")", expression)
-  while (balancedExpr) {
-    if (balancedExpr.body === "") {
-      throw new Error(functionIdentifier + "(): '" + expression + "' must contain a non-whitespace string")
-    }
-
-    var evaluated = evaluateExpression(balancedExpr.body, functionIdentifier, call)
-
-    // if result didn't change since the last try, we consider it won't change anymore
-    if (evaluated === balancedExpr.body) {
-      balancedExpr = false
-    }
-    else {
-      expression = balancedExpr.pre + evaluated + balancedExpr.post
-      balancedExpr = balanced("(", ")", expression)
-    }
-  }
+  expression = evaluateNestedExpression(expression, call)
 
   var units = getUnitsInExpression(expression)
 
@@ -112,12 +95,41 @@ function evaluateExpression (expression, functionIdentifier, call) {
   return result
 }
 
+/**
+ * Evaluates nested expressions
+ *
+ * @param {String} expression
+ * @returns {String}
+ */
+function evaluateNestedExpression(expression, call) {
+  var evaluatedPart = ""
+  var nonEvaluatedPart = expression
+  var matches
+  while ((matches = NESTED_CALC_RE.exec(nonEvaluatedPart))) {
+    if (matches[0].index > 0) {
+      evaluatedPart += nonEvaluatedPart.substring(0, matches[0].index)
+    }
+
+    var balancedExpr = balanced("(", ")", nonEvaluatedPart.substring([0].index))
+    if (balancedExpr.body === "") {
+      throw new Error("'" + expression + "' must contain a non-whitespace string")
+    }
+
+    var evaluated = evaluateExpression(balancedExpr.body, "", call)
+
+    evaluatedPart += balancedExpr.pre + evaluated
+    nonEvaluatedPart = balancedExpr.post
+  }
+
+  return evaluatedPart + nonEvaluatedPart
+}
+
+
 /**
  * Checks what units are used in an expression
  *
  * @param {String} expression
  * @returns {Array}
- * @api private
  */
 
 function getUnitsInExpression(expression) {

test/index.js

@@ -79,5 +79,24 @@ test("handle rounding issues", function(t) {
 
 test("ignore unrecognized values", function(t) {
   t.equal(reduceCSSCalc("calc((4px * 2) + 4.2 + a1 + (2rem * .4))"), "calc(8px + 4.2 + a1 + 0.8rem)", "ignore when eval fail")
+
+  t.equal(reduceCSSCalc("calc(z)"), "calc(z)", "ignore when there is something unknow")
+
+  t.equal(reduceCSSCalc("calc((a) + 1)"), "calc((a) + 1)", "ignore when there is something unknow in ( )")
+
+  t.equal(reduceCSSCalc("calc(1 (a))"), "calc(1 (a))", "ignore when there is something unknow in ( ) after something else")
+
+  t.equal(reduceCSSCalc("calc(b(a) + 1)"), "calc(b(a) + 1)", "ignore when there is unknown function used")
+
+  t.equal(reduceCSSCalc("calc(var(--foo) + 10px)"), "calc(var(--foo) + 10px)", "ignore when there is css var() at the beginning")
+  t.equal(reduceCSSCalc("calc(10px + var(--foo))"), "calc(10px + var(--foo))", "ignore when there is css var() at the end")
+  t.equal(reduceCSSCalc("calc(10px + var(--foo) + 2)"), "calc(10px + var(--foo) + 2)", "ignore when there is css var() in the middle")
+
+  t.equal(reduceCSSCalc("calc((4px + 8px) + --foo + (10% * 20%))"), "calc(12px + --foo + 2%)", "ignore unrecognized part")
+  t.equal(reduceCSSCalc("calc((4px + 8px) + (--foo) + (10% * 20%))"), "calc(12px + (--foo) + 2%)", "ignore unrecognized part between parenthesis")
+  t.equal(reduceCSSCalc("calc((4px + 8px) + var(--foo) + (10% * 20%))"), "calc(12px + var(--foo) + 2%)", "ignore unrecognized function")
+
+  t.equal(reduceCSSCalc("calc(calc(4px + 8px) + calc(var(--foo) + 10px) + calc(10% * 20%))"), "calc(12px + calc(var(--foo) + 10px) + 2%)", "ignore unrecognized nested call")
+
   t.end()
 })