Makeboxes overhault

mathics/builtin/forms/print.py

@@ -12,19 +12,16 @@
 below are the functions that appear in '$PrintForms' at startup.
 """
 
-from mathics.builtin.box.layout import InterpretationBox, StyleBox, TagBox
+from mathics.builtin.box.layout import InterpretationBox, PaneBox, StyleBox
 from mathics.builtin.forms.base import FormBaseClass
 from mathics.core.atoms import String
+from mathics.core.element import BaseElement
+from mathics.core.evaluation import Evaluation
 from mathics.core.expression import Expression
-from mathics.core.symbols import SymbolFalse, SymbolFullForm, SymbolTrue
+from mathics.core.symbols import SymbolFalse, SymbolTrue
 from mathics.core.systemsymbols import SymbolInputForm, SymbolOutputForm
-from mathics.format.box import (
-    eval_makeboxes_fullform,
-    eval_makeboxes_outputform,
-    eval_mathmlform,
-    eval_texform,
-)
-from mathics.format.form import render_input_form
+from mathics.format.box.makeboxes import is_print_form_callback
+from mathics.format.form import render_input_form, render_output_form
 
 sort_order = "mathics.builtin.forms.general-purpose-forms"
 
@@ -52,19 +49,6 @@ class FullForm(FormBaseClass):
     in_printforms = False
     summary_text = "format expression in underlying M-Expression representation"
 
-    def eval_makeboxes(self, expr, fmt, evaluation):
-        """MakeBoxes[FullForm[expr_], fmt_]"""
-        fullform_box = eval_makeboxes_fullform(expr, evaluation)
-        style_box = StyleBox(
-            fullform_box,
-            **{
-                "System`ShowSpecialCharacters": SymbolFalse,
-                "System`ShowStringCharacters": SymbolTrue,
-                "System`NumberMarks": SymbolTrue,
-            },
-        )
-        return TagBox(style_box, SymbolFullForm)
-
 
 class InputForm(FormBaseClass):
     r"""
@@ -116,26 +100,6 @@ class InputForm(FormBaseClass):
     in_printforms = True
     summary_text = "format expression suitable for Mathics3 input"
 
-    # TODO: eventually, remove OutputForm in the second argument.
-    def eval_makeboxes(self, expr, evaluation):
-        """MakeBoxes[InputForm[expr_], StandardForm|TraditionalForm]"""
-
-        inputform = String(render_input_form(expr, evaluation))
-        inputform = StyleBox(
-            inputform,
-            **{
-                "System`ShowSpecialCharacters": SymbolFalse,
-                "System`ShowStringCharacters": SymbolTrue,
-                "System`NumberMarks": SymbolTrue,
-            },
-        )
-        expr = Expression(SymbolInputForm, expr)
-        return InterpretationBox(
-            inputform,
-            expr,
-            **{"System`Editable": SymbolTrue, "System`AutoDelete": SymbolTrue},
-        )
-
 
 class MathMLForm(FormBaseClass):
     """
@@ -169,10 +133,6 @@ class MathMLForm(FormBaseClass):
 
     summary_text = "format expression as MathML commands"
 
-    def eval_mathml(self, expr, evaluation) -> Expression:
-        "MakeBoxes[MathMLForm[expr_], StandardForm|TraditionalForm]"
-        return eval_mathmlform(expr, evaluation)
-
 
 class OutputForm(FormBaseClass):
     """
@@ -202,13 +162,6 @@ class OutputForm(FormBaseClass):
     formats = {"OutputForm[s_String]": "s"}
     summary_text = "format expression in plain text"
 
