You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@ignite.apache.org by an...@apache.org on 2015/05/08 13:36:49 UTC
[24/52] [partial] incubator-ignite git commit: # ignite-843 WIP.
http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/0ef79031/modules/webconfig/nodejs/node_modules/jade/Readme_zh-cn.md
----------------------------------------------------------------------
diff --git a/modules/webconfig/nodejs/node_modules/jade/Readme_zh-cn.md b/modules/webconfig/nodejs/node_modules/jade/Readme_zh-cn.md
new file mode 100644
index 0000000..da54583
--- /dev/null
+++ b/modules/webconfig/nodejs/node_modules/jade/Readme_zh-cn.md
@@ -0,0 +1,1285 @@
+# Jade - 模板引擎
+
+Jade 是一个高性能的模板引擎，它深受 [Haml](http://haml-lang.com) 影响，它是用 JavaScript 实现的, 并且可以供 [Node](http://nodejs.org) 使用.
+
+翻译: [草依山](http://jser.me) 等
+
+## 声明
+
+从 Jade `v0.31.0` 开始放弃了对于 `<script>` 和 `<style>` 标签的平文本支持. 这个问题你可以在 `<script> <style>` 标签后加上 `.` 来解决.
+
+希望这一点能让 Jade 对新手更友好, 同时也不影响到 Jade 本身的能力或者导致过度冗长.
+
+如果你有大量的文件需要转换你可以用下 [fix-jade](https://github.com/ForbesLindesay/fix-jade) 尝试自动完成这个过程.
+
+## Test drive
+
+你可以在网上[试玩 Jade](http://naltatis.github.com/jade-syntax-docs).
+
+## README 目录
+
+- [特性](#a1)
+- [其它实现](#a2)
+- [安装](#a3)
+- [浏览器支持](#a4)
+- [公开 API](#a5)
+- [语法](#a6)
+ - [行结束标志](#a6-1)
+ - [标签](#a6-2)
+ - [标签文本](#a6-3)
+ - [注释](#a6-4)
+ - [块注释](#a6-5)
+ - [内联](#a6-6)
+ - [块展开](#a6-7)
+ - [Case](#a6-8)
+ - [属性](#a6-9)
+ - [HTML](#a6-10)
+ - [Doctypes](#a6-11)
+- [过滤器](#a7)
+- [代码](#a8)
+- [循环](#a9)
+- [条件语句](#a10)
+- [模板继承](#a11)
+- [Block append/prepend](#a12)
+- [包含](#a13)
+- [Mixins](#a14)
+- [产生输出](#a15)
+- [Makefile 的一个例子](#a16)
+- [命令行的 Jade](#a17)
+- [教程](#a18)
+- [License](#a19)
+
+<a name="a1"/>
+## 特性
+
+ - 客户端支持
+ - 代码高可读
+ - 灵活的缩进
+ - 块展开
+ - Mixins
+ - 静态包含
+ - 属性改写
+ - 安全，默认代码是转义的
+ - 运行时和编译时上下文错误报告
+ - 命令行下编译jade模板
+ - HTML5 模式 (使用 ~~`!!! 5`~~ `doctype html` 文档类型)
+ - 在内存中缓存(可选)
+ - 合并动态和静态标签类
+ - 可以通过 `filters` 修改树
+ - 模板继承
+ - 原生支持 [Express JS](http://expressjs.com)
+ - 通过 `each` 枚举对象、数组甚至是不能枚举的对象
+ - 块注释
+ - 没有前缀的标签
+ - AST Filters
+ - 过滤器
+ - `:stylus` 必须已经安装 [stylus](http://github.com/LearnBoost/stylus)
+ - `:less` 必须已经安装 [less.js](http://github.com/cloudhead/less.js)
+ - `:markdown` 必须已经安装 [markdown-js](http://github.com/evilstreak/markdown-js) 或者 [node-discount](http://github.com/visionmedia/node-discount)
+ - `:cdata`
+ - `:coffeescript` 必须已经安装[coffee-script](http://jashkenas.github.com/coffee-script/)
+ - [Emacs Mode](https://github.com/brianc/jade-mode)
+ - [Vim Syntax](https://github.com/digitaltoad/vim-jade)
+ - [TextMate Bundle](http://github.com/miksago/jade-tmbundle)
+ - [Coda/SubEtha syntax Mode](https://github.com/aaronmccall/jade.mode)
+ - [Screencasts](http://tjholowaychuk.com/post/1004255394/jade-screencast-template-engine-for-nodejs)
+ - [html2jade](https://github.com/donpark/html2jade) converter
+
+<a name="a2"/>
+## 其它实现
+
+ - [php](http://github.com/everzet/jade.php)
+ - [scala](http://scalate.fusesource.org/versions/snapshot/documentation/scaml-reference.html)
+ - [ruby](https://github.com/slim-template/slim)
+ - [python](https://github.com/SyrusAkbary/pyjade)
+ - [java](https://github.com/neuland/jade4j)
+
+<a name="a3"/>
+## 安装
+
+通过 NPM:
+
+```sh
+npm install jade
+```
+
+<a name="a4"/>
+## 浏览器支持
+
+把 Jade 编译为一个可供浏览器使用的单文件，只需要简单的执行:
+
+```sh
+$ make jade.js
+```
+
+如果你已经安装了 uglifyjs (`npm install uglify-js`)，你可以执行下面的命令它会生成所有的文件。其实每一个正式版本里都帮你做了这事。
+
+```sh
+make jade.min.js
+```
+
+默认情况下，为了方便调试Jade会把模板组织成带有形如 `__.lineno = 3` 的行号的形式。
+在浏览器里使用的时候，你可以通过传递一个选项 `{ compileDebug: false }` 来去掉这个。
+下面的模板
+
+```sh
+p Hello #{name}
+```
+
+会被翻译成下面的函数：
+
+```js
+function anonymous(locals, attrs, escape, rethrow) {
+ var buf = [];
+ with (locals || {}) {
+ var interp;
+ buf.push('\n<p>Hello ' + escape((interp = name) == null ? '' : interp) + '\n</p>');
+ }
+ return buf.join("");
+}
+```
+
+通过使用 Jade 的 `./runtime.js`你可以在浏览器使用这些预编译的模板而不需要使用 Jade, 你只需要使用 `runtime.js` 里的工具函数, 它们会放在 `jade.attrs`, `jade.escape` 这些里。 把选项 `{ client: true }` 传递给 `jade.compile()`, Jade 会把这些帮助函数的引用放在`jade.attrs`, `jade.escape`.
+
+```js
+function anonymous(locals, attrs, escape, rethrow) {
+ var attrs = jade.attrs, escape = jade.escape, rethrow = jade.rethrow;
+ var buf = [];
+ with (locals || {}) {
+ var interp;
+ buf.push('\n<p>Hello ' + escape((interp = name) == null ? '' : interp) + '\n</p>');
+ }
+ return buf.join("");
+}
+```
+
+<a name="a5"/>
+## 公开 API
+
+```javascript
+var jade = require('jade');
+
+// Compile a function
+var fn = jade.compile('string of jade', options);
+fn(locals);
+```
+
+### 选项
+
+ - `self` 使用 `self` 命名空间来持有本地变量. _(默认为 `false`)_
+ - `locals` 本地变量对象
+ - `filename` 异常发生时使用，includes 时必需
+ - `debug` 输出 token 和翻译后的函数体
+ - `compiler` 替换掉 jade 默认的编译器
+ - `compileDebug` `false`的时候调试的结构不会被输出
+ - `pretty` 为输出加上了漂亮的空格缩进 _(默认为 `false`)_
+
+<a name="a6"/>
+## 语法
+
+<a name="a6-1"/>
+### 行结束标志
+
+**CRLF** 和 **CR** 会在编译之前被转换为 **LF**
+
+<a name="a6-2"/>
+### 标签
+
+标签就是一个简单的单词:
+
+```jade
+html
+```
+
+它会被转换为 `<html></html>`
+
+标签也是可以有 id 的:
+
+```jade
+div#container
+```
+
+它会被转换为 `<div id="container"></div>`
+
+怎么加 class 呢？
+
+```jade
+div.user-details
+```
+
+转换为 `<div class="user-details"></div>`
+
+多个 class 和 id? 也是可以搞定的:
+
+ div#foo.bar.baz
+
+转换为 `<div id="foo" class="bar baz"></div>`
+
+不停的 `div div div` 很讨厌啊 , 可以这样:
+
+```jade
+#foo
+.bar
+```
+
+这个算是我们的语法糖，它已经被很好的支持了，上面的会输出：
+
+```html
+<div id="foo"></div><div class="bar"></div>
+```
+
+<a name="a6-3"/>
+### 标签文本
+
+只需要简单的把内容放在标签之后：
+
+```jade
+p wahoo!
+```
+
+它会被渲染为 `<p>wahoo!</p>`.
+
+很帅吧，但是大段的文本怎么办呢：
+
+```jade
+p
+ | foo bar baz
+ | rawr rawr
+ | super cool
+ | go jade go
+```
+
+渲染为 `<p>foo bar baz rawr.....</p>`
+
+怎么和数据结合起来？ 所有类型的文本展示都可以和数据结合起来，如果我们把 `{ name: 'tj', email: 'tj@vision-media.ca' }` 传给编译函数，下面是模板上的写法:
+
+```jade
+#user #{name} <#{email}>
+```
+
+它会被渲染为 `<div id="user">tj <tj@vision-media.ca></div>`
+
+当就是要输出 `#{}` 的时候怎么办? 转义一下!
+
+ p \#{something}
+
+它会输出 `<p>#{something}</p>`
+
+同样可以使用非转义的变量 `!{html}`, 下面的模板将直接输出一个 `<script>` 标签:
+
+```jade
+- var html = "<script></script>"
+| !{html}
+```
+
+内联标签同样可以使用文本块来包含文本：
+
+```jade
+label
+ | Username:
+ input(name='user[name]')
+```
+
+或者直接使用标签文本:
+
+```jade
+label Username:
+ input(name='user[name]')
+```
+
+_只_ 包含文本的标签，比如 `<script>`, `<style>`, 和 `<textarea>` 不需要前缀 `|` 字符, 比如:
+
+```jade
+html
+ head
+ title Example
+ script
+ if (foo) {
+ bar();
+ } else {
+ baz();
+ }
+```
+
+这里还有一种选择，可以使用 `.` 来开始一段文本块，比如：
+
+```jade
+p.
+ foo asdf
+ asdf
+ asdfasdfaf
+ asdf
+ asd.
+```
+
+会被渲染为:
+
+```jade
+<p>foo asdf
+asdf
+ asdfasdfaf
+ asdf
+asd
+.
+</p>
+```
+
+这和带一个空格的 `.` 是不一样的, 带空格的会被 Jade 的解析器忽略，当作一个普通的文字:
+
+```jade
+p .
+```
+
+渲染为:
+
+```jade
+<p>.</p>
+```
+
+需要注意的是文本块需要两次转义。比如想要输出下面的文本：
+
+```jade
+<p>foo\bar</p>
+```
+
+使用:
+
+```jade
+p.
+ foo\\bar
+```
+
+<a name="a6-4"/>
+### 注释
+
+单行注释和 JavaScript 里是一样的，通过 `//` 来开始，并且必须单独一行：
+
+```jade
+// just some paragraphs
+p foo
+p bar
+```
+
+渲染为：
+
+```html
+<!-- just some paragraphs -->
+<p>foo</p>
+<p>bar</p>
+```
+
+Jade 同样支持不输出的注释，加一个短横线就行了：
+
+```jade
+//- will not output within markup
+p foo
+p bar
+```
+
+渲染为：
+
+```html
+<p>foo</p>
+<p>bar</p>
+```
+
+<a name="a6-5"/>
+### 块注释
+
+块注释也是支持的：
+
+```jade
+body
+ //
+ #content
+ h1 Example
+```
+
+渲染为：
+
+```html
+<body>
+ <!--
+ <div id="content">
+ <h1>Example</h1>
+ </div>
+ -->
+</body>
+```
+
+Jade 同样很好的支持了条件注释：
+
+```jade
+body
+ //if IE
+ a(href='http://www.mozilla.com/en-US/firefox/') Get Firefox
+```
+
+渲染为：
+
+```html
+<body>
+ <!--[if IE]>
+ <a href="http://www.mozilla.com/en-US/firefox/">Get Firefox</a>
+ <![endif]-->
+</body>
+```
+
+<a name="a6-6"/>
+### 内联
+
+Jade 支持以自然的方式定义标签嵌套:
+
+```jade
+ul
+ li.first
+ a(href='#') foo
+ li
+ a(href='#') bar
+ li.last
+ a(href='#') baz
+```
+
+<a name="a6-7"/>
+### 块展开
+
+块展开可以帮助你在一行内创建嵌套的标签，下面的例子和上面的是一样的：
+
+```jade
+ul
+ li.first: a(href='#') foo
+ li: a(href='#') bar
+ li.last: a(href='#') baz
+```
+
+<a name="a6-8"/>
+### Case
+
+`case` 表达式按下面这样的形式写:
+
+```jade
+html
+ body
+ friends = 10
+ case friends
+ when 0
+ p you have no friends
+ when 1
+ p you have a friend
+ default
+ p you have #{friends} friends
+```
+
+块展开在这里也可以使用:
+
+```jade
+friends = 5
+
+html
+ body
+ case friends
+ when 0: p you have no friends
+ when 1: p you have a friend
+ default: p you have #{friends} friends
+```
+
+<a name="a6-9"/>
+### 属性
+
+Jade 现在支持使用 `(` 和 `)` 作为属性分隔符
+
+```jade
+a(href='/login', title='View login page') Login
+```
+
+当一个值是 `undefined` 或者 `null` 属性 _不_ 会被加上,
+所以呢，它不会编译出 'something="null"'.
+
+```jade
+div(something=null)
+```
+
+Boolean 属性也是支持的:
+
+```jade
+input(type="checkbox", checked)
+```
+
+使用代码的 Boolean 属性只有当属性为 `true` 时才会输出：
+
+```jade
+input(type="checkbox", checked=someValue)
+```
+
+多行同样也是可用的：
+
+```jade
+input(type='checkbox',
+ name='agreement',
+ checked)
+```
+
+多行的时候可以不加逗号：
+
+```jade
+input(type='checkbox'
+ name='agreement'
+ checked)
+```
+
+加点空格，格式好看一点？同样支持
+
+```jade
+input(
+ type='checkbox'
+ name='agreement'
+ checked)
+```
+
+冒号也是支持的:
+
+```jade
+rss(xmlns:atom="atom")
+```
+
+假如我有一个 `user` 对象 `{ id: 12, name: 'tobi' }`
+我们希望创建一个指向 `/user/12` 的链接 `href`, 我们可以使用普通的 JavaScript 字符串连接，如下:
+
+```jade
+a(href='/user/' + user.id)= user.name
+```
+
+或者我们使用 Jade 的修改方式, 这个我想很多使用 Ruby 或者 CoffeeScript 的人会看起来像普通的 JS..:
+
+```jade
+a(href='/user/#{user.id}')= user.name
+```
+
+`class` 属性是一个特殊的属性，你可以直接传递一个数组，比如 `bodyClasses = ['user', 'authenticated']` :
+
+```jade
+body(class=bodyClasses)
+```
+
+<a name="a6-10"/>
+### HTML
+
+内联的 HTML 是可以的，我们可以使用管道定义一段文本 :
+
+```jade
+html
+ body
+ | <h1>Title</h1>
+ | <p>foo bar baz</p>
+```
+
+或者我们可以使用 `.` 来告诉 Jade 我们需要一段文本：
+
+```jade
+html
+ body.
+ <h1>Title</h1>
+ <p>foo bar baz</p>
+```
+
+上面的两个例子都会渲染成相同的结果：
+
+```jade
+<html><body><h1>Title</h1>
+<p>foo bar baz</p>
+</body></html>
+```
+
+ 这条规则适应于在 Jade 里的任何文本：
+
+```
+html
+ body
+ h1 User <em>#{name}</em>
+```
+
+<a name="a6-11"/>
+### Doctypes
+
+添加文档类型只需要简单的使用 `!!!`, 或者 `doctype` 跟上下面的可选项:
+
+```jade
+!!!
+```
+
+会渲染出 _transitional_ 文档类型, 或者:
+
+```jade
+!!! 5
+```
+
+或
+
+```jade
+!!! html
+```
+
+或
+
+```jade
+doctype html
+```
+
+Doctype 是大小写不敏感的, 所以下面两个是一样的:
+
+```jade
+doctype Basic
+doctype basic
+```
+
+当然也是可以直接传递一段文档类型的文本：
+
+```jade
+doctype html PUBLIC "-//W3C//DTD XHTML Basic 1.1//EN"
+```
+
+渲染后:
+
+```html
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML Basic 1.1//EN">
+```
+
+会输出 _HTML5_ 文档类型. 下面的默认的文档类型，可以很简单的扩展：
+
+```javascript
+var doctypes = exports.doctypes = {
+ '5': '<!DOCTYPE html>',
+ 'xml': '<?xml version="1.0" encoding="utf-8" ?>',
+ 'default': '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">',
+ 'transitional': '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">',
+ 'strict': '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">',
+ 'frameset': '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd">',
+ '1.1': '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">',
+ 'basic': '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML Basic 1.1//EN" "http://www.w3.org/TR/xhtml-basic/xhtml-basic11.dtd">',
+ 'mobile': '<!DOCTYPE html PUBLIC "-//WAPFORUM//DTD XHTML Mobile 1.2//EN" "http://www.openmobilealliance.org/tech/DTD/xhtml-mobile12.dtd">'
+};
+```
+
+通过下面的代码可以很简单的改变默认的文档类型：
+
+```javascript
+ jade.doctypes.default = 'whatever you want';
+```
+
+<a name="a7"/>
+## 过滤器
+
+过滤器前缀 `:`, 比如 `:markdown` 会把下面块里的文本交给专门的函数进行处理。查看顶部 _特性_ 里有哪些可用的过滤器。
+
+```jade
+body
+ :markdown
+ Woah! jade _and_ markdown, very **cool**
+ we can even link to [stuff](http://google.com)
+```
+
+渲染为:
+
+```html
+<body><p>Woah! jade <em>and</em> markdown, very <strong>cool</strong> we can even link to <a href="http://google.com">stuff</a></p></body>
+```
+
+<a name="a8"/>
+## 代码
+
+Jade 目前支持三种类型的可执行代码。第一种是前缀 `-`， 这是不会被输出的：
+
+```jade
+- var foo = 'bar';
+```
+
+这可以用在条件语句或者循环中：
+
+```jade
+- for (var key in obj)
+ p= obj[key]
+```
+
+由于 Jade 的缓存技术，下面的代码也是可以的：
+
+```jade
+- if (foo)
+ ul
+ li yay
+ li foo
+ li worked
+- else
+ p oh no! didnt work
+```
+
+哈哈，甚至是很长的循环也是可以的：
+
+ - if (items.length)
+ ul
+ - items.forEach(function(item){
+ li= item
+ - })
+
+所以你想要的！
+
+下一步我们要 _转义_ 输出的代码，比如我们返回一个值，只要前缀一个 `=`：
+
+```jade
+- var foo = 'bar'
+= foo
+h1= foo
+```
+
+它会渲染为 `bar<h1>bar</h1>`. 为了安全起见，使用 `=` 输出的代码默认是转义的,如果想直接输出不转义的值可以使用 `!=`：
+
+```jade
+p!= aVarContainingMoreHTML
+```
+
+Jade 同样是设计师友好的，它可以使 JavaScript 更直接更富表现力。比如下面的赋值语句是相等的，同时表达式还是通常的 JavaScript：
+
+```jade
+- var foo = 'foo ' + 'bar'
+foo = 'foo ' + 'bar'
+```
+
+Jade 会把 `if`, `else if`, `else`, `until`, `while`, `unless` 同别的优先对待, 但是你得记住它们还是普通的 JavaScript：
+
+```jade
+if foo == 'bar'
+ ul
+ li yay
+ li foo
+ li worked
+else
+ p oh no! didnt work
+```
+
+<a name="a9"/>
+## 循环
+
+尽管已经支持 JavaScript 原生代码，Jade 还是支持了一些特殊的标签，它们可以让模板更加易于理解，其中之一就是 `each`, 这种形式：
+
+```jade
+each VAL[, KEY] in OBJ
+```
+
+一个遍历数组的例子 ：
+
+```jade
+- var items = ["one", "two", "three"]
+each item in items
+ li= item
+```
+
+渲染为:
+
+```html
+<li>one</li>
+<li>two</li>
+<li>three</li>
+```
+
+遍历一个数组同时带上索引：
+
+```jade
+items = ["one", "two", "three"]
+each item, i in items
+ li #{item}: #{i}
+```
+
+渲染为:
+
+```html
+<li>one: 0</li>
+<li>two: 1</li>
+<li>three: 2</li>
+```
+
+遍历一个数组的键值：
+
+```jade
+obj = { foo: 'bar' }
+each val, key in obj
+ li #{key}: #{val}
+```
+
+将会渲染为：`<li>foo: bar</li>`
+
+Jade 在内部会把这些语句转换成原生的 JavaScript 语句，就像使用 `users.forEach(function(user){`, 词法作用域和嵌套会像在普通的 JavaScript 中一样：
+
+```jade
+each user in users
+ each role in user.roles
+ li= role
+```
+
+如果你喜欢，也可以使用 `for` ：
+
+```jade
+for user in users
+ for role in user.roles
+ li= role
+```
+
+<a name="a10"/>
+## 条件语句
+
+Jade 条件语句和使用了(`-`) 前缀的 JavaScript 语句是一致的,然后它允许你不使用圆括号，这样会看上去对设计师更友好一点，
+同时要在心里记住这个表达式渲染出的是 _常规_ JavaScript：
+
+```jade
+for user in users
+ if user.role == 'admin'
+ p #{user.name} is an admin
+ else
+ p= user.name
+```
+
+和下面的使用了常规 JavaScript 的代码是相等的：
+
+```jade
+for user in users
+ - if (user.role == 'admin')
+ p #{user.name} is an admin
+ - else
+ p= user.name
+```
+
+Jade 同时支持 `unless`, 这和 `if (!(expr))` 是等价的：
+
+```jade
+for user in users
+ unless user.isAnonymous
+ p
+ | Click to view
+ a(href='/users/' + user.id)= user.name
+```
+
+<a name="a11"/>
+## 模板继承
+
+Jade 支持通过 `block` 和 `extends` 关键字来实现模板继承。 一个块就是一个 Jade 的 block ，它将在子模板中实现，同时是支持递归的。
+
+Jade 块如果没有内容，Jade 会添加默认内容，下面的代码默认会输出 `block scripts`, `block content`, 和 `block foot`.
+
+```jade
+html
+ head
+ h1 My Site - #{title}
+ block scripts
+ script(src='/jquery.js')
+ body
+ block content
+ block foot
+ #footer
+ p some footer content
+```
+
+现在我们来继承这个布局，简单创建一个新文件，像下面那样直接使用 `extends`，给定路径（可以选择带 `.jade` 扩展名或者不带）. 你可以定义一个或者更多的块来覆盖父级块内容, 注意到这里的 `foot` 块 _没有_ 定义，所以它还会输出父级的 "some footer content"。
+
+```jade
+extends extend-layout
+
+block scripts
+ script(src='/jquery.js')
+ script(src='/pets.js')
+
+block content
+ h1= title
+ each pet in pets
+ include pet
+```
+
+同样可以在一个子块里添加块，就像下面实现的块 `content` 里又定义了两个可以被实现的块 `sidebar` 和 `primary`，或者子模板直接实现 `content`。
+
+```jade
+extends regular-layout
+
+block content
+ .sidebar
+ block sidebar
+ p nothing
+ .primary
+ block primary
+ p nothing
+```
+
+<a name="a12"/>
+
+## 前置、追加代码块
+
+Jade允许你 _替换_ （默认）、 _前置_ 和 _追加_ blocks. 比如，假设你希望在 _所有_ 页面的头部都加上默认的脚本，你可以这么做：
+
+
+```jade
+html
+ head
+ block head
+ script(src='/vendor/jquery.js')
+ script(src='/vendor/caustic.js')
+ body
+ block content
+```
+
+现在假设你有一个Javascript游戏的页面，你希望在默认的脚本之外添加一些游戏相关的脚本，你可以直接`append`上代码块：
+
+
+```jade
+extends layout
+
+block append head
+ script(src='/vendor/three.js')
+ script(src='/game.js')
+```
+
+使用 `block append` 或 `block prepend` 时 `block` 是可选的:
+
+```jade
+extends layout
+
+append head
+ script(src='/vendor/three.js')
+ script(src='/game.js')
+```
+
+<a name="a13"/>
+## 包含
+
+Includes 允许你静态包含一段 Jade, 或者别的存放在单个文件中的东西比如 CSS, HTML 非常常见的例子是包含头部和页脚。 假设我们有一个下面目录结构的文件夹：
+
+```
+./layout.jade
+./includes/
+ ./head.jade
+ ./tail.jade
+```
+
+下面是 `layout.jade` 的内容:
+
+```jade
+html
+ include includes/head
+ body
+ h1 My Site
+ p Welcome to my super amazing site.
+ include includes/foot
+```
+
+这两个包含 `includes/head` 和 `includes/foot` 都会读取相对于给 `layout.jade` 参数`filename` 的路径的文件, 这是一个绝对路径，不用担心Express帮你搞定这些了。Include 会解析这些文件，并且插入到已经生成的语法树中，然后渲染为你期待的内容：
+
+```html
+<html>
+ <head>
+ <title>My Site</title>
+ <script src="/javascripts/jquery.js">
+ </script><script src="/javascripts/app.js"></script>
+ </head>
+ <body>
+ <h1>My Site</h1>
+ <p>Welcome to my super lame site.</p>
+ <div id="footer">
+ <p>Copyright>(c) foobar</p>
+ </div>
+ </body>
+</html>
+```
+
+前面已经提到，`include` 可以包含比如 HTML 或者 CSS 这样的内容。给定一个扩展名后，Jade 不会把这个文件当作一个 Jade 源代码，并且会把它当作一个普通文本包含进来：
+
+```
+html
+ head
+ //- css and js have simple filters that wrap them in
+ <style> and <script> tags, respectively
+ include stylesheet.css
+ include script.js
+ body
+ //- "markdown" files will use the "markdown" filter
+ to convert Markdown to HTML
+ include introduction.markdown
+ //- html files have no filter and are included verbatim
+ include content.html
+```
+
+Include 也可以接受块内容，给定的块将会附加到包含文件 _最后_ 的块里。 举个例子，`head.jade` 包含下面的内容：
+
+```jade
+head
+ script(src='/jquery.js')
+```
+
+我们可以像下面给`include head`添加内容, 这里是添加两个脚本.
+
+```
+html
+ include head
+ script(src='/foo.js')
+ script(src='/bar.js')
+ body
+ h1 test
+```
+
+
+在被包含的模板中，你也可以使用`yield`语句。`yield`语句允许你明确地标明`include`的代码块的放置位置。比如，假设你希望把代码块放在scripts之前，而不是附加在scripts之后：
+
+```jade
+head
+ yield
+ script(src='/jquery.js')
+ script(src='/jquery.ui.js')
+```
+
+由于被包含的Jade会按字面解析并合并到AST中，词法范围的变量的效果和直接写在同一个文件中的相同。这就意味着`include`可以用作partial的替代，例如，假设我们有一个引用了`user`变量的user.jade`文件：
+
+
+```jade
+h1= user.name
+p= user.occupation
+```
+
+接着，当我们迭代users的时候，只需简单地加上`include user`。因为在循环中`user`变量已经被定义了，被包含的模板可以访问它。
+
+
+
+```jade
+users = [{ name: 'Tobi', occupation: 'Ferret' }]
+
+each user in users
+ .user
+ include user
+```
+
+以上代码会生成：
+
+```html
+<div class="user">
+ <h1>Tobi</h1>
+ <p>Ferret</p>
+</div>
+```
+
+`user.jade`引用了`user`变量，如果我们希望使用一个不同的变量`user`，那么我们可以直接定义一个新变量`user = person`，如下所示：
+
+```jade
+each person in users
+ .user
+ user = person
+ include user
+```
+
+
+<a name="a14"/>
+## Mixins
+
+Mixins 在编译的模板里会被 Jade 转换为普通的 JavaScript 函数。 Mixins 可以还参数，但不是必需的：
+
+```jade
+mixin list
+ ul
+ li foo
+ li bar
+ li baz
+```
+
+使用不带参数的 mixin 看上去非常简单，在一个块外：
+
+```jade
+h2 Groceries
+mixin list
+```
+
+Mixins 也可以带一个或者多个参数，参数就是普通的 JavaScript 表达式，比如下面的例子：
+
+```jade
+mixin pets(pets)
+ ul.pets
+ - each pet in pets
+ li= pet
+
+mixin profile(user)
+ .user
+ h2= user.name
+ mixin pets(user.pets)
+```
+
+会输出像下面的 HTML:
+
+
+```html
+<div class="user">
+ <h2>tj</h2>
+ <ul class="pets">
+ <li>tobi</li>
+ <li>loki</li>
+ <li>jane</li>
+ <li>manny</li>
+ </ul>
+</div>
+```
+
+<a name="a15"/>
+## 产生输出
+
+假设我们有下面的 Jade 源码：
+
+```jade
+- var title = 'yay'
+h1.title #{title}
+p Just an example
+```
+
+当 `compileDebug` 选项不是 `false`, Jade 会编译时会把函数里加上 `__.lineno = n;`, 这个参数会在编译出错时传递给 `rethrow()`, 而这个函数会在 Jade 初始输出时给出一个有用的错误信息。
+
+```js
+function anonymous(locals) {
+ var __ = { lineno: 1, input: "- var title = 'yay'\nh1.title #{title}\np Just an example", filename: "testing/test.js" };
+ var rethrow = jade.rethrow;
+ try {
+ var attrs = jade.attrs, escape = jade.escape;
+ var buf = [];
+ with (locals || {}) {
+ var interp;
+ __.lineno = 1;
+ var title = 'yay'
+ __.lineno = 2;
+ buf.push('<h1');
+ buf.push(attrs({ "class": ('title') }));
+ buf.push('>');
+ buf.push('' + escape((interp = title) == null ? '' : interp) + '');
+ buf.push('</h1>');
+ __.lineno = 3;
+ buf.push('<p>');
+ buf.push('Just an example');
+ buf.push('</p>');
+ }
+ return buf.join("");
+ } catch (err) {
+ rethrow(err, __.input, __.filename, __.lineno);
+ }
+}
+```
+
+当 `compileDebug` 参数是 `false`, 这个参数会被去掉，这样对于轻量级的浏览器端模板是非常有用的。结合 Jade 的参数和当前源码库里的 `./runtime.js` 文件，你可以通过 `toString()` 来编译模板而不需要在浏览器端运行整个 Jade 库，这样可以提高性能，也可以减少载入的 JavaScript 数量。
+
+```js
+function anonymous(locals) {
+ var attrs = jade.attrs, escape = jade.escape;
+ var buf = [];
+ with (locals || {}) {
+ var interp;
+ var title = 'yay'
+ buf.push('<h1');
+ buf.push(attrs({ "class": ('title') }));
+ buf.push('>');
+ buf.push('' + escape((interp = title) == null ? '' : interp) + '');
+ buf.push('</h1>');
+ buf.push('<p>');
+ buf.push('Just an example');
+ buf.push('</p>');
+ }
+ return buf.join("");
+}
+```
+
+<a name="a16"/>
+## Makefile 的一个例子
+
+通过执行 `make`， 下面的 Makefile 例子可以把 `pages/*.jade` 编译为 `pages/*.html` 。
+
+```make
+JADE = $(shell find pages/*.jade)
+HTML = $(JADE:.jade=.html)
+
+all: $(HTML)
+
+%.html: %.jade
+ jade < $< --path $< > $@
+
+clean:
+ rm -f $(HTML)
+
+.PHONY: clean
+```
+
+这个可以和 `watch(1)` 命令起来产生像下面的行为：
+
+```sh
+$ watch make
+```
+
+<a name="a17"/>
+## 命令行的 Jade
+
+```
+
+使用: jade [options] [dir|file ...]
+
+选项:
+
+ -h, --help 输出帮助信息
+ -v, --version 输出版本号
+ -o, --out <dir> 输出编译后的 HTML 到 <dir>
+ -O, --obj <str> JavaScript 选项
+ -p, --path <path> 在处理 stdio 时，查找包含文件时的查找路径
+ -P, --pretty 格式化 HTML 输出
+ -c, --client 编译浏览器端可用的 runtime.js
+ -D, --no-debug 关闭编译的调试选项(函数会更小)
+ -w, --watch 监视文件改变自动刷新编译结果
+
+Examples:
+
+ # 编译整个目录
+ $ jade templates
+
+ # 生成 {foo,bar}.html
+ $ jade {foo,bar}.jade
+
+ # 在标准IO下使用jade
+ $ jade < my.jade > my.html
+
+ # 在标准IO下使用jade, 同时指定用于查找包含的文件
+ $ jade < my.jade -p my.jade > my.html
+
+ # 在标准IO下使用jade
+ $ echo "h1 Jade!" | jade
+
+ # foo, bar 目录渲染到 /tmp
+ $ jade foo bar --out /tmp
+
+```
+
+*注意: 从 `v0.31.0` 的 `-o` 选项已经指向 `--out`, `-O` 相应做了交换*
+
+<a name="a18"/>
+## 教程
+
+ - cssdeck interactive [Jade syntax tutorial](http://cssdeck.com/labs/learning-the-jade-templating-engine-syntax)
+ - cssdeck interactive [Jade logic tutorial](http://cssdeck.com/labs/jade-templating-tutorial-codecast-part-2)
+ - in [Japanese](http://blog.craftgear.net/4f501e97c1347ec934000001/title/10%E5%88%86%E3%81%A7%E3%82%8F%E3%81%8B%E3%82%8Bjade%E3%83%86%E3%83%B3%E3%83%97%E3%83%AC%E3%83%BC%E3%83%88%E3%82%A8%E3%83%B3%E3%82%B8%E3%83%B3)
+
+<a name="a19"/>
+## License
+
+(The MIT License)
+
+Copyright (c) 2009-2010 TJ Holowaychuk <tj@vision-media.ca>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/0ef79031/modules/webconfig/nodejs/node_modules/jade/bin/jade.js
----------------------------------------------------------------------
diff --git a/modules/webconfig/nodejs/node_modules/jade/bin/jade.js b/modules/webconfig/nodejs/node_modules/jade/bin/jade.js
new file mode 100755
index 0000000..8fff75f
--- /dev/null
+++ b/modules/webconfig/nodejs/node_modules/jade/bin/jade.js
@@ -0,0 +1,267 @@
+#!/usr/bin/env node
+
+/**
+ * Module dependencies.
+ */
+
+var fs = require('fs')
+ , program = require('commander')
+ , path = require('path')
+ , basename = path.basename
+ , dirname = path.dirname
+ , resolve = path.resolve
+ , normalize = path.normalize
+ , join = path.join
+ , mkdirp = require('mkdirp')
+ , jade = require('../');
+
+// jade options
+
+var options = {};
+
+// options
+
+program
+ .version(require('../package.json').version)
+ .usage('[options] [dir|file ...]')
+ .option('-O, --obj <str|path>', 'JavaScript options object or JSON file containing it')
+ .option('-o, --out <dir>', 'output the compiled html to <dir>')
+ .option('-p, --path <path>', 'filename used to resolve includes')
+ .option('-P, --pretty', 'compile pretty html output')
+ .option('-c, --client', 'compile function for client-side runtime.js')
+ .option('-n, --name <str>', 'The name of the compiled template (requires --client)')
+ .option('-D, --no-debug', 'compile without debugging (smaller functions)')
+ .option('-w, --watch', 'watch files for changes and automatically re-render')
+ .option('-E, --extension <ext>', 'specify the output file extension')
+ .option('--name-after-file', 'Name the template after the last section of the file path (requires --client and overriden by --name)')
+ .option('--doctype <str>', 'Specify the doctype on the command line (useful if it is not specified by the template)')
+
+
+program.on('--help', function(){
+ console.log(' Examples:');
+ console.log('');
+ console.log(' # translate jade the templates dir');
+ console.log(' $ jade templates');
+ console.log('');
+ console.log(' # create {foo,bar}.html');
+ console.log(' $ jade {foo,bar}.jade');
+ console.log('');
+ console.log(' # jade over stdio');
+ console.log(' $ jade < my.jade > my.html');
+ console.log('');
+ console.log(' # jade over stdio');
+ console.log(' $ echo \'h1 Jade!\' | jade');
+ console.log('');
+ console.log(' # foo, bar dirs rendering to /tmp');
+ console.log(' $ jade foo bar --out /tmp ');
+ console.log('');
+});
+
+program.parse(process.argv);
+
+// options given, parse them
+
+if (program.obj) {
+ options = parseObj(program.obj);
+}
+
+/**
+ * Parse object either in `input` or in the file called `input`. The latter is
+ * searched first.
+ */
+function parseObj (input) {
+ var str, out;
+ try {
+ str = fs.readFileSync(program.obj);
+ } catch (e) {
+ return eval('(' + program.obj + ')');
+ }
+ // We don't want to catch exceptions thrown in JSON.parse() so have to
+ // use this two-step approach.
+ return JSON.parse(str);
+}
+
+// --path
+
+if (program.path) options.filename = program.path;
+
+// --no-debug
+
+options.compileDebug = program.debug;
+
+// --client
+
+options.client = program.client;
+
+// --pretty
+
+options.pretty = program.pretty;
+
+// --watch
+
+options.watch = program.watch;
+
+// --name
+
+if (typeof program.name === 'string') {
+ options.name = program.name;
+}
+
+// --doctype
+
+options.doctype = program.doctype;
+
+// left-over args are file paths
+
+var files = program.args;
+
+// array of paths that are being watched
+
+var watchList = [];
+
+// compile files
+
+if (files.length) {
+ console.log();
+ if (options.watch) {
+ process.on('SIGINT', function() {
+ process.exit(1);
+ });
+ files.forEach(tryRender);
+ } else {
+ files.forEach(renderFile);
+ }
+ process.on('exit', function () {
+ console.log();
+ });
+// stdio
+} else {
+ stdin();
+}
+
+/**
+ * Watch for changes on path
+ *
+ * Renders `base` if specified, otherwise renders `path`.
+ */
+function watchFile(path, base) {
+ path = normalize(path);
+ if (watchList.indexOf(path) !== -1) return;
+ console.log(" \033[90mwatching \033[36m%s\033[0m", path);
+ fs.watchFile(path, {persistent: true, interval: 200},
+ function (curr, prev) {
+ // File doesn't exist anymore. Keep watching.
+ if (curr.mtime.getTime() === 0) return;
+ // istanbul ignore if
+ if (curr.mtime.getTime() === prev.mtime.getTime()) return;
+ tryRender(base || path);
+ });
+ watchList.push(path);
+}
+
+/**
+ * Convert error to string
+ */
+function errorToString(e) {
+ return e.stack || /* istanbul ignore next */ (e.message || e);
+}
+
+/**
+ * Try to render `path`; if an exception is thrown it is printed to stderr and
+ * otherwise ignored.
+ *
+ * This is used in watch mode.
+ */
+function tryRender(path) {
+ try {
+ renderFile(path);
+ } catch (e) {
+ // keep watching when error occured.
+ console.error(errorToString(e));
+ }
+}
+
+/**
+ * Compile from stdin.
+ */
+
+function stdin() {
+ var buf = '';
+ process.stdin.setEncoding('utf8');
+ process.stdin.on('data', function(chunk){ buf += chunk; });
+ process.stdin.on('end', function(){
+ var output;
+ if (options.client) {
+ output = jade.compileClient(buf, options);
+ } else {
+ var fn = jade.compile(buf, options);
+ var output = fn(options);
+ }
+ process.stdout.write(output);
+ }).resume();
+
+ process.on('SIGINT', function() {
+ process.stdout.write('\n');
+ process.stdin.emit('end');
+ process.stdout.write('\n');
+ process.exit();
+ })
+}
+
+/**
+ * Process the given path, compiling the jade files found.
+ * Always walk the subdirectories.
+ */
+
+function renderFile(path) {
+ var re = /\.jade$/;
+ var stat = fs.lstatSync(path);
+ // Found jade file/\.jade$/
+ if (stat.isFile() && re.test(path)) {
+ if (options.watch) watchFile(path);
+ var str = fs.readFileSync(path, 'utf8');
+ options.filename = path;
+ if (program.nameAfterFile) {
+ options.name = getNameFromFileName(path);
+ }
+ var fn = options.client ? jade.compileClient(str, options) : jade.compile(str, options);
+ if (options.watch && fn.dependencies) {
+ // watch dependencies, and recompile the base
+ fn.dependencies.forEach(function (dep) {
+ watchFile(dep, path);
+ });
+ }
+
+ // --extension
+ if (program.extension) var extname = '.' + program.extension;
+ else if (options.client) var extname = '.js';
+ else var extname = '.html';
+
+ path = path.replace(re, extname);
+ if (program.out) path = join(program.out, basename(path));
+ var dir = resolve(dirname(path));
+ mkdirp.sync(dir, 0755);
+ var output = options.client ? fn : fn(options);
+ fs.writeFileSync(path, output);
+ console.log(' \033[90mrendered \033[36m%s\033[0m', normalize(path));
+ // Found directory
+ } else if (stat.isDirectory()) {
+ var files = fs.readdirSync(path);
+ files.map(function(filename) {
+ return path + '/' + filename;
+ }).forEach(renderFile);
+ }
+}
+
+/**
+ * Get a sensible name for a template function from a file path
+ *
+ * @param {String} filename
+ * @returns {String}
+ */
+function getNameFromFileName(filename) {
+ var file = basename(filename, '.jade');
+ return file.toLowerCase().replace(/[^a-z0-9]+([a-z])/g, function (_, character) {
+ return character.toUpperCase();
+ }) + 'Template';
+}
http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/0ef79031/modules/webconfig/nodejs/node_modules/jade/component.json
----------------------------------------------------------------------
diff --git a/modules/webconfig/nodejs/node_modules/jade/component.json b/modules/webconfig/nodejs/node_modules/jade/component.json
new file mode 100644
index 0000000..92e2b40
--- /dev/null
+++ b/modules/webconfig/nodejs/node_modules/jade/component.json
@@ -0,0 +1,16 @@
+{
+ "name": "jade",
+ "repo": "visionmedia/jade",
+ "description": "Jade template runtime",
+ "version": "1.9.2",
+ "keywords": [
+ "template"
+ ],
+ "dependencies": {},
+ "development": {},
+ "license": "MIT",
+ "scripts": [
+ "lib/runtime.js"
+ ],
+ "main": "lib/runtime.js"
+}
\ No newline at end of file