Removed support for Markdown and XML

Author: michalpokusa

adafruit_templateengine.py

@@ -42,21 +42,6 @@
     del implementation
 
 
-class Language:  # pylint: disable=too-few-public-methods
-    """
-    Enum-like class that contains languages supported for escaping.
-    """
-
-    HTML = "html"
-    """HTML language"""
-
-    XML = "xml"
-    """XML language"""
-
-    MARKDOWN = "markdown"
-    """Markdown language"""
-
-
 class Token:  # pylint: disable=too-few-public-methods
     """Stores a token with its position in a template."""
 
@@ -201,59 +186,6 @@ def _replace_amp_or_semi(match: re.Match):
     )
 
 
-def safe_xml(value: Any) -> str:
-    """
-    Encodes unsafe symbols in ``value`` to XML entities and returns the string that can be safely
-    used in XML.
-
-    Example::
-
-        safe_xml('<a href="https://circuitpython.org/">CircuitPython</a>')
-        # &lt;a href=&quot;https://circuitpython.org/&quot;&gt;CircuitPython&lt;/a&gt;
-    """
-
-    return (
-        str(value)
-        .replace("&", "&amp;")
-        .replace('"', "&quot;")
-        .replace("'", "&apos;")
-        .replace("<", "&lt;")
-        .replace(">", "&gt;")
-    )
-
-
-def safe_markdown(value: Any) -> str:
-    """
-    Encodes unsafe symbols in ``value`` and returns the string that can be safely used in Markdown.
-
-    Example::
-
-        safe_markdown('[CircuitPython](https://circuitpython.org/)')
-        # \\[CircuitPython\\]\\(https://circuitpython.org/\\)
-    """
-
-    return (
-        str(value)
-        .replace("_", "\\_")
-        .replace("-", "\\-")
-        .replace("!", "\\!")
-        .replace("(", "\\(")
-        .replace(")", "\\)")
-        .replace("[", "\\[")
-        .replace("]", "\\]")
-        .replace("*", "\\*")
-        .replace("*", "\\*")
-        .replace("&", "\\&")
-        .replace("#", "\\#")
-        .replace("`", "\\`")
-        .replace("+", "\\+")
-        .replace("<", "\\<")
-        .replace(">", "\\>")
-        .replace("|", "\\|")
-        .replace("~", "\\~")
-    )
-
-
 _EXTENDS_PATTERN = re.compile(r"{% extends '.+?' %}|{% extends \".+?\" %}")
 _BLOCK_PATTERN = re.compile(r"{% block \w+? %}")
 _INCLUDE_PATTERN = re.compile(r"{% include '.+?' %}|{% include \".+?\" %}")
