Merge pull request #512 from edx/peterb/formula-preview

Calc module changes: previewing and <formulaequationinput>

To see individual commits, see tag peterb/formula-preview/presquash

common/lib/calc/preview.py

+"""
+Provide a `latex_preview` method similar in syntax to `evaluator`.
+
+That is, given a math string, parse it and render each branch of the result,
+always returning valid latex.
+
+Because intermediate values of the render contain more data than simply the
+string of latex, store it in a custom class `LatexRendered`.
+"""
+
+from calc import ParseAugmenter, DEFAULT_VARIABLES, DEFAULT_FUNCTIONS, SUFFIXES
+
+
+class LatexRendered(object):
+    """
+    Data structure to hold a typeset representation of some math.
+
+    Fields:
+     -`latex` is a generated, valid latex string (as if it were standalone).
+     -`sans_parens` is usually the same as `latex` except without the outermost
+      parens (if applicable).
+     -`tall` is a boolean representing if the latex has any elements extending
+      above or below a normal height, specifically things of the form 'a^b' and
+      '\frac{a}{b}'. This affects the height of wrapping parenthesis.
+    """
+    def __init__(self, latex, parens=None, tall=False):
+        """
+        Instantiate with the latex representing the math.
+
+        Optionally include parenthesis to wrap around it and the height.
+        `parens` must be one of '(', '[' or '{'.
+        `tall` is a boolean (see note above).
+        """
+        self.latex = latex
+        self.sans_parens = latex
+        self.tall = tall
+
+        # Generate parens and overwrite `self.latex`.
+        if parens is not None:
+            left_parens = parens
+            if left_parens == '{':
+                left_parens = r'\{'
+
+            pairs = {'(': ')',
+                     '[': ']',
+                     r'\{': r'\}'}
+            if left_parens not in pairs:
+                raise Exception(
+                    u"Unknown parenthesis '{}': coder error".format(left_parens)
+                )
+            right_parens = pairs[left_parens]
+
+            if self.tall:
+                left_parens = r"\left" + left_parens
+                right_parens = r"\right" + right_parens
+
+            self.latex = u"{left}{expr}{right}".format(
+                left=left_parens,
+                expr=latex,
+                right=right_parens
+            )
+
+    def __repr__(self):  # pragma: no cover
+        """
+        Give a sensible representation of the object.
+
+        If `sans_parens` is different, include both.
+        If `tall` then have '<[]>' around the code, otherwise '<>'.
+        """
+        if self.latex == self.sans_parens:
+            latex_repr = u'"{}"'.format(self.latex)
+        else:
+            latex_repr = u'"{}" or "{}"'.format(self.latex, self.sans_parens)
+
+        if self.tall:
+            wrap = u'<[{}]>'
+        else:
+            wrap = u'<{}>'
+
+        return wrap.format(latex_repr)
+
+
+def render_number(children):
+    """
+    Combine the elements forming the number, escaping the suffix if needed.
+    """
+    children_latex = [k.latex for k in children]
+
+    suffix = ""
+    if children_latex[-1] in SUFFIXES:
+        suffix = children_latex.pop()
+        suffix = ur"\text{{{s}}}".format(s=suffix)
+
+    # Exponential notation-- the "E" splits the mantissa and exponent
+    if "E" in children_latex:
+        pos = children_latex.index("E")
+        mantissa = "".join(children_latex[:pos])
+        exponent = "".join(children_latex[pos + 1:])
+        latex = ur"{m}\!\times\!10^{{{e}}}{s}".format(
+            m=mantissa, e=exponent, s=suffix
+        )
+        return LatexRendered(latex, tall=True)
+    else:
+        easy_number = "".join(children_latex)
+        return LatexRendered(easy_number + suffix)
+
+
+def enrich_varname(varname):
+    """
+    Prepend a backslash if we're given a greek character.
+    """
+    greek = ("alpha beta gamma delta epsilon varepsilon zeta eta theta "
+             "vartheta iota kappa lambda mu nu xi pi rho sigma tau upsilon "
+             "phi varphi chi psi omega").split()
+
+    if varname in greek:
+        return ur"\{letter}".format(letter=varname)
+    else:
+        return varname.replace("_", r"\_")
+
+
+def variable_closure(variables, casify):
+    """
+    Wrap `render_variable` so it knows the variables allowed.
+    """
+    def render_variable(children):
+        """
+        Replace greek letters, otherwise escape the variable names.
+        """
+        varname = children[0].latex
+        if casify(varname) not in variables:
+            pass  # TODO turn unknown variable red or give some kind of error
+
+        first, _, second = varname.partition("_")
+
+        if second:
+            # Then 'a_b' must become 'a_{b}'
+            varname = ur"{a}_{{{b}}}".format(
+                a=enrich_varname(first),
+                b=enrich_varname(second)
+            )
+        else:
+            varname = enrich_varname(varname)
+
+        return LatexRendered(varname)  # .replace("_", r"\_"))
+    return render_variable
+
+
+def function_closure(functions, casify):
+    """
+    Wrap `render_function` so it knows the functions allowed.
+    """
+    def render_function(children):
+        """
+        Escape function names and give proper formatting to exceptions.
+
+        The exceptions being 'sqrt', 'log2', and 'log10' as of now.
+        """
+        fname = children[0].latex
+        if casify(fname) not in functions:
+            pass  # TODO turn unknown function red or give some kind of error
+
+        # Wrap the input of the function with parens or braces.
+        inner = children[1].latex
+        if fname == "sqrt":
+            inner = u"{{{expr}}}".format(expr=inner)
+        else:
+            if children[1].tall:
+                inner = ur"\left({expr}\right)".format(expr=inner)
+            else:
+                inner = u"({expr})".format(expr=inner)
+
+        # Correctly format the name of the function.
+        if fname == "sqrt":
+            fname = ur"\sqrt"
+        elif fname == "log10":
+            fname = ur"\log_{10}"
+        elif fname == "log2":
+            fname = ur"\log_2"
+        else:
+            fname = ur"\text{{{fname}}}".format(fname=fname)
+
+        # Put it together.
+        latex = fname + inner
+        return LatexRendered(latex, tall=children[1].tall)
+    # Return the function within the closure.
+    return render_function
+
+
+def render_power(children):
+    """
+    Combine powers so that the latex is wrapped in curly braces correctly.
+
+    Also, if you have 'a^(b+c)' don't include that last set of parens:
+    'a^{b+c}' is correct, whereas 'a^{(b+c)}' is extraneous.
+    """
+    if len(children) == 1:
+        return children[0]
+
+    children_latex = [k.latex for k in children if k.latex != "^"]
+    children_latex[-1] = children[-1].sans_parens
+
+    raise_power = lambda x, y: u"{}^{{{}}}".format(y, x)
+    latex = reduce(raise_power, reversed(children_latex))
+    return LatexRendered(latex, tall=True)
+
+
+def render_parallel(children):
+    """
+    Simply join the child nodes with a double vertical line.
+    """
+    if len(children) == 1:
+        return children[0]
+
+    children_latex = [k.latex for k in children if k.latex != "||"]
+    latex = r"\|".join(children_latex)
+    tall = any(k.tall for k in children)
+    return LatexRendered(latex, tall=tall)
+
+
+def render_frac(numerator, denominator):
+    r"""
+    Given a list of elements in the numerator and denominator, return a '\frac'
+
+    Avoid parens if they are unnecessary (i.e. the only thing in that part).
+    """
+    if len(numerator) == 1:
+        num_latex = numerator[0].sans_parens
+    else:
+        num_latex = r"\cdot ".join(k.latex for k in numerator)
+
+    if len(denominator) == 1:
+        den_latex = denominator[0].sans_parens
+    else:
+        den_latex = r"\cdot ".join(k.latex for k in denominator)
+
+    latex = ur"\frac{{{num}}}{{{den}}}".format(num=num_latex, den=den_latex)
+    return latex
+
+
+def render_product(children):
+    r"""
+    Format products and division nicely.
+
+    Group bunches of adjacent, equal operators. Every time it switches from
+    denominator to the next numerator, call `render_frac`. Join these groupings
+    together with '\cdot's, ending on a numerator if needed.
+
+    Examples: (`children` is formed indirectly by the string on the left)
+      'a*b' -> 'a\cdot b'
+      'a/b' -> '\frac{a}{b}'
+      'a*b/c/d' -> '\frac{a\cdot b}{c\cdot d}'
+      'a/b*c/d*e' -> '\frac{a}{b}\cdot \frac{c}{d}\cdot e'
+    """
+    if len(children) == 1:
+        return children[0]
+
+    position = "numerator"  # or denominator
+    fraction_mode_ever = False
+    numerator = []
+    denominator = []
+    latex = ""
+
+    for kid in children:
+        if position == "numerator":
+            if kid.latex == "*":
+                pass  # Don't explicitly add the '\cdot' yet.
+            elif kid.latex == "/":
+                # Switch to denominator mode.
+                fraction_mode_ever = True
+                position = "denominator"
+            else:
+                numerator.append(kid)
+        else:
+            if kid.latex == "*":
+                # Switch back to numerator mode.
+                # First, render the current fraction and add it to the latex.
+                latex += render_frac(numerator, denominator) + r"\cdot "
+
+                # Reset back to beginning state
+                position = "numerator"
+                numerator = []
+                denominator = []
+            elif kid.latex == "/":
+                pass  # Don't explicitly add a '\frac' yet.
+            else:
+                denominator.append(kid)
+
+    # Add the fraction/numerator that we ended on.
+    if position == "denominator":
+        latex += render_frac(numerator, denominator)
+    else:
+        # We ended on a numerator--act like normal multiplication.
+        num_latex = r"\cdot ".join(k.latex for k in numerator)
+        latex += num_latex
+
+    tall = fraction_mode_ever or any(k.tall for k in children)
+    return LatexRendered(latex, tall=tall)
+
+
+def render_sum(children):
+    """
+    Concatenate elements, including the operators.
+    """
+    if len(children) == 1:
+        return children[0]
+
+    children_latex = [k.latex for k in children]
+    latex = "".join(children_latex)
+    tall = any(k.tall for k in children)
+    return LatexRendered(latex, tall=tall)
+
+
+def render_atom(children):
+    """
+    Properly handle parens, otherwise this is trivial.
+    """
+    if len(children) == 3:
+        return LatexRendered(
+            children[1].latex,
+            parens=children[0].latex,
+            tall=children[1].tall
+        )
+    else:
+        return children[0]
+
+
+def add_defaults(var, fun, case_sensitive=False):
+    """
+    Create sets with both the default and user-defined variables.
+
+    Compare to calc.add_defaults
+    """
+    var_items = set(DEFAULT_VARIABLES)
+    fun_items = set(DEFAULT_FUNCTIONS)
+
+    var_items.update(var)
+    fun_items.update(fun)
+
+    if not case_sensitive:
+        var_items = set(k.lower() for k in var_items)
+        fun_items = set(k.lower() for k in fun_items)
+
+    return var_items, fun_items
+
+
+def latex_preview(math_expr, variables=(), functions=(), case_sensitive=False):
+    """
+    Convert `math_expr` into latex, guaranteeing its parse-ability.
+
+    Analagous to `evaluator`.
+    """
+    # No need to go further
+    if math_expr.strip() == "":
+        return ""
+
+    # Parse tree
+    latex_interpreter = ParseAugmenter(math_expr, case_sensitive)
+    latex_interpreter.parse_algebra()
+
+    # Get our variables together.
+    variables, functions = add_defaults(variables, functions, case_sensitive)
+
+    # Create a recursion to evaluate the tree.
+    if case_sensitive:
+        casify = lambda x: x
+    else:
+        casify = lambda x: x.lower()  # Lowercase for case insens.
+
+    render_actions = {
+        'number': render_number,
+        'variable': variable_closure(variables, casify),
+        'function': function_closure(functions, casify),
+        'atom': render_atom,
+        'power': render_power,
+        'parallel': render_parallel,
+        'product': render_product,
+        'sum': render_sum
+    }
+
+    backslash = "\\"
+    wrap_escaped_strings = lambda s: LatexRendered(
+        s.replace(backslash, backslash * 2)
+    )
+
+    output = latex_interpreter.reduce_tree(
+        render_actions,
+        terminal_converter=wrap_escaped_strings
+    )
+    return output.latex

