eknkc/amber/README.md

# amber [![GoDoc](https://godoc.org/github.com/golang/gddo?status.svg)](http://godoc.org/github.com/eknkc/amber) [![Build Status](https://travis-ci.org/eknkc/amber.svg?branch=master)](https://travis-ci.org/eknkc/amber)

## Notice
> While Amber is perfectly fine and stable to use, I've been working on a direct Pug.js port for Go. It is somewhat hacky at the moment but take a look at [Pug.go](https://github.com/eknkc/pug) if you are looking for a [Pug.js](https://github.com/pugjs/pug) compatible Go template engine.

### Usage
```go
import "github.com/eknkc/amber"
```

Amber is an elegant templating engine for Go Programming Language
It is inspired from HAML and Jade

### Tags

A tag is simply a word:

    html

is converted to

```html
<html></html>
```

It is possible to add ID and CLASS attributes to tags:

    div#main
    span.time

are converted to

```html
<div id="main"></div>
<span class="time"></span>
```

Any arbitrary attribute name / value pair can be added this way:

    a[href="http://www.google.com"]

You can mix multiple attributes together

    a#someid[href="/"][title="Main Page"].main.link Click Link

gets converted to

```html
<a id="someid" class="main link" href="/" title="Main Page">Click Link</a>
```

It is also possible to define these attributes within the block of a tag

    a
        #someid
        [href="/"]
        [title="Main Page"]
        .main
        .link
        | Click Link

### Doctypes

To add a doctype, use `!!!` or `doctype` keywords:

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

or use `doctype`

    doctype 5
    // <!DOCTYPE html>

Available options: `5`, `default`, `xml`, `transitional`, `strict`, `frameset`, `1.1`, `basic`, `mobile`

### Tag Content

For single line tag text, you can just append the text after tag name:

    p Testing!

would yield

    <p>Testing!</p>

For multi line tag text, or nested tags, use indentation:

    html
        head
            title Page Title
        body
            div#content
                p
                    | This is a long page content
                    | These lines are all part of the parent p

                    a[href="/"] Go To Main Page

### Data

Input template data can be reached by key names directly. For example, assuming the template has been
executed with following JSON data:

```json
{
  "Name": "Ekin",
  "LastName": "Koc",
  "Repositories": [
    "amber",
    "dateformat"
  ],
  "Avatar": "/images/ekin.jpg",
  "Friends": 17
}
```

It is possible to interpolate fields using `#{}`

    p Welcome #{Name}!

would print

```html
<p>Welcome Ekin!</p>
```

Attributes can have field names as well

    a[title=Name][href="/ekin.koc"]

would print

```html
<a title="Ekin" href="/ekin.koc"></a>
```

### Expressions

Amber can expand basic expressions. For example, it is possible to concatenate strings with + operator:

    p Welcome #{Name + " " + LastName}

Arithmetic expressions are also supported:

    p You need #{50 - Friends} more friends to reach 50!

Expressions can be used within attributes

    img[alt=Name + " " + LastName][src=Avatar]

### Variables

It is possible to define dynamic variables within templates,
all variables must start with a $ character and can be assigned as in the following example:

    div
        $fullname = Name + " " + LastName
        p Welcome #{$fullname}

If you need to access the supplied data itself (i.e. the object containing Name, LastName etc fields.) you can use `$` variable

    p $.Name

### Conditions

For conditional blocks, it is possible to use `if <expression>`

    div
        if Friends > 10
            p You have more than 10 friends
        else if Friends > 5
            p You have more than 5 friends
        else
            p You need more friends

Again, it is possible to use arithmetic and boolean operators

    div
        if Name == "Ekin" && LastName == "Koc"
            p Hey! I know you..

There is a special syntax for conditional attributes. Only block attributes can have conditions;

    div
        .hasfriends ? Friends > 0

This would yield a div with `hasfriends` class only if the `Friends > 0` condition holds. It is
perfectly fine to use the same method for other types of attributes:

    div
        #foo ? Name == "Ekin"
        [bar=baz] ? len(Repositories) > 0

### Iterations

It is possible to iterate over arrays and maps using `each`:

    each $repo in Repositories
        p #{$repo}

would print

    p amber
    p dateformat