-    def eval_makeboxes(self, expr, form, evaluation):
-        """MakeBoxes[OutputForm[expr_], form_]"""
-        pane = eval_makeboxes_outputform(expr, evaluation, form)
-        return InterpretationBox(
-            pane, Expression(SymbolOutputForm, expr), **{"System`Editable": SymbolFalse}
-        )
-
 
 class StandardForm(FormBaseClass):
     """
@@ -276,8 +229,34 @@ class TeXForm(FormBaseClass):
     in_printforms = True
     summary_text = "format expression as LaTeX commands"
 
-    def eval_tex(self, expr, evaluation) -> Expression:
-        "MakeBoxes[TeXForm[expr_], StandardForm|TraditionalForm]"
-        # TeXForm by default uses `TraditionalForm`
 
-        return eval_texform(expr, evaluation)
+@is_print_form_callback("System`InputForm")
+def eval_makeboxes_inputform(expr: BaseElement, evaluation: Evaluation):
+    """MakeBoxes[InputForm[expr_], StandardForm|TraditionalForm]"""
+    inputform = String(render_input_form(expr, evaluation))
+    inputform = StyleBox(
+        inputform,
+        **{
+            "System`ShowStringCharacters": SymbolTrue,
+            "System`NumberMarks": SymbolTrue,
+        },
+    )
+    expr = Expression(SymbolInputForm, expr)
+    return InterpretationBox(
+        inputform,
+        expr,
+        **{"System`Editable": SymbolTrue, "System`AutoDelete": SymbolTrue},
+    )
+
+
+@is_print_form_callback("System`OutputForm")
+def eval_makeboxes_outputform(expr: BaseElement, evaluation: Evaluation, **kwargs):
+    """
+    Build a 2D representation of the expression using only keyboard characters.
+    """
+
+    text_outputform = str(render_output_form(expr, evaluation, **kwargs))
+    pane = PaneBox(String('"' + text_outputform + '"'))
+    return InterpretationBox(
+        pane, Expression(SymbolOutputForm, expr), **{"System`Editable": SymbolFalse}
+    )

mathics/builtin/list/constructing.py

@@ -12,7 +12,6 @@
 from itertools import permutations
 from typing import Optional, Tuple
 
-from mathics.builtin.box.layout import RowBox
 from mathics.core.atoms import ByteArray, Integer, Integer1, is_integer_rational_or_real
 from mathics.core.attributes import A_HOLD_FIRST, A_LISTABLE, A_LOCKED, A_PROTECTED
 from mathics.core.builtin import BasePattern, Builtin, IterationFunction
@@ -24,7 +23,7 @@
 from mathics.core.list import ListExpression
 from mathics.core.symbols import Atom, Symbol
 from mathics.core.systemsymbols import SymbolNormal, SymbolTuples
-from mathics.eval.lists import get_tuples, list_boxes
+from mathics.eval.lists import get_tuples
 
 
 class Array(Builtin):
@@ -165,13 +164,6 @@ def eval(self, elements, evaluation: Evaluation):
         elements_part_of_elements__ = elements.get_sequence()
         return ListExpression(*elements_part_of_elements__)
 
-    def eval_makeboxes(self, items, f, evaluation):
-        """MakeBoxes[{items___},
-        (f:StandardForm|TraditionalForm)]"""
-
-        items = items.get_sequence()
-        return RowBox(*list_boxes(items, f, evaluation, "{", "}"))
-
 
 class Normal(Builtin):
     """

mathics/builtin/makeboxes.py

@@ -3,10 +3,9 @@
 Low-level Format definitions
 """
 
-
 from mathics.core.attributes import A_HOLD_ALL_COMPLETE, A_READ_PROTECTED
 from mathics.core.builtin import Builtin, Predefined
-from mathics.format.box import eval_generic_makeboxes, format_element
+from mathics.format.box import format_element
 
 # TODO: Differently from the current implementation, MakeBoxes should only
 # accept as its format field the symbols in `$BoxForms`. This is something to
@@ -85,16 +84,12 @@ class MakeBoxes(Builtin):
         "MakeBoxes[expr_]": "MakeBoxes[expr, StandardForm]",
         # The following rule is temporal.
         "MakeBoxes[expr_, form:(TeXForm|MathMLForm)]": "MakeBoxes[form[expr], StandardForm]",
-        (
-            "MakeBoxes[(form:StandardForm|TraditionalForm)"
-            "[expr_], StandardForm|TraditionalForm]"
-        ): ("MakeBoxes[expr, form]"),
     }
     summary_text = "settable low-level translator from expression to display boxes"
 
     def eval_general(self, expr, f, evaluation):
         """MakeBoxes[expr_, f:TraditionalForm|StandardForm]"""
-        return eval_generic_makeboxes(expr, f, evaluation)
+        return format_element(expr, evaluation, f)
 
 
 class ToBoxes(Builtin):
@@ -126,5 +121,6 @@ def eval(self, expr, form, evaluation):
         form_name = form.get_name()
         if form_name is None:
             evaluation.message("ToBoxes", "boxfmt", form)
+
         boxes = format_element(expr, evaluation, form)
         return boxes

mathics/core/builtin.py

@@ -347,7 +347,7 @@ def contextify_form_name(f):
                 """Handle adding 'System`' to a form name, unless it's ""
                 (meaning the rule applies to all forms).
                 """
-                return "" if f == "" else ensure_context(f)
+                return f if f in ("", "_MakeBoxes") else ensure_context(f)
 
             if isinstance(pattern, tuple):
                 forms, pattern = pattern
@@ -383,6 +383,9 @@ def contextify_form_name(f):
                 formatvalues[form].append(
                     Rule(pattern, parse_builtin_rule(replace), system=True)
                 )
+
+        formatvalues.setdefault("_MakeBoxes", []).extend(box_rules)
+
         for form, formatrules in formatvalues.items():
             formatrules.sort(key=lambda x: x.pattern_precedence)
 
@@ -434,10 +437,6 @@ def contextify_form_name(f):
         else:
             definitions.builtin[name] = definition
 
-        makeboxes_def = definitions.builtin["System`MakeBoxes"]
-        for rule in box_rules:
-            makeboxes_def.add_rule(rule)
-
     # This method is used to produce generic argument mismatch errors
     # (tags: "argx", "argr", "argrx", "argt", or "argtu") for builtin
     # functions that define this as an eval method. e.g.  For example

mathics/core/load_builtin.py

@@ -133,11 +133,8 @@ def definition_contribute(definitions):
     Load the Definition objects associated to all the builtins
     on `Definitions`
     """