common/lib/calc/tests/test_calc.py

@@ -14,7 +14,7 @@ class EvaluatorTest(unittest.TestCase):
     Go through all functionalities as specifically as possible--
     work from number input to functions and complex expressions
     Also test custom variable substitutions (i.e.
-      `evaluator({'x':3.0},{}, '3*x')`
+      `evaluator({'x':3.0}, {}, '3*x')`
     gives 9.0) and more.
     """
 
@@ -41,37 +41,40 @@ class EvaluatorTest(unittest.TestCase):
         """
         The string '.' should not evaluate to anything.
         """
-        self.assertRaises(ParseException, calc.evaluator, {}, {}, '.')
-        self.assertRaises(ParseException, calc.evaluator, {}, {}, '1+.')
+        with self.assertRaises(ParseException):
+            calc.evaluator({}, {}, '.')
+        with self.assertRaises(ParseException):
+            calc.evaluator({}, {}, '1+.')
 
     def test_trailing_period(self):
         """
         Test that things like '4.' will be 4 and not throw an error
         """
-        try:
-            self.assertEqual(4.0, calc.evaluator({}, {}, '4.'))
-        except ParseException:
-            self.fail("'4.' is a valid input, but threw an exception")
+        self.assertEqual(4.0, calc.evaluator({}, {}, '4.'))
 
     def test_exponential_answer(self):
         """
         Test for correct interpretation of scientific notation
         """
         answer = 50
-        correct_responses = ["50", "50.0", "5e1", "5e+1",
-                             "50e0", "50.0e0", "500e-1"]
+        correct_responses = [
+            "50", "50.0", "5e1", "5e+1",
+            "50e0", "50.0e0", "500e-1"
+        ]
         incorrect_responses = ["", "3.9", "4.1", "0", "5.01e1"]
 
         for input_str in correct_responses:
             result = calc.evaluator({}, {}, input_str)
             fail_msg = "Expected '{0}' to equal {1}".format(
-                input_str, answer)
+                input_str, answer
+            )
             self.assertEqual(answer, result, msg=fail_msg)
 
         for input_str in incorrect_responses:
             result = calc.evaluator({}, {}, input_str)
             fail_msg = "Expected '{0}' to not equal {1}".format(
-                input_str, answer)
+                input_str, answer
+            )
             self.assertNotEqual(answer, result, msg=fail_msg)
 
     def test_si_suffix(self):
@@ -80,17 +83,21 @@ class EvaluatorTest(unittest.TestCase):
 
         For instance 'k' stand for 'kilo-' so '1k' should be 1,000
         """
-        test_mapping = [('4.2%', 0.042), ('2.25k', 2250), ('8.3M', 8300000),
-                        ('9.9G', 9.9e9), ('1.2T', 1.2e12), ('7.4c', 0.074),
-                        ('5.4m', 0.0054), ('8.7u', 0.0000087),
-                        ('5.6n', 5.6e-9), ('4.2p', 4.2e-12)]
+        test_mapping = [
+            ('4.2%', 0.042), ('2.25k', 2250), ('8.3M', 8300000),
+            ('9.9G', 9.9e9), ('1.2T', 1.2e12), ('7.4c', 0.074),
+            ('5.4m', 0.0054), ('8.7u', 0.0000087),
+            ('5.6n', 5.6e-9), ('4.2p', 4.2e-12)
+        ]
 
         for (expr, answer) in test_mapping:
             tolerance = answer * 1e-6  # Make rel. tolerance, because of floats
             fail_msg = "Failure in testing suffix '{0}': '{1}' was not {2}"
             fail_msg = fail_msg.format(expr[-1], expr, answer)
-            self.assertAlmostEqual(calc.evaluator({}, {}, expr), answer,
-                                   delta=tolerance, msg=fail_msg)
+            self.assertAlmostEqual(
+                calc.evaluator({}, {}, expr), answer,
+                delta=tolerance, msg=fail_msg
+            )
 
     def test_operator_sanity(self):
         """
@@ -104,19 +111,20 @@ class EvaluatorTest(unittest.TestCase):
             input_str = "{0} {1} {2}".format(var1, operator, var2)
             result = calc.evaluator({}, {}, input_str)
             fail_msg = "Failed on operator '{0}': '{1}' was not {2}".format(
-                operator, input_str, answer)
+                operator, input_str, answer
+            )
             self.assertEqual(answer, result, msg=fail_msg)
 
     def test_raises_zero_division_err(self):
         """
         Ensure division by zero gives an error
         """
-        self.assertRaises(ZeroDivisionError, calc.evaluator,
-                          {}, {}, '1/0')
-        self.assertRaises(ZeroDivisionError, calc.evaluator,
-                          {}, {}, '1/0.0')
-        self.assertRaises(ZeroDivisionError, calc.evaluator,
-                          {'x': 0.0}, {}, '1/x')
+        with self.assertRaises(ZeroDivisionError):
+            calc.evaluator({}, {}, '1/0')
+        with self.assertRaises(ZeroDivisionError):
+            calc.evaluator({}, {}, '1/0.0')
+        with self.assertRaises(ZeroDivisionError):
+            calc.evaluator({'x': 0.0}, {}, '1/x')
 
     def test_parallel_resistors(self):
         """
@@ -153,7 +161,8 @@ class EvaluatorTest(unittest.TestCase):
             input_str = "{0}({1})".format(fname, arg)
             result = calc.evaluator({}, {}, input_str)
             fail_msg = "Failed on function {0}: '{1}' was not {2}".format(
-                fname, input_str, val)
+                fname, input_str, val
+            )
             self.assertAlmostEqual(val, result, delta=tolerance, msg=fail_msg)
 
     def test_trig_functions(self):
@@ -303,21 +312,29 @@ class EvaluatorTest(unittest.TestCase):
         """
 
         # Test sqrt
-        self.assert_function_values('sqrt',
-                                    [0, 1, 2, 1024],  # -1
-                                    [0, 1, 1.414, 32])  # 1j
+        self.assert_function_values(
+            'sqrt',
+            [0, 1, 2, 1024],  # -1
+            [0, 1, 1.414, 32]  # 1j
+        )
         # sqrt(-1) is NAN not j (!!).
 
         # Test logs
-        self.assert_function_values('log10',
-                                    [0.1, 1, 3.162, 1000000, '1+j'],
-                                    [-1, 0, 0.5, 6, 0.151 + 0.341j])
-        self.assert_function_values('log2',
-                                    [0.5, 1, 1.414, 1024, '1+j'],
-                                    [-1, 0, 0.5, 10, 0.5 + 1.133j])
-        self.assert_function_values('ln',
-                                    [0.368, 1, 1.649, 2.718, 42, '1+j'],
-                                    [-1, 0, 0.5, 1, 3.738, 0.347 + 0.785j])
+        self.assert_function_values(
+            'log10',
+            [0.1, 1, 3.162, 1000000, '1+j'],
+            [-1, 0, 0.5, 6, 0.151 + 0.341j]
+        )
+        self.assert_function_values(
+            'log2',
+            [0.5, 1, 1.414, 1024, '1+j'],
+            [-1, 0, 0.5, 10, 0.5 + 1.133j]
+        )
+        self.assert_function_values(
+            'ln',
+            [0.368, 1, 1.649, 2.718, 42, '1+j'],
+            [-1, 0, 0.5, 1, 3.738, 0.347 + 0.785j]
+        )
 
         # Test abs
         self.assert_function_values('abs', [-1, 0, 1, 'j'], [1, 0, 1, 1])
@@ -341,26 +358,28 @@ class EvaluatorTest(unittest.TestCase):
         """
 
         # Of the form ('expr', python value, tolerance (or None for exact))
-        default_variables = [('j', 1j, None),
-                             ('e', 2.7183, 1e-3),
-                             ('pi', 3.1416, 1e-3),
-                             # c = speed of light
-                             ('c', 2.998e8, 1e5),
-                             # 0 deg C = T Kelvin
-                             ('T', 298.15, 0.01),
-                             # Note k = scipy.constants.k = 1.3806488e-23
-                             ('k', 1.3806488e-23, 1e-26),
-                             # Note q = scipy.constants.e = 1.602176565e-19
-                             ('q', 1.602176565e-19, 1e-22)]
+        default_variables = [
+            ('i', 1j, None),
+            ('j', 1j, None),
+            ('e', 2.7183, 1e-4),
+            ('pi', 3.1416, 1e-4),
+            ('k', 1.3806488e-23, 1e-26),  # Boltzmann constant (Joules/Kelvin)
+            ('c', 2.998e8, 1e5),  # Light Speed in (m/s)
+            ('T', 298.15, 0.01),  # 0 deg C = T Kelvin
+            ('q', 1.602176565e-19, 1e-22)  # Fund. Charge (Coulombs)
+        ]
         for (variable, value, tolerance) in default_variables:
             fail_msg = "Failed on constant '{0}', not within bounds".format(
-                variable)
+                variable
+            )
             result = calc.evaluator({}, {}, variable)
             if tolerance is None:
                 self.assertEqual(value, result, msg=fail_msg)
             else:
