summaryrefslogtreecommitdiff
path: root/test/mustache-th/RenderNonTH.hs
blob: 464d651a454159d065e687d5aa90b8e7eff0dd1c (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
{-|
Copyright: (c) Tom Smeding 2026
License: AGPL-3.0-or-later
-}
module RenderNonTH (render) where

import Data.Aeson.Key qualified as Aeson
import Data.Aeson.KeyMap qualified as Aeson
import Data.List.NonEmpty (NonEmpty(..))
import Data.List.NonEmpty qualified as NE
import Data.Map.Strict (Map)
import Data.Scientific qualified as Sc
import Data.Text (Text)
import Data.Text qualified as T
import Data.Text.Builder.Linear qualified as TBL
import Data.Vector (Vector)
import Data.Vector qualified as V
import Data.Yaml qualified as Y

import EscapeXML
import Mustache.TH.Parser


render :: Map Text Template -> Template -> Y.Value -> Text
render partials = \(Template chunks) value -> TBL.runBuilder (renderChunks (value :| []) chunks)
  where
    renderChunks :: NonEmpty Y.Value -> Vector Chunk -> TBL.Builder
    renderChunks stack chs = V.foldMap' (renderChunk stack) chs

    renderChunk :: NonEmpty Y.Value -> Chunk -> TBL.Builder
    renderChunk stack = \case
      Text text -> TBL.fromText text
      Var esc var ->
        case search (V.toList var) stack of
          Just (Y.String text) -> TBL.fromText (if esc then escapeXML text else text)
          Just (Y.Number v)
            | Sc.base10Exponent v >= 0 -> TBL.fromText (T.show (round v :: Integer))
            | otherwise -> TBL.fromText (T.show v)
          Just Y.Null -> mempty
          Just thing -> error $ "Cannot render " ++ show thing
          Nothing -> mempty  -- the typed renderer raises a compile-time error here
      Section positive var chunks -> do
        let mthing = case search (V.toList var) stack of
              Just val@Y.Object{} -> Just (Right val)
              Just (Y.Array vals) -> Just (Left vals)
              Just val@(Y.String t) | not (T.null t) -> Just (Right val)
              Just val@(Y.Number v) | v /= 0 -> Just (Right val)
              Just val@(Y.Bool True) -> Just (Right val)
              _ -> Nothing
        case (positive, mthing) of
          (True, Just (Right val)) -> renderChunks (val NE.<| stack) chunks
          (True, Just (Left vals)) -> V.foldMap' (\val -> renderChunks (val NE.<| stack) chunks) vals
          (False, Nothing) -> renderChunks stack chunks
          (False, Just (Left vals)) | V.null vals -> renderChunks stack chunks
          _ -> mempty
      Partial mindent path ->
        let Template chs' = inlinePartials False True partials (Template (V.singleton (Partial mindent path)))
        in renderChunks stack chs'

search :: [Text] -> NonEmpty Y.Value -> Maybe Y.Value
search [] (value :| _) = Just value
search (key : keys) (value :| stack) =
  case value of
    Y.Object fields ->
      case Aeson.lookup (Aeson.fromText key) fields of
        Just value' -> search keys (value' :| [])
        Nothing -> search (key : keys) =<< NE.nonEmpty stack
    _ ->
      search (key : keys) =<< NE.nonEmpty stack