Handlebars.Helper

Helpers can be set in the config type.

There are two kinds of helpers:

(Expression) Helpers {{helper a b c}}
(Block) Helpers {{#helper a}} content {{/helper}}

Expression Helper

lookup : List Value -> Result String Value

import Parser
import Handlebars.Expression as Expression exposing (Expression(..), SubExp(..))
import Result.Extra as Result
import Handlebars
import Json.Decode as D


compile : String -> String -> Maybe String
compile template value =
    case value |> D.decodeString D.value of
        Ok v ->
            case
                v
                |> Handlebars.compile Handlebars.defaultConfig
                    template
            of
            Ok result -> Just result
            Err _ -> Nothing
        Err _ -> Nothing


"{ \"key\":\"1\",\"users\": [\"Jack\",\"Gill\"] }"
    |> compile "Hello {{lookup users key}}"
    --> Just "Hello Gill"

equals : List Value -> Result String Value

import Parser
import Handlebars.Expression as Expression exposing (Expression(..), SubExp(..))
import Result.Extra as Result
import Handlebars
import Json.Decode as D


compile : String -> String -> Maybe String
compile template value =
    case value |> D.decodeString D.value of
        Ok v ->
            case
                v
                |> Handlebars.compile Handlebars.defaultConfig
                    template
            of
            Ok result -> Just result
            Err _ -> Nothing
        Err _ -> Nothing


"{ \"first\":[\"Gill\",\"Jack\"],\"second\": [\"Jack\",\"Gill\"] }"
    |> compile "{{#if (equals first second)}}equal{{/if}}"
    --> Just ""


"{ \"first\":[\"Jack\", \"Gill\"],\"second\": [\"Jack\",\"Gill\"] }"
    |> compile "{{#if (equals first second)}}equal{{/if}}"
    --> Just "equal"


"{ \"first\":[\"Jack\", \"Gill\"],\"second\": [\"Jack\",\"Gill\"] }"
    |> compile "{{#if (equals first.0 second.0)}}equal{{/if}}"
    --> Just "equal"


"{ \"first\":[\"Jack\", \"Gill\"],\"second\": [\"Jack\",\"Gill\"] }"
    |> compile "{{#if (equals first.0)}}equal{{/if}}"
    --> Nothing

Block Helper

if_ :

{ arg : Value

, throw : String -> Error

, content : Path -> Result Error String

}

-> Path

-> Result Error String

import Parser
import Handlebars.Expression as Expression exposing (Expression(..), SubExp(..))
import Result.Extra as Result
import Handlebars
import Json.Decode as D


compile : String -> String -> Maybe String
compile template value =
    case value |> D.decodeString D.value of
        Ok v ->
            case
                v
                |> Handlebars.compile Handlebars.defaultConfig
                    template
            of
            Ok result -> Just result
            Err _ -> Nothing
        Err _ -> Nothing


"{ \"valid\":null }"
    |> compile "{{#if valid}}Hello There{{/if}}"


    --> Just ""


"{ \"valid\":false }"
    |> compile "{{#if valid}}Hello There{{/if}}"


    --> Just ""


"{ \"valid\":true }"
    |> compile "{{#if valid}}Hello There{{/if}}"


    --> Just "Hello There"


"{ \"name\":\"Jack\" }"
    |> compile "{{#if name}}Hello There{{/if}}"


    --> Just "Hello There"


"{ \"name\":\"\" }"
    |> compile "{{#if name}}Hello There{{/if}}"


    --> Just ""


"{ \"list\": [] }"
    |> compile "{{#if list}}Hello There{{/if}}"


    --> Just ""


"{ \"list\": [ \"something\" ] }"
    |> compile "{{#if list}}Hello There{{/if}}"


    --> Just "Hello There"


"{ \"list\": [ \"something\" ] }"
    |> compile "{{#if .}}Hello There{{/if}}"


    --> Just "Hello There"


"{}"
    |> compile "{{#if .}}Hello There{{/if}}"


    --> Just ""

unless :

{ arg : Value

, throw : String -> Error

, content : Path -> Result Error String

}

-> Path

-> Result Error String

import Parser
import Handlebars.Expression as Expression exposing (Expression(..), SubExp(..))
import Result.Extra as Result
import Handlebars
import Json.Decode as D


compile : String -> String -> Maybe String
compile template value =
    case value |> D.decodeString D.value of
        Ok v ->
            case
                v
                |> Handlebars.compile Handlebars.defaultConfig
                    template
            of
            Ok result -> Just result
            Err _ -> Nothing
        Err _ -> Nothing


"{ \"valid\":null }"
    |> compile "{{#unless valid}}Hello There{{/unless}}"


    --> Just "Hello There"


"{ \"valid\":false }"
    |> compile "{{#unless valid}}Hello There{{/unless}}"


    --> Just "Hello There"


"{ \"valid\":true }"
    |> compile "{{#unless valid}}Hello There{{/unless}}"


    --> Just ""


"{ \"name\":\"Jack\" }"
    |> compile "{{#unless name}}Hello There{{/unless}}"


    --> Just ""


"{ \"name\":\"\" }"
    |> compile "{{#unless name}}Hello There{{/unless}}"


    --> Just "Hello There"


"{ \"list\": [] }"
    |> compile "{{#unless list}}Hello There{{/unless}}"


    --> Just "Hello There"


"{ \"list\": [ \"something\" ] }"
    |> compile "{{#unless list}}Hello There{{/unless}}"


    --> Just ""


"{ \"list\": [ \"something\" ] }"
    |> compile "{{#unless .}}Hello There{{/unless}}"


    --> Just ""


"{}"
    |> compile "{{#unless .}}Hello There{{/unless}}"


    --> Just "Hello There"

inline :

{ arg : Value

, throw : String -> Error

, content : Path -> Result Error String

}

-> Path

-> Result Error String

import Parser
import Handlebars.Expression as Expression exposing (Expression(..), SubExp(..))
import Result.Extra as Result
import Handlebars
import Json.Decode as D


compile : String -> String -> Maybe String
compile template value =
    case value |> D.decodeString D.value of
        Ok v ->
            case
                v
                |> Handlebars.compile Handlebars.defaultConfig
                    template
            of
            Ok result -> Just result
            Err _ -> Nothing
        Err _ -> Nothing


"{ \"test\":\"true\" }"
    |> compile "{{#inline .}}Hello\n There{{/inline}}"
    --> Just "Hello There"

inside :

{ arg : Value

, throw : String -> Error

, content : Path -> Result Error String

}

-> Path

-> Result Error String

import Parser
import Handlebars.Expression as Expression exposing (Expression(..), SubExp(..))
import Handlebars exposing (Error(..))
import Result.Extra as Result
import Json.Decode as D


compile : String -> String -> Maybe String
compile template value =
    case value |> D.decodeString D.value of
        Ok v ->
            case
                v
                |> Handlebars.compile Handlebars.defaultConfig
                    template
            of
            Ok result -> Just result
            Err _ -> Nothing
        Err _ -> Nothing




"{ \"name\":\"Jack\",\"key\":\"name\" }"
    |> compile "{{#inside key}}{{.}}{{/inside}}"


    --> Just ("Jack")


"{ \"name\":\"Jack\",\"key\":false }"
    |> compile "{{#inside key}}{{.}}{{/inside}}"


    --> Nothing


"{ \"name\":\"Jack\",\"key\":0 }"
    |> compile "{{#inside key}}{{.}}{{/inside}}"


    --> Nothing
"{ \"name\":\"Jack\",\"key\":\"notAPath...\" }"
    |> compile "{{#inside key}}{{.}}{{/inside}}"


    --> Nothing

Orasund/elm-handlebars/1.0.2

Handlebars.Helper

Expression Helper

Block Helper

Modules