Plim 中文文档¶

行内标识符（Line Indicator）¶

|

管道符告诉 Plim 只需要复制整行即可，不需要做任何转换。

,

逗号告诉 Plim 复制整行（与管道符类似），但是在行尾添加一个空格字符。

注解

在 Slim 中对应的是单引号（'）。

-

横线表示控制模块，包括循环、条件、mako 标签以及扩展。

=

等号表示 Python 调用，并会将代码的输出添加到 HTML 输出缓冲区中。

=,

与等号类似，但是会在 Python 代码的输出后添加一个空格字符。

==

与等号类似，但是会在输出为 mako 时添加 ‘过滤器 “n” <http://docs.makotemplates.org/en/latest/filtering.html>`_ 。

== python_expression                       =>      ${python_expression|n}

== python_expression | custom_filter       =>      ${python_expression |n,custom_filter}

==,

和 == 类似，但是会在 Python 表达式的结尾添加空格字符。

/

正斜线用于代码注释，其后的任何内容都不会输出到 Mako 模板中。

注解

Slim 中的 “/!” HTML 注释并没有对应的 Plim 写法 ，这是因为 Plim 现在已经支持原生的 HTML 标记，无需多余的控制语法。

/ You can use raw HTML comment tags, as well as all other tags
<!-- HTML comment -->
<div>

  / You can use Plim markup inside the raw HTML
  a href="#" = link.title

/ If you use raw HTML, you have to close all tags manually
</div>

缩进¶

Plim 缩进规则和 Slim 类似：缩进很重要，但是并不需要像 Haml 那样严格，你尽可以在代码中使用 2 空格、5 空格缩进。实际上只需要提供 1 个以上的空格即符合 Plim 的语法。

标签属性¶

input type='text' name="username" value='''Max Power''' maxlength="""32"""

<input type="text" name="username" value="Max Power" maxlength="32"/>

input value='It\'s simple'
input value="It's simple"
input value='''It's simple'''
input value="""It's simple"""

input value="He said \"All right!\""
input value='He said "All right!"'
input value='''He said "All right!"'''
input value="""He said "All right!\""""

input type='text' name="measure" value=+.97 maxlength=32

<input type="text" name="measure" value="+.97" maxlength="32"/>

<input type="text" name="username" value="${user.name}" maxlength="32"/>
<a href="${request.route_url('user_profile', tagname=user.login, _scheme='https')}"></a>

/ Static boolean attribute "disabled"
input type="text" name="username" disabled="disabled"

/ If you wrap your attributes with parentheses, you can use
  shortcut form
input (type="text" name="username" disabled)

/ Dynamic boolean attribute "disabled"
  will be evaluated to 'disabled="disabled"' if `is_disabled`
  evaluates to True

input type="text" name="username" disabled=${is_disabled}?

/ or you can write it that way
input type="text" name="username" disabled=is_disabled?

/ or even that way
input type="text" name="username" disabled=(is_disabled or
                                            is_really_disabled)?

attrs = {
    'id': 'navbar-1',
    'class': 'navbar',
    'href': '#',
    'data-context': 'same-frame',
}

a**attrs Link

<a id="navbar-1" class="navbar" href="#" data-context="same-frame">Link</a>

a **attrs|Link

a **attrs **more_attrs Link

a(**attrs disabled) Disabled Link

a **function_returning_dict(
  *args, **kwargs
) Link

Attribute Wrapping¶

你可以是用圆括号 () 包裹标签属性。但和 Slim 不同的是，Plim 并不支持方括号 [] 和花括号 {} 用作属性封装。

body
  h1(id="logo" class="small tagline") = page_logo
  h2 id=(id_from_variable + '-idx') = page_tagline

使用属性包裹后，属性赋值将支持跨行：

body

  h1 (id="logo"
    class="small tagline") = page_logo

  h2 id=(
    id_from_variable +
    '-idx'
  ) = page_tagline

单行标签内容¶

你可以将标签中的内容与标签写在同一行：

body
  h1 id="headline" Welcome to my site.

也可以使用缩进嵌套。注意：需要使用管道符或者 隐式文本标识（Implicit literal indicators）

body
  h1 id="headline"

    / Explicit literal with pipe character
    | Welcome to my site.

    / Implicit literal (uppercase letter at the beginning of the line)
    Yes, Welcome to my site

动态标签内容¶

你可以在同一行调用动态属性

body
  h1 id="headline" = page_headline

或者缩进：

