Héllo,
I've been lurking around skribillo and artanis. I don't really like
the
rails-like syntax
of artanis, even if it has its use-cases and I wanted to hack on
something "small", so
I've put together sfx.
The code of skribe reader is included in sfx.scm. So the only
dependency
is guile (2.0.11) and
guile-reader that you can install using `guix package -i
guile-reader`.
This bare template language has the following features:
- wanna be simpler sxml syntax
- templates with custom environment
- external libraries loading inside the template
# Wanna be simpler sxml syntax
Skribe reader (implemented with guile-reader) provide a handy syntax
to
both define keywords and quasiquote. In an sxml context those features
are used to implemented attributes and text nodes.
## attributes
Attributes in sxml are defined as follow:
(div (@ (id "shell")) "This the main area")
Instead of requiring the nesting of `(attribute-name attribute-value)`
sfx use
the simpler keyword syntax `:keyword`. The above snippet becomes:
(div (@ :id "shell") "This the main area")
I'm not sure it's worth the trouble of diverting from sxml standard.
That said, it looks
more like plain xml.
## text nodes
Text nodes can be defined as
(p [héllo hacker])
This is looks the same as the default reader. It becomes handy when
you
include an
inline element inside the text node:
(p [héllo ,(b [hacker])
`,()` is a special syntax of skribe reader which provides `(unquote)`
inside [bracket] `quasiquote`.
With the default guile reader, this must be written as:
(p "héllo " (b "hacker"))
This is looks verbose and prone to error. One must not forget the
space
in the
string before the `(b)` element.
# templates with custom environment
Right now this part of the template language is not really
userfriendly.
But you can pass custom
variables to the template but those must be parameters. In the example
sfx.scm (which includes
example use of the procedures) the environment in which the template
is
evaled is defined as follow:
(define value (make-parameter 42))
(define amirouche (make-person "amirouche" 30))
(define env (let ((value value)
(amirouche amirouche))
(the-environment)))
Then `value` can be echo'ed inside the template using the unquote
syntax
`,()`, e.g.
(p [Here is a lucky number for you «,(value)»])
As you can see the previous snippet, there is also a `<record>` record
inside the environment.
One can (maybe) provide in the environment the required procedures to
echo the correct
fields but this is verbose. Instead sfx use `(use-modules)` inside the
template definition
file. This is presented in the following and last part.
# external libraries loading inside the template
Currently it's (only) possible to do `(use-modules)` inside the
template
file. The template
file looks like the following:
```
(use-modules (person))
`(html
(body
(p [My name is ,(person-name amirouche)])))
```
I could not make procedure definition work inside the template, this
my
be linked to the way
I eval the template. It's shame because for quick and dirty hacks it
can
be handy like defining
mini-templates inside the big template.
This is my second try at this and having a look at the code of haunt
[1]
was helpful.
Hope this helps!
[1] https://git.dthompson.us/haunt.git