实现模板引擎

模板引擎是wap开发的一大利器,方便我们生成复杂的动态页面。我们学习一下如何用Python实现一个模板引擎

一、目标分析

首先,我们需要明白我们的模板引擎需要干什么。观察下方的HTML,其中不仅包含原生的HTML元素,还包含一些其它的标签({{ }}{%%})。开发者通过使用这些符号,实现将动态的数据片段嵌入其中。这些符号在很多模板引擎中都是差不多的。

<!DOCTYPE html>
<html>
<head>
    <meta charset='utf-8'>
    <title>{{ obj.title }}</title>
</head>
<body>
    {# Hello world #}
    <div class="content">
        <p> {{ obj.content }} </p>
        
        <table>
            {% for value in obj.list %}
                <td> {{ value }} </td>
            {% endfor %}
        </table>
        
        {% if obj.show %}
            <p> {{ obj.foot }} </p>
        {% endif %}        
    </div>
</body>
</html>

而我们的模板引擎就是负责将这些静态模板结合上下文来生成一个纯HTML的字符串。模板引擎的任务就是翻译模板,使用上下文中提供的动态数据替换这些代码片段。
举个栗子,如果我们提供如下的上下文给模板引擎去翻译上面的HTML页面

context = {"obj": {"title":"这是标题","content":"这是内容","foot":"这是页脚","list":["td1","td2","td3","td5"],"show":"True"}}

那么它的翻译结果应该是这样

<!DOCTYPE html>
<html>
<head>
    <meta charset='utf-8'>
    <title>这是标题</title>
</head>
<body>
    <div class="content">
        <p> 这是内容 </p>
        <table>
                <td> td1 </td>
                <td> td2 </td>
                <td> td3 </td>
                <td> td5 </td>
        </table>
            <p> 这是页脚 </p>
    </div>
</body>
</html>

二、实现方法

那么问题就来了,我们怎么让我们的Python去认识,分析这些片段呢?
有两个主要的选择:一是向Django的模板引擎那样,通过解析HTML产生一个数据结构表示模板的结构,然后遍历那个数据结构,基于找到的指令装配结果文本,二是将原始HTML解析成某种形式的可直接执行的代码,然后执行代码就能产生结果。
我们将要实现的引擎就是将模板编译成Python代码。只需要提供所需的上下文并执行编译后的代码,即可获得所需的渲染后的HTML。
先观察一下将上面的HTML编译后的Python代码

def render_function(context, do_dots):
    c_obj = context['obj']
    result = []
    append_result = result.append
    extend_result = result.extend
    to_str = str
    extend_result(["\n<!DOCTYPE html>\n<html>\n<head>\n    <meta charset='utf-8'>\n    <title>",to_str(do_dots(c_obj, 'title')),'</title>\n</head>\n<body>\n    ','\n    <div class="content">\n        <p> ',to_str(do_dots(c_obj, 'content')),' </p>\n        \n        <table>\n            '])
    for c_value in do_dots(c_obj, 'list'):
        extend_result(['\n                <td> ',to_str(c_value),' </td>\n            '])
    append_result('\n        </table>\n        \n        ')
    if do_dots(c_obj, 'show'):
        extend_result(['\n            <p> ',to_str(do_dots(c_obj, 'foot')),' </p>\n        '])
    append_result('        \n    </div>\n</body>\n</html>\n')
    return ''.join(result)

观察一下上面的Python代码,我们的模板引擎将HTML编译成了一个函数。执行函数,就能生成我们所需要的完整HTML了。

三、模板引擎

现在我们的目标明确了。就是去解析HTML元素,编译成一个Python函数。
先做点简单的,我们需要构造一个方法用于生成格式化的Python代码,最主要的是管理Python中的缩进和换行

class CodeBuilder(object):
    """一个简单的 Python 代码生成器"""

    def __init__(self, indent=0):
        # CodeBuilder生成的所有代码片段都存储在该列表中
        self.code = []
        # 生成的代码的缩进等级
        self.indent_level = indent

    def __str__(self):
        """返回完整的Python代码"""
        return "".join(str(c) for c in self.code)

    def add_line(self, line):
        """将代码行添加到生成器中"""
        # 构造器主要为我们做了三个工作
        # 1、缩进
        # 2、原始代码的添加
        # 3、换行处理
        self.code.extend([" "*self.indent_level, line, "\n"])

    def add_section(self):
        """添加一个代码组"""
        section = CodeBuilder(self.indent_level)
        self.code.append(section)
        return section

    INDENT_STEP = 4

    def indent(self):
        """增加缩进"""
        self.indent_level += self.INDENT_STEP

    def dedent(self):
        """减小缩进"""
        self.indent_level -= self.INDENT_STEP

    def get_globals(self):
        """执行代码,并且返回它定义的全局变量字典"""
        assert self.indent_level == 0

        python_source = str(self)

        global_namespace = {}
        exec(python_source, global_namespace)

        return global_namespace

有了上面的代码生成器,我们可以很方便的添加Python代码了。

# 初始化一个构造器
code = CodeBuilder()
# 添加函数名和参数
code.add_line("def render_function(context, do_dots):")
# 添加一个缩进
code.indent()
# 继续添加后面的代码
code.add_line("result = []")
code.add_line("append_result = result.append")
code.add_line("extend_result = result.extend")
code.add_line("to_str = str")

未完待续...
我们的最核心模板类:

class Templite(object):

    def __init__(self, text, *contexts):

        # 存储所有的上下文
        self.context = {}
        for context in contexts:
            self.context.update(context)

        self.all_vars = set()
        self.loop_vars = set()

        code = CodeBuilder()

        code.add_line("def render_function(context, do_dots):")
        code.indent()

        vars_code = code.add_section()
        code.add_line("result = []")
        code.add_line("append_result = result.append")
        code.add_line("extend_result = result.extend")
        code.add_line("to_str = str")


        buffered = []
        def flush_output():
            if len(buffered) == 1:
                code.add_line("append_result(%s)" % buffered[0])
            elif len(buffered) > 1:
                code.add_line("extend_result([%s])" % ",".join(buffered))
            del buffered[:]

        ops_stack = []

        # 使用正则表达式分割数据
        tokens = re.split(r"(?s)({{.*?}}|{%.*?%}|{#.*?#})", text)
        for token in tokens:
            if token.startswith("{#"):
                # 模板中的注释部分
                continue
            elif token.startswith("{{"):
                # 处理模板中的变量部分
                expr = self._expr_code(token[2:-2].strip())
                buffered.append("to_str(%s)" % expr)
            elif token.startswith("{%"):
                flush_output()
                words = token[2:-2].strip().split()
                if words[0] == 'if':
                    if len(words) != 2:
                        self._syntax_error("Don't understand if", token)
                    ops_stack.append('if')
                    code.add_line("if %s:" % self._expr_code(words[1]))
                    code.indent()
                elif words[0] == 'for':
                    if len(words) != 4 or words[2] != 'in':
                        self._syntax_error("Don't understand for", token)
                    ops_stack.append('for')
                    self._variable(words[1], self.loop_vars)
                    code.add_line("for c_%s in %s:" % (words[1],self._expr_code(words[3])))
                    code.indent()
                elif words[0].startswith('end'):
                    if len(words) != 1:
                        self._syntax_error("Don't understand end", token)
                    end_what = words[0][3:]
                    if not ops_stack:
                        self._syntax_error("Too many ends", token)
                    start_what = ops_stack.pop()
                    if start_what != end_what:
                        self._syntax_error("Mismatched end tag", end_what)
                    code.dedent()
                else:
                    self._syntax_error("Don't understand tag", words[0])
            else:
                if token:
                    buffered.append(repr(token))
        if ops_stack:
            self._syntax_error("Unmatched action tag", ops_stack[-1])

        flush_output()

        for var_name in self.all_vars - self.loop_vars:
            vars_code.add_line("c_%s = context[%r]" % (var_name, var_name))

        code.add_line("return ''.join(result)")
        code.dedent()
        print(str(code))
        self._render_function = code.get_globals()['render_function']

    def _expr_code(self, expr):
        """将expr转换成Python表达式"""
        if "|" in expr:
            # 表达式中有过滤管道
            pipes = expr.split("|")
            code = self._expr_code(pipes[0])
            # 取出所有的过滤函数,依次生成执行语句
            for func in pipes[1:]:
                self._variable(func, self.all_vars)
                code = "c_%s(%s)" % (func, code)
        elif "." in expr:
            dots = expr.split(".")
            code = self._expr_code(dots[0])
            args = ",".join(repr(d) for d in dots[1:])
            code = "do_dots(%s, %s)" % (code, args)
        else:
            self._variable(expr, self.all_vars)
            code = "c_%s" % expr
        return code

    def _syntax_error(self, msg, thing):
        raise  TempliteSyntaxError("%s: %r" % (msg, thing))


    def _variable(self, name, vars_set):
        """Track that 'name' is used as a variable.
        Adds the name to 'vars_set', a set of variable names.
        Raises an syntax error if 'name' is not a valid name."""
        if not re.match(r"[_a-zA-Z][_a-zA-Z0-9]*$", name):
            self._syntax_error("Not a valid name", name)
        vars_set.add(name)


    def render(self, context=None):
        render_context = dict(self.context)
        if context:
            render_context.update(context)
        return self._render_function(render_context, self._do_dots)

    def _do_dots(self, value, *dots):
        for dot in dots:
            try:
                value = getattr(value, dot)
            except AttributeError:
                value = value[dot]
            if callable(value):
                value = value()
        return value

以上的内容主要参考了500lines这个项目中的template-engine部分,关于更详细的内容分析可以阅读下方的参考文章。同时也极力推荐500lines这个项目,使用最精简的代码让我们能学习很多有意思的东西。
参考文章
源码地址

推荐阅读更多精彩内容