mustache 3.3.0 (latest) · OCaml Package

A module for creating and rendering mustache templates in OCaml.

module Json : sig ... end

type loc = {

loc_start : Stdlib.Lexing.position;
loc_end : Stdlib.Lexing.position;

}

type name = string

type dotted_name = string list

type t = {

loc : loc;
desc : desc;

}

and desc =

| String of string
| Escaped of dotted_name
| Unescaped of dotted_name
| Section of section
| Inverted_section of section
| Partial of partial
| Param of param
| Concat of t list
| Comment of string

and section = {

name : dotted_name;
contents : t;

}

and partial = {

indent : int;
name : name;
params : param list option;
contents : t option Stdlib.Lazy.t;

}

and param = {

indent : int;
name : name;
contents : t;

}

val pp_loc : Stdlib.Format.formatter -> loc -> unit

type template_parse_error

Read template files; those function may raise Parse_error.

exception Parse_error of template_parse_error

val parse_lx : Stdlib.Lexing.lexbuf -> t

val of_string : string -> t

val pp_template_parse_error : 
  Stdlib.Format.formatter ->
  template_parse_error ->
  unit

pp_template_parse_error fmt err prints a human-readable description of a template parse error on the given formatter. The function does not flush the formatter (in case you want to use it within boxes), so you should remember to do it yourself.

try ignore (Mustache.of_string "{{!") with Mustache.Parse_error err ->
Format.eprintf "%a@." Mustache.pp_template_parse_error err

val pp : Stdlib.Format.formatter -> t -> unit

pp fmt template print a template as raw mustache to the formatter fmt.

val to_formatter : Stdlib.Format.formatter -> t -> unit

Alias for compatibility

val to_string : t -> string

to_string template uses to_formatter in order to return a string representing the template as raw mustache.

type render_error_kind =

| Invalid_param of {
1. name : dotted_name;
2. expected_form : string;
}
| Missing_variable of {
1. name : dotted_name;
}
| Missing_section of {
1. name : dotted_name;
}
| Missing_partial of {
1. name : name;
}

Render templates; those functions may raise Render_error.

type render_error = {

loc : loc;
kind : render_error_kind;

}

exception Render_error of render_error

val pp_render_error : Stdlib.Format.formatter -> render_error -> unit

val render_fmt : 
  ?strict:bool ->
  ?partials:(name -> t option) ->
  Stdlib.Format.formatter ->
  t ->
  Json.t ->
  unit

render_fmt fmt template json renders template, filling it with data from json, printing it to formatter fmt.

For each partial p, if partials p is Some t then the partial is substituted by t. Otherwise, the partial is substituted by the empty string is strict is false. If strict is true, a Missing_partial error is raised.

raises Render_error
when there is a mismatch between the template and the data. The Missing_* cases are only raised in strict mode, when strict is true.

val render_buf : 
  ?strict:bool ->
  ?partials:(name -> t option) ->
  Stdlib.Buffer.t ->
  t ->
  Json.t ->
  unit

render_buf buf template json renders template, filling it with data from json, printing it to the buffer buf. See render_fmt.

val render : 
  ?strict:bool ->
  ?partials:(name -> t option) ->
  t ->
  Json.t ->
  string

render template json renders template, filling it with data from json, and returns the resulting string. See render_fmt.

val fold : 
  string:(string -> 'a) ->
  section:(inverted:bool -> dotted_name -> 'a -> 'a) ->
  escaped:(dotted_name -> 'a) ->
  unescaped:(dotted_name -> 'a) ->
  partial:
    (?indent:int ->
      name ->
      ?params:(int * name * 'a) list ->
      t option Stdlib.Lazy.t ->
      'a) ->
  param:(?indent:int -> name -> 'a -> 'a) ->
  comment:(string -> 'a) ->
  concat:('a list -> 'a) ->
  t ->
  'a

fold template is the composition of f over parts of template, called in order of occurrence, where each f is one of the labelled arguments applied to the corresponding part. The default for f is the identity function.

parameter string
Applied to each literal part of the template.

parameter escaped
Applied to "name" for occurrences of {{name}}.

parameter unescaped
Applied to "name" for occurrences of {{{name}}}.

parameter partial
Applied to "box" for occurrences of {{> box}} or {{< box}}.

parameter params
Applied to "param" for occurrences of {{$ param}}.

parameter comment
Applied to "comment" for occurrences of {{! comment}}.

val expand_partials : (name -> t option) -> t -> t

expand_partials f template is template where for each Partial p node, p.contents now evaluates to f p.name if they were evaluating to None. Note that no lazy is forced at this point, and calls to f are delayed until p.contents is forced.

module Infix : sig ... end

Shortcut for concatening two templates pieces.

val escape_html : string -> string

Escape &, "\"", ', < and > character for html rendering.

val raw : string -> t

<p>This is raw text.</p>

val escaped : dotted_name -> t

{{name}}

val unescaped : dotted_name -> t

{{{name}}}

val inverted_section : dotted_name -> t -> t

{{^person}} {{/person}}

val section : dotted_name -> t -> t

{{#person}} {{/person}}

val partial : 
  ?indent:int ->
  name ->
  ?params:(int * name * t) list ->
  t option Stdlib.Lazy.t ->
  t

{{> box}} or

{{< box}}
  {{$param1}} default value for param1 {{/param1}}
  {{$param2}} default value for param1 {{/param2}}
{{/box}}

val param : ?indent:int -> name -> t -> t

{{$foo}} {{/foo}}

val comment : string -> t

{{! this is a comment}}

val concat : t list -> t

Group a t list as a single t.

module With_locations : sig ... end

Variant of the t mustache datatype which includes source-file locations, and associated functions.

val erase_locs : With_locations.t -> t

Erase locations from a mustache value of type With_locations.t.

val add_dummy_locs : t -> With_locations.t

Add the dummy_loc location to each node of a mustache value of type t.

package mustache