-    # let MakeBoxes contribute first
-    _builtins["System`MakeBoxes"].contribute(definitions)
     for name, item in _builtins.items():
-        if name != "System`MakeBoxes":
-            item.contribute(definitions)
+        item.contribute(definitions)
 
     from mathics.core.definitions import Definition
     from mathics.core.expression import ensure_context

mathics/doc/documentation/1-Manual.mdoc

@@ -912,14 +912,13 @@ In a similar way, in the CLI, we can ask for TraditionalForm explicitly
   = c
 
 'MakeBoxes' for another form:
-
   >> MakeBoxes[TeXForm[b], form_] = "d";
   >> b // TeXForm
   = ...
 
 You can cause a much bigger mess by overriding 'MakeBoxes' than by sticking to 'Format', e.g. generate invalid XML:
 
-  >> MakeBoxes[MathMLForm[c], form_] = "<not closed";
+  >> MakeBoxes[MathMLForm[c], form_] := "<not closed";
   >> c // MathMLForm //StandardForm
   = <not closed
 

mathics/eval/assignments/assignment.py

@@ -661,19 +661,26 @@ def eval_assign_makeboxes(
         True if the assignment was successful.
 
     """
-    # FIXME: the below is a big hack.
-    # Currently MakeBoxes boxing is implemented as a bunch of rules.
-    # See mathics.core.builtin contribute().
-    # I think we want to change this so it works like normal SetDelayed
-    # That is:
-    #   MakeBoxes[CubeRoot, StandardForm] := RadicalBox[3, StandardForm]
-    # rather than:
-    #   MakeBoxes[CubeRoot, StandardForm] -> RadicalBox[3, StandardForm]
+    if not lhs.has_form("MakeBoxes", 2):
+        evaluation.message("MakeBoxes", "argrx", Integer(len(lhs.elements)))
+        raise AssignmentException(lhs, None)
+    target, form = lhs.elements
+    # Check second argument
+
     makeboxes_rule = Rule(lhs, rhs, system=False)
+    tags = [] if tags is None else tags
+    if upset:
+        tags = tags + [target.get_lookup_name()]
+    else:
+        if not tags:
+            tags = ["System`MakeBoxes"]
+
     definitions = evaluation.definitions
-    definitions.add_rule("System`MakeBoxes", makeboxes_rule, "downvalues")
-    #    makeboxes_defs = evaluation.definitions.builtin["System`MakeBoxes"]
-    #    makeboxes_defs.add_rule(makeboxes_rule)
+    for tag in tags:
+        if is_protected(tag, definitions):
+            evaluation.message(self.get_name(), "wrsym", Symbol(tag))
+            return False
+        definitions.add_format(tag, makeboxes_rule, "_MakeBoxes")
     return True
 
 

mathics/eval/lists.py

@@ -1,4 +1,3 @@
-from mathics.builtin.box.layout import RowBox
 from mathics.core.atoms import String
 from mathics.core.convert.expression import to_expression
 from mathics.core.exceptions import PartDepthError, PartRangeError
@@ -61,6 +60,8 @@ def get_tuples(items):
 
 
 def list_boxes(items, f, evaluation, open=None, close=None):
+    from mathics.builtin.box.layout import RowBox
+
     result = [
         Expression(SymbolMakeBoxes, item, f).evaluate(evaluation) for item in items
     ]

mathics/format/box/__init__.py

@@ -6,9 +6,7 @@
 from mathics.format.box.makeboxes import (
     _boxed_string,
     eval_generic_makeboxes,
-    eval_makeboxes,
     eval_makeboxes_fullform,
-    eval_makeboxes_outputform,
     format_element,
     to_boxes,
 )
@@ -36,9 +34,7 @@
     "eval_baseform",
     "eval_generic_makeboxes",
     "eval_infix",
-    "eval_makeboxes",
     "eval_makeboxes_fullform",
-    "eval_makeboxes_outputform",
     "eval_mathmlform",
     "eval_postprefix",
     "eval_tableform",