packages feed

hspec-core 2.10.6 → 2.10.7

raw patch · 8 files changed

+167/−467 lines, 8 filesdep +haskell-lexerdep −ghcdep −ghc-boot-thPVP ok

version bump matches the API change (PVP)

Dependencies added: haskell-lexer

Dependencies removed: ghc, ghc-boot-th

API changes (from Hackage documentation)

Files

hspec-core.cabal view
@@ -5,7 +5,7 @@ -- see: https://github.com/sol/hpack  name:             hspec-core-version:          2.10.6+version:          2.10.7 license:          MIT license-file:     LICENSE copyright:        (c) 2011-2022 Simon Hengel,@@ -43,6 +43,7 @@     , deepseq     , directory     , filepath+    , haskell-lexer     , hspec-expectations ==0.8.2.*     , process     , quickcheck-io >=0.2.0@@ -80,7 +81,7 @@       Test.Hspec.Core.Formatters.Internal       Test.Hspec.Core.Formatters.Pretty       Test.Hspec.Core.Formatters.Pretty.Parser-      Test.Hspec.Core.Formatters.Pretty.Parser.Types+      Test.Hspec.Core.Formatters.Pretty.Parser.Parser       Test.Hspec.Core.Formatters.Pretty.Unicode       Test.Hspec.Core.Formatters.V1.Free       Test.Hspec.Core.Formatters.V1.Monad@@ -96,10 +97,6 @@       Data.Algorithm.Diff       Paths_hspec_core   default-language: Haskell2010-  if impl(ghc >= 8.2.1)-    build-depends:-        ghc-      , ghc-boot-th   if impl(ghc >= 8.4.1)     build-depends:         stm >=2.2@@ -129,6 +126,7 @@     , deepseq     , directory     , filepath+    , haskell-lexer     , hspec-expectations ==0.8.2.*     , hspec-meta ==2.10.5     , process@@ -163,7 +161,7 @@       Test.Hspec.Core.Formatters.Internal       Test.Hspec.Core.Formatters.Pretty       Test.Hspec.Core.Formatters.Pretty.Parser-      Test.Hspec.Core.Formatters.Pretty.Parser.Types+      Test.Hspec.Core.Formatters.Pretty.Parser.Parser       Test.Hspec.Core.Formatters.Pretty.Unicode       Test.Hspec.Core.Formatters.V1       Test.Hspec.Core.Formatters.V1.Free@@ -217,10 +215,6 @@       Test.Hspec.Core.UtilSpec       Paths_hspec_core   default-language: Haskell2010-  if impl(ghc >= 8.2.1)-    build-depends:-        ghc-      , ghc-boot-th   if impl(ghc >= 8.4.1)     build-depends:         stm >=2.2
src/Test/Hspec/Core/Formatters/Pretty.hs view
@@ -24,16 +24,12 @@   (Just expected_, Just actual_) -> (expected_, actual_)   _ -> case (pretty unicode expected, pretty unicode actual) of     (Just expected_, Just actual_) -> (expected_, actual_)-#if __GLASGOW_HASKELL__ >= 802-    _ -> (expected, actual)-#else     _ -> (rec expected, rec actual)   where     rec = if unicode then urecover else id      urecover :: String -> String     urecover xs = maybe xs ushow $ readMaybe xs-#endif  recoverString :: Bool -> String -> Maybe String recoverString unicode input = case readMaybe input of@@ -45,24 +41,22 @@     isSafe c = (unicode || isAscii c) && (not $ isControl c) || c == '\n'  pretty :: Bool -> String -> Maybe String-pretty unicode = parseExpression >=> render_+pretty unicode = parseValue >=> render_   where-    render_ :: Expression -> Maybe String-    render_ expr = guard (shouldParseBack expr) >> Just (renderExpression unicode expr)+    render_ :: Value -> Maybe String+    render_ value = guard (shouldParseBack value) >> Just (renderValue unicode value) -    shouldParseBack :: Expression -> Bool+    shouldParseBack :: Value -> Bool     shouldParseBack = go       where-        go expr = case expr of-          Literal (String _) -> True-          Literal _ -> False-          Id _ -> False-          App (Id _) e -> go e-          App _ _ -> False-          Parentheses e -> go e+        go value = case value of+          Char _ -> False+          String _ -> True+          Number _ -> False+          Record _ _ -> True+          Constructor _ xs -> any go xs           Tuple xs -> any go xs           List xs -> any go xs-          Record _ _ -> True  newtype Builder = Builder ShowS @@ -91,24 +85,18 @@ instance IsString Builder where   fromString = Builder . showString -renderExpression :: Bool -> Expression -> String-renderExpression unicode = runBuilder . render+renderValue :: Bool -> Value -> String+renderValue unicode = runBuilder . render   where-    renderLiteral lit = case lit of+    render :: Value -> Builder+    render value = case value of       Char c -> shows c       String str -> if unicode then Builder $ ushows str else shows str-      Integer n -> shows n-      Rational n -> fromString n--    render :: Expression -> Builder-    render expr = case expr of-      Literal lit -> renderLiteral lit-      Id name -> fromString name-      App a b -> render a <> " " <> render b-      Parentheses e@Record{} -> render e-      Parentheses e -> "(" <> render e <> ")"+      Number n -> fromString n+      Record name fields -> fromString name <> " {\n  " <> (intercalate ",\n  " $ map renderField fields) <> "\n}"+      Constructor name values -> intercalate " " (fromString name : map render values)+      Tuple [e@Record{}] -> render e       Tuple xs -> "(" <> intercalate ", " (map render xs) <> ")"       List xs -> "[" <> intercalate ", " (map render xs) <> "]"-      Record name fields -> fromString name <> " {\n  " <> (intercalate ",\n  " $ map renderField fields) <> "\n}"      renderField (name, value) = fromString name <> " = " <> render value
src/Test/Hspec/Core/Formatters/Pretty/Parser.hs view
@@ -1,395 +1,102 @@-{-# LANGUAGE CPP #-}-{-# LANGUAGE RankNTypes #-}-{-# LANGUAGE OverloadedStrings #-}-{-# LANGUAGE FlexibleInstances #-}-#if __GLASGOW_HASKELL__ >= 810-{-# LANGUAGE EmptyCase #-}-#endif module Test.Hspec.Core.Formatters.Pretty.Parser (-  Expression(..)-, Literal(..)-, parseExpression-, unsafeParseExpression+  Value(..)+, parseValue ) where  import           Prelude ()-import           Test.Hspec.Core.Compat hiding (fail)-import           Test.Hspec.Core.Formatters.Pretty.Parser.Types--#ifndef __GHCJS__-#if __GLASGOW_HASKELL__ >= 802 && __GLASGOW_HASKELL__ <= 904-#define PRETTY_PRINTING_SUPPORTED-#endif-#endif--#ifndef PRETTY_PRINTING_SUPPORTED--parseExpression :: String -> Maybe Expression-parseExpression _ = Nothing--unsafeParseExpression :: String -> Maybe Expression-unsafeParseExpression _ = Nothing--#else--import           GHC.Stack-import           GHC.Exception (throw, errorCallWithCallStackException)--#if __GLASGOW_HASKELL__ >= 904-import           GHC.Utils.Error-import           GHC.Utils.Outputable-#endif--#if __GLASGOW_HASKELL__ >= 804 && __GLASGOW_HASKELL__ < 904-import           GHC.LanguageExtensions.Type-#endif--#if __GLASGOW_HASKELL__ >= 902-import           GHC.Types.SourceText-#elif __GLASGOW_HASKELL__ >= 900-import           GHC.Types.Basic-import           GHC.Unit.Types-#endif--#if __GLASGOW_HASKELL__ >= 900-import qualified GHC.Parser as GHC-import           GHC.Parser.Lexer-import           GHC.Data.StringBuffer-import           GHC.Data.FastString-import           GHC.Types.SrcLoc-import           GHC.Types.Name-import           GHC.Types.Name.Reader-import           GHC.Parser.PostProcess hiding (Tuple)-#else-import           Lexer-import qualified Parser as GHC-import           StringBuffer-import           FastString-import           SrcLoc-import           Name-import           RdrName-import           BasicTypes-import           Module-#endif--#if __GLASGOW_HASKELL__ >= 804 && __GLASGOW_HASKELL__ < 904-#if __GLASGOW_HASKELL__ >= 900-import qualified GHC.Data.EnumSet as EnumSet-#else-import qualified EnumSet-#endif-#endif--#if __GLASGOW_HASKELL__ == 810-import           RdrHsSyn hiding (Tuple)-#endif--#if __GLASGOW_HASKELL__ >= 810-import           GHC.Hs-#else-import           HsSyn-#endif--#if __GLASGOW_HASKELL__ <= 806-import           Data.Bits-import           Control.Exception-#endif--parseExpression :: String -> Maybe Expression-parseExpression = parseWith (const Nothing)--unsafeParseExpression :: String -> Maybe Expression-unsafeParseExpression = parseWith throwError--parseWith :: (Error -> Maybe Expression) -> String -> Maybe Expression-parseWith err = parse >=> either err Just . toExpression--data Error = Error CallStack String--throwError :: Error -> a-throwError (Error stack err) = throw $ errorCallWithCallStackException err stack--fail :: HasCallStack => String -> Either Error a-fail = Left . Error callStack--class ToExpression a where-  toExpression :: a -> Either Error Expression--#if __GLASGOW_HASKELL__ < 806-#define _x-#endif--#if __GLASGOW_HASKELL__ >= 900-#define X(name, expr)-#elif __GLASGOW_HASKELL__ == 810-#define X(name, expr) name none -> case none of-#elif __GLASGOW_HASKELL__ >= 806-#define X(name, expr) name none -> case none of NoExt -> expr-#else-#define X(name, expr)-#endif--#if __GLASGOW_HASKELL__ >= 804-#define GhcPsHsLit GhcPs-#else-type GhcPs = RdrName-#define GhcPsHsLit-#endif--#if __GLASGOW_HASKELL__ >= 902-#define _listSynExpr-#endif--#if __GLASGOW_HASKELL__ >= 806-#define RecCon(name, fields) RecordCon _ (L _ name) fields-#else-#define RecCon(name, fields) RecordCon (L _ name) _ _ fields-#endif--#define REJECT(name) name{} -> fail "name"+import           Test.Hspec.Core.Compat -instance ToExpression (HsExpr GhcPs) where-  toExpression expr = case expr of-    HsVar _x name -> toExpression name-    HsLit _x lit -> toExpression lit-    HsOverLit _x lit -> toExpression lit-    HsApp _x f x -> App <$> toExpression f <*> toExpression x-    NegApp _x e _ -> toExpression e >>= \ x -> case x of-      Literal (Rational n) -> return $ Literal (Rational $ '-' : n)-      Literal (Integer n) -> return $ Literal (Integer $ negate n)-      _ -> fail "NegApp"+import           Test.Hspec.Core.Formatters.Pretty.Parser.Parser hiding (Parser)+import qualified Test.Hspec.Core.Formatters.Pretty.Parser.Parser as P -    HsPar _x-#if __GLASGOW_HASKELL__ >= 904-      _ e _ ->-#else-      e ->-#endif-        Parentheses <$> toExpression e-    ExplicitTuple _x xs _ -> Tuple <$> mapM toExpression xs-    ExplicitList _ _listSynExpr xs -> List <$> mapM toExpression xs-    RecCon(name, fields) -> Record (showRdrName name) <$> (recordFields $ rec_flds fields)-      where-#if __GLASGOW_HASKELL__ >= 904-        hsRecFieldLbl = hfbLHS-        hsRecFieldArg = hfbRHS-#endif-        fieldName = showFieldLabel . unLoc . hsRecFieldLbl-        recordFields = mapM (recordField . unLoc)-        recordField field = (,) (fieldName field) <$> toExpression (hsRecFieldArg field)+import           Language.Haskell.Lexer hiding (Pos(..)) -    REJECT(HsUnboundVar)-    REJECT(HsOverLabel)-    REJECT(HsIPVar)-    REJECT(HsLam)-    REJECT(HsLamCase)-    REJECT(HsAppType)-    REJECT(OpApp)-    REJECT(SectionL)-    REJECT(SectionR)-    REJECT(ExplicitSum)-    REJECT(HsCase)-    REJECT(HsIf)-    REJECT(HsMultiIf)-    REJECT(HsLet)-    REJECT(HsDo)-    REJECT(RecordUpd)-    REJECT(ExprWithTySig)-    REJECT(ArithSeq)-    REJECT(HsSpliceE)-    REJECT(HsProc)-    REJECT(HsStatic)+type Name = String -#if __GLASGOW_HASKELL__ >= 904-    REJECT(HsRecSel)-    REJECT(HsTypedBracket)-    REJECT(HsUntypedBracket)-#endif-#if __GLASGOW_HASKELL__ >= 902-    REJECT(HsGetField)-    REJECT(HsProjection)-#endif-#if __GLASGOW_HASKELL__ >= 900-    REJECT(HsPragE)-#endif+data Value =+    Char Char+  | String String+  | Number String+  | Record Name [(Name, Value)]+  | Constructor Name [Value]+  | Tuple [Value]+  | List [Value]+  deriving (Eq, Show) -#if __GLASGOW_HASKELL__ < 904-    REJECT(HsConLikeOut)-    REJECT(HsRecFld)-    REJECT(HsBracket)-    REJECT(HsRnBracketOut)-    REJECT(HsTcBracketOut)-    REJECT(HsTick)-    REJECT(HsBinTick)-#endif-#if __GLASGOW_HASKELL__ < 900-    REJECT(HsSCC)-    REJECT(HsCoreAnn)-    REJECT(HsTickPragma)-    REJECT(HsWrap)-#endif-#if __GLASGOW_HASKELL__ < 810-    REJECT(HsArrApp)-    REJECT(HsArrForm)-    REJECT(EWildPat)-    REJECT(EAsPat)-    REJECT(EViewPat)-    REJECT(ELazyPat)-#endif-#if __GLASGOW_HASKELL__ < 806-    REJECT(HsAppTypeOut)-    REJECT(ExplicitPArr)-    REJECT(ExprWithTySigOut)-    REJECT(PArrSeq)-#endif-    X(XExpr, fail "XExpr")+type Parser = P.Parser (Token, String) -instance ToExpression RdrName where-  toExpression = return . Id . showRdrName+parseValue :: String -> Maybe Value+parseValue input = case runParser value (tokenize input) of+  Just (v, []) -> Just v+  _ -> Nothing -instance ToExpression (HsTupArg GhcPs) where-  toExpression t = case t of-    Present _x expr -> toExpression expr-    Missing _ -> fail "Missing (tuple section)"-    X(XTupArg, fail "XTupArg")+value :: Parser Value+value =+      char+  <|> string+  <|> number+  <|> record+  <|> constructor+  <|> tuple+  <|> list -instance ToExpression e => ToExpression (GenLocated l e) where-  toExpression (L _ e) = toExpression e+char :: Parser Value+char = Char <$> (token CharLit >>= readA) -instance ToExpression (HsOverLit GhcPs) where-  toExpression = toExpression . ol_val+string :: Parser Value+string = String <$> (token StringLit >>= readA) -#if __GLASGOW_HASKELL__ > 802-#define _integralSource+number :: Parser Value+number = integer <|> float+  where+    integer :: Parser Value+    integer = Number <$> token IntLit -instance ToExpression IntegralLit where-  toExpression il = toExpression (il_value il)-#endif+    float :: Parser Value+    float = Number <$> token FloatLit -instance ToExpression OverLitVal where-  toExpression lit = case lit of-    HsIntegral _integralSource il -> toExpression il-    HsFractional fl -> toExpression fl-    HsIsString _ str -> toExpression str+record :: Parser Value+record = Record <$> token Conid <* special "{" <*> fields <* special "}"+  where+    fields :: Parser [(Name, Value)]+    fields = field `sepBy1` comma -instance ToExpression FractionalLit where-  toExpression fl = case fl_text fl of-#if __GLASGOW_HASKELL__ > 802-    REJECT(NoSourceText)-    SourceText n-#else-    n-#endif-      -> return . Literal $ Rational n+    field :: Parser (Name, Value)+    field = (,) <$> token Varid <* equals <*> value -instance ToExpression FastString where-  toExpression = return . Literal . String . unpackFS+constructor :: Parser Value+constructor = Constructor <$> token Conid <*> many value -instance ToExpression Integer where-  toExpression = return . Literal . Integer+tuple :: Parser Value+tuple = Tuple <$> (special "(" *> items) <* special ")" -instance ToExpression Char where-  toExpression = return . Literal . Char+list :: Parser Value+list = List <$> (special "[" *> items) <* special "]" -instance ToExpression (HsLit GhcPsHsLit) where-  toExpression lit = case lit of-    HsChar _ c -> toExpression c-    HsString _ str -> toExpression str-    REJECT(HsCharPrim)-    REJECT(HsStringPrim)-    REJECT(HsInt)-    REJECT(HsIntPrim)-    REJECT(HsWordPrim)-    REJECT(HsInt64Prim)-    REJECT(HsWord64Prim)-    REJECT(HsInteger)-    REJECT(HsRat)-    REJECT(HsFloatPrim)-    REJECT(HsDoublePrim)-    X(XLit, fail "XLit")+items :: Parser [Value]+items = value `sepBy` comma -showFieldLabel :: FieldOcc GhcPs -> String-showFieldLabel label = case label of-#if __GLASGOW_HASKELL__ >= 806-  FieldOcc _ (L _ name) -> showRdrName name-#else-  FieldOcc (L _ name) _ -> showRdrName name-#endif-  X(XFieldOcc, "")+special :: String -> Parser ()+special s = require (Special, s) -showRdrName :: RdrName -> String-showRdrName n = case n of-  Unqual name -> showOccName name-  Qual _ name -> showOccName name-  Orig _ name -> showOccName name-  Exact name -> showOccName (nameOccName name)+comma :: Parser ()+comma = special "," -showOccName :: OccName -> String-showOccName = unpackFS . occNameFS+equals :: Parser ()+equals = require (Reservedop, "=") -parse :: String -> Maybe (HsExpr GhcPs)-parse input = case runParser input pHsExpr of-  POk _ (L _ x) -> Just x-  PFailed {} -> Nothing-  where-    pHsExpr = do-      r <- GHC.parseExpression-      runPV (unECP r)+token :: Token -> Parser String+token t = snd <$> satisfy (fst >>> (== t)) -#if __GLASGOW_HASKELL__ <= 900-#if __GLASGOW_HASKELL__ >= 810-    unECP = runECP_PV-#else-    unECP = return-    runPV = id-#endif-#endif+require :: (Token, String) -> Parser ()+require t = void $ satisfy (== t) -runParser :: String -> P a -> ParseResult a-runParser str parser = unP parser parseState+tokenize :: String -> [(Token, String)]+tokenize = go . map (fmap snd) . rmSpace . lexerPass0   where-    location = mkRealSrcLoc "" 1 1-    input = stringToStringBuffer str-    parseState = initParserState opts input location-    opts = mkParserOpts warn-#if __GLASGOW_HASKELL__ >= 904-      (DiagOpts mempty mempty False False Nothing defaultSDocContext)-#endif-      extensions False False False True--#if __GLASGOW_HASKELL__ >= 804 && __GLASGOW_HASKELL__ < 904-    warn = EnumSet.empty-#else-    warn = mempty-#endif--#if __GLASGOW_HASKELL__ >= 904-    extensions = ["TraditionalRecordSyntax"]-#elif __GLASGOW_HASKELL__ >= 804-    extensions = EnumSet.fromList [TraditionalRecordSyntax]-#else-    extensions = mempty-#endif--#if __GLASGOW_HASKELL__ <= 900-    initParserState = mkPStatePure-    mkParserOpts warningFlags extensionFlags = mkParserFlags' warningFlags extensionFlags unit-#if __GLASGOW_HASKELL__ == 900-    unit = UnitId ""-#else-    unit = fsToUnitId ""-#endif-#endif--#if __GLASGOW_HASKELL__ <= 806-    mkParserFlags' ws es u _ _ _ _ = assert (traditionalRecordSyntaxEnabled extensionsBitmap) $-      ParserFlags ws es u extensionsBitmap-    extensionsBitmap = shift 1 traditionalRecordSyntaxBit-#if __GLASGOW_HASKELL__ == 806-    traditionalRecordSyntaxBit = 28-#else-    traditionalRecordSyntaxBit = 29-#endif-#endif--#endif+    go :: [(Token, String)] -> [(Token, String)]+    go tokens = case tokens of+      [] -> []+      (Varsym, "-") : (IntLit, n) : xs -> (IntLit, "-" ++ n) : go xs+      (Varsym, "-") : (FloatLit, n) : xs -> (FloatLit, "-" ++ n) : go xs+      x : xs -> x : go xs
+ src/Test/Hspec/Core/Formatters/Pretty/Parser/Parser.hs view
@@ -0,0 +1,34 @@+{-# LANGUAGE DeriveFunctor #-}+module Test.Hspec.Core.Formatters.Pretty.Parser.Parser where++import           Prelude ()+import           Test.Hspec.Core.Compat++newtype Parser token a = Parser { runParser :: [token] -> Maybe (a, [token]) }+  deriving Functor++instance Applicative (Parser token) where+  pure a = Parser $ \ input -> Just (a, input)+  (<*>) = ap++instance Monad (Parser token) where+  return = pure+  p1 >>= p2 = Parser $ runParser p1 >=> uncurry (runParser . p2)++instance Alternative (Parser token) where+  empty = Parser $ const Nothing+  p1 <|> p2 = Parser $ \ input -> runParser p1 input <|> runParser p2 input++satisfy :: (token -> Bool) -> Parser token token+satisfy p = Parser $ \ input -> case input of+  t : ts | p t -> Just (t, ts)+  _ -> Nothing++sepBy :: Alternative m => m a -> m sep -> m [a]+sepBy p sep = sepBy1 p sep <|> pure []++sepBy1 :: Alternative m => m a -> m sep -> m [a]+sepBy1 p sep = (:) <$> p <*> many (sep *> p)++readA :: (Alternative m, Read a) => String -> m a+readA = maybe empty pure . readMaybe
− src/Test/Hspec/Core/Formatters/Pretty/Parser/Types.hs 
@@ -1,21 +0,0 @@-module Test.Hspec.Core.Formatters.Pretty.Parser.Types where--import           Prelude ()-import           Test.Hspec.Core.Compat--data Expression =-    Literal Literal-  | Id String-  | App Expression Expression-  | Parentheses Expression-  | Tuple [Expression]-  | List [Expression]-  | Record String [(String, Expression)]-  deriving (Eq, Show)--data Literal =-    Char Char-  | String String-  | Integer Integer-  | Rational String-  deriving (Eq, Show)
test/Test/Hspec/Core/Formatters/Pretty/ParserSpec.hs view
@@ -1,4 +1,5 @@-{-# LANGUAGE CPP #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE ConstraintKinds #-} module Test.Hspec.Core.Formatters.Pretty.ParserSpec (spec, Person(..)) where  import           Prelude ()@@ -11,59 +12,61 @@ , personAge :: Int } deriving (Eq, Show) -string :: String -> Expression-string = Literal . String+infix 1 `shouldParseAs` -integer :: Integer -> Expression-integer = Literal . Integer+shouldParseAs :: HasCallStack => String -> Value -> Expectation+shouldParseAs input expected = parseValue input `shouldBe` Just expected +unit :: Value+unit = Tuple []++parentheses :: Value -> Value+parentheses value = Tuple [value]+ spec :: Spec spec = do-  let parse = unsafeParseExpression-  describe "parseExpression" $ do+  describe "parseValue" $ do+    it "parses unit" $ do+      show () `shouldParseAs` unit+     it "parses characters" $ do-      parse (show 'c') `shouldBe` just (Literal $ Char 'c')+      show 'c' `shouldParseAs` Char 'c'      it "parses strings" $ do-      parse (show "foo") `shouldBe` just (string "foo")+      show "foo" `shouldParseAs` String "foo" -    it "parses integers" $ do-      parse "23" `shouldBe` just (integer 23)+    context "when parsing numbers" $ do+      it "accepts integers" $ do+        "23" `shouldParseAs` Number "23" -    it "parses negative integers" $ do-      parse "-23" `shouldBe` just (integer (-23))+      it "accepts negative integers" $ do+        "-23" `shouldParseAs` Number "-23" -    it "parses rationals" $ do-      parse "23.0" `shouldBe` just (Literal $ Rational "23.0")+      it "accepts floats" $ do+        show (23.0 :: Float) `shouldParseAs` Number "23.0" -    it "parses negative rationals" $ do-      parse "-23.0" `shouldBe` just (Literal $ Rational "-23.0")+      it "accepts negative floats" $ do+        show (-23.0 :: Float) `shouldParseAs` Number "-23.0"      it "parses lists" $ do-      parse (show ["foo", "bar", "baz"]) `shouldBe` just (List [string "foo", string "bar", string "baz"])+      show ["foo", "bar", "baz"] `shouldParseAs` List [String "foo", String "bar", String "baz"]      it "parses tuples" $ do-      parse (show ("foo", "bar", "baz")) `shouldBe` just (Tuple [string "foo", string "bar", string "baz"])+      show ("foo", "bar", "baz") `shouldParseAs` Tuple [String "foo", String "bar", String "baz"]      it "parses Nothing" $ do-      parse (show (Nothing :: Maybe Int)) `shouldBe` just (Id "Nothing")+      show (Nothing :: Maybe Int) `shouldParseAs` Constructor "Nothing" []      it "parses Just" $ do-      parse (show $ Just "foo") `shouldBe` just (App (Id "Just") (string "foo"))+      show (Just "foo") `shouldParseAs` Constructor "Just" [String "foo"]      it "parses nested Just" $ do-      parse (show $ Just $ Just "foo") `shouldBe` just (App (Id "Just") . Parentheses $ App (Id "Just") (string "foo"))+      show (Just $ Just "foo") `shouldParseAs` Constructor "Just" [parentheses (Constructor "Just" [String "foo"])]      it "parses records" $ do       let person = Person "Joe" 23 -      parse (show person) `shouldBe` just (Record "Person" [-          ("personName", string "Joe")-        , ("personAge", integer 23)-        ])-  where-#if __GLASGOW_HASKELL__ >= 802-    just = Just-#else-    just _ = Nothing-#endif+      show person `shouldParseAs` Record "Person" [+          ("personName", String "Joe")+        , ("personAge", Number "23")+        ]
test/Test/Hspec/Core/Formatters/PrettySpec.hs view
@@ -1,4 +1,3 @@-{-# LANGUAGE CPP #-} module Test.Hspec.Core.Formatters.PrettySpec (spec) where  import           Prelude ()@@ -110,8 +109,4 @@         let input = unlines ["foo", "bar", "baz"]         pretty True input `shouldBe` Nothing   where-#if __GLASGOW_HASKELL__ >= 802     just = Just . intercalate "\n"-#else-    just _ = Nothing-#endif
version.yaml view
@@ -1,1 +1,1 @@-&version 2.10.6+&version 2.10.7