body
  h1 id="headline"
    = page_headline

id 和 class 的简易写法¶

你可以使用下面的格式设置标签的 id 和 class 属性：

body

  / Static shortcuts
  h1#headline
    = page_headline
  h2#tagline.small.tagline
    = page_tagline
  .content
    = show_content

与下面的写法等价：

body
  h1 id="headline"
    = page_headline
  h2 id="tagline" class="small tagline"
    = page_tagline
  div class="content"
    = show_content

与 Slim 不同 的是，Plim 支持在这种简写中混合动态表达式：

/ Dynamic shortcuts
h1#headline-${'dynamic'} = page_headline
h2#${tagline.id}.small-${tagline.cls}.${tagline.other_cls}
  = page_tagline
.${'content'}
  = show_content

与下面的写法等价：

h1 id="headline-${'dynamic'}" = page_headline
h2 id="${tagline.id}" class="small-${tagline.cls} ${tagline.other_cls}"
  = page_tagline
div class="${'content'}"
  = show_content

行内标签¶

你可能会希望这样更简洁的行内标签支持：

ul
  li.first: a href="/a" A link
  li: a href="/b" B link

别忘了，还可以使用圆括号增加代码的可读性：

ul
  li.first: a(href="/a") A link
  li: a(href="/b") B link

行内状态（Inline Statement）¶

Python 循环和条件表达式的单行写法和 HTML 标签类似：

ul: -for link in ['About', 'Blog', 'Sitemap']: li: a href=route_to(link) = link

将会输出：

<ul>
%for link in ['About', 'Blog', 'Sitemap']:
<li><a href="${route_to(link)}">${link}</a></li>
%endfor
</ul>

Python 代码与纯文本混合¶

使用标准 Mako 表达式语法 。文本的解析方式决定于 Mako 默认过滤器的设置 。

body
  h1 Welcome ${current_user.name} to the show.
  Explicit non-escaped ${content|n} is also possible.

目前，Mako 并没有提供一种简单的其嵌入表达式的渲染方法（比如原样输出）。你可以使用 <%text> 标签（或者 Plim -text 标记）或者下面的取巧办法：

body
  h1 Welcome ${'${current_user.name}'} to the show.

嵌入的标记¶

你可以在隐式文本块中嵌入 Plim 标记：

a href="#" Embedded `strong string` everywhere

将输出：

<a href="#">Embedded <strong>string</strong> everywhere</a>

如果你想要紧接着使用两个嵌入标记，需要在第一个嵌入标记后跟上一个下划线 _：

a href="#" Embedded `strong string`_`i s` everywhere

将输出：

<a href="#">Embedded <strong>string</strong><i>s</i> everywhere</a>

这种嵌入机制可迭代，也就是说你可以在嵌入标记中使用嵌入标记：

Another `a href="#" very ``strong funny ````i recursive``````` test

将输出：

Another <a href="#">very <strong>funny <i>recursive</i></strong></a> test

停用 HTML 转义¶

使用双等号：

body
  h1 id="headline"
    == page_headline

或者在表达式的结尾添加 | n 过滤器：

body
  h1 id="headline"
    = page_headline | n

代码注释¶

使用正斜线 / 标记代码中的注释：

body
  p
    / This is a comment.
      Indentation is the natural way to get block comments

原生 HTML 标签¶

在 Plim 中你可以使用原生的 HTML 标签，也可以和所有逻辑控制模块混合使用，在下面的情况中非常实用：

- if edit_profile
  / Wrap interface with editable block
  <div id="edit-profile">

- include new_or_edit_interface.html

- if edit_profile
  / close wrapper tag
  </div>

Doctype 声明¶

Plim 并不提供默认的 doctype 声明，因此你需要指定 HTML 的 doctype

doctype 5

可用的 HTML doctype 包括：

doctype html

<!DOCTYPE html>

doctype 5

<!DOCTYPE html>

doctype 1.1

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">

doctype strict

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

doctype xml

<?xml version="1.0" encoding="utf-8" ?>

doctype transitional

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

doctype frameset

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd">

doctype basic

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML Basic 1.1//EN" "http://www.w3.org/TR/xhtml-basic/xhtml-basic11.dtd">

doctype mobile

<!DOCTYPE html PUBLIC "-//WAPFORUM//DTD XHTML Mobile 1.2//EN" "http://www.openmobilealliance.org/tech/DTD/xhtml-mobile12.dtd">

逻辑控制¶

