Orasund / elm-handlebars / Handlebars.Helper

Helpers can be set in the config type.

There are two kinds of helpers:

Expression Helper

lookup : List Handlebars.Value.Value -> Result String Handlebars.Value.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 Handlebars.Value.Value -> Result String Handlebars.Value.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 : Handlebars.Value.Value, throw : String -> Handlebars.Expression.Error, content : Handlebars.Path.Path -> Result Handlebars.Expression.Error String } -> Handlebars.Path.Path -> Result Handlebars.Expression.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 : Handlebars.Value.Value, throw : String -> Handlebars.Expression.Error, content : Handlebars.Path.Path -> Result Handlebars.Expression.Error String } -> Handlebars.Path.Path -> Result Handlebars.Expression.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 : Handlebars.Value.Value, throw : String -> Handlebars.Expression.Error, content : Handlebars.Path.Path -> Result Handlebars.Expression.Error String } -> Handlebars.Path.Path -> Result Handlebars.Expression.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 : Handlebars.Value.Value, throw : String -> Handlebars.Expression.Error, content : Handlebars.Path.Path -> Result Handlebars.Expression.Error String } -> Handlebars.Path.Path -> Result Handlebars.Expression.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