mustache 3.3.0 · OCaml Package

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

type nonrec loc = loc = {

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

}

and desc = 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 = section = {

name : dotted_name;
contents : t;

}

and partial = partial = {

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

}

and param = param = {

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

}

and t = t = {

loc : loc;
desc : desc;

}

val dummy_loc : loc

A value of type loc, guaranteed to be different from any valid location.

val parse_lx : Lexing.lexbuf -> t

Read

val of_string : string -> t

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

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

val to_formatter : 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.

val render_fmt : 
  ?strict:bool ->
  ?partials:(name -> t option) ->
  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) ->
  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:(loc:loc -> string -> 'a) ->
  section:(loc:loc -> inverted:bool -> dotted_name -> 'a -> 'a) ->
  escaped:(loc:loc -> dotted_name -> 'a) ->
  unescaped:(loc:loc -> dotted_name -> 'a) ->
  partial:
    (loc:loc ->
      ?indent:int ->
      name ->
      ?params:(int * name * 'a) list ->
      t option Lazy.t ->
      'a) ->
  param:(loc:loc -> ?indent:int -> name -> 'a -> 'a) ->
  comment:(loc:loc -> string -> 'a) ->
  concat:(loc:loc -> '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 raw : loc:loc -> string -> t

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

val escaped : loc:loc -> dotted_name -> t

{{name}}

val unescaped : loc:loc -> dotted_name -> t

{{{name}}}

val inverted_section : loc:loc -> dotted_name -> t -> t

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

val section : loc:loc -> dotted_name -> t -> t

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

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

{{> box}} or

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

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

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

val comment : loc:loc -> string -> t

{{! this is a comment}}

val concat : loc:loc -> t list -> t

Group a t list as a single t.

package mustache