@@ -515,7 +447,6 @@ def _remove_matched_comment(template: str, comment_match: re.Match):
 
 def _create_template_rendering_function(  # pylint: disable=,too-many-locals,too-many-branches,too-many-statements
     template: str,
-    language: str = Language.HTML,
     *,
     trim_blocks: bool = True,
     lstrip_blocks: bool = True,
@@ -575,11 +506,11 @@ def _create_template_rendering_function(  # pylint: disable=,too-many-locals,too
             else:
                 autoescape = True
 
-            # Expression should be escaped with language-specific function
+            # Expression should be escaped
             if autoescape:
                 function_string += (
                     indent * indentation_level
-                    + f"yield safe_{language.lower()}({token.content[3:-3]})\n"
+                    + f"yield safe_html({token.content[3:-3]})\n"
                 )
             # Expression should not be escaped
             else:
@@ -761,22 +692,13 @@ class Template:
 
     _template_function: "Generator[str]"
 
-    def __init__(self, template_string: str, *, language: str = Language.HTML) -> None:
+    def __init__(self, template_string: str) -> None:
         """
         Creates a reusable template from the given template string.
 
-        For better performance, instantiate the template in global scope and reuse it as many times.
-        If memory is a concern, instantiate the template in a function or method that uses it.
-
-        By default, the template is rendered as HTML. To render it as XML or Markdown, use the
-        ``language`` parameter.
-
         :param str template_string: String containing the template to be rendered
-        :param str language: Language for autoescaping. Defaults to HTML
         """
-        self._template_function = _create_template_rendering_function(
-            template_string, language
-        )
+        self._template_function = _create_template_rendering_function(template_string)
 
     def render_iter(
         self, context: dict = None, *, chunk_size: int = None
@@ -826,26 +748,19 @@ class FileTemplate(Template):
     Class that loads a template from a file and allows to rendering it with different contexts.
     """
 
-    def __init__(self, template_path: str, *, language: str = Language.HTML) -> None:
+    def __init__(self, template_path: str) -> None:
         """
         Loads a file and creates a reusable template from its contents.
 
-        For better performance, instantiate the template in global scope and reuse it as many times.
-        If memory is a concern, instantiate the template in a function or method that uses it.
-
-        By default, the template is rendered as HTML. To render it as XML or Markdown, use the
-        ``language`` parameter.
-
         :param str template_path: Path to a file containing the template to be rendered
-        :param str language: Language for autoescaping. Defaults to HTML
         """
 
         if not _exists_and_is_file(template_path):
             raise TemplateNotFoundError(template_path)
 
         with open(template_path, "rt", encoding="utf-8") as template_file:
             template_string = template_file.read()
-        super().__init__(template_string, language=language)
+        super().__init__(template_string)
 
 
 _CACHE: "dict[int, Template| FileTemplate]" = {}
@@ -856,7 +771,6 @@ def render_string_iter(
     context: dict = None,
     *,
     chunk_size: int = None,
-    language: str = Language.HTML,
     cache: bool = True,
 ):
     """
@@ -866,7 +780,6 @@ def render_string_iter(
     :param dict context: Dictionary containing the context for the template
     :param int chunk_size: Size of the chunks to be yielded. If ``None``, the generator yields
         the template in chunks sized specifically for the given template
-    :param str language: Language for autoescaping. Defaults to HTML
     :param bool cache: When ``True``, the template is saved and reused on next calls.
 
     Example::
@@ -884,7 +797,7 @@ def render_string_iter(
             _CACHE[key].render_iter(context or {}, chunk_size), chunk_size
         )
 
-    template = Template(template_string, language=language)
+    template = Template(template_string)
 
     if cache:
         _CACHE[key] = template
@@ -898,15 +811,13 @@ def render_string(
     template_string: str,
     context: dict = None,
     *,
-    language: str = Language.HTML,
     cache: bool = True,
 ):
     """
     Creates a `Template` from the given ``template_string`` and renders it using the provided
     ``context``. Returns the rendered output as a string.
 
     :param dict context: Dictionary containing the context for the template
-    :param str language: Language for autoescaping. Defaults to HTML
     :param bool cache: When ``True``, the template is saved and reused on next calls.
 
     Example::
@@ -919,7 +830,7 @@ def render_string(
     if cache and key in _CACHE:
         return _CACHE[key].render(context or {})
 
-    template = Template(template_string, language=language)
+    template = Template(template_string)
 
     if cache:
         _CACHE[key] = template
@@ -932,7 +843,6 @@ def render_template_iter(
     context: dict = None,
     *,
     chunk_size: int = None,
-    language: str = Language.HTML,
     cache: bool = True,
 ):
     """
@@ -942,7 +852,6 @@ def render_template_iter(
     :param dict context: Dictionary containing the context for the template
     :param int chunk_size: Size of the chunks to be yielded. If ``None``, the generator yields
         the template in chunks sized specifically for the given template
-    :param str language: Language for autoescaping. Defaults to HTML
     :param bool cache: When ``True``, the template is saved and reused on next calls.
 
     Example::
@@ -960,7 +869,7 @@ def render_template_iter(
             _CACHE[key].render_iter(context or {}, chunk_size), chunk_size
         )
 
-    template = FileTemplate(template_path, language=language)
+    template = FileTemplate(template_path)
 
     if cache:
         _CACHE[key] = template
@@ -974,15 +883,13 @@ def render_template(
     template_path: str,
     context: dict = None,
     *,
-    language: str = Language.HTML,
     cache: bool = True,
 ):
     """
     Creates a `FileTemplate` from the given ``template_path`` and renders it using the provided
     ``context``. Returns the rendered output as a string.
 
     :param dict context: Dictionary containing the context for the template
-    :param str language: Language for autoescaping. Defaults to HTML
     :param bool cache: When ``True``, the template is saved and reused on next calls.
 
     Example::
@@ -996,7 +903,7 @@ def render_template(
     if cache and key in _CACHE:
         return _CACHE[key].render(context or {})
 
-    template = FileTemplate(template_path, language=language)
+    template = FileTemplate(template_path)
 
     if cache:
         _CACHE[key] = template

examples/autoescape.html

@@ -22,7 +22,7 @@
         This is a {{ "<b>bold text</b>" }}, because autoescaping is turned off in this block.
 
         {% autoescape on %}
-            And againg, this is not a {{ "<b>bold text</b>" }},
+            And again, this is not a {{ "<b>bold text</b>" }},
             because in this block autoescaping is turned on again.
         {% endautoescape %}
     {% endautoescape %}

examples/autoescape.md

@@ -2,12 +2,7 @@
 #
 # SPDX-License-Identifier: Unlicense
 
-from adafruit_templateengine import render_template, Language
+from adafruit_templateengine import render_template
 
-# By default autoescape is enabled for HTML
-print("HTML autoescape:")
+# By default autoescape is enabled for HTML entities
 print(render_template("./examples/autoescape.html"))
-
-# But XML and Markdown are also supported
-print("Markdown autoescape:")
-print(render_template("./examples/autoescape.md", language=Language.MARKDOWN))

examples/templateengine_autoescape.py

@@ -29,7 +29,6 @@ keywords = [
     "substitution",
     "web",
     "html",
-    "xml",
     "escaping",
     "syntax",
 ]