Ce modèle de méta-programmation d'exécution en Python est intéressant

Arrière-plan

Je travaille actuellement sur un framework d'interface utilisateur construit sur Pyodide, appelé Zenaura. Récemment, j'ai remarqué que l'interface du constructeur – la principale façon dont les utilisateurs créent des éléments d'interface utilisateur – était un peu trop complexe et peu attrayante. Bien qu'il fasse abstraction de l'interface sous-jacente, plus lourde, pour interagir avec la structure de données virtuelle DOM "Node" de Zenaura, cela n'était toujours pas satisfaisant. Je voulais simplifier les choses et offrir aux utilisateurs une expérience plus propre et plus intuitive, tout en jetant les bases du développement potentiel d'un compilateur pour une syntaxe complètement nouvelle. Quelque chose comme ça :

div(attr1=val1, child1, child2, child3)

Énoncé du problème

L'interface actuelle du constructeur est de trop bas niveau et peu conviviale. Les utilisateurs ne devraient pas avoir à interagir avec quelque chose comme ceci :

builder = Builder(name__)
if children:
    builder.with_children(*children)
if attributes:
    builder.with_attributes(**attributes)
if text:
    builder.with_text(text)
# print("data", builder.node.children, builder.node.attributes)
return builder.build()

Au lieu de cela, ils devraient pouvoir utiliser une syntaxe plus propre et plus lisible comme :

div(id="some-id", h1("text"), p("text"))

En regardant la documentation MDN, il y a 91 balises HTML, avec possibilité d'ajouts ou de dépréciations. J'ai d'abord envisagé de générer dynamiquement le code pour simplifier ce processus, mais même si cela fonctionne, ce n'est pas la solution la plus pratique. L'objectif principal était d'afficher des docstrings chaque fois qu'un utilisateur appelle une fonction, mais l'approche générée dynamiquement introduit certains défis, tels qu'un manque d'auto-complétion.

L'approche dynamique

Voici le code généré dynamiquement que j'ai expérimenté :

tag_config = {
    # root elements
    "html": "nestable",
    "main": "nestable",
    "body": "nestable",
}

tags_factory = {
    "nestable": lambda name__: f"""
{name__} = partial(nestable, "{name__}")
{name__}.__doc__ = nestable.__doc__
""",
    "textable": lambda name__: f"""
{name__} = partial(textable, "{name__}")
""",
    "self_closing": lambda name__: f"""
{name__} = partial(self_closing, "{name__}")
""",
    "nestable_no_attrs": lambda name__: f"""
{name__} = partial(nestable_no_attrs, "{name__}")
"""
}

for k, v in tag_config.items():
    exec(tags_factory[v](k), globals())

Cela fonctionne bien en termes de fonctionnalité mais manque de convivialité. Le principal inconvénient est l’absence de saisie semi-automatique, puisque le code est injecté au moment de l’exécution. Cependant, les balises HTML elles-mêmes sont relativement simples, ce n'est donc pas vraiment un problème pour le moment.

Avantages et limites

L'un des avantages significatifs de cette approche est la flexibilité. Prendre en charge ou déprécier un élément HTML dans Zenaura est aussi simple que d'ajouter ou de supprimer une paire clé-valeur du dictionnaire tag_config. C'est un moyen simple de s'adapter aux modifications des balises HTML au fil du temps.

De plus, les seules limitations concernent la saisie semi-automatique et l'affichage des chaînes de documentation aux utilisateurs. Je pense que c'est un compromis à faire car les éléments HTML sont assez basiques.

Cependant, le compromis se présente sous la forme d'une convivialité : sans la saisie semi-automatique, les utilisateurs peuvent être confrontés à des difficultés lorsqu'ils interagissent avec l'interface. Cela dit, je pense que c'est un bon point de départ pour expérimenter de nouvelles façons de gérer les éléments de balise dans Zenaura.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!