It is also possible to iterate over values and indexes at the same time

    each $i, $repo in Repositories
        p
            .even ? $i % 2 == 0
            .odd ? $i % 2 == 1

### Mixins

Mixins (reusable template blocks that accept arguments) can be defined:

    mixin surprise
        span Surprise!
    mixin link($href, $title, $text)
        a[href=$href][title=$title] #{$text}

and then called multiple times within a template (or even within another mixin definition):

    div
        +surprise
        +surprise
        +link("http://google.com", "Google", "Check out Google")

Template data, variables, expressions, etc., can all be passed as arguments:

    +link(GoogleUrl, $googleTitle, "Check out " + $googleTitle)

### Imports

A template can import other templates using `import`:

    a.amber
        p this is template a

    b.amber
        p this is template b

    c.amber
        div
            import a
            import b

gets compiled to

    div
        p this is template a
        p this is template b

### Inheritance

A template can inherit other templates. In order to inherit another template, an `extends` keyword should be used.
Parent template can define several named blocks and child template can modify the blocks.

    master.amber
        !!! 5
        html
            head
                block meta
                    meta[name="description"][content="This is a great website"]

                title
                    block title
                        | Default title
            body
                block content

    subpage.amber
        extends master

        block title
            | Some sub page!

        block append meta
            // This will be added after the description meta tag. It is also possible
            // to prepend someting to an existing block
            meta[name="keywords"][content="foo bar"]

        block content
            div#main
                p Some content here

### License
(The MIT License)

Copyright (c) 2012 Ekin Koc <ekin@eknkc.com>

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.

## Usage

```go
var DefaultOptions = Options{true, false}
var DefaultDirOptions = DirOptions{".amber", true}
```

#### func  Compile

```go
func Compile(input string, options Options) (*template.Template, error)
```
Parses and compiles the supplied amber template string. Returns corresponding Go
Template (html/templates) instance. Necessary runtime functions will be injected
and the template will be ready to be executed.

#### func  CompileFile

```go
func CompileFile(filename string, options Options) (*template.Template, error)
```
Parses and compiles the contents of supplied filename. Returns corresponding Go
Template (html/templates) instance. Necessary runtime functions will be injected
and the template will be ready to be executed.

#### func  CompileDir
```go
func CompileDir(dirname string, dopt DirOptions, opt Options) (map[string]*template.Template, error)
```
Parses and compiles the contents of a supplied directory name. Returns a mapping of template name (extension stripped) to corresponding Go Template (html/template) instance. Necessary runtime functions will be injected and the template will be ready to be executed.

If there are templates in subdirectories, its key in the map will be it's path relative to `dirname`. For example:
```
templates/
   |-- index.amber
   |-- layouts/
         |-- base.amber
```
```go
templates, err := amber.CompileDir("templates/", amber.DefaultDirOptions, amber.DefaultOptions)
templates["index"] // index.amber Go Template
templates["layouts/base"] // base.amber Go Template
```
By default, the search will be recursive and will match only files ending in ".amber". If recursive is turned off, it will only search the top level of the directory. Specified extension must start with a period.

#### type Compiler

```go
type Compiler struct {
        // Compiler options
        Options
}
```

Compiler is the main interface of Amber Template Engine. In order to use an
Amber template, it is required to create a Compiler and compile an Amber source
to native Go template.

    compiler := amber.New()
    // Parse the input file
    err := compiler.ParseFile("./input.amber")
    if err == nil {
        // Compile input file to Go template
        tpl, err := compiler.Compile()
        if err == nil {
                // Check built in html/template documentation for further details
                tpl.Execute(os.Stdout, somedata)
        }
    }

#### func  New

```go
func New() *Compiler
```
Create and initialize a new Compiler

#### func (*Compiler) Compile

```go
func (c *Compiler) Compile() (*template.Template, error)
```
Compile amber and create a Go Template (html/templates) instance. Necessary
runtime functions will be injected and the template will be ready to be
executed.

#### func (*Compiler) CompileString

```go
func (c *Compiler) CompileString() (string, error)
```
Compile template and return the Go Template source You would not be using this
unless debugging / checking the output. Please use Compile method to obtain a
template instance directly.

#### func (*Compiler) CompileWriter

```go
func (c *Compiler) CompileWriter(out io.Writer) (err error)
```
Compile amber and write the Go Template source into given io.Writer instance You
would not be using this unless debugging / checking the output. Please use
Compile method to obtain a template instance directly.

