Move the FATAL_UNDEFINED check into the AST.

2 files changed, 30 insertions, 45 deletions

diff --git a/scss/expression.py b/scss/expression.py
index 785ba52..8305bdc 100644
--- a/scss/expression.py
+++ b/scss/expression.py
@@ -23,6 +23,7 @@ except ImportError:
 
 log = logging.getLogger(__name__)
 
+FATAL_UNDEFINED = True
 ast_cache = {}
 
 
@@ -108,45 +109,35 @@ class Calculator(object):
 
 
     def evaluate_expression(self, expr):
-        results = None
-
         if not isinstance(expr, six.string_types):
-            results = expr
+            raise TypeError("Expected string, got %r" % (expr,))
 
-        if results is None:
-            try:
-                results = self.namespace.variable(expr, throw=True)
-            except KeyError:
-                pass
+        if expr in ast_cache:
+            ast = ast_cache[expr]
 
-            if not isinstance(expr, six.string_types):
-                results = expr
+        elif _variable_re.match(expr):
+            # Short-circuit for variable names
+            ast = Variable(expr)
 
-        ast = None
-        if results is None:
-            if expr in ast_cache:
-                ast = ast_cache[expr]
-                results = ast.evaluate(self)
+        else:
+            try:
+                P = SassExpression(SassExpressionScanner())
+                P.reset(expr)
+                ast = P.goal()
+            except SyntaxError:
+                if config.DEBUG:
+                    raise
+                return None
+            except Exception:
+                # TODO hoist me up since the rule is gone
+                #log.exception("Exception raised: %s in `%s' (%s)", e, expr, rule.file_and_line)
+                if config.DEBUG:
+                    raise
+                return None
             else:
-                try:
-                    P = SassExpression(SassExpressionScanner())
-                    P.reset(expr)
-                    ast = P.goal()
-                except SyntaxError:
-                    if config.DEBUG:
-                        raise
-                except Exception:
-                    # TODO hoist me up since the rule is gone
-                    #log.exception("Exception raised: %s in `%s' (%s)", e, expr, rule.file_and_line)
-                    if config.DEBUG:
-                        raise
-                else:
-                    ast_cache[expr] = ast
+                ast_cache[expr] = ast
 
-                    results = ast.evaluate(self)
-
-        # print >>sys.stderr, repr(expr),'==',results,'=='
-        return results
+        return ast.evaluate(self)
 
     def parse_expression(self, expr, target='goal'):
         if expr in ast_cache:
@@ -317,10 +308,11 @@ class Variable(Expression):
         try:
             value = calculator.namespace.variable(self.name)
         except KeyError:
-            # TODO well, no.  should probably let this raise.
-            # TODO this should return an opaque anyway
-            raise
-            return self.name
+            if FATAL_UNDEFINED:
+                raise
+            else:
+                log.error("Undefined variable '%s'", self.name)
+                return Undefined()
         else:
             if isinstance(value, six.string_types):
                 evald = calculator.evaluate_expression(value)
diff --git a/scss/rule.py b/scss/rule.py
index cd99d7a..82ebe11 100644
--- a/scss/rule.py
+++ b/scss/rule.py
@@ -5,7 +5,6 @@ import six
 import logging
 
 from scss.cssdefs import _has_placeholder_re
-from scss.types import Undefined
 
 
 log = logging.getLogger(__name__)
@@ -84,13 +83,7 @@ class Namespace(object):
 
     def variable(self, name, throw=False):
         name = normalize_var(name)
-        try:
-            return self._variables[name]
-        except KeyError:
-            if throw:
-                raise
-            log.error("Undefined variable '%s'", name)
-            return Undefined()
+        return self._variables[name]
 
     def set_variable(self, name, value):
         name = normalize_var(name)