From ffbde7ba6bc275e7cc8c6b2dcca15ad775bedb9b Mon Sep 17 00:00:00 2001 From: Tom Smeding Date: Sun, 8 Nov 2026 13:37:43 +0000 Subject: Use own mustache parser; drop mustache&aeson deps --- test/mustache-th/Main.hs | 101 ++++++++++++++++++++++++++++++++++++++++ test/mustache-th/RenderNonTH.hs | 69 +++++++++++++++++++++++++++ 2 files changed, 170 insertions(+) create mode 100644 test/mustache-th/Main.hs create mode 100644 test/mustache-th/RenderNonTH.hs (limited to 'test/mustache-th') diff --git a/test/mustache-th/Main.hs b/test/mustache-th/Main.hs new file mode 100644 index 0000000..4a30a64 --- /dev/null +++ b/test/mustache-th/Main.hs @@ -0,0 +1,101 @@ +{-| +Copyright: (c) Tom Smeding 2026 +License: AGPL-3.0-or-later +-} +{-# LANGUAGE OverloadedStrings #-} +module Main where + +import Control.Monad.Trans.Class (lift) +import Control.Monad (forM_) +import Control.Monad.Trans.Except +import Data.Bifunctor (first) +import Data.IORef +import Data.Map.Strict (Map) +import Data.Text (Text) +import Data.Text qualified as T +import Data.Yaml qualified as Y +import System.Directory +import System.Environment (getArgs) +import System.Exit (exitSuccess, exitFailure) +import System.FilePath + +import Mustache.TH.Parser +import RenderNonTH + + +-- TODO: This tests only the parser, not the renderer. Parse all the test YAMLs +-- in TH and generate data types for the data objects?? + + +data SpecFile = SpecFile [SpecTest] + deriving (Show) + +data SpecTest = SpecTest + { stName :: Text + , stDesc :: Text + , stData :: Y.Value + , stTemplate :: Text + , stExpected :: Text + , stPartials :: Map Text Text } + deriving (Show) + +instance Y.FromJSON SpecFile where + parseJSON = Y.withObject "SpecFile" $ \v -> SpecFile + <$> v Y..: "tests" + +instance Y.FromJSON SpecTest where + parseJSON = Y.withObject "SpecTest" $ \v -> SpecTest + <$> v Y..: "name" + <*> v Y..: "desc" + <*> v Y..: "data" + <*> v Y..: "template" + <*> v Y..: "expected" + <*> v Y..:? "partials" Y..!= mempty + +runTest :: String -> SpecTest -> IO (Either String ()) +runTest fname test = runExceptT $ do + let name = fname ++ "/" ++ T.unpack (stName test) + let quote s = "<<\x1B[38:5:249m" ++ s ++ "\x1B[0m>>" + formatOK = "\x1B[32mOK\x1B[0m " ++ name + formatParseError e = "\x1B[31;1m> " ++ name ++ "\n\x1B[0;31mParse failed:\x1B[0m " ++ e + formatWrong tpl out = + "\x1B[31;1m> " ++ name ++ "\n\x1B[0;31mTest failed;\x1B[0m template:\n" ++ + quote (T.unpack (stTemplate test)) ++ "\nparsed:\n" ++ + quote (show tpl) ++ "\nexpected:\n" ++ + quote (show (stExpected test)) ++ "\ngot:\n" ++ quote (show out) + + partials <- except $ first formatParseError $ traverse parseTemplate (stPartials test) + + tpl <- except $ first formatParseError $ parseTemplate (stTemplate test) + let res = render partials tpl (stData test) + if res == stExpected test + then lift $ putStrLn formatOK + else throwE $ formatWrong tpl res + +printUsage :: IO () +printUsage = putStrLn + "Usage: test-mustache-th \n\ + \The should point to a checkout of https://github.com/mustache/spec ;\n\ + \this test suite reads files /specs/*.yml ." + +main :: IO () +main = do + specDirname <- getArgs >>= \case + [path] | path /= "-h", path /= "--help" -> return path + [_] -> printUsage >> exitSuccess + _ -> printUsage >> exitFailure + + let suitable name = + takeExtension name == ".yml" && + take 1 name /= "~" + fnames <- filter suitable <$> listDirectory (specDirname "specs") + ok <- newIORef True + forM_ fnames $ \fname -> do + SpecFile tests <- Y.decodeFileThrow (specDirname "specs" fname) + forM_ tests $ \test -> do + runTest fname test >>= \case + Left err -> putStrLn err >> writeIORef ok False + Right () -> return () + readIORef ok >>= \case + True -> return () + False -> exitFailure diff --git a/test/mustache-th/RenderNonTH.hs b/test/mustache-th/RenderNonTH.hs new file mode 100644 index 0000000..464d651 --- /dev/null +++ b/test/mustache-th/RenderNonTH.hs @@ -0,0 +1,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 -- cgit v1.3.1