flasklet 0.3.0__tar.gz → 0.3.2__tar.gz

{flasklet-0.3.0 → flasklet-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: flasklet
-Version: 0.3.0
+Version: 0.3.2
 Summary: A few nice things for Flask
 Author: Marcel Kröker
 Author-email: Marcel Kröker <kroeker.marcel@gmail.com>

{flasklet-0.3.0 → flasklet-0.3.2}/flasklet/render/block.py

@@ -9,7 +9,7 @@ def render_block(
 	template_name: str,
 	block_name: str,
 	**context: Any,
-) -> Markup:
+) -> str:
 	"""
 	Render a specific block from a given template.
 

flasklet-0.3.2/flasklet/render/macro.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+import re
+from typing import TYPE_CHECKING, Any, cast
+
+from jinja2 import Template
+from jinja2.nodes import Macro, Name, Output, TemplateData
+from markupsafe import Markup
+
+if TYPE_CHECKING:
+	from jinja2.nodes import Expr
+
+from flasklet.render.jinja import load_jinja_env
+
+
+def _extract_macro_source(template_source: str, macro_name: str) -> str:
+	"""
+	Extracts the source code of a macro from the template source code.
+	"""
+
+	# Pattern to match the macro definition, including parameters and content
+	macro_pattern = re.compile(
+		r"{%\s*macro\s+"
+		+ re.escape(macro_name)
+		+ r"\s*\((.*?)\)\s*%}(.*?)"
+		+ r"{%\s*endmacro\s*%}",
+		re.DOTALL,
+	)
+
+	if not (match := macro_pattern.search(template_source)):
+		msg = f"Macro '{macro_name}' not found in template."
+		raise ValueError(msg)
+
+	# Return macro source code, including the {% macro %} and {% endmacro %} lines
+	return match.group(0)
+
+
+def _flatten_macro_source_nodes(nodes: list[Expr]) -> str:
+	"""Flattens the nodes of a macro's body into a single string of source code."""
+	res = ""
+	for node in nodes:
+		if isinstance(node, TemplateData):
+			res += node.data
+		elif isinstance(node, Name):
+			res += r"{{ " + node.name + r" }}"
+		else:
+			msg = f"Unsupported node type: {type(node)}"
+			raise TypeError(msg)
+	return res
+
+
+def render_macro_unsafe(template_name: str, macro_name: str, **kwargs: Any) -> str:
+	"""
+	Render a specific macro from a given template.
+	It returns unescaped HTML, meaning that it is not safe to use with user input.
+	"""
+	env, env_loader = load_jinja_env()
+
+	template_source, _, _ = env_loader.get_source(env, template_name)
+	parsed_template = env.parse(template_source)
+	macros = parsed_template.find_all(Macro)
+
+	if not (macro := next((m for m in macros if m.name == macro_name), None)):
+		msg = f"Macro {macro_name} not found in template {template_name}"
+		raise ValueError(msg)
+
+	macro_source = _flatten_macro_source_nodes(cast("Output", macro.body[0]).nodes)
+
+	return Template(macro_source).render(**kwargs, g=env.globals)
+
+
+def render_macro(template_name: str, macro_name: str, **kwargs: Any) -> str:
+	"""
+	Render a specific macro from a given template.
+	"""
+	env, env_loader = load_jinja_env()
+
+	# Load the template source code
+	template_source, _, _ = env_loader.get_source(env, template_name)
+
+	# Extract the macro source code
+	macro_source = _extract_macro_source(template_source, macro_name)
+
+	# Create a new template that includes the macro and calls it
+	macro_call_template_source = macro_source + "\n{{ " + macro_name + "()" + " }}"
+
+	# Compile the new template
+	macro_template = env.from_string(macro_call_template_source)
+
+	# Render the template with the provided arguments
+	rendered = macro_template.render(**kwargs)
+
+	# Return the rendered macro content
+	return Markup(rendered)  # noqa: S704

{flasklet-0.3.0 → flasklet-0.3.2}/flasklet/render/partial.py

@@ -4,7 +4,7 @@ from flask import render_template
 from markupsafe import Markup
 
 