-                self.assertAlmostEqual(value, result,
-                                       delta=tolerance, msg=fail_msg)
+                self.assertAlmostEqual(
+                    value, result,
+                    delta=tolerance, msg=fail_msg
+                )
 
     def test_complex_expression(self):
         """
@@ -370,21 +389,51 @@ class EvaluatorTest(unittest.TestCase):
         self.assertAlmostEqual(
             calc.evaluator({}, {}, "(2^2+1.0)/sqrt(5e0)*5-1"),
             10.180,
-            delta=1e-3)
-
+            delta=1e-3
+        )
         self.assertAlmostEqual(
             calc.evaluator({}, {}, "1+1/(1+1/(1+1/(1+1)))"),
             1.6,
-            delta=1e-3)
+            delta=1e-3
+        )
         self.assertAlmostEqual(
             calc.evaluator({}, {}, "10||sin(7+5)"),
-            -0.567, delta=0.01)
-        self.assertAlmostEqual(calc.evaluator({}, {}, "sin(e)"),
-                               0.41, delta=0.01)
-        self.assertAlmostEqual(calc.evaluator({}, {}, "k*T/q"),
-                               0.025, delta=1e-3)
-        self.assertAlmostEqual(calc.evaluator({}, {}, "e^(j*pi)"),
-                               -1, delta=1e-5)
+            -0.567, delta=0.01
+        )
+        self.assertAlmostEqual(
+            calc.evaluator({}, {}, "sin(e)"),
+            0.41, delta=0.01
+        )
+        self.assertAlmostEqual(
+            calc.evaluator({}, {}, "k*T/q"),
+            0.025, delta=1e-3
+        )
+        self.assertAlmostEqual(
+            calc.evaluator({}, {}, "e^(j*pi)"),
+            -1, delta=1e-5
+        )
+
+    def test_explicit_sci_notation(self):
+        """
+        Expressions like 1.6*10^-3 (not 1.6e-3) it should evaluate.
+        """
+        self.assertEqual(
+            calc.evaluator({}, {}, "-1.6*10^-3"),
+            -0.0016
+        )
+        self.assertEqual(
+            calc.evaluator({}, {}, "-1.6*10^(-3)"),
+            -0.0016
+        )
+
+        self.assertEqual(
+            calc.evaluator({}, {}, "-1.6*10^3"),
+            -1600
+        )
+        self.assertEqual(
+            calc.evaluator({}, {}, "-1.6*10^(3)"),
+            -1600
+        )
 
     def test_simple_vars(self):
         """
@@ -404,19 +453,24 @@ class EvaluatorTest(unittest.TestCase):
         self.assertEqual(calc.evaluator(variables, {}, 'loooooong'), 6.4)
 
         # Test a simple equation
-        self.assertAlmostEqual(calc.evaluator(variables, {}, '3*x-y'),
-                               21.25, delta=0.01)  # = 3 * 9.72 - 7.91
-        self.assertAlmostEqual(calc.evaluator(variables, {}, 'x*y'),
-                               76.89, delta=0.01)
+        self.assertAlmostEqual(
+            calc.evaluator(variables, {}, '3*x-y'),
+            21.25, delta=0.01  # = 3 * 9.72 - 7.91
+        )
+        self.assertAlmostEqual(
+            calc.evaluator(variables, {}, 'x*y'),
+            76.89, delta=0.01
+        )
 
         self.assertEqual(calc.evaluator({'x': 9.72, 'y': 7.91}, {}, "13"), 13)
         self.assertEqual(calc.evaluator(variables, {}, "13"), 13)
         self.assertEqual(
-            calc.evaluator({
-                'a': 2.2997471478310274, 'k': 9, 'm': 8,
-                'x': 0.66009498411213041},
-                {}, "5"),
-            5)
+            calc.evaluator(
+                {'a': 2.2997471478310274, 'k': 9, 'm': 8, 'x': 0.6600949841121},
+                {}, "5"
+            ),
+            5
+        )
 
     def test_variable_case_sensitivity(self):
         """
@@ -424,15 +478,21 @@ class EvaluatorTest(unittest.TestCase):
         """
         self.assertEqual(
             calc.evaluator({'R1': 2.0, 'R3': 4.0}, {}, "r1*r3"),
-            8.0)
+            8.0
+        )
 
         variables = {'t': 1.0}
         self.assertEqual(calc.evaluator(variables, {}, "t"), 1.0)
         self.assertEqual(calc.evaluator(variables, {}, "T"), 1.0)
-        self.assertEqual(calc.evaluator(variables, {}, "t", cs=True), 1.0)
+        self.assertEqual(
+            calc.evaluator(variables, {}, "t", case_sensitive=True),
+            1.0
+        )
         # Recall 'T' is a default constant, with value 298.15
-        self.assertAlmostEqual(calc.evaluator(variables, {}, "T", cs=True),
-                               298, delta=0.2)
+        self.assertAlmostEqual(
+            calc.evaluator(variables, {}, "T", case_sensitive=True),
+            298, delta=0.2
+        )
 
     def test_simple_funcs(self):
         """
@@ -445,22 +505,41 @@ class EvaluatorTest(unittest.TestCase):
         self.assertEqual(calc.evaluator(variables, functions, 'id(x)'), 4.712)
 
         functions.update({'f': numpy.sin})
-        self.assertAlmostEqual(calc.evaluator(variables, functions, 'f(x)'),
-                               -1, delta=1e-3)
+        self.assertAlmostEqual(
+            calc.evaluator(variables, functions, 'f(x)'),
+            -1, delta=1e-3
+        )
 
-    def test_function_case_sensitivity(self):
+    def test_function_case_insensitive(self):
         """
-        Test the case sensitivity of functions
+        Test case insensitive evaluation
+
+        Normal functions with some capitals should be fine
         """
-        functions = {'f': lambda x: x,
-                     'F': lambda x: x + 1}
-        # Test case insensitive evaluation
-        # Both evaulations should call the same function
-        self.assertEqual(calc.evaluator({}, functions, 'f(6)'),
-                         calc.evaluator({}, functions, 'F(6)'))
-        # Test case sensitive evaluation
-        self.assertNotEqual(calc.evaluator({}, functions, 'f(6)', cs=True),
-                            calc.evaluator({}, functions, 'F(6)', cs=True))
+        self.assertAlmostEqual(
+            -0.28,
+            calc.evaluator({}, {}, 'SiN(6)', case_sensitive=False),
+            delta=1e-3
+        )
+
+    def test_function_case_sensitive(self):
+        """
+        Test case sensitive evaluation
+
+        Incorrectly capitilized should fail
+        Also, it should pick the correct version of a function.
+        """
+        with self.assertRaisesRegexp(calc.UndefinedVariable, 'SiN'):
+            calc.evaluator({}, {}, 'SiN(6)', case_sensitive=True)
+
+        # With case sensitive turned on, it should pick the right function
+        functions = {'f': lambda x: x, 'F': lambda x: x + 1}
+        self.assertEqual(
+            calc.evaluator({}, functions, 'f(6)', case_sensitive=True), 6
+        )
+        self.assertEqual(
+            calc.evaluator({}, functions, 'F(6)', case_sensitive=True), 7
+        )
 
     def test_undefined_vars(self):
         """
