More tests (one currently failing) and fixes

Nix/Parser.hs

@@ -71,8 +71,8 @@ nixInt = mkInt <$> decimal <?> "integer"
 
 nixBool :: Parser NExpr
 nixBool = try (true <|> false) <?> "bool" where
-  true = mkBool . (== "true") <$> string "true"
-  false =mkBool . (== "false") <$> string "false"
+  true = mkBool True <$ string "true"
+  false = mkBool False <$ string "false"
 
 nixNull :: Parser NExpr
 nixNull = try (mkNull <$ string "null") <?> "null"
@@ -169,8 +169,7 @@ lookaheadForSet = do
             (symbolic '=' *> return True) <|> return False
 
 parseNixFile :: MonadIO m => FilePath -> m (Result NExpr)
-parseNixFile = parseFromFileEx nixApp
-
+parseNixFile = parseFromFileEx $ nixApp <* eof
 
 parseNixString :: String -> Result NExpr
-parseNixString = parseFromString nixApp
+parseNixString = parseFromString $ nixApp <* eof

hnix.cabal

@@ -76,7 +76,7 @@ executable hnix
     PatternGuards
     RankNTypes
     TupleSections
-  build-depends:       
+  build-depends:
       base                     >= 4.3          && < 5
     , hnix
     , ansi-wl-pprint
@@ -102,6 +102,7 @@ test-suite hnix-tests
   build-depends:
       base >= 4.3 && < 5
     , containers
+    , text
     , hnix
     , tasty
     , tasty-th

tests/ParserTests.hs

@@ -5,53 +5,79 @@ module ParserTests (tests) where
 import Test.Tasty
 import Test.Tasty.HUnit
 import Test.Tasty.TH
+import Data.Text (pack)
 
 import Nix.Types
 import Nix.Parser
 
 case_constant_int :: Assertion
-case_constant_int = assertParseString "234" $ Fix (NConstant (NInt 234))
+case_constant_int = assertParseString "234" $ mkInt 234
+
+case_constant_bool :: Assertion
+case_constant_bool = do
+  assertParseString "true" $ mkBool True
+  assertParseString "false" $ mkBool False
 
 case_simple_set :: Assertion
 case_simple_set = assertParseString "{ a = 23; b = 4; }" $ Fix $ NSet NonRec
-  [ (Fix (NConstant (NSym "a")), Fix (NConstant (NInt 23)))
-  , (Fix (NConstant (NSym "b")), Fix (NConstant (NInt 4)))
+  [ (mkSym "a", mkInt 23)
+  , (mkSym "b", mkInt 4)
   ]
 
 case_int_list :: Assertion
 case_int_list = assertParseString "[1 2 3]" $ Fix $ NList
-  [ Fix (NConstant (NInt i)) | i <- [1,2,3] ]
+  [ mkInt i | i <- [1,2,3] ]
 
 case_int_null_list :: Assertion
 case_int_null_list = assertParseString "[1 2 3 null 4]" $ Fix (NList (map (Fix . NConstant) [NInt 1, NInt 2, NInt 3, NNull, NInt 4]))
 
 case_simple_lambda :: Assertion
-case_simple_lambda = assertParseString "a: a" $ Fix (NAbs asym asym) where
-  asym = Fix (NConstant (NSym "a"))
+case_simple_lambda = assertParseString "a: a" $ Fix (NAbs (mkSym "a") (mkSym "a"))
 
 case_lambda_app_int :: Assertion
-case_lambda_app_int = assertParseString "(a:a) 3" $ Fix (NApp lam int) where
-  int = Fix (NConstant (NInt 3))
+case_lambda_app_int = assertParseString "(a: a) 3" $ Fix (NApp lam int) where
+  int = mkInt 3
   lam = Fix (NAbs asym asym)
-  asym = Fix (NConstant (NSym "a"))
+  asym = mkSym "a"
 
 case_simple_let :: Assertion
 case_simple_let = assertParseString "let a = 4; in a" $ Fix (NLet binds asym) where
-  binds = [(asym, Fix (NConstant (NInt 4)))]
-  asym = Fix (NConstant (NSym "a"))
+  binds = [(asym, mkInt 4)]
+  asym = mkSym "a"
 
 case_identifier_special_chars :: Assertion
 case_identifier_special_chars = do
-  assertParseString "_a" $ Fix (NConstant (NSym "_a"))
-  assertParseString "a_b" $ Fix (NConstant (NSym "a_b"))
-  assertParseString "a'b" $ Fix (NConstant (NSym "a'b"))
-  assertParseString "a''b" $ Fix (NConstant (NSym "a''b"))
-  assertParseString "a-b" $ Fix (NConstant (NSym "a-b"))
-  assertParseString "a--b" $ Fix (NConstant (NSym "a--b"))
-  assertParseString "a12a" $ Fix (NConstant (NSym "a12a"))
+  assertParseString "_a" $ mkSym "_a"
+  assertParseString "a_b" $ mkSym "a_b"
+  assertParseString "a'b" $ mkSym "a'b"
+  assertParseString "a''b" $ mkSym "a''b"
+  assertParseString "a-b" $ mkSym "a-b"
+  assertParseString "a--b" $ mkSym "a--b"
+  assertParseString "a12a" $ mkSym "a12a"
   assertParseFail ".a"
   assertParseFail "'a"
 
+makeStringParseTest :: String -> Assertion
+makeStringParseTest str = assertParseString ("\"" ++ str ++ "\"") $ mkStr $ pack str
+
+case_simple_string :: Assertion
+case_simple_string = mapM_ makeStringParseTest ["abcdef", "a", "A"]
+
+case_string_dollar :: Assertion
+case_string_dollar = mapM_ makeStringParseTest ["a$b", "a$$b", "$cdef", "gh$i"]
+
+case_string_escape :: Assertion
+case_string_escape = assertParseString "\"\\$\\n\\t\\r\\\\\"" $ mkStr "$\n\t\r\\"
+
+case_if :: Assertion
+case_if = do
+  assertParseString "if true then true else false" $ Fix $ NIf (mkBool True) (mkBool True) (mkBool False)
+  assertParseFail "if true then false"
+  assertParseFail "else"
+  assertParseFail "if true then false else"
+  assertParseFail "if true then false else false else"
+  assertParseFail "1 + 2 then"
+
 tests :: TestTree
 tests = $testGroupGenerator