-def render_partial(template_name: str, **context: Any) -> Markup:
+def render_partial(template_name: str, **context: Any) -> str:
 	"""
 	Render a full template as safe markup, for embedding inside another template.
 

{flasklet-0.3.0 → flasklet-0.3.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "flasklet"
-version = "0.3.0"
+version = "0.3.2"
 description = "A few nice things for Flask"
 readme = "README.md"
 authors = [{ name = "Marcel Kröker", email = "kroeker.marcel@gmail.com" }]

flasklet-0.3.0/flasklet/render/macro.py

@@ -1,108 +0,0 @@
-from typing import Any
-
-from jinja2 import Template
-from markupsafe import Markup
-
-from flasklet.render.jinja import load_jinja_env
-
-
-def _get_macro(template: Template, macro_name: str, template_name: str) -> Any:
-	"""Look up a callable macro on a compiled template, or raise if absent."""
-	macro = getattr(template.module, macro_name, None)
-	if not callable(macro):
-		msg = f"Macro {macro_name!r} not found in template {template_name!r}"
-		raise TypeError(msg)
-	return macro
-
-
-def render_macro(template_name: str, macro_name: str, **kwargs: Any) -> Markup:
-	"""
-	Render a single macro from a template, calling it with the given arguments.
-
-	The macro is looked up on the compiled template's module and called with
-	`**kwargs` as its parameters, so all Jinja features (filters, expressions,
-	control flow, autoescaping) behave exactly as they do in normal rendering.
-	Values interpolated inside the macro are HTML-escaped, so this is safe to
-	call with untrusted `**kwargs`.
-
-	Args:
-		template_name: Name of the template that defines the macro.
-		macro_name: Name of the macro to call.
-		**kwargs: Arguments passed to the macro's parameters.
-
-	Returns:
-		The rendered macro output as safe `Markup`.
-
-	Raises:
-		ValueError: If the template has no macro named `macro_name`.
-
-	Example:
-		Template "components/button.html":
-
-		```jinja
-		{% macro button(label, kind="primary") %}
-			<button class="{{ kind }}">{{ label }}</button>
-		{% endmacro %}
-		```
-
-		In Python:
-
-		>>> render_macro("components/button.html", "button", label="Save")
-		Markup('<button class="primary">Save</button>')
-
-		In a Jinja template:
-
-		```jinja
-		{{ render_macro("components/button.html", "button", label="Save") }}
-		```
-	"""
-	env, _ = load_jinja_env()
-
-	macro = _get_macro(env.get_template(template_name), macro_name, template_name)
-
-	return Markup(macro(**kwargs))  # noqa: S704
-
-
-def render_macro_unsafe(template_name: str, macro_name: str, **kwargs: Any) -> Markup:
-	"""
-	Render a single macro with autoescaping disabled.
-
-	Like `render_macro`, but values interpolated inside the macro are NOT
-	HTML-escaped, so the macro can emit raw markup passed in via `**kwargs`. The
-	result is still returned as `Markup` so it embeds into a parent template
-	without being re-escaped.
-
-	Because interpolated values are not escaped, this is unsafe to call with
-	untrusted `**kwargs`. Prefer `render_macro` unless you specifically need to
-	pass through trusted HTML.
-
-	Args:
-		template_name: Name of the template that defines the macro.
-		macro_name: Name of the macro to call.
-		**kwargs: Arguments passed to the macro's parameters.
-
-	Returns:
-		The rendered macro output as `Markup`, with its contents left unescaped.
-
-	Raises:
-		ValueError: If the template has no macro named `macro_name`.
-
-	Example:
-		Template "components/raw.html":
-
-		```jinja
-		{% macro raw(html) %}<div>{{ html }}</div>{% endmacro %}
-		```
-
-		In Python:
-
-		>>> render_macro_unsafe("components/raw.html", "raw", html="<b>hi</b>")
-		Markup('<div><b>hi</b></div>')
-	"""
-	env, env_loader = load_jinja_env()
-
-	source, _, _ = env_loader.get_source(env, template_name)
-	unsafe_template = env.overlay(autoescape=False).from_string(source)
-	macro = _get_macro(unsafe_template, macro_name, template_name)
-
-	return Markup(macro(**kwargs))  # noqa: S704