@@ -468,9 +547,9 @@ class EvaluatorTest(unittest.TestCase):
         """
         variables = {'R1': 2.0, 'R3': 4.0}
 
-        self.assertRaises(calc.UndefinedVariable, calc.evaluator,
-                          {}, {}, "5+7 QWSEKO")
-        self.assertRaises(calc.UndefinedVariable, calc.evaluator,
-                          {'r1': 5}, {}, "r1+r2")
-        self.assertRaises(calc.UndefinedVariable, calc.evaluator,
-                          variables, {}, "r1*r3", cs=True)
+        with self.assertRaisesRegexp(calc.UndefinedVariable, 'QWSEKO'):
+            calc.evaluator({}, {}, "5+7*QWSEKO")
+        with self.assertRaisesRegexp(calc.UndefinedVariable, 'r2'):
+            calc.evaluator({'r1': 5}, {}, "r1+r2")
+        with self.assertRaisesRegexp(calc.UndefinedVariable, 'r1 r3'):
+            calc.evaluator(variables, {}, "r1*r3", case_sensitive=True)

common/lib/calc/tests/test_preview.py

+# -*- coding: utf-8 -*-
+"""
+Unit tests for preview.py
+"""
+
+import unittest
+import preview
+import pyparsing
+
+
+class LatexRenderedTest(unittest.TestCase):
+    """
+    Test the initializing code for LatexRendered.
+
+    Specifically that it stores the correct data and handles parens well.
+    """
+    def test_simple(self):
+        """
+        Test that the data values are stored without changing.
+        """
+        math = 'x^2'
+        obj = preview.LatexRendered(math, tall=True)
+        self.assertEquals(obj.latex, math)
+        self.assertEquals(obj.sans_parens, math)
+        self.assertEquals(obj.tall, True)
+
+    def _each_parens(self, with_parens, math, parens, tall=False):
+        """
+        Helper method to test the way parens are wrapped.
+        """
+        obj = preview.LatexRendered(math, parens=parens, tall=tall)
+        self.assertEquals(obj.latex, with_parens)
+        self.assertEquals(obj.sans_parens, math)
+        self.assertEquals(obj.tall, tall)
+
+    def test_parens(self):
+        """ Test curvy parens. """
+        self._each_parens('(x+y)', 'x+y', '(')
+
+    def test_brackets(self):
+        """ Test brackets. """
+        self._each_parens('[x+y]', 'x+y', '[')
+
+    def test_squiggles(self):
+        """ Test curly braces. """
+        self._each_parens(r'\{x+y\}', 'x+y', '{')
+
+    def test_parens_tall(self):
+        """ Test curvy parens with the tall parameter. """
+        self._each_parens(r'\left(x^y\right)', 'x^y', '(', tall=True)
+
+    def test_brackets_tall(self):
+        """ Test brackets, also tall. """
+        self._each_parens(r'\left[x^y\right]', 'x^y', '[', tall=True)
+
+    def test_squiggles_tall(self):
+        """ Test tall curly braces. """
+        self._each_parens(r'\left\{x^y\right\}', 'x^y', '{', tall=True)
+
+    def test_bad_parens(self):
+        """ Check that we get an error with invalid parens. """
+        with self.assertRaisesRegexp(Exception, 'Unknown parenthesis'):
+            preview.LatexRendered('x^2', parens='not parens')
+
+
+class LatexPreviewTest(unittest.TestCase):
+    """
+    Run integrative tests for `latex_preview`.
+
+    All functionality was tested `RenderMethodsTest`, but see if it combines
+    all together correctly.
+    """
+    def test_no_input(self):
+        """
+        With no input (including just whitespace), see that no error is thrown.
+        """
+        self.assertEquals('', preview.latex_preview(''))
+        self.assertEquals('', preview.latex_preview('  '))
+        self.assertEquals('', preview.latex_preview(' \t '))
+
+    def test_number_simple(self):
+        """ Simple numbers should pass through. """
+        self.assertEquals(preview.latex_preview('3.1415'), '3.1415')
+
+    def test_number_suffix(self):
+        """ Suffixes should be escaped. """
+        self.assertEquals(preview.latex_preview('1.618k'), r'1.618\text{k}')
+
+    def test_number_sci_notation(self):
+        """ Numbers with scientific notation should display nicely """
+        self.assertEquals(
+            preview.latex_preview('6.0221413E+23'),
+            r'6.0221413\!\times\!10^{+23}'
+        )
+        self.assertEquals(
+            preview.latex_preview('-6.0221413E+23'),
+            r'-6.0221413\!\times\!10^{+23}'
+        )
+
+    def test_number_sci_notation_suffix(self):
+        """ Test numbers with both of these. """
+        self.assertEquals(
+            preview.latex_preview('6.0221413E+23k'),
+            r'6.0221413\!\times\!10^{+23}\text{k}'
+        )
+        self.assertEquals(
+            preview.latex_preview('-6.0221413E+23k'),
+            r'-6.0221413\!\times\!10^{+23}\text{k}'
+        )
+
+    def test_variable_simple(self):
+        """ Simple valid variables should pass through. """
+        self.assertEquals(preview.latex_preview('x', variables=['x']), 'x')
+
+    def test_greek(self):
+        """ Variable names that are greek should be formatted accordingly. """
+        self.assertEquals(preview.latex_preview('pi'), r'\pi')
+
+    def test_variable_subscript(self):
+        """ Things like 'epsilon_max' should display nicely """
+        self.assertEquals(
+            preview.latex_preview('epsilon_max', variables=['epsilon_max']),
+            r'\epsilon_{max}'
+        )
+
+    def test_function_simple(self):
+        """ Valid function names should be escaped. """
+        self.assertEquals(
+            preview.latex_preview('f(3)', functions=['f']),
+            r'\text{f}(3)'
+        )
+
+    def test_function_tall(self):
+        r""" Functions surrounding a tall element should have \left, \right """
+        self.assertEquals(
+            preview.latex_preview('f(3^2)', functions=['f']),
+            r'\text{f}\left(3^{2}\right)'
+        )
+
+    def test_function_sqrt(self):
+        """ Sqrt function should be handled specially. """
+        self.assertEquals(preview.latex_preview('sqrt(3)'), r'\sqrt{3}')
+
+    def test_function_log10(self):
+        """ log10 function should be handled specially. """
+        self.assertEquals(preview.latex_preview('log10(3)'), r'\log_{10}(3)')
+
+    def test_function_log2(self):
+        """ log2 function should be handled specially. """
+        self.assertEquals(preview.latex_preview('log2(3)'), r'\log_2(3)')
+
+    def test_power_simple(self):
+        """ Powers should wrap the elements with braces correctly. """
+        self.assertEquals(preview.latex_preview('2^3^4'), '2^{3^{4}}')
+
+    def test_power_parens(self):
+        """ Powers should ignore the parenthesis of the last math. """
+        self.assertEquals(preview.latex_preview('2^3^(4+5)'), '2^{3^{4+5}}')
+
+    def test_parallel(self):
+        r""" Parallel items should combine with '\|'. """
+        self.assertEquals(preview.latex_preview('2||3'), r'2\|3')
+
+    def test_product_mult_only(self):
+        r""" Simple products should combine with a '\cdot'. """
+        self.assertEquals(preview.latex_preview('2*3'), r'2\cdot 3')
+
+    def test_product_big_frac(self):
+        """ Division should combine with '\frac'. """
+        self.assertEquals(
+            preview.latex_preview('2*3/4/5'),
+            r'\frac{2\cdot 3}{4\cdot 5}'
+        )
+
+    def test_product_single_frac(self):
+        """ Division should ignore parens if they are extraneous. """
+        self.assertEquals(
+            preview.latex_preview('(2+3)/(4+5)'),
+            r'\frac{2+3}{4+5}'
+        )
+
+    def test_product_keep_going(self):
+        """
+        Complex products/quotients should split into many '\frac's when needed.
+        """
+        self.assertEquals(
+            preview.latex_preview('2/3*4/5*6'),
+            r'\frac{2}{3}\cdot \frac{4}{5}\cdot 6'
+        )
+
+    def test_sum(self):
+        """ Sums should combine its elements. """
+        # Use 'x' as the first term (instead of, say, '1'), so it can't be
+        # interpreted as a negative number.
+        self.assertEquals(
+            preview.latex_preview('-x+2-3+4', variables=['x']),
+            '-x+2-3+4'
+        )
+
+    def test_sum_tall(self):
+        """ A complicated expression should not hide the tallness. """
+        self.assertEquals(
+            preview.latex_preview('(2+3^2)'),
+            r'\left(2+3^{2}\right)'
+        )
+
+    def test_complicated(self):
+        """
+        Given complicated input, ensure that exactly the correct string is made.
+        """
+        self.assertEquals(
+            preview.latex_preview('11*f(x)+x^2*(3||4)/sqrt(pi)'),
+            r'11\cdot \text{f}(x)+\frac{x^{2}\cdot (3\|4)}{\sqrt{\pi}}'
+        )
+
+        self.assertEquals(
+            preview.latex_preview('log10(1+3/4/Cos(x^2)*(x+1))',
+                                  case_sensitive=True),
+            (r'\log_{10}\left(1+\frac{3}{4\cdot \text{Cos}\left(x^{2}\right)}'
+             r'\cdot (x+1)\right)')
+        )
+
+    def test_syntax_errors(self):
+        """
+        Test a lot of math strings that give syntax errors
+
+        Rather than have a lot of self.assertRaises, make a loop and keep track
+        of those that do not throw a `ParseException`, and assert at the end.
+        """
+        bad_math_list = [
+            '11+',
+            '11*',
+            'f((x)',
+            'sqrt(x^)',
+            '3f(x)',  # Not 3*f(x)
+            '3|4',
+            '3|||4'
+        ]
+        bad_exceptions = {}
+        for math in bad_math_list:
+            try:
+                preview.latex_preview(math)
+            except pyparsing.ParseException:
+                pass  # This is what we were expecting. (not excepting :P)
+            except Exception as error:  # pragma: no cover
+                bad_exceptions[math] = error
+            else:  # pragma: no cover
+                # If there is no exception thrown, this is a problem
+                bad_exceptions[math] = None
+
+        self.assertEquals({}, bad_exceptions)

common/lib/capa/capa/inputtypes.py

@@ -16,6 +16,8 @@ Module containing the problem elements which render into input objects
 - crystallography
 - vsepr_input
 - drag_and_drop
+- formulaequationinput
+- chemicalequationinput
 
 These are matched by *.html files templates/*.html which are mako templates with the
 actual html.
@@ -47,6 +49,7 @@ import pyparsing
 
 from .registry import TagRegistry
 from chem import chemcalc
+from preview import latex_preview
 import xqueue_interface
 from datetime import datetime
 
@@ -531,7 +534,7 @@ class TextLine(InputTypeBase):
     is used e.g. for embedding simulations turned into questions.
 
     Example:
-        <texline math="1" trailing_text="m/s" />
+        <textline math="1" trailing_text="m/s" />
 
     This example will render out a text line with a math preview and the text 'm/s'
     after the end of the text line.
@@ -1037,15 +1040,16 @@ class ChemicalEquationInput(InputTypeBase):
 
         result = {'preview': '',
                   'error': ''}
-        formula = data['formula']
-        if formula is None:
+        try:
+            formula = data['formula']
+        except KeyError:
             result['error'] = "No formula specified."
             return result
 
         try:
             result['preview'] = chemcalc.render_to_html(formula)
         except pyparsing.ParseException as p:
-            result['error'] = "Couldn't parse formula: {0}".format(p)
+            result['error'] = u"Couldn't parse formula: {0}".format(p.msg)
         except Exception:
             # this is unexpected, so log
             log.warning(
@@ -1056,6 +1060,98 @@ class ChemicalEquationInput(InputTypeBase):
 
 registry.register(ChemicalEquationInput)
 
+#-------------------------------------------------------------------------
+
+
+class FormulaEquationInput(InputTypeBase):
+    """
+    An input type for entering formula equations.  Supports live preview.
+
+    Example:
+
+    <formulaequationinput size="50"/>
+
+    options: size -- width of the textbox.
+    """
+
+    template = "formulaequationinput.html"
+    tags = ['formulaequationinput']
+
+    @classmethod
+    def get_attributes(cls):
+        """
+        Can set size of text field.
+        """
+        return [Attribute('size', '20'), ]
+
+    def _extra_context(self):
+        """
+        TODO (vshnayder): Get rid of 'previewer' once we have a standard way of requiring js to be loaded.
+        """
+        # `reported_status` is basically `status`, except we say 'unanswered'
+        reported_status = ''
+        if self.status == 'unsubmitted':
+            reported_status = 'unanswered'
+        elif self.status in ('correct', 'incorrect', 'incomplete'):
+            reported_status = self.status
+
+        return {
+            'previewer': '/static/js/capa/src/formula_equation_preview.js',
+            'reported_status': reported_status
+        }
+
+    def handle_ajax(self, dispatch, get):
+        '''
+        Since we only have formcalc preview this input, check to see if it
+        matches the corresponding dispatch and send it through if it does
+        '''
+        if dispatch == 'preview_formcalc':
+            return self.preview_formcalc(get)
+        return {}
+
+    def preview_formcalc(self, get):
+        """
+        Render an preview of a formula or equation. `get` should
+        contain a key 'formula' with a math expression.
+
+        Returns a json dictionary:
+        {
+           'preview' : '<some latex>' or ''
+           'error' : 'the-error' or ''
+           'request_start' : <time sent with request>
+        }
+        """
+
+        result = {'preview': '',
+                  'error': ''}
+
+        try:
+            formula = get['formula']
+        except KeyError:
+            result['error'] = "No formula specified."
+            return result
+
+        result['request_start'] = int(get.get('request_start', 0))
+
+        try:
+            # TODO add references to valid variables and functions
+            # At some point, we might want to mark invalid variables as red
+            # or something, and this is where we would need to pass those in.
+            result['preview'] = latex_preview(formula)
+        except pyparsing.ParseException as err:
+            result['error'] = "Sorry, couldn't parse formula"
+            result['formula'] = formula
+        except Exception:
+            # this is unexpected, so log
+            log.warning(
+                "Error while previewing formula", exc_info=True
+            )
+            result['error'] = "Error while rendering preview"
+
+        return result
+
+registry.register(FormulaEquationInput)
+
 #-----------------------------------------------------------------------------
 
 

common/lib/capa/capa/responsetypes.py

@@ -822,7 +822,7 @@ class NumericalResponse(LoncapaResponse):
 
     response_tag = 'numericalresponse'
     hint_tag = 'numericalhint'
-    allowed_inputfields = ['textline']
+    allowed_inputfields = ['textline', 'formulaequationinput']
     required_attributes = ['answer']
     max_inputfields = 1
 
@@ -837,11 +837,6 @@ class NumericalResponse(LoncapaResponse):
             self.tolerance = contextualize_text(self.tolerance_xml, context)
         except IndexError:  # xpath found an empty list, so (...)[0] is the error
             self.tolerance = '0'
-        try:
-            self.answer_id = xml.xpath('//*[@id=$id]//textline/@id',
-                                       id=xml.get('id'))[0]
-        except IndexError:  # Same as above
-            self.answer_id = None
 
     def get_score(self, student_answers):
         '''Grade a numeric response '''
@@ -936,7 +931,7 @@ class CustomResponse(LoncapaResponse):
                            'chemicalequationinput', 'vsepr_input',
                            'drag_and_drop_input', 'editamoleculeinput',
                            'designprotein2dinput', 'editageneinput',
-                           'annotationinput', 'jsinput']
+                           'annotationinput', 'jsinput', 'formulaequationinput']
 
     def setup_response(self):
         xml = self.xml
@@ -1692,7 +1687,7 @@ class FormulaResponse(LoncapaResponse):
 
     response_tag = 'formularesponse'
     hint_tag = 'formulahint'
-    allowed_inputfields = ['textline']
+    allowed_inputfields = ['textline', 'formulaequationinput']
     required_attributes = ['answer', 'samples']
     max_inputfields = 1
 
@@ -1737,7 +1732,7 @@ class FormulaResponse(LoncapaResponse):
                            samples.split('@')[1].split('#')[0].split(':')))
 
         ranges = dict(zip(variables, sranges))
-        for i in range(numsamples):
+        for _ in range(numsamples):
             instructor_variables = self.strip_dict(dict(self.context))
             student_variables = dict()
             # ranges give numerical ranges for testing
@@ -1748,38 +1743,58 @@ class FormulaResponse(LoncapaResponse):
                 student_variables[str(var)] = value
             # log.debug('formula: instructor_vars=%s, expected=%s' %
             # (instructor_variables,expected))
-            instructor_result = evaluator(instructor_variables, dict(),
-                                          expected, cs=self.case_sensitive)
+
+            # Call `evaluator` on the instructor's answer and get a number
+            instructor_result = evaluator(
+                instructor_variables, dict(),
+                expected, case_sensitive=self.case_sensitive
+            )
             try:
                 # log.debug('formula: student_vars=%s, given=%s' %
                 # (student_variables,given))
-                student_result = evaluator(student_variables,
-                                           dict(),
-                                           given,
-                                           cs=self.case_sensitive)
+
+                # Call `evaluator` on the student's answer; look for exceptions
+                student_result = evaluator(
+                    student_variables,
+                    dict(),
+                    given,
+                    case_sensitive=self.case_sensitive
+                )
             except UndefinedVariable as uv:
                 log.debug(
-                    'formularesponse: undefined variable in given=%s' % given)
+                    'formularesponse: undefined variable in given=%s',
+                    given
+                )
                 raise StudentInputError(
-                    "Invalid input: " + uv.message + " not permitted in answer")
+                    "Invalid input: " + uv.message + " not permitted in answer"
+                )
             except ValueError as ve:
                 if 'factorial' in ve.message:
                     # This is thrown when fact() or factorial() is used in a formularesponse answer
                     #   that tests on negative and/or non-integer inputs
-                    # ve.message will be: `factorial() only accepts integral values` or `factorial() not defined for negative values`
+                    # ve.message will be: `factorial() only accepts integral values` or
+                    # `factorial() not defined for negative values`
                     log.debug(
-                        'formularesponse: factorial function used in response that tests negative and/or non-integer inputs. given={0}'.format(given))
+                        ('formularesponse: factorial function used in response '
+                         'that tests negative and/or non-integer inputs. '
+                         'given={0}').format(given)
+                    )
                     raise StudentInputError(
-                        "factorial function not permitted in answer for this problem. Provided answer was: {0}".format(given))
+                        ("factorial function not permitted in answer "
+                         "for this problem. Provided answer was: "
+                         "{0}").format(cgi.escape(given))
+                    )
                 # If non-factorial related ValueError thrown, handle it the same as any other Exception
                 log.debug('formularesponse: error {0} in formula'.format(ve))
                 raise StudentInputError("Invalid input: Could not parse '%s' as a formula" %
                                         cgi.escape(given))
             except Exception as err:
                 # traceback.print_exc()
-                log.debug('formularesponse: error %s in formula' % err)
+                log.debug('formularesponse: error %s in formula', err)
                 raise StudentInputError("Invalid input: Could not parse '%s' as a formula" %
                                         cgi.escape(given))
+
+            # No errors in student's response--actually test for correctness
             if not compare_with_tolerance(student_result, instructor_result, self.tolerance):
                 return "incorrect"
         return "correct"

common/lib/capa/capa/templates/formulaequationinput.html

+<section id="formulaequationinput_${id}" class="formulaequationinput">
+  <div class="${reported_status}" id="status_${id}">
+    <input type="text" name="input_${id}" id="input_${id}"
+	   data-input-id="${id}" value="${value|h}"
+	   % if size:
+	   size="${size}"
+	   % endif
+	   />
+
+      <p class="status">${reported_status}</p>
+
+      <div id="input_${id}_preview" class="equation">
+        \[\]
+        <img src="/static/images/spinner.gif" class="loading"/>
+      </div>
+    <p id="answer_${id}" class="answer"></p>
+  </div>
+
+  <div class="script_placeholder" data-src="${previewer}"/>
+</section>

common/lib/capa/capa/tests/test_input_templates.py

@@ -448,6 +448,32 @@ class TextlineTemplateTest(TemplateTestCase):
         self.assert_has_text(xml, xpath, self.context['msg'])
 
 
+class FormulaEquationInputTemplateTest(TemplateTestCase):
+    """
+    Test make template for `<formulaequationinput>`s.
+    """
+    TEMPLATE_NAME = 'formulaequationinput.html'
+
+    def setUp(self):
+        self.context = {
+            'id': 2,
+            'value': 'PREFILLED_VALUE',
+            'status': 'unsubmitted',
+            'previewer': 'file.js',
+            'reported_status': 'REPORTED_STATUS',
+        }
+        super(FormulaEquationInputTemplateTest, self).setUp()
+
+    def test_no_size(self):
+        xml = self.render_to_xml(self.context)
+        self.assert_no_xpath(xml, "//input[@size]", self.context)
+
+    def test_size(self):
+        self.context['size'] = '40'
+        xml = self.render_to_xml(self.context)
+
+        self.assert_has_xpath(xml, "//input[@size='40']", self.context)
+
 class AnnotationInputTemplateTest(TemplateTestCase):
     """
     Test mako template for `<annotationinput>` input.