#### func (*Compiler) Parse

```go
func (c *Compiler) Parse(input string) (err error)
```
Parse given raw amber template string.

#### func (*Compiler) ParseFile

```go
func (c *Compiler) ParseFile(filename string) (err error)
```
Parse the amber template file in given path

#### type Options

```go
type Options struct {
        // Setting if pretty printing is enabled.
        // Pretty printing ensures that the output html is properly indented and in human readable form.
        // If disabled, produced HTML is compact. This might be more suitable in production environments.
        // Defaukt: true
        PrettyPrint bool
        // Setting if line number emitting is enabled
        // In this form, Amber emits line number comments in the output template. It is usable in debugging environments.
        // Default: false
        LineNumbers bool
}
```

#### type DirOptions

```go
// Used to provide options to directory compilation
type DirOptions struct {
        // File extension to match for compilation
        Ext string
        // Whether or not to walk subdirectories
        Recursive bool
}
```
Revision:	1.1
Committed:	Mon Sep 30 00:42:06 2024 UTC (6 weeks, 4 days ago) by yakumo_izuru
Branch:	MAIN
CVS Tags:	HEAD
Log Message:	Mirrored from https://git.chaotic.ninja/git/yakumo_izuru/aya
#	User	Rev	Content
1	yakumo_izuru	1.1	# amber [![GoDoc](https://godoc.org/github.com/golang/gddo?status.svg)](http://godoc.org/github.com/eknkc/amber) [![Build Status](https://travis-ci.org/eknkc/amber.svg?branch=master)](https://travis-ci.org/eknkc/amber)
2
3			## Notice
4			> While Amber is perfectly fine and stable to use, I've been working on a direct Pug.js port for Go. It is somewhat hacky at the moment but take a look at [Pug.go](https://github.com/eknkc/pug) if you are looking for a [Pug.js](https://github.com/pugjs/pug) compatible Go template engine.
5
6			### Usage
7			```go
8			import "github.com/eknkc/amber"
9			```
10
11			Amber is an elegant templating engine for Go Programming Language
12			It is inspired from HAML and Jade
13
14			### Tags
15
16			A tag is simply a word:
17
18			html
19
20			is converted to
21
22			```html
23			<html></html>
24			```
25
26			It is possible to add ID and CLASS attributes to tags:
27
28			div#main
29			span.time
30
31			are converted to
32
33			```html
34			<div id="main"></div>
35			<span class="time"></span>
36			```
37
38			Any arbitrary attribute name / value pair can be added this way:
39
40			a[href="http://www.google.com"]
41
42			You can mix multiple attributes together
43
44			a#someid[href="/"][title="Main Page"].main.link Click Link
45
46			gets converted to
47
48			```html
49			<a id="someid" class="main link" href="/" title="Main Page">Click Link</a>
50			```
51
52			It is also possible to define these attributes within the block of a tag
53
54			a
55			#someid
56			[href="/"]
57			[title="Main Page"]
58			.main
59			.link
60			\| Click Link
61
62			### Doctypes
63
64			To add a doctype, use `!!!` or `doctype` keywords:
65
66			!!! transitional
67			// <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
68
69			or use `doctype`
70
71			doctype 5
72			// <!DOCTYPE html>
73
74			Available options: `5`, `default`, `xml`, `transitional`, `strict`, `frameset`, `1.1`, `basic`, `mobile`
75
76			### Tag Content
77
78			For single line tag text, you can just append the text after tag name:
79
80			p Testing!
81
82			would yield
83
84			<p>Testing!</p>
85
86			For multi line tag text, or nested tags, use indentation:
87
88			html
89			head
90			title Page Title
91			body
92			div#content
93			p
94			\| This is a long page content
95			\| These lines are all part of the parent p
96
97			a[href="/"] Go To Main Page
98
99			### Data
100
101			Input template data can be reached by key names directly. For example, assuming the template has been
102			executed with following JSON data:
103
104			```json
105			{
106			"Name": "Ekin",
107			"LastName": "Koc",
108			"Repositories": [
109			"amber",
110			"dateformat"
111			],
112			"Avatar": "/images/ekin.jpg",
113			"Friends": 17
114			}
115			```
116
117			It is possible to interpolate fields using `#{}`
118
119			p Welcome #{Name}!
120
121			would print
122
123			```html
124			<p>Welcome Ekin!</p>
125			```
126
127			Attributes can have field names as well
128
129			a[title=Name][href="/ekin.koc"]
130
131			would print
132
133			```html
134			<a title="Ekin" href="/ekin.koc"></a>
135			```
136
137			### Expressions
138
139			Amber can expand basic expressions. For example, it is possible to concatenate strings with + operator:
140
141			p Welcome #{Name + " " + LastName}
142
143			Arithmetic expressions are also supported:
144
145			p You need #{50 - Friends} more friends to reach 50!
146
147			Expressions can be used within attributes
148
149			img[alt=Name + " " + LastName][src=Avatar]
150
151			### Variables
152
153			It is possible to define dynamic variables within templates,
154			all variables must start with a $ character and can be assigned as in the following example:
155
156			div
157			$fullname = Name + " " + LastName
158			p Welcome #{$fullname}
159
160			If you need to access the supplied data itself (i.e. the object containing Name, LastName etc fields.) you can use `$` variable
161
162			p $.Name
163
164			### Conditions
165
166			For conditional blocks, it is possible to use `if <expression>`
167
168			div
169			if Friends > 10
170			p You have more than 10 friends
171			else if Friends > 5
172			p You have more than 5 friends
173			else
174			p You need more friends
175
176			Again, it is possible to use arithmetic and boolean operators
177
178			div
179			if Name == "Ekin" && LastName == "Koc"
180			p Hey! I know you..
181
182			There is a special syntax for conditional attributes. Only block attributes can have conditions;
183
184			div
185			.hasfriends ? Friends > 0
186
187			This would yield a div with `hasfriends` class only if the `Friends > 0` condition holds. It is
188			perfectly fine to use the same method for other types of attributes:
189
190			div
191			#foo ? Name == "Ekin"
192			[bar=baz] ? len(Repositories) > 0
193
194			### Iterations
195
196			It is possible to iterate over arrays and maps using `each`:
197
198			each $repo in Repositories
199			p #{$repo}
200
201			would print
202
203			p amber
204			p dateformat
205
206			It is also possible to iterate over values and indexes at the same time
207
208			each $i, $repo in Repositories
209			p
210			.even ? $i % 2 == 0
211			.odd ? $i % 2 == 1
212
213			### Mixins
214
215			Mixins (reusable template blocks that accept arguments) can be defined:
216
217			mixin surprise
218			span Surprise!
219			mixin link($href, $title, $text)
220			a[href=$href][title=$title] #{$text}
221
222			and then called multiple times within a template (or even within another mixin definition):
223
224			div
225			+surprise
226			+surprise
227			+link("http://google.com", "Google", "Check out Google")
228
229			Template data, variables, expressions, etc., can all be passed as arguments:
230
231			+link(GoogleUrl, $googleTitle, "Check out " + $googleTitle)
232
233			### Imports
234
235			A template can import other templates using `import`:
236
237			a.amber
238			p this is template a
239
240			b.amber
241			p this is template b
242
243			c.amber
244			div
245			import a
246			import b
247
248			gets compiled to
249
250			div
251			p this is template a
252			p this is template b
253
254			### Inheritance
255
256			A template can inherit other templates. In order to inherit another template, an `extends` keyword should be used.
257			Parent template can define several named blocks and child template can modify the blocks.
258
259			master.amber
260			!!! 5
261			html
262			head
263			block meta
264			meta[name="description"][content="This is a great website"]
265
266			title
267			block title
268			\| Default title
269			body
270			block content
271
272			subpage.amber
273			extends master
274
275			block title
276			\| Some sub page!
277
278			block append meta
279			// This will be added after the description meta tag. It is also possible
280			// to prepend someting to an existing block
281			meta[name="keywords"][content="foo bar"]
282
283			block content
284			div#main
285			p Some content here
286
287			### License
288			(The MIT License)
289
290			Copyright (c) 2012 Ekin Koc <ekin@eknkc.com>
291
292			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:
293
294			The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
295
296			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.
297
298			## Usage
299
300			```go
301			var DefaultOptions = Options{true, false}
302			var DefaultDirOptions = DirOptions{".amber", true}
303			```
304
305			#### func Compile
306
307			```go
308			func Compile(input string, options Options) (*template.Template, error)
309			```
310			Parses and compiles the supplied amber template string. Returns corresponding Go
311			Template (html/templates) instance. Necessary runtime functions will be injected
312			and the template will be ready to be executed.
313
314			#### func CompileFile
315
316			```go
317			func CompileFile(filename string, options Options) (*template.Template, error)
318			```
319			Parses and compiles the contents of supplied filename. Returns corresponding Go
320			Template (html/templates) instance. Necessary runtime functions will be injected
321			and the template will be ready to be executed.
322
323			#### func CompileDir
324			```go
325			func CompileDir(dirname string, dopt DirOptions, opt Options) (map[string]*template.Template, error)
326			```
327			Parses and compiles the contents of a supplied directory name. Returns a mapping of template name (extension stripped) to corresponding Go Template (html/template) instance. Necessary runtime functions will be injected and the template will be ready to be executed.
328
329			If there are templates in subdirectories, its key in the map will be it's path relative to `dirname`. For example:
330			```
331			templates/
332			\|-- index.amber
333			\|-- layouts/
334			\|-- base.amber
335			```
336			```go
337			templates, err := amber.CompileDir("templates/", amber.DefaultDirOptions, amber.DefaultOptions)
338			templates["index"] // index.amber Go Template
339			templates["layouts/base"] // base.amber Go Template
340			```
341			By default, the search will be recursive and will match only files ending in ".amber". If recursive is turned off, it will only search the top level of the directory. Specified extension must start with a period.
342
343			#### type Compiler
344
345			```go
346			type Compiler struct {
347			// Compiler options
348			Options
349			}
350			```
351
352			Compiler is the main interface of Amber Template Engine. In order to use an
353			Amber template, it is required to create a Compiler and compile an Amber source
354			to native Go template.
355
356			compiler := amber.New()
357			// Parse the input file
358			err := compiler.ParseFile("./input.amber")
359			if err == nil {
360			// Compile input file to Go template
361			tpl, err := compiler.Compile()
362			if err == nil {
363			// Check built in html/template documentation for further details
364			tpl.Execute(os.Stdout, somedata)
365			}
366			}
367
368			#### func New
369
370			```go
371			func New() *Compiler
372			```
373			Create and initialize a new Compiler
374
375			#### func (*Compiler) Compile
376
377			```go
378			func (c Compiler) Compile() (template.Template, error)
379			```
380			Compile amber and create a Go Template (html/templates) instance. Necessary
381			runtime functions will be injected and the template will be ready to be
382			executed.
383
384			#### func (*Compiler) CompileString
385
386			```go
387			func (c *Compiler) CompileString() (string, error)
388			```
389			Compile template and return the Go Template source You would not be using this
390			unless debugging / checking the output. Please use Compile method to obtain a
391			template instance directly.
392
393			#### func (*Compiler) CompileWriter
394
395			```go
396			func (c *Compiler) CompileWriter(out io.Writer) (err error)
397			```
398			Compile amber and write the Go Template source into given io.Writer instance You
399			would not be using this unless debugging / checking the output. Please use
400			Compile method to obtain a template instance directly.
401
402			#### func (*Compiler) Parse
403
404			```go
405			func (c *Compiler) Parse(input string) (err error)
406			```
407			Parse given raw amber template string.
408
409			#### func (*Compiler) ParseFile
410
411			```go
412			func (c *Compiler) ParseFile(filename string) (err error)
413			```
414			Parse the amber template file in given path
415
416			#### type Options
417
418			```go
419			type Options struct {
420			// Setting if pretty printing is enabled.
421			// Pretty printing ensures that the output html is properly indented and in human readable form.
422			// If disabled, produced HTML is compact. This might be more suitable in production environments.
423			// Defaukt: true
424			PrettyPrint bool
425			// Setting if line number emitting is enabled
426			// In this form, Amber emits line number comments in the output template. It is usable in debugging environments.
427			// Default: false
428			LineNumbers bool
429			}
430			```
431
432			#### type DirOptions
433
434			```go
435			// Used to provide options to directory compilation
436			type DirOptions struct {
437			// File extension to match for compilation
438			Ext string
439			// Whether or not to walk subdirectories
440			Recursive bool
441			}
442			```