-if items
  table
    -for item in items
      tr
        td = item.name
        td = item.price
-elif show_empty
  p No items found
-else
  a href=request.route_url('items.add') =, _('Add items')

-unless user.authenticated
  p Please, sign in.
-else
  p Welcome, ${user.name}!

table
  -for item in items
    tr
      td = item.name
      td = item.price

-python
  i = 0
  limit = 5

ul
  -while i < limit
    li#idx-${i}.up: a href='#' title="Title" == i
    -py i += 1

-until i < 0
  li#idx-${i}.down-${i}: a href='''#''' title="""Title""" ==, i
  -py i -= 1

-with <EXPR> as <VAR>
  / Do some stuff

- try
  div = item[0]
  div = price['usd']

- except IndexError
  div IndexError

- except KeyError as e
  div = e

- if not len(records)
  No records found.
  -return

- if not len(records)
  No records found.
  -py return

文本块¶

你可以定义显式或者隐式的文本块，区别在于以 | 显式声明符还是隐式声明符开头。

body
  p
    / Explicit literal
    | This is a test of the text block.

body
  p
    |
      This is a test of the text block.

<body><p>This is a test of the text block.</p></body>

body
  p
    |  This line is on the zero left margin.
        This line will have one space in front of it.
          This line will have two spaces in front of it.
            And so on...

p
  | pipe is the explicit literal indicator. It is required if your line starts with
    the non-literal character.

p
  I'm the implicit literal, because my first letter is in uppercase.

p
  1. Digits
  2. are
  3. the
  4. implicit
  5. literals
  6. too.

p
  ${raw_mako_expression} indicates the implicit literal line.

p
  If subsequent lines do not start with implicit literal indicator,
    you must indent them
  | or you can use the "explicit" pipe.

p
  если ваш блок текста написан на русском, или любом другом языке, не
  использующим символы из ASCII-диапазона, то вам даже не обязательно
  использовать заглавную букву в начале блока.

  / if your literal blocks are written in Russian, or any other
    language which uses non-ASCII letters, you can put even the
    lowercase letter at the beginning of the block

Python 代码块¶

- python x = 1

-py
    x = 1

- python x = 1
    y = x + 1
    if True:
        y += 1
    else:
        y -= 1

--- x = 1

-------------
    x = 1

--- x = 1
    y = x + 1
    if True:
        y += 1
    else:
        y -= 1

ul#userlist
    ---------- # prepare a list of users ---------------
        users = UsersService.get_many(max=100, offset=0)
        friends = UsersService.get_friends_for(users)
    ----------------------------------------------------
    -for user in users: li
        h4: a#user-${user.id} href='#' = user.name
        ul: -for friend in friends[user.id]: li
            a#friend-${friend.id} href='#' = friend.name

<ul id="userlist">
    <%
        # prepare a list of users
        users = UsersService.get_many(max=100, offset=0)
        friends = UsersService.get_friends_for(users)
    %>

    %for user in users:
        <li>
            <h4>
                <a href="#" id="user-${user.id}">${user.name}</a>
            </h4>
            <ul>
                %for friend in friends[user.id]:
                    <li>
                        <a href="#" id="friend-${friend.id}">${friend.name}</a>
                    </li>
                %endfor
            </ul>
        </li>
    %endfor
</ul>

模块级 Block¶

使用 -py! 或者 -python! 代替 <%! %> mako 标签 。

-py!
    import mylib
    import re

    def filter(text):
        return re.sub(r'^@', '', text)

---! import mylib
     import re

     def filter(text):
         return re.sub(r'^@', '', text)

Mako 标签¶

Plim supports a complete set of Mako Tags, except the <%doc>. The latter has been considered deprecated, since Plim itself has built-in support of multi-line comments.

-page args="x, y, z='default'"

<%page args="x, y, z='default'"/>

-include footer.html

-include file="footer.html"

<%include file="footer.html"/>

-inherit base.html

-inherit file="base.html"

<%inherit file="base.html"/>

-namespace name="helper" helpers.html

-namespace file="helpers.html" name="helper"

<%namespace file="helpers.html" name="helper"/>

-def account(accountname, type='regular')

-def name="account(accountname, type='regular')"

<%def name="account(accountname, type='regular')">
</%def>

-block
  This is an anonymous block.

-block name="post_prose"
  = pageargs['post'].content

-block post_prose
  = pageargs['post'].content

<%block name="post_prose">
${pageargs['post'].content}</%block>

- block filter="h"
  html this is some escaped html.