common/lib/capa/capa/tests/test_inputtypes.py

+# -*- coding: utf-8 -*-
 """
 Tests of input types.
 
@@ -23,7 +24,8 @@ import xml.sax.saxutils as saxutils
 
 from . import test_system
 from capa import inputtypes
-from mock import ANY
+from mock import ANY, patch
+from pyparsing import ParseException
 
 # just a handy shortcut
 lookup_tag = inputtypes.registry.get_class_for_tag
@@ -47,7 +49,7 @@ class OptionInputTest(unittest.TestCase):
                  'status': 'answered'}
         option_input = lookup_tag('optioninput')(test_system(), element, state)
 
-        context = option_input._get_render_context()
+        context = option_input._get_render_context()  # pylint: disable=W0212
 
         expected = {'value': 'Down',
                     'options': [('Up', 'Up'), ('Down', 'Down')],
@@ -94,7 +96,7 @@ class ChoiceGroupTest(unittest.TestCase):
 
         the_input = lookup_tag(tag)(test_system(), element, state)
 
-        context = the_input._get_render_context()
+        context = the_input._get_render_context()  # pylint: disable=W0212
 
         expected = {'id': 'sky_input',
                     'value': 'foil3',
@@ -144,7 +146,7 @@ class JavascriptInputTest(unittest.TestCase):
         state = {'value': '3', }
         the_input = lookup_tag('javascriptinput')(test_system(), element, state)
 
-        context = the_input._get_render_context()
+        context = the_input._get_render_context()  # pylint: disable=W0212
 
         expected = {'id': 'prob_1_2',
                     'status': 'unanswered',
@@ -172,7 +174,7 @@ class TextLineTest(unittest.TestCase):
         state = {'value': 'BumbleBee', }
         the_input = lookup_tag('textline')(test_system(), element, state)
 
-        context = the_input._get_render_context()
+        context = the_input._get_render_context()  # pylint: disable=W0212
 
         expected = {'id': 'prob_1_2',
                     'value': 'BumbleBee',
@@ -200,7 +202,7 @@ class TextLineTest(unittest.TestCase):
         state = {'value': 'BumbleBee', }
         the_input = lookup_tag('textline')(test_system(), element, state)
 
-        context = the_input._get_render_context()
+        context = the_input._get_render_context()  # pylint: disable=W0212
 
         expected = {'id': 'prob_1_2',
                     'value': 'BumbleBee',
@@ -238,7 +240,7 @@ class TextLineTest(unittest.TestCase):
             state = {'value': 'BumbleBee', }
             the_input = lookup_tag('textline')(test_system(), element, state)
 
-            context = the_input._get_render_context()
+            context = the_input._get_render_context()  # pylint: disable=W0212
 
             expected = {'id': 'prob_1_2',
                         'value': 'BumbleBee',
@@ -276,7 +278,7 @@ class FileSubmissionTest(unittest.TestCase):
         input_class = lookup_tag('filesubmission')
         the_input = input_class(test_system(), element, state)
 
-        context = the_input._get_render_context()
+        context = the_input._get_render_context()  # pylint: disable=W0212
 
         expected = {'id': 'prob_1_2',
                     'status': 'queued',
@@ -321,7 +323,7 @@ class CodeInputTest(unittest.TestCase):
         input_class = lookup_tag('codeinput')
         the_input = input_class(test_system(), element, state)
 
-        context = the_input._get_render_context()
+        context = the_input._get_render_context()  # pylint: disable=W0212
 
         expected = {'id': 'prob_1_2',
                     'value': 'print "good evening"',
@@ -371,7 +373,7 @@ class MatlabTest(unittest.TestCase):
         self.the_input = self.input_class(test_system(), elt, state)
 
     def test_rendering(self):
-        context = self.the_input._get_render_context()
+        context = self.the_input._get_render_context()  # pylint: disable=W0212
 
         expected = {'id': 'prob_1_2',
                     'value': 'print "good evening"',
@@ -397,7 +399,7 @@ class MatlabTest(unittest.TestCase):
         elt = etree.fromstring(self.xml)
 
         the_input = self.input_class(test_system(), elt, state)
-        context = the_input._get_render_context()
+        context = the_input._get_render_context()  # pylint: disable=W0212
 
         expected = {'id': 'prob_1_2',
                     'value': 'print "good evening"',
@@ -424,7 +426,7 @@ class MatlabTest(unittest.TestCase):
             elt = etree.fromstring(self.xml)
 
             the_input = self.input_class(test_system(), elt, state)
-            context = the_input._get_render_context()
+            context = the_input._get_render_context()  # pylint: disable=W0212
             expected = {'id': 'prob_1_2',
                         'value': 'print "good evening"',
                         'status': status,
@@ -449,7 +451,7 @@ class MatlabTest(unittest.TestCase):
         elt = etree.fromstring(self.xml)
 
         the_input = self.input_class(test_system(), elt, state)
-        context = the_input._get_render_context()
+        context = the_input._get_render_context()  # pylint: disable=W0212
         expected = {'id': 'prob_1_2',
                     'value': 'print "good evening"',
                     'status': 'queued',
@@ -554,7 +556,7 @@ class SchematicTest(unittest.TestCase):
 
         the_input = lookup_tag('schematic')(test_system(), element, state)
 
-        context = the_input._get_render_context()
+        context = the_input._get_render_context()  # pylint: disable=W0212
 
         expected = {'id': 'prob_1_2',
                     'value': value,
@@ -593,7 +595,7 @@ class ImageInputTest(unittest.TestCase):
 
         the_input = lookup_tag('imageinput')(test_system(), element, state)
 
-        context = the_input._get_render_context()
+        context = the_input._get_render_context()  # pylint: disable=W0212
 
         expected = {'id': 'prob_1_2',
                     'value': value,
@@ -644,7 +646,7 @@ class CrystallographyTest(unittest.TestCase):
 
         the_input = lookup_tag('crystallography')(test_system(), element, state)
 
-        context = the_input._get_render_context()
+        context = the_input._get_render_context()  # pylint: disable=W0212
 
         expected = {'id': 'prob_1_2',
                     'value': value,
@@ -682,7 +684,7 @@ class VseprTest(unittest.TestCase):
 
         the_input = lookup_tag('vsepr_input')(test_system(), element, state)
 
-        context = the_input._get_render_context()
+        context = the_input._get_render_context()  # pylint: disable=W0212
 
         expected = {'id': 'prob_1_2',
                     'value': value,
@@ -711,7 +713,7 @@ class ChemicalEquationTest(unittest.TestCase):
 
     def test_rendering(self):
         ''' Verify that the render context matches the expected render context'''
-        context = self.the_input._get_render_context()
+        context = self.the_input._get_render_context()  # pylint: disable=W0212
 
         expected = {'id': 'prob_1_2',
                     'value': 'H2OYeah',
@@ -727,10 +729,168 @@ class ChemicalEquationTest(unittest.TestCase):
         data = {'formula': "H"}
         response = self.the_input.handle_ajax("preview_chemcalc", data)
 
-        self.assertTrue('preview' in response)
+        self.assertIn('preview', response)
         self.assertNotEqual(response['preview'], '')
         self.assertEqual(response['error'], "")
 
+    def test_ajax_bad_method(self):
+        """
+        With a bad dispatch, we shouldn't recieve anything
+        """
+        response = self.the_input.handle_ajax("obviously_not_real", {})
+        self.assertEqual(response, {})
+
+    def test_ajax_no_formula(self):
+        """
+        When we ask for a formula rendering, there should be an error if no formula
+        """
+        response = self.the_input.handle_ajax("preview_chemcalc", {})
+        self.assertIn('error', response)
+        self.assertEqual(response['error'], "No formula specified.")
+
+    def test_ajax_parse_err(self):
+        """
+        With parse errors, ChemicalEquationInput should give an error message
+        """
+        # Simulate answering a problem that raises the exception
+        with patch('capa.inputtypes.chemcalc.render_to_html') as mock_render:
+            mock_render.side_effect = ParseException(u"ȧƈƈḗƞŧḗḓ ŧḗẋŧ ƒǿř ŧḗşŧīƞɠ")
+            response = self.the_input.handle_ajax(
+                "preview_chemcalc",
+                {'formula': 'H2O + invalid chemistry'}
+            )
+
+        self.assertIn('error', response)
+        self.assertTrue("Couldn't parse formula" in response['error'])
+
+    @patch('capa.inputtypes.log')
+    def test_ajax_other_err(self, mock_log):
+        """
+        With other errors, test that ChemicalEquationInput also logs it
+        """
+        with patch('capa.inputtypes.chemcalc.render_to_html') as mock_render:
+            mock_render.side_effect = Exception()
+            response = self.the_input.handle_ajax(
+                "preview_chemcalc",
+                {'formula': 'H2O + superterrible chemistry'}
+            )
+        mock_log.warning.assert_called_once_with(
+            "Error while previewing chemical formula", exc_info=True
+        )
+        self.assertIn('error', response)
+        self.assertEqual(response['error'], "Error while rendering preview")
+
+
+class FormulaEquationTest(unittest.TestCase):
+    """
+    Check that formula equation inputs work.
+    """
+    def setUp(self):
+        self.size = "42"
+        xml_str = """<formulaequationinput id="prob_1_2" size="{size}"/>""".format(size=self.size)
+
+        element = etree.fromstring(xml_str)
+
+        state = {'value': 'x^2+1/2'}
+        self.the_input = lookup_tag('formulaequationinput')(test_system(), element, state)
+
+    def test_rendering(self):
+        """
+        Verify that the render context matches the expected render context
+        """
+        context = self.the_input._get_render_context()  # pylint: disable=W0212
+
+        expected = {
+            'id': 'prob_1_2',
+            'value': 'x^2+1/2',
+            'status': 'unanswered',
+            'reported_status': '',
+            'msg': '',
+            'size': self.size,
+            'previewer': '/static/js/capa/src/formula_equation_preview.js',
+        }
+        self.assertEqual(context, expected)
+
+    def test_rendering_reported_status(self):
+        """
+        Verify that the 'reported status' matches expectations.
+        """
+        test_values = {
+            '': '',  # Default
+            'unsubmitted': 'unanswered',
+            'correct': 'correct',
+            'incorrect': 'incorrect',
+            'incomplete': 'incomplete',
+            'not a status': ''
+        }
+
+        for self_status, reported_status in test_values.iteritems():
+            self.the_input.status = self_status
+            context = self.the_input._get_render_context()  # pylint: disable=W0212
+            self.assertEqual(context['reported_status'], reported_status)
+
+    def test_formcalc_ajax_sucess(self):
+        """
+        Verify that using the correct dispatch and valid data produces a valid response
+        """
+        data = {'formula': "x^2+1/2", 'request_start': 0}
+        response = self.the_input.handle_ajax("preview_formcalc", data)
+
+        self.assertIn('preview', response)
+        self.assertNotEqual(response['preview'], '')
+        self.assertEqual(response['error'], "")
+        self.assertEqual(response['request_start'], data['request_start'])
+
+    def test_ajax_bad_method(self):
+        """
+        With a bad dispatch, we shouldn't recieve anything
+        """
+        response = self.the_input.handle_ajax("obviously_not_real", {})
+        self.assertEqual(response, {})
+
+    def test_ajax_no_formula(self):
+        """
+        When we ask for a formula rendering, there should be an error if no formula
+        """
+        response = self.the_input.handle_ajax(
+            "preview_formcalc",
+            {'request_start': 1, }
+        )
+        self.assertIn('error', response)
+        self.assertEqual(response['error'], "No formula specified.")
+
+    def test_ajax_parse_err(self):
+        """
+        With parse errors, FormulaEquationInput should give an error message
+        """
+        # Simulate answering a problem that raises the exception
+        with patch('capa.inputtypes.latex_preview') as mock_preview:
+            mock_preview.side_effect = ParseException("Oopsie")
+            response = self.the_input.handle_ajax(
+                "preview_formcalc",
+                {'formula': 'x^2+1/2', 'request_start': 1, }
+            )
+
+        self.assertIn('error', response)
+        self.assertEqual(response['error'], "Sorry, couldn't parse formula")
+
+    @patch('capa.inputtypes.log')
+    def test_ajax_other_err(self, mock_log):
+        """
+        With other errors, test that FormulaEquationInput also logs it
+        """
+        with patch('capa.inputtypes.latex_preview') as mock_preview:
+            mock_preview.side_effect = Exception()
+            response = self.the_input.handle_ajax(
+                "preview_formcalc",
+                {'formula': 'x^2+1/2', 'request_start': 1, }
+            )
+        mock_log.warning.assert_called_once_with(
+            "Error while previewing formula", exc_info=True
+        )
+        self.assertIn('error', response)
+        self.assertEqual(response['error'], "Error while rendering preview")
+
 
 class DragAndDropTest(unittest.TestCase):
     '''
@@ -784,7 +944,7 @@ class DragAndDropTest(unittest.TestCase):
 
         the_input = lookup_tag('drag_and_drop_input')(test_system(), element, state)
 
-        context = the_input._get_render_context()
+        context = the_input._get_render_context()  # pylint: disable=W0212
         expected = {'id': 'prob_1_2',
                     'value': value,
                     'status': 'unsubmitted',
@@ -833,7 +993,7 @@ class AnnotationInputTest(unittest.TestCase):
 
         the_input = lookup_tag(tag)(test_system(), element, state)
 
-        context = the_input._get_render_context()
+        context = the_input._get_render_context()  # pylint: disable=W0212
 
         expected = {
             'id': 'annotation_input',
@@ -920,7 +1080,7 @@ class TestChoiceText(unittest.TestCase):
         }
         expected.update(state)
         the_input = lookup_tag(tag)(test_system(), element, state)
-        context = the_input._get_render_context()
+        context = the_input._get_render_context()  # pylint: disable=W0212
         self.assertEqual(context, expected)
 
     def test_radiotextgroup(self):

common/lib/xmodule/test_files/formularesponse_with_hint.xml

@@ -32,7 +32,7 @@ $wrongans</tt> to see a hint.</p>
 
 <formularesponse samples="x@-5:5#11" id="11" answer="$answer">
  <responseparam description="Numerical Tolerance" type="tolerance" default="0.001" name="tol" /> 
- <text>y = <textline size="25" /></text>
+ <text>y = <formulaequationinput size="25" /></text>
   <hintgroup>
    <formulahint samples="x@-5:5#11" answer="$wrongans" name="inversegrad">
    </formulahint>

common/lib/xmodule/xmodule/css/capa/display.scss

@@ -173,7 +173,7 @@ section.problem {
       }
     }
 
-    &.incorrect, &.ui-icon-close {
+    &.incorrect, &.incomplete, &.ui-icon-close {
       p.status {
         @include inline-block();
         background: url('../images/incorrect-icon.png') center center no-repeat;
@@ -214,6 +214,16 @@ section.problem {
       clear: both;
       margin-top: 3px;
 
+      .MathJax_Display {
+        display: inline-block;
+        width: auto;
+      }
+
+      img.loading {
+        display: inline-block;
+        padding-left: 10px;
+      }
+
       span {
         margin-bottom: 0;
 
@@ -265,7 +275,7 @@ section.problem {
         width: 25px;
       }
 
-      &.incorrect, &.ui-icon-close {
+      &.incorrect, &.incomplete, &.ui-icon-close {
         @include inline-block();
         background: url('../images/incorrect-icon.png') center center no-repeat;
         height: 20px;

common/lib/xmodule/xmodule/js/spec/problem/edit_spec.coffee

@@ -121,18 +121,18 @@ describe 'MarkdownEditingDescriptor', ->
         <p>Enter the numerical value of Pi:</p>
         <numericalresponse answer="3.14159">
           <responseparam type="tolerance" default=".02" />
-          <textline />
+          <formulaequationinput />
         </numericalresponse>
         
         <p>Enter the approximate value of 502*9:</p>
         <numericalresponse answer="4518">
           <responseparam type="tolerance" default="15%" />
-          <textline />
+          <formulaequationinput />
         </numericalresponse>
         
         <p>Enter the number of fingers on a human hand:</p>
         <numericalresponse answer="5">
-          <textline />
+          <formulaequationinput />
         </numericalresponse>
         
         <solution>
@@ -157,7 +157,7 @@ describe 'MarkdownEditingDescriptor', ->
         <p>Enter 0 with a tolerance:</p>
         <numericalresponse answer="0">
           <responseparam type="tolerance" default=".02" />
-          <textline />
+          <formulaequationinput />
         </numericalresponse>
 
 

common/lib/xmodule/xmodule/js/src/problem/edit.coffee

@@ -239,7 +239,7 @@ class @MarkdownEditingDescriptor extends XModule.Descriptor
           } else {
             string = '<numericalresponse answer="' + floatValue + '">\n';
           }
-          string += '  <textline />\n';
+          string += '  <formulaequationinput />\n';
           string += '</numericalresponse>\n\n';
         } else {
           string = '<stringresponse answer="' + p + '" type="ci">\n  <textline size="20"/>\n</stringresponse>\n\n';

common/lib/xmodule/xmodule/templates/problem/forumularesponse.yaml

@@ -24,15 +24,15 @@ data: |
   </script>
   <p>Give an equation for the relativistic energy of an object with mass m.  Explicitly indicate multiplication with a <tt>*</tt> symbol.</p>
   <formularesponse type="cs" samples="m,c@1,2:3,4#10" answer="m*c^2">
-      <responseparam type="tolerance" default="0.00001"/> 
-      <br/><text>E =</text> <textline size="40" math="1" />    
+      <responseparam type="tolerance" default="0.00001"/>
+      <br/><text>E =</text> <formulaequationinput size="40" />
   </formularesponse>
 
   <p>The answer to this question is (R_1*R_2)/R_3. </p>
 
   <formularesponse type="ci" samples="R_1,R_2,R_3@1,2,3:3,4,5#10" answer="$VoVi">
       <responseparam type="tolerance" default="0.00001"/> 
-      <textline size="40" math="1" />    
+      <formulaequationinput size="40" />    
   </formularesponse>
       <solution>
           <div class="detailed-solution">

common/lib/xmodule/xmodule/templates/problem/latex_problem.yaml

@@ -119,9 +119,8 @@ data: |
         <p>
           <p style="display:inline">Energy saved = </p>
           <numericalresponse inline="1" answer="0.52">
-            <textline inline="1">
-              <responseparam description="Numerical Tolerance" type="tolerance" default="0.02" name="tol"/>
-            </textline>
+            <responseparam description="Numerical Tolerance" type="tolerance" default="0.02" name="tol"/>
+            <formulaequationinput/>
           </numericalresponse>
           <p style="display:inline">&#xA0;EJ/year</p>
         </p>

common/lib/xmodule/xmodule/templates/problem/numericalresponse.yaml

@@ -47,19 +47,19 @@ data: |
    <p>Enter the numerical value of Pi:
        <numericalresponse answer="3.14159">
            <responseparam type="tolerance" default=".02" />
-           <textline />
+           <formulaequationinput />
        </numericalresponse>
    </p>
    <p>Enter the approximate value of 502*9:
        <numericalresponse answer="$computed_response">
            <responseparam type="tolerance" default="15%"/>
-           <textline />
+           <formulaequationinput />
        </numericalresponse>
    </p>
 
    <p>Enter the number of fingers on a human hand:
        <numericalresponse answer="5">
-           <textline />
+           <formulaequationinput />
        </numericalresponse>
    </p>
        <solution>

common/lib/xmodule/xmodule/tests/__init__.py

@@ -71,51 +71,6 @@ class ModelsTest(unittest.TestCase):
         vc_str = "<class 'xmodule.video_module.VideoDescriptor'>"
         self.assertEqual(str(vc), vc_str)
 
-    def test_calc(self):
-        variables = {'R1': 2.0, 'R3': 4.0}
-        functions = {'sin': numpy.sin, 'cos': numpy.cos}
-
-        self.assertTrue(abs(calc.evaluator(variables, functions, "10000||sin(7+5)+0.5356")) < 0.01)
-        self.assertEqual(calc.evaluator({'R1': 2.0, 'R3': 4.0}, {}, "13"), 13)
-        self.assertEqual(calc.evaluator(variables, functions, "13"), 13)
-        self.assertEqual(calc.evaluator({'a': 2.2997471478310274, 'k': 9, 'm': 8, 'x': 0.66009498411213041}, {}, "5"), 5)
-        self.assertEqual(calc.evaluator({}, {}, "-1"), -1)
-        self.assertEqual(calc.evaluator({}, {}, "-0.33"), -.33)
-        self.assertEqual(calc.evaluator({}, {}, "-.33"), -.33)
-        self.assertEqual(calc.evaluator(variables, functions, "R1*R3"), 8.0)
-        self.assertTrue(abs(calc.evaluator(variables, functions, "sin(e)-0.41")) < 0.01)
-        self.assertTrue(abs(calc.evaluator(variables, functions, "k*T/q-0.025")) < 0.001)
-        self.assertTrue(abs(calc.evaluator(variables, functions, "e^(j*pi)") + 1) < 0.00001)
-        self.assertTrue(abs(calc.evaluator(variables, functions, "j||1") - 0.5 - 0.5j) < 0.00001)
-        variables['t'] = 1.0
-        # Use self.assertAlmostEqual here...
-        self.assertTrue(abs(calc.evaluator(variables, functions, "t") - 1.0) < 0.00001)
-        self.assertTrue(abs(calc.evaluator(variables, functions, "T") - 1.0) < 0.00001)
-        self.assertTrue(abs(calc.evaluator(variables, functions, "t", cs=True) - 1.0) < 0.00001)
-        self.assertTrue(abs(calc.evaluator(variables, functions, "T", cs=True) - 298) < 0.2)
-        # Use self.assertRaises here...
-        exception_happened = False
-        try:
-            calc.evaluator({}, {}, "5+7 QWSEKO")
-        except:
-            exception_happened = True
-        self.assertTrue(exception_happened)
-
-        try:
-            calc.evaluator({'r1': 5}, {}, "r1+r2")
-        except calc.UndefinedVariable:
-            pass
-
-        self.assertEqual(calc.evaluator(variables, functions, "r1*r3"), 8.0)
-
-        exception_happened = False
-        try:
-            calc.evaluator(variables, functions, "r1*r3", cs=True)
-        except:
-            exception_happened = True
-        self.assertTrue(exception_happened)
-
-
 class PostData(object):
     """Class which emulate postdata."""
     def __init__(self, dict_data):

common/lib/xmodule/xmodule/tests/test_crowdsource_hinter.py

@@ -28,7 +28,7 @@ class CHModuleFactory(object):
           <p>The answer is correct if it is within a specified numerical tolerance of the expected answer.</p>
           <p>Enter the number of fingers on a human hand:</p>
           <numericalresponse answer="5">
-            <textline/>
+            <formulaequationinput/>
           </numericalresponse>
           <solution>
             <div class="detailed-solution">
@@ -114,7 +114,7 @@ class VerticalWithModulesFactory(object):
             <problem display_name="Numerical Input" markdown=" " rerandomize="never" showanswer="finished">
               <p>Test numerical problem.</p>
               <numericalresponse answer="5">
-                <textline/>
+                <formulaequationinput/>
               </numericalresponse>
               <solution>
                 <div class="detailed-solution">
@@ -129,7 +129,7 @@ class VerticalWithModulesFactory(object):
             <problem display_name="Numerical Input" markdown=" " rerandomize="never" showanswer="finished">
               <p>Another test numerical problem.</p>
               <numericalresponse answer="5">
-                <textline/>
+                <formulaequationinput/>
               </numericalresponse>
               <solution>
                 <div class="detailed-solution">

common/static/js/capa/spec/formula_equation_preview_spec.js

+function callPeriodicallyUntil(block, delay, condition, i) {  // i is optional
+    i = i || 0;
+    block(i);
+    waits(delay);
+    runs(function () {
+        if (!condition()) {
+            callPeriodicallyUntil(block, delay, condition, i + 1);
+        }
+    });
+}
+
+describe("Formula Equation Preview", function () {
+    beforeEach(function () {
+        // Simulate an environment conducive to a FormulaEquationInput
+        var $fixture = this.$fixture = $('\
+<section class="problems-wrapper" data-url="THE_URL">\
+  <section class="formulaequationinput">\
+    <input type="text" id="input_THE_ID" data-input-id="THE_ID"\
+        value="prefilled_value"/>\
+    <div id="input_THE_ID_preview" class="equation">\
+      \[\]\
+      <img class="loading" style="visibility:hidden"/>\
+    </div>\
+  </section>\
+</section>');
+
+        // Modify $ for the test to search the fixture.
+        var old$find = this.old$find = $.find;
+        $.find = function () {
+            // Given the default context, swap it out for the fixture.
+            if (arguments[1] == document) {
+                arguments[1] = $fixture[0];
+            }
+
+            // Call old function.
+            return old$find.apply(this, arguments);
+        }
+        $.find.matchesSelector = old$find.matchesSelector;
+
+        this.oldDGEBI = document.getElementById;
+        document.getElementById = function (id) {
+            return $("*#" + id)[0] || null;
+        };
+
+        // Catch the AJAX requests
+        var ajaxTimes = this.ajaxTimes = [];
+        this.oldProblem = window.Problem;
+
+        window.Problem = {};
+        Problem.inputAjax = jasmine.createSpy('Problem.inputAjax')
+            .andCallFake(function () {
+                ajaxTimes.push(Date.now());
+            });
+
+        // Spy on MathJax
+        this.jax = 'OUTPUT_JAX';
+        this.oldMathJax = window.MathJax;
+
+        window.MathJax = {Hub: {}};
+        MathJax.Hub.getAllJax = jasmine.createSpy('MathJax.Hub.getAllJax')
+            .andReturn([this.jax]);
+        MathJax.Hub.Queue = jasmine.createSpy('MathJax.Hub.Queue');
+    });
+
+    it('(the test) should be able to swap out the behavior of $', function () {
+        // This was a pain to write, make sure it doesn't get screwed up.
+
+        // Find the DOM element using DOM methods.
+        var legitInput = this.$fixture[0].getElementsByTagName("input")[0];
+
+        // Use the (modified) jQuery.
+        var jqueryInput = $('.formulaequationinput input');
+        var byIdInput = $("#input_THE_ID");
+
+        expect(jqueryInput[0]).toEqual(legitInput);
+        expect(byIdInput[0]).toEqual(legitInput);
+    });
+
+    describe('Ajax requests', function () {
+        it('has an initial request with the correct parameters', function () {
+            formulaEquationPreview.enable();
+
+	    expect(MathJax.Hub.Queue).toHaveBeenCalled();
+	    // Do what Queue would've done--call the function.
+	    var args = MathJax.Hub.Queue.mostRecentCall.args;
+	    args[1].call(args[0]);
+
+            // This part may be asynchronous, so wait.
+            waitsFor(function () {
+                return Problem.inputAjax.wasCalled;
+            }, "AJAX never called initially", 1000);
+
+	    runs(function () {
+		expect(Problem.inputAjax.callCount).toEqual(1);
+
+		// Use `.toEqual` rather than `.toHaveBeenCalledWith`
+		// since it supports `jasmine.any`.
+		expect(Problem.inputAjax.mostRecentCall.args).toEqual([
+                    "THE_URL",
+                    "THE_ID",
+                    "preview_formcalc",
+                    {formula: "prefilled_value",
+                     request_start: jasmine.any(Number)},
+                    jasmine.any(Function)
+		]);
+	    });
+        });
+
+        it('makes a request on user input', function () {
+            formulaEquationPreview.enable();
+            $('#input_THE_ID').val('user_input').trigger('input');
+
+            // This part is probably asynchronous
+            waitsFor(function () {
+                return Problem.inputAjax.wasCalled;
+            }, "AJAX never called on user input", 1000);
+
+            runs(function () {
+                expect(Problem.inputAjax.mostRecentCall.args[3].formula
+                      ).toEqual('user_input');
+            });
+        });
+
+        it("shouldn't be requested for empty input", function () {
+            formulaEquationPreview.enable();
+	    MathJax.Hub.Queue.reset();
+
+            // When we make an input of '',
+            $('#input_THE_ID').val('').trigger('input');
+
+            // Either it makes a request or jumps straight into displaying ''.
+            waitsFor(function () {
+                // (Short circuit if `inputAjax` is indeed called)
+                return Problem.inputAjax.wasCalled || 
+                    MathJax.Hub.Queue.wasCalled;
+            }, "AJAX never called on user input", 1000);
+
+            runs(function () {
+                // Expect the request not to have been called.
+                expect(Problem.inputAjax).not.toHaveBeenCalled();
+            });
+        });
+
+        it('should limit the number of requests per second', function () {
+            formulaEquationPreview.enable();
+
+	    var minDelay = formulaEquationPreview.minDelay;
+            var end = Date.now() + minDelay * 1.1;
+            var step = 10;  // ms
+
+            var $input = $('#input_THE_ID');
+            var value;
+            function inputAnother(iter) {
+                value = "math input " + iter;
+                $input.val(value).trigger('input');
+            }
+
+            callPeriodicallyUntil(inputAnother, step, function () {
+                return Date.now() > end;  // Stop when we get to `end`.
+            });
+
+            waitsFor(function () {
+                return Problem.inputAjax.wasCalled &&
+                    Problem.inputAjax.mostRecentCall.args[3].formula == value;
+            }, "AJAX never called with final value from input", 1000);
+
+            runs(function () {
+                // There should be 2 or 3 calls (depending on leading edge).
+                expect(Problem.inputAjax.callCount).not.toBeGreaterThan(3);
+
+                // The calls should happen approximately `minDelay` apart.
+                for (var i =1; i < this.ajaxTimes.length; i ++) {
+                    var diff = this.ajaxTimes[i] - this.ajaxTimes[i - 1];
+                    expect(diff).toBeGreaterThan(minDelay - 10);
+                }
+            });
+        });
+    });
+
+    describe("Visible results (icon and mathjax)", function () {
+        it('should display a loading icon when requests are open', function () {
+            formulaEquationPreview.enable();
+            var $img = $("img.loading");
+            expect($img.css('visibility')).toEqual('hidden');
+
+            $("#input_THE_ID").val("different").trigger('input');
+            expect($img.css('visibility')).toEqual('visible');
+
+            // Don't let it fail later.
+            waitsFor(function () {
+		return Problem.inputAjax.wasCalled;
+            });
+        });
+
+        it('should update MathJax and loading icon on callback', function () {
+            formulaEquationPreview.enable();
+            $('#input_THE_ID').val('user_input').trigger('input');
+
+            waitsFor(function () {
+                return Problem.inputAjax.wasCalled;
+            }, "AJAX never called initially", 1000);
+
+            runs(function () {
+                var args = Problem.inputAjax.mostRecentCall.args;
+                var callback = args[4];
+                callback({
+                    preview: 'THE_FORMULA',
+                    request_start: args[3].request_start
+                });
+
+                // The only request returned--it should hide the loading icon.
+                expect($("img.loading").css('visibility')).toEqual('hidden');
+
+                // We should look in the preview div for the MathJax.
+                var previewDiv = $("div")[0];
+                expect(MathJax.Hub.getAllJax).toHaveBeenCalledWith(previewDiv);
+
+                // Refresh the MathJax.
+                expect(MathJax.Hub.Queue).toHaveBeenCalledWith(
+                    ['Text', this.jax, 'THE_FORMULA'],
+                    ['Reprocess', this.jax]
+                );
+            });
+        });
+
+        it('should display errors from the server well', function () {
+            var $img = $("img.loading");
+            formulaEquationPreview.enable();
+	    MathJax.Hub.Queue.reset();
+            $("#input_THE_ID").val("different").trigger('input');
+
+            waitsFor(function () {
+                return Problem.inputAjax.wasCalled;
+            }, "AJAX never called initially", 1000);
+
+            runs(function () {
+                var args = Problem.inputAjax.mostRecentCall.args;
+                var callback = args[4];
+                callback({
+                    error: 'OOPSIE',
+                    request_start: args[3].request_start
+                });
+                expect(MathJax.Hub.Queue).not.toHaveBeenCalled();
+                expect($img.css('visibility')).toEqual('visible');
+            });
+
+            var errorDelay = formulaEquationPreview.errorDelay * 1.1;
+            waitsFor(function () {
+                return MathJax.Hub.Queue.wasCalled;
+            }, "Error message never displayed", 2000);
+
+            runs(function () {
+                // Refresh the MathJax.
+                expect(MathJax.Hub.Queue).toHaveBeenCalledWith(
+                    ['Text', this.jax, '\\text{OOPSIE}'],
+                    ['Reprocess', this.jax]
+                );
+                expect($img.css('visibility')).toEqual('hidden');
+            });
+        });
+    });
+
+    describe('Multiple callbacks', function () {
+        beforeEach(function () {
+            formulaEquationPreview.enable();
+	    MathJax.Hub.Queue.reset();
+            $('#input_THE_ID').val('different').trigger('input');
+
+	    waitsFor(function () {
+		return Problem.inputAjax.wasCalled;
+	    });
+
+	    runs(function () {
+		$("#input_THE_ID").val("different2").trigger('input');
+	    });
+
+            waitsFor(function () {
+                return Problem.inputAjax.callCount > 1;
+            });
+
+            runs(function () {
+                var args = Problem.inputAjax.argsForCall;
+                var response0 = {
+                    preview: 'THE_FORMULA_0',
+                    request_start: args[0][3].request_start
+                };
+                var response1 = {
+                    preview: 'THE_FORMULA_1',
+                    request_start: args[1][3].request_start
+                };
+
+                this.callbacks = [args[0][4], args[1][4]];
+                this.responses = [response0, response1];
+            });
+        });
+
+        it('should update requests sequentially', function () {
+            var $img = $("img.loading");
+
+            expect($img.css('visibility')).toEqual('visible');
+
+            this.callbacks[0](this.responses[0]);
+            expect(MathJax.Hub.Queue).toHaveBeenCalledWith(
+                ['Text', this.jax, 'THE_FORMULA_0'],
+                ['Reprocess', this.jax]
+            );
+            expect($img.css('visibility')).toEqual('visible');
+
+            this.callbacks[1](this.responses[1]);
+            expect(MathJax.Hub.Queue).toHaveBeenCalledWith(
+                ['Text', this.jax, 'THE_FORMULA_1'],
+                ['Reprocess', this.jax]
+            );
+            expect($img.css('visibility')).toEqual('hidden')
+        });
+
+        it("shouldn't display outdated information", function () {
+            var $img = $("img.loading");
+
+            expect($img.css('visibility')).toEqual('visible');
+
+            // Switch the order (1 returns before 0)
+            this.callbacks[1](this.responses[1]);
+            expect(MathJax.Hub.Queue).toHaveBeenCalledWith(
+                ['Text', this.jax, 'THE_FORMULA_1'],
+                ['Reprocess', this.jax]
+            );
+            expect($img.css('visibility')).toEqual('hidden')
+
+            MathJax.Hub.Queue.reset();
+            this.callbacks[0](this.responses[0]);
+            expect(MathJax.Hub.Queue).not.toHaveBeenCalled();
+            expect($img.css('visibility')).toEqual('hidden')
+        });
+
+        it("shouldn't show an error if the responses are close together",
+           function () {
+               this.callbacks[0]({
+                   error: 'OOPSIE',
+                   request_start: this.responses[0].request_start
+               });
+               expect(MathJax.Hub.Queue).not.toHaveBeenCalled();
+               // Error message waiting to be displayed
+
+               this.callbacks[1](this.responses[1]);
+               expect(MathJax.Hub.Queue).toHaveBeenCalledWith(
+                   ['Text', this.jax, 'THE_FORMULA_1'],
+                   ['Reprocess', this.jax]
+               );
+
+               // Make sure that it doesn't indeed show up later
+               MathJax.Hub.Queue.reset();
+               var errorDelay = formulaEquationPreview.errorDelay * 1.1;
+               waits(errorDelay);
+
+               runs(function () {
+                   expect(MathJax.Hub.Queue).not.toHaveBeenCalled();
+               })
+           });
+    });
+
+    afterEach(function () {
+        // Return jQuery
+        $.find = this.old$find;
+        document.getElementById = this.oldDGEBI;
+
+        // Return Problem
+        Problem = this.oldProblem;
+        if (Problem === undefined) {
+            delete Problem;
+        }
+
+        // Return MathJax
+        MathJax = this.oldMathJax;
+        if (MathJax === undefined) {
+            delete MathJax;
+        }
+    });
+});

common/static/js/capa/spec/jsinput/jsinput.js → common/static/js/capa/spec/jsinput_spec.js

-describe("A jsinput has:", function () {
+xdescribe("A jsinput has:", function () {
 
     beforeEach(function () {
         $('#fixture').remove();