{Pretty, & Test modules}: String -> Text

Author: Anton-Latukha

src/Nix/Pretty.hs

@@ -29,7 +29,6 @@ import           Nix.Parser
 import           Nix.String
 import           Nix.Thunk
 import           Nix.Value
-import qualified GHC.OldList                   as OldList
 
 -- | This type represents a pretty printed nix expression
 -- together with some information about the expression.
@@ -356,7 +355,7 @@ prettyNValueProv v =
       fillSep
         [ prettyNVal
         , indent 2 $
-          "(" <> fold ("from: " : (prettyOriginExpr . _originExpr <$> ps)) <> ")"
+          "(" <> fold (one "from: " <> (prettyOriginExpr . _originExpr <$> ps)) <> ")"
         ]
     )
     (citations @m @(NValue t f m) v)
@@ -380,36 +379,36 @@ prettyNThunk t =
       fillSep
         [ v'
         , indent 2 $
-          "(" <> fold ( "thunk from: " : (prettyOriginExpr . _originExpr <$> ps)) <> ")"
+          "(" <> fold (one "thunk from: " <> (prettyOriginExpr . _originExpr <$> ps)) <> ")"
         ]
 
 -- | This function is used only by the testing code.
-printNix :: forall t f m . MonadDataContext f m => NValue t f m -> String
+printNix :: forall t f m . MonadDataContext f m => NValue t f m -> Text
 printNix = iterNValueByDiscardWith thk phi
  where
-  thk = toString thunkStubText
+  thk = thunkStubText
 