-call expression="${4==4}" self:conditional
  |i'm the result

- call expression=${4==4} self:conditional
  | i'm the result

- call self:conditional
  | i'm the result

- call self:conditional

<%self:conditional expression="${4==4}">
i'm the result
</%self:conditional>

<%self:conditional expression="${4==4}">
i'm the result
</%self:conditional>

<%self:conditional>
i'm the result
</%self:conditional>

<%self:conditional>
</%self:conditional>

-text filter="h"
  here's some fake mako ${syntax}
  <%def name="x()">${x}</%def>

- text filter="h" here's some fake mako ${syntax}
  <%def name="x()">${x}</%def>

- text filter="h" = syntax
  <%def name="x()">${x}</%def>

-text
  here's some fake mako ${syntax}
  <%def name="x()">${x}</%def>

-text , here's some fake mako ${syntax}
  <%def name="x()">${x}</%def>

标准扩展¶

- coffee
  # Assignment:
  number   = 42
  opposite = true

  # Conditions:
  number = -42 if opposite

  # Functions:
  square = (x) -> x * x

  # Arrays:
  list = [1, 2, 3, 4, 5]

  # Objects:
  math =
    root:   Math.sqrt
    square: square
    cube:   (x) -> x * square x

  # Splats:
  race = (winner, runners...) ->
    print winner, runners

  # Existence:
  alert "I knew it!" if elvis?

  # Array comprehensions:
  cubes = (math.cube num for num in list)

- scss
  @option compress: no;
  .selector {
    a {
      display: block;
    }
    strong {
      color: blue;
    }
  }

<style>.selector a {
  display: block;
}
.selector strong {
  color: #00f;
}</style>

- stylus
  @import 'nib'
  body
    background: linear-gradient(top, white, black)

  border-radius()
    -webkit-border-radius arguments
    -moz-border-radius arguments
    border-radius arguments

  a.button
    border-radius 5px

