stache: Mustache templates for Haskell

Versions [RSS]	0.1.0, 0.1.1, 0.1.2, 0.1.3, 0.1.4, 0.1.5, 0.1.6, 0.1.7, 0.1.8, 0.2.0, 0.2.1, 0.2.2, 1.0.0, 1.1.0, 1.1.1, 1.1.2, 1.2.0, 1.2.1, 2.0.0, 2.0.1, 2.1.0, 2.1.1, 2.2.0, 2.2.1, 2.3.0, 2.3.1, 2.3.2, 2.3.3, 2.3.4
Change log	CHANGELOG.md
Dependencies	aeson (>=0.11 && <0.12), base (>=4.7 && <5.0), bytestring (>=0.10 && <0.11), containers (>=0.5 && <0.6), deepseq (>=1.4 && <1.5), directory (>=1.2 && <1.3), exceptions (>=0.8 && <0.9), filepath (>=1.2 && <1.5), megaparsec (>=5.0 && <6.0), mtl (>=2.1 && <3.0), semigroups (>=0.18 && <0.19), template-haskell (>=2.10 && <2.12), text (>=1.2 && <1.3), unordered-containers (>=0.2.5 && <0.3), vector (>=0.11 && <0.12) [details]
License	BSD-3-Clause
Author	Mark Karpov <markkarpov@openmailbox.org>
Maintainer	Mark Karpov <markkarpov@openmailbox.org>
Category	Text
Home page	https://github.com/stackbuilders/stache
Bug tracker	https://github.com/stackbuilders/stache/issues
Source repo	head: git clone https://github.com/stackbuilders/stache.git
Uploaded	by mrkkrp at 2016-07-30T19:47:07Z
Distributions	LTSHaskell:2.3.4, NixOS:2.3.4, Stackage:2.3.4
Reverse Dependencies	7 direct, 0 indirect [details]
Downloads	20890 total (146 in the last 30 days)
Rating	2.0 (votes: 1) [estimated by Bayesian average]
Your Rating	λ λ λ
Status	Docs available [build log] Last success reported on 2016-07-30 [all 1 reports]

Readme for stache-0.1.4

[back to package description]

Stache

This is a Haskell implementation of Mustache templates. The implementation conforms to the version 1.1.3 of official [Mustache specification] (https://github.com/mustache/spec). It is extremely simple and straightforward to use with minimal but complete API — three functions to compile templates (from directory, from file, and from lazy text) and one to render them.

The implementation uses the Megaparsec parsing library to parse the templates which is results in superior quality of error messages.

For rendering you only need to create Aeson's Value where you put the data to interpolate. Since the library re-uses Aeson's instances and most data types in Haskell ecosystem are instances of classes like Data.Aeson.ToJSON, the whole process is very simple for end user.

Template Haskell helpers for compilation of templates at compile time are available in the Text.Mustache.Compile.TH module. The helpers are currently available only for GHC 8 users though.

One feature that is not currently supported is lambdas. The feature is marked as optional in the spec and can be emulated via processing of parsed template representation. The decision to drop lambdas is intentional, for the sake of simplicity and better integration with Aeson.

Quick start

Here is an example of basic usage:

{-# LANGUAGE OverloadedStrings #-}

module Main (main) where

import Data.Aeson
import Data.Text
import Text.Megaparsec
import Text.Mustache
import qualified Data.Text.Lazy.IO as TIO

main :: IO ()
main = do
  let res = compileMustacheText "foo"
        "Hi, {{name}}! You have:\n{{#things}}\n  * {{.}}\n{{/things}}\n"
  case res of
    Left err -> putStrLn (parseErrorPretty err)
    Right template -> TIO.putStr $ renderMustache template $ object
      [ "name"   .= ("John" :: Text)
      , "things" .= ["pen" :: Text, "candle", "egg"]
      ]

If I run the program, it prints the following:

Hi, John! You have:
  * pen
  * candle
  * egg

For more information about Mustache templates the following links may be helpful:

The official Mustache site: https://mustache.github.io/
The manual: https://mustache.github.io/mustache.5.html
The specification: https://github.com/mustache/spec

License

Distributed under BSD 3 clause license.