-  phi :: NValue' t f m String -> String
-  phi (NVConstant' a ) = toString $ atomText a
+  phi :: NValue' t f m Text -> Text
+  phi (NVConstant' a ) = atomText a
   phi (NVStr'      ns) = show $ stringIgnoreContext ns
-  phi (NVList'     l ) = "[ " <> OldList.unwords l <> " ]"
+  phi (NVList'     l ) = "[ " <> unwords l <> " ]"
   phi (NVSet' _ s) =
     "{ " <>
       fold
-        [ check (toString k) <> " = " <> v <> "; "
-        | (k, v) <- sort $ toList s
+        [ check k <> " = " <> v <> "; "
+        | (coerce -> k, v) <- sort $ toList s
         ] <> "}"
    where
-    check :: [Char] -> [Char]
+    check :: Text -> Text
     check v =
       fromMaybe
         v
         (tryRead @Int <|> tryRead @Float)
      where
       surround s = "\"" <> s <> "\""
 
-      tryRead :: forall a . (Read a, Show a) => Maybe String
-      tryRead = fmap (surround . show) (readMaybe v :: Maybe a)
+      tryRead :: forall a . (Read a, Show a) => Maybe Text
+      tryRead = fmap (surround . show) (readMaybe (toString v) :: Maybe a)
   phi NVClosure'{}        = "<<lambda>>"
-  phi (NVPath' fp       ) = coerce fp
-  phi (NVBuiltin' name _) = toString @Text $ "<<builtin " <> coerce name <> ">>"
+  phi (NVPath' fp       ) = fromString $ coerce fp
+  phi (NVBuiltin' name _) = "<<builtin " <> coerce name <> ">>"

tests/EvalTests.hs

@@ -598,7 +598,7 @@ constantEqual expected actual =
         "Inequal normal forms:\n"
         <> "Expected: " <> printNix expectedNF <> "\n"
         <>  "Actual:   " <> printNix actualNF
-    assertBool message eq
+    assertBool (toString message) eq
  where
   getNormForm = normalForm <=< nixEvalExprLoc mempty
 

tests/NixLanguageTests.hs

@@ -158,7 +158,7 @@ assertLangOk opts fileBaseName =
   do
     actual   <- printNix <$> hnixEvalFile opts (addNixExt fileBaseName)
     expected <- read fileBaseName ".exp"
-    assertEqual mempty expected $ fromString (actual <> "\n")
+    assertEqual mempty expected (actual <> "\n")
 
 assertLangOkXml :: Options -> Path -> Assertion
 assertLangOkXml opts fileBaseName =
@@ -218,7 +218,7 @@ assertEvalFail file =
   do
     time       <- liftIO getCurrentTime
     evalResult <- printNix <$> hnixEvalFile (defaultOptions time) file
-    evalResult `seq` assertFailure $ "File: ''" <> coerce file <> "'' should not evaluate.\nThe evaluation result was `" <> evalResult <> "`."
+    evalResult `seq` assertFailure $ "File: ''" <> coerce file <> "'' should not evaluate.\nThe evaluation result was `" <> toString evalResult <> "`."
 
 nixTestDir :: FilePath
 nixTestDir = "data/nix/tests/lang/"

tests/PrettyTests.hs

@@ -9,29 +9,48 @@ import           Nix.Expr
 import           Nix.Pretty
 
 case_indented_antiquotation :: Assertion
-case_indented_antiquotation = do
-  assertPretty (mkIndentedStr 0 "echo $foo")   "''echo $foo''"
-  assertPretty (mkIndentedStr 0 "echo ${foo}") "''echo ''${foo}''"
+case_indented_antiquotation =
+  do
+    assertPretty
+      (mkIndentedStr 0 "echo $foo")
+      "''echo $foo''"
+    assertPretty
+      (mkIndentedStr 0 "echo ${foo}")
+      "''echo ''${foo}''"
 
 case_string_antiquotation :: Assertion
-case_string_antiquotation = do
-  assertPretty (mkStr "echo $foo")   "\"echo \\$foo\""
-  assertPretty (mkStr "echo ${foo}") "\"echo \\${foo}\""
+case_string_antiquotation =
+  do
+    assertPretty
+      (mkStr "echo $foo")
+      "\"echo \\$foo\""
+    assertPretty
+      (mkStr "echo ${foo}")
+      "\"echo \\${foo}\""
 
 case_function_params :: Assertion
 case_function_params =
-  assertPretty (mkFunction (mkVariadicParamSet mempty) (mkInt 3)) "{ ... }:\n  3"
+  assertPretty
+    (mkFunction (mkVariadicParamSet mempty) (mkInt 3))
+    "{ ... }:\n  3"
 
 case_paths :: Assertion
-case_paths = do
-  assertPretty (mkPath False "~/test.nix") "~/test.nix"
-  assertPretty (mkPath False "/test.nix")  "/test.nix"
-  assertPretty (mkPath False "./test.nix") "./test.nix"
+case_paths =
+  do
+    assertPretty
+      (mkPath False "~/test.nix")
+      "~/test.nix"
+    assertPretty
+      (mkPath False "/test.nix")
+      "/test.nix"
+    assertPretty
+      (mkPath False "./test.nix")
+      "./test.nix"
 
 tests :: TestTree
 tests = $testGroupGenerator
 
 ---------------------------------------------------------------------------------
-assertPretty :: NExpr -> String -> Assertion
+assertPretty :: NExpr -> Text -> Assertion
 assertPretty e s =
   assertEqual ("When pretty-printing " <> show e) s . show $ prettyNix e

tests/TestCommon.hs

@@ -5,6 +5,7 @@ module TestCommon where
 import           GHC.Err                        ( errorWithoutStackTrace )
 import           Control.Monad.Catch
 import           Data.Time
+import           Data.Text.IO as Text
 import           Nix
 import           Nix.Standard
 import           Nix.Fresh.Basic
@@ -45,30 +46,31 @@ hnixEvalText opts src =
     )
     (parseNixText src)
 
-nixEvalString :: String -> IO String
-nixEvalString expr = do
-  (coerce -> fp, h) <- mkstemp "nix-test-eval"
-  hPutStr h expr
-  hClose h
-  res <- nixEvalFile fp
-  removeLink $ coerce fp
-  pure res
+nixEvalString :: Text -> IO Text
+nixEvalString expr =
+  do
+    (coerce -> fp, h) <- mkstemp "nix-test-eval"
+    Text.hPutStr h expr
+    hClose h
+    res <- nixEvalFile fp
+    removeLink $ coerce fp
+    pure res
 
-nixEvalFile :: Path -> IO String
-nixEvalFile fp = readProcess "nix-instantiate" ["--eval", "--strict", coerce fp] mempty
+nixEvalFile :: Path -> IO Text
+nixEvalFile fp = fromString <$> readProcess "nix-instantiate" ["--eval", "--strict", coerce fp] mempty
 
 assertEvalFileMatchesNix :: Path -> Assertion
-assertEvalFileMatchesNix fp = do
-  time    <- liftIO getCurrentTime
-  hnixVal <- (<> "\n") . printNix <$> hnixEvalFile (defaultOptions time) fp
-  nixVal  <- nixEvalFile fp
-  assertEqual (coerce fp) nixVal hnixVal
+assertEvalFileMatchesNix fp =
+  do
+    time    <- liftIO getCurrentTime
+    hnixVal <- (<> "\n") . printNix <$> hnixEvalFile (defaultOptions time) fp
+    nixVal  <- nixEvalFile fp
+    assertEqual (coerce fp) nixVal hnixVal
 
 assertEvalMatchesNix :: Text -> Assertion
-assertEvalMatchesNix expr = do
-  time    <- liftIO getCurrentTime
-  hnixVal <- (<> "\n") . printNix <$> hnixEvalText (defaultOptions time) expr
-  nixVal  <- nixEvalString expr'
-  assertEqual expr' nixVal hnixVal
- where
-  expr' = toString expr
+assertEvalMatchesNix expr =
+  do
+    time    <- liftIO getCurrentTime
+    hnixVal <- (<> "\n") . printNix <$> hnixEvalText (defaultOptions time) expr
+    nixVal  <- nixEvalString expr
+    assertEqual (toString expr) nixVal hnixVal