<style>body {
  background: -webkit-gradient(linear, left top, left bottom, color-stop(0, #fff), color-stop(1, #000));
  background: -webkit-linear-gradient(top, #fff 0%, #000 100%);
  background: -moz-linear-gradient(top, #fff 0%, #000 100%);
  background: -o-linear-gradient(top, #fff 0%, #000 100%);
  background: -ms-linear-gradient(top, #fff 0%, #000 100%);
  background: linear-gradient(top, #fff 0%, #000 100%);
}
a.button {
  -webkit-border-radius: 5px;
  -moz-border-radius: 5px;
  border-radius: 5px;
}</style>

- markdown
  A First Level Header
  ====================

  A Second Level Header
  ---------------------

  Now is the time for all good men to come to
  the aid of their country. This is just a
  regular paragraph.

  The quick brown fox jumped over the lazy
  dog's back.

  ### Header 3

  > This is a blockquote.
  >
  > This is the second paragraph in the blockquote.
  >
  > ## This is an H2 in a blockquote

<h1>A First Level Header</h1>

<h2>A Second Level Header</h2>

<p>Now is the time for all good men to come to
the aid of their country. This is just a
regular paragraph.</p>

<p>The quick brown fox jumped over the lazy
dog's back.</p>

<h3>Header 3</h3>

<blockquote>
    <p>This is a blockquote.</p>

    <p>This is the second paragraph in the blockquote.</p>

    <h2>This is an H2 in a blockquote</h2>
</blockquote>

- rest
  Grid table:

  +------------+------------+-----------+
  | Header 1   | Header 2   | Header 3  |
  +============+============+===========+
  | body row 1 | column 2   | column 3  |
  +------------+------------+-----------+
  | body row 2 | Cells may span columns.|
  +------------+------------+-----------+
  | body row 3 | Cells may  | - Cells   |
  +------------+ span rows. | - contain |
  | body row 4 |            | - blocks. |
  +------------+------------+-----------+

<p>Grid table:</p>
<table border="1">
  <thead valign="bottom">
    <tr>
      <th>Header 1
      </th><th>Header 2
      </th><th>Header 3
    </th></tr>
  </thead>
  <tbody valign="top">
    <tr>
      <td>body row 1
      </td><td>column 2
      </td><td>column 3
    </td></tr>
    <tr>
      <td>body row 2
      </td><td colspan="2">Cells may span columns.
    </td></tr>
    <tr>
      <td>body row 3
      </td><td rowspan="2">Cells may<br>span rows.
      </td><td rowspan="2">
        <ul>
          <li>Cells
          </li><li>contain
          </li><li>blocks.
        </li></ul>
    </td></tr>
    <tr>
      <td>body row 4
    </td></tr>
</tbody></table>

<script type="text/x-handlebars"></script>

html
    body
        handlebars#testapp
            .container {{outlet}}

        handlebars#about: .container {{outlet}}

<html>
    <body>
        <script type="text/x-handlebars" id="testapp">
            <div class="container">{{outlet}}</div>
        </script>
        <script type="text/x-handlebars" id="about">
            <div class="container">{{outlet}}</div>
        </script>
    </body>
</html>

使用定制的分析器扩展 Plim¶

你也可以自己扩展 Plim 标签，该功能允许你在 Plim 之上定义自己的 DSL。例如，下面的代码将定义一个新的 HTML 链接解释器，将会处理 http_url > title 形式的链接。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

# my_module.py
import re
from plim import preprocessor_factory


PARSE_HTTP_LINKS_RE = re.compile('(?P<url>https?://[^>]+)+\s+>\s+(?P<title>.*)')


def parse_http_link(indent_level, current_line, matched, source, syntax):
    url = matched.group('url')
    url_title = matched.group('title')
    rt = '<a href="{}">{}</a>'.format(url, url_title)
    return rt, indent_level, '', source


CUSTOM_PARSERS = [
    (PARSE_HTTP_LINKS_RE, parse_http_link)
]


custom_preprocessor = preprocessor_factory(custom_parsers=CUSTOM_PARSERS, syntax='mako')

parse_http_link() 函数的定义严格地遵循了 Plim API，

所有扩展解释器都应该接受 5 个参数：

1. indent_level - an indentation level of the current line. When the parser reaches a line which indentation is lower or equal to indent_level, it returns control to a top-level function.
2. current_line - a line which is being parsed. This is the line that has been matched by matched object at the previous parsing step.
3. matched - an instance of re.MatchObject of the regex associated with the current parser.
4. source - an instance of an enumerated object returned by plim.lexer.enumerate_source().
5. syntax - an instance of one of plim.syntax.BaseSyntax children.

并返回 4 位元组：

1. parsed_data - a string of successfully parsed data
2. tail_indent - an indentation level of the tail line
3. tail_line - a line which indentation level (tail_indent) is lower or equal to the input indent_level.
4. source - an instance of enumerated object returned by plim.lexer.enumerate_source() which represents the remaining (untouched) plim markup.

现在我们已经可以像使用标准 Plim 预处理器 plim.preprocessor 一样使用 custom_preprocessor 了。

让我们使用新定义的语法来创建一个 plim 文档：

1
2
3
4
5
6
7
8
9

/ hamilton.plim
---------------
html
    head:title Alexander Hamilton
    body
        h1 Alexander Hamilton
        ul
            li: http://en.wikipedia.org/wiki/Alexander_Hamilton > Wikipedia Article
            li: http://www.amazon.com/Alexander-Hamilton-Ron-Chernow/dp/0143034758 > Full-length Biography

将会输出这样的有效 HTML （注意 -p 参数）：

$ plimc -H -p my_module:custom_preprocessor hamilton.plim

输出结果：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

<html>
    <head>
        <title>Alexander Hamilton</title>
    </head>
    <body>
        <h1>Alexander Hamilton</h1>
        <ul>
            <li><a href="http://en.wikipedia.org/wiki/Alexander_Hamilton">Wikipedia Article</a></li>
            <li><a href="http://www.amazon.com/Alexander-Hamilton-Ron-Chernow/dp/0143034758">Full-length Biography</a></li>
        </ul>
    </body>
</html>

Pyramid¶

将 plim.adapters.pyramid_renderer 添加至项目 .ini 配置文件的 pyram`id.includes 列表中：

[app:main]
pyramid.includes =
    # ... (other packages)
    plim.adapters.pyramid_renderer

The adapter will add the .plim renderer for use in Pyramid. This can be overridden and more may be added via the config.add_plim_renderer() directive:

config.add_plim_renderer('.plm', mako_settings_prefix='mako.')

The renderer will load its configuration from a provided mako prefix in the Pyramid settings dictionary. The default prefix is ‘mako.’.

Flask¶

想要在 Flask 中使用 plim 只需要在项目中添加下面的代码：

from flask import Flask
from flask.ext.mako import MakoTemplates, render_template
from plim import preprocessor

app = Flask(__name__)
mako = MakoTemplates(app)
app.config['MAKO_PREPROCESSOR'] = preprocessor

@app.route('/')
def hello():
    return render_template('hello.html', name='mako')

if __name__ == "__main__":
    app.run(debug=True)

templates 目录中的 hello.html 需要写成这样：

doctype html
html
  head
    title hello ${name}
  body
    p hello ${name}

代码高亮¶

现在还没有专门的 plim 语法高亮工具。

不过，由于 Plim 和 Slim 的语法很相似，你可以使用 Slim 的语法高亮工具 作为替代。

Version 0.9¶

• 0.9.11

  • Hotfix: Windows-样式换行（CR+LF）的错误解析修复

• 0.9.10

  • Hotfix: 修复 plimc 无法使用当前目录下的预处理器模块问题。

• 0.9.9

  • Hotfix: Fix UnicodeEncodeError in -def blocks with unicode strings as default argument values.

• 0.9.8

  • Change: Stylus extension no longer depends on the nib package.

• 0.9.7

  • Hotfix: Include requirements.txt into the distribution.

• 0.9.6

  • Hotfix: Conditional statements parser now can handle strings containing inline tag separator sequences (#27).

• 0.9.5

  • Hotfix: Fix plimc unicode decoding regression introduced by the previous hotfix.

• 0.9.4

  • Hotfix: plimc no longer crashes with TypeError in Python3 environments

    when it writes bytes to sys.stdout.

• 0.9.3

  • Hotfix: Fix UnicodeEncodeError in plimc when it writes to STDOUT.

• 0.9.2

  • Feature: added support for Custom Parsers.

• 0.9.1

  • New Syntax: New-style Python Blocks.
  • New Syntax: New-style Module-level Blocks.

• 0.9.0

  • Change: Pyramid adapter now relies on Pyramid>=1.5a2 and pyramid_mako>=0.3.1.

  • Change: The package now depends on Mako>=0.9.0.

  • Change: Sass/Scss extension now requires PyScss>=1.2.0.post3.

  • Change: Pyramid adapter’s plim.file_extension configuration option is deprecated.

    The config.add_plim_renderer() directive is provided instead.

Version 0.8¶

• 0.8.9

  • Bugfix: Use sys.maxsize instead of unavailable sys.maxint on Python 3.

• 0.8.8

  • Hotfix: Make Plim working with a development version of pyScss for Python-3.x setups.

• 0.8.7

  • Bugfix: Pyramid adapter is now compatible with the 1.5a2+ version of the framework.

  • Change: default template file extension

    used in pyramid bindings is changed from ”.plm” to ”.plim”.

• 0.8.6

  • Hotfix: fixed assertion error in handlebars parser.

• 0.8.5

  • Feature: added support for Handlebars blocks.

• 0.8.4

  • Hotfix: updated links to github.

• 0.8.3

  • Hotfix: prevent lexer from parsing embedded markup inside style and script blocks.

• 0.8.2

  • Feature: added support for Embedded Markup.
  • Feature: plimc utility is now able to output plain HTML.

• 0.8.1

  • Feature: added support for Inline Statements.

• 0.8.0

  • Feature: added support for dynamic attributes unpacker (an equivalent to Slim’s splat attributes).

Version 0.7¶

• 0.7.14
  • Hotfix: fixed bug with unicode handling.
• 0.7.13
  • Hotfix: fixed bug with static unicode attributes.
• 0.7.12
  • Unnecessary newline characters at the end of literal blocks have been removed.
  • Added the command-line tool plimc.
• 0.7.11
  • Fixed bug that had to do with incorrect parsing of multi-line dynamic class attributes.
  • Fixed bug that had to do with passing incorrect data to plim parser in babel adapter.
• 0.7.10 Fixed bug with unicode error in python block. Thanks to sqrabs@github!
• 0.7.9 Added babel message extraction plugin.
• 0.7.8 Expanded range of possible numeric values that don’t require double-quoting.
• 0.7.7
  • Fixed bug with linebreaks without trailing newline character.
  • Fixed bug with missing explicit whitespace after =, and ==, line indicators.
• 0.7.6 Fixed bug with incorrect parsing of static boolean attributes.
• 0.7.5 Fixed bug with comment and content blocks separated by empty lines.
• 0.7.4 Added -stylus extension.
• 0.7.3 Fix bug with literal one-liners.
• 0.7.1 Fixed installation error caused by missing README.rst.
• 0.7